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