Use webrtc::MouseCursorMonitor for cursor shapes

remoting/host/desktop_session_proxy.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 #define REMOTING_HOST_DESKTOP_SESSION_PROXY_H_
 
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 14 matching lines @@
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace IPC {
 class ChannelProxy;
 class Message;
 }  // namespace IPC
 
+namespace webrtc {
+class MouseCursor;
+}  // namespace webrtc
+
 struct SerializedDesktopFrame;
+struct SerializedMouseCursor;
 
 namespace remoting {
 
 class AudioPacket;
 class ClientSession;
 class ClientSessionControl;
 class DesktopSessionConnector;
 struct DesktopSessionProxyTraits;
 class IpcAudioCapturer;
+class IpcMouseCursorMonitor;
 class IpcVideoFrameCapturer;
 class ScreenControls;
 
 // DesktopSessionProxy is created by an owning DesktopEnvironment to route
 // requests from stubs to the DesktopSessionAgent instance through
 // the IPC channel. DesktopSessionProxy is owned both by the DesktopEnvironment
 // and the stubs, since stubs can out-live their DesktopEnvironment.
 //
 // DesktopSessionProxy objects are ref-counted but are always deleted on
 // the |caller_tast_runner_| thread. This makes it possible to continue
@@ skipping 16 matching lines @@
       scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control,
       base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
       bool virtual_terminal);
 
   // Mirrors DesktopEnvironment.
   scoped_ptr<AudioCapturer> CreateAudioCapturer();
   scoped_ptr<InputInjector> CreateInputInjector();
   scoped_ptr<ScreenControls> CreateScreenControls();
   scoped_ptr<webrtc::ScreenCapturer> CreateVideoCapturer();
+  scoped_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor();
   std::string GetCapabilities() const;
   void SetCapabilities(const std::string& capabilities);
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
   // Connects to the desktop session agent.
   bool AttachToDesktop(base::ProcessHandle desktop_process,
@@ skipping 13 matching lines @@
   // APIs used to implement the webrtc::ScreenCapturer interface. These must be
   // called on the |video_capture_task_runner_| thread.
   void InvalidateRegion(const SkRegion& invalid_region);
   void CaptureFrame();
 
   // Stores |video_capturer| to be used to post captured video frames. Called on
   // the |video_capture_task_runner_| thread.
   void SetVideoCapturer(
       const base::WeakPtr<IpcVideoFrameCapturer> video_capturer);
 
+  // Stores |mouse_cursor_monitor| to be used to post mouse cursor changes.
+  // Called on the |video_capture_task_runner_| thread.
+  void SetMouseCursorMonitor(
+      const base::WeakPtr<IpcMouseCursorMonitor>& mouse_cursor_monitor);
+
   // APIs used to implement the InputInjector interface.
   void InjectClipboardEvent(const protocol::ClipboardEvent& event);
   void InjectKeyEvent(const protocol::KeyEvent& event);
   void InjectMouseEvent(const protocol::MouseEvent& event);
   void StartInputInjector(scoped_ptr<protocol::ClipboardStub> client_clipboard);
 
   // API used to implement the SessionController interface.
   void SetScreenResolution(const ScreenResolution& resolution);
 
  private:
@@ skipping 16 matching lines @@
   void OnCreateSharedBuffer(int id,
                             IPC::PlatformFileForTransit handle,
                             uint32 size);
 
   // Drops a cached reference to the shared buffer.
   void OnReleaseSharedBuffer(int id);
 
   // Handles CaptureCompleted notification from the desktop session agent.
   void OnCaptureCompleted(const SerializedDesktopFrame& serialized_frame);
 
-  // Handles CursorShapeChanged notification from the desktop session agent.
-  void OnCursorShapeChanged(const webrtc::MouseCursorShape& cursor_shape);
+  // Handles MouseCursor notification from the desktop session agent.
+  void OnMouseCursor(const SerializedMouseCursor& mouse_cursor);
 
   // Handles InjectClipboardEvent request from the desktop integration process.
   void OnInjectClipboardEvent(const std::string& serialized_event);
 
   // Posts OnCaptureCompleted() to |video_capturer_| on the video thread,
   // passing |frame|.
   void PostCaptureCompleted(scoped_ptr<webrtc::DesktopFrame> frame);
 
-  // Posts OnCursorShapeChanged() to |video_capturer_| on the video thread,
-  // passing |cursor_shape|.
-  void PostCursorShape(scoped_ptr<webrtc::MouseCursorShape> cursor_shape);
+  // Posts OnMouseCursor() to |mouse_cursor_monitor_| on the video thread,
+  // passing |mouse_cursor|.
+  void PostMouseCursor(scoped_ptr<webrtc::MouseCursor> mouse_cursor);
 
   // Sends a message to the desktop session agent. The message is silently
   // deleted if the channel is broken.
   void SendToDesktop(IPC::Message* message);
 
   // Task runners:
   //   - |audio_capturer_| is called back on |audio_capture_task_runner_|.
   //   - public methods of this class (with some exceptions) are called on
   //     |caller_task_runner_|.
   //   - background I/O is served on |io_task_runner_|.
@@ skipping 12 matching lines @@
   // Used to disconnect the client session.
   base::WeakPtr<ClientSessionControl> client_session_control_;
 
   // Used to create a desktop session and receive notifications every time
   // the desktop process is replaced.
   base::WeakPtr<DesktopSessionConnector> desktop_session_connector_;
 
   // Points to the video capturer receiving captured video frames.
   base::WeakPtr<IpcVideoFrameCapturer> video_capturer_;
 
+  // Points to the mouse cursor monitor receiving mouse cursor changes.
+  base::WeakPtr<IpcMouseCursorMonitor> mouse_cursor_monitor_;
+
   // IPC channel to the desktop session agent.
   scoped_ptr<IPC::ChannelProxy> desktop_channel_;
 
   // Handle of the desktop process.
   base::ProcessHandle desktop_process_;
 
   int pending_capture_frame_requests_;
 
   // Shared memory buffers by Id. Each buffer is owned by the corresponding
   // frame.
@@ skipping 12 matching lines @@
 };
 
 // Destroys |DesktopSessionProxy| instances on the caller's thread.
 struct DesktopSessionProxyTraits {
   static void Destruct(const DesktopSessionProxy* desktop_session_proxy);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DESKTOP_SESSION_PROXY_H_