src/remoting/host/desktop_session_proxy.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
   6 #define REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
   7
   8 #include <map>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/process/process.h"
  15 #include "base/sequenced_task_runner_helpers.h"
  16 #include "ipc/ipc_listener.h"
  17 #include "ipc/ipc_platform_file.h"
  18 #include "remoting/host/audio_capturer.h"
  19 #include "remoting/host/desktop_environment.h"
  20 #include "remoting/host/screen_resolution.h"
  21 #include "remoting/proto/event.pb.h"
  22 #include "remoting/protocol/clipboard_stub.h"
  23 #include "third_party/skia/include/core/SkRegion.h"
  24 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
  25
  26 namespace base {
  27 class SingleThreadTaskRunner;
  28 }  // namespace base
  29
  30 namespace IPC {
  31 class ChannelProxy;
  32 class Message;
  33 }  // namespace IPC
  34
  35 struct SerializedDesktopFrame;
  36
  37 namespace remoting {
  38
  39 class AudioPacket;
  40 class ClientSession;
  41 class ClientSessionControl;
  42 class DesktopSessionConnector;
  43 struct DesktopSessionProxyTraits;
  44 class IpcAudioCapturer;
  45 class IpcVideoFrameCapturer;
  46 class ScreenControls;
  47
  48 // DesktopSessionProxy is created by an owning DesktopEnvironment to route
  49 // requests from stubs to the DesktopSessionAgent instance through
  50 // the IPC channel. DesktopSessionProxy is owned both by the DesktopEnvironment
  51 // and the stubs, since stubs can out-live their DesktopEnvironment.
  52 //
  53 // DesktopSessionProxy objects are ref-counted but are always deleted on
  54 // the |caller_tast_runner_| thread. This makes it possible to continue
  55 // to receive IPC messages after the ref-count has dropped to zero, until
  56 // the proxy is deleted. DesktopSessionProxy must therefore avoid creating new
  57 // references to the itself while handling IPC messages and desktop
  58 // attach/detach notifications.
  59 //
  60 // All public methods of DesktopSessionProxy are called on
  61 // the |caller_task_runner_| thread unless it is specified otherwise.
  62 class DesktopSessionProxy
  63     : public base::RefCountedThreadSafe<DesktopSessionProxy,
  64                                         DesktopSessionProxyTraits>,
  65       public IPC::Listener {
  66  public:
  67   DesktopSessionProxy(
  68       scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner,
  69       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  70       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
  71       scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
  72       base::WeakPtr<ClientSessionControl> client_session_control,
  73       base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
  74       bool virtual_terminal);
  75
  76   // Mirrors DesktopEnvironment.
  77   scoped_ptr<AudioCapturer> CreateAudioCapturer();
  78   scoped_ptr<InputInjector> CreateInputInjector();
  79   scoped_ptr<ScreenControls> CreateScreenControls();
  80   scoped_ptr<webrtc::ScreenCapturer> CreateVideoCapturer();
  81   std::string GetCapabilities() const;
  82   void SetCapabilities(const std::string& capabilities);
  83
  84   // IPC::Listener implementation.
  85   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
  86   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
  87   virtual void OnChannelError() OVERRIDE;
  88
  89   // Connects to the desktop session agent.
  90   bool AttachToDesktop(base::ProcessHandle desktop_process,
  91                        IPC::PlatformFileForTransit desktop_pipe);
  92
  93   // Closes the connection to the desktop session agent and cleans up
  94   // the associated resources.
  95   void DetachFromDesktop();
  96
  97   // Disconnects the client session that owns |this|.
  98   void DisconnectSession();
  99
 100   // Stores |audio_capturer| to be used to post captured audio packets. Called
 101   // on the |audio_capture_task_runner_| thread.
 102   void SetAudioCapturer(const base::WeakPtr<IpcAudioCapturer>& audio_capturer);
 103
 104   // APIs used to implement the webrtc::ScreenCapturer interface. These must be
 105   // called on the |video_capture_task_runner_| thread.
 106   void InvalidateRegion(const SkRegion& invalid_region);
 107   void CaptureFrame();
 108
 109   // Stores |video_capturer| to be used to post captured video frames. Called on
 110   // the |video_capture_task_runner_| thread.
 111   void SetVideoCapturer(
 112       const base::WeakPtr<IpcVideoFrameCapturer> video_capturer);
 113
 114   // APIs used to implement the InputInjector interface.
 115   void InjectClipboardEvent(const protocol::ClipboardEvent& event);
 116   void InjectKeyEvent(const protocol::KeyEvent& event);
 117   void InjectMouseEvent(const protocol::MouseEvent& event);
 118   void StartInputInjector(scoped_ptr<protocol::ClipboardStub> client_clipboard);
 119
 120   // API used to implement the SessionController interface.
 121   void SetScreenResolution(const ScreenResolution& resolution);
 122
 123  private:
 124   friend class base::DeleteHelper<DesktopSessionProxy>;
 125   friend struct DesktopSessionProxyTraits;
 126
 127   class IpcSharedBufferCore;
 128   class IpcSharedBuffer;
 129   typedef std::map<int, scoped_refptr<IpcSharedBufferCore> > SharedBuffers;
 130
 131   virtual ~DesktopSessionProxy();
 132
 133   // Returns a shared buffer from the list of known buffers.
 134   scoped_refptr<IpcSharedBufferCore> GetSharedBufferCore(int id);
 135
 136   // Handles AudioPacket notification from the desktop session agent.
 137   void OnAudioPacket(const std::string& serialized_packet);
 138
 139   // Registers a new shared buffer created by the desktop process.
 140   void OnCreateSharedBuffer(int id,
 141                             IPC::PlatformFileForTransit handle,
 142                             uint32 size);
 143
 144   // Drops a cached reference to the shared buffer.
 145   void OnReleaseSharedBuffer(int id);
 146
 147   // Handles CaptureCompleted notification from the desktop session agent.
 148   void OnCaptureCompleted(const SerializedDesktopFrame& serialized_frame);
 149
 150   // Handles CursorShapeChanged notification from the desktop session agent.
 151   void OnCursorShapeChanged(const webrtc::MouseCursorShape& cursor_shape);
 152
 153   // Handles InjectClipboardEvent request from the desktop integration process.
 154   void OnInjectClipboardEvent(const std::string& serialized_event);
 155
 156   // Posts OnCaptureCompleted() to |video_capturer_| on the video thread,
 157   // passing |frame|.
 158   void PostCaptureCompleted(scoped_ptr<webrtc::DesktopFrame> frame);
 159
 160   // Posts OnCursorShapeChanged() to |video_capturer_| on the video thread,
 161   // passing |cursor_shape|.
 162   void PostCursorShape(scoped_ptr<webrtc::MouseCursorShape> cursor_shape);
 163
 164   // Sends a message to the desktop session agent. The message is silently
 165   // deleted if the channel is broken.
 166   void SendToDesktop(IPC::Message* message);
 167
 168   // Task runners:
 169   //   - |audio_capturer_| is called back on |audio_capture_task_runner_|.
 170   //   - public methods of this class (with some exceptions) are called on
 171   //     |caller_task_runner_|.
 172   //   - background I/O is served on |io_task_runner_|.
 173   //   - |video_capturer_| is called back on |video_capture_task_runner_|.
 174   scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner_;
 175   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 176   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 177   scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner_;
 178
 179   // Points to the audio capturer receiving captured audio packets.
 180   base::WeakPtr<IpcAudioCapturer> audio_capturer_;
 181
 182   // Points to the client stub passed to StartInputInjector().
 183   scoped_ptr<protocol::ClipboardStub> client_clipboard_;
 184
 185   // Used to disconnect the client session.
 186   base::WeakPtr<ClientSessionControl> client_session_control_;
 187
 188   // Used to create a desktop session and receive notifications every time
 189   // the desktop process is replaced.
 190   base::WeakPtr<DesktopSessionConnector> desktop_session_connector_;
 191
 192   // Points to the video capturer receiving captured video frames.
 193   base::WeakPtr<IpcVideoFrameCapturer> video_capturer_;
 194
 195   // IPC channel to the desktop session agent.
 196   scoped_ptr<IPC::ChannelProxy> desktop_channel_;
 197
 198   // Handle of the desktop process.
 199   base::ProcessHandle desktop_process_;
 200
 201   int pending_capture_frame_requests_;
 202
 203   // Shared memory buffers by Id. Each buffer is owned by the corresponding
 204   // frame.
 205   SharedBuffers shared_buffers_;
 206
 207   // Keeps the desired screen resolution so it can be passed to a newly attached
 208   // desktop session agent.
 209   ScreenResolution screen_resolution_;
 210
 211   // True if |this| has been connected to the desktop session.
 212   bool is_desktop_session_connected_;
 213
 214   bool virtual_terminal_;
 215
 216   DISALLOW_COPY_AND_ASSIGN(DesktopSessionProxy);
 217 };
 218
 219 // Destroys |DesktopSessionProxy| instances on the caller's thread.
 220 struct DesktopSessionProxyTraits {
 221   static void Destruct(const DesktopSessionProxy* desktop_session_proxy);
 222 };
 223
 224 }  // namespace remoting
 225
 226 #endif  // REMOTING_HOST_DESKTOP_SESSION_PROXY_H_