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