Use webrtc::DesktopCapturer for screen capturer implementation.

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"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/video/capture/screen/screen_capturer.h"
-#include "media/video/capture/screen/shared_buffer.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace IPC {
 class ChannelProxy;
 class Message;
 }  // namespace IPC
 
-struct SerializedCapturedData;
+struct SerializedDesktopFrame;
 
 namespace remoting {
 
 class AudioPacket;
 class ClientSession;
 class ClientSessionControl;
 class DesktopSessionConnector;
 struct DesktopSessionProxyTraits;
 class IpcAudioCapturer;
 class IpcVideoFrameCapturer;
@@ skipping 70 matching lines @@
   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:
   friend class base::DeleteHelper<DesktopSessionProxy>;
   friend struct DesktopSessionProxyTraits;
+
+  class IpcSharedBufferCore;
+  class IpcSharedBuffer;
+  typedef std::map<int, scoped_refptr<IpcSharedBufferCore> > SharedBuffers;
+
   virtual ~DesktopSessionProxy();
 
   // Returns a shared buffer from the list of known buffers.
-  scoped_refptr<media::SharedBuffer> GetSharedBuffer(int id);
+  scoped_refptr<IpcSharedBufferCore> GetSharedBufferCore(int id);
 
   // Handles AudioPacket notification from the desktop session agent.
   void OnAudioPacket(const std::string& serialized_packet);
 
   // Registers a new shared buffer created by the desktop process.
   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 SerializedCapturedData& serialized_data);
+  void OnCaptureCompleted(const SerializedDesktopFrame& serialized_frame);
 
   // Handles CursorShapeChanged notification from the desktop session agent.
   void OnCursorShapeChanged(const media::MouseCursorShape& cursor_shape);
 
   // 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 |capture_data|.
-  void PostCaptureCompleted(
-      scoped_refptr<media::ScreenCaptureData> capture_data);
+  // 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<media::MouseCursorShape> cursor_shape);
 
   // 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:
@@ skipping 24 matching lines @@
   base::WeakPtr<IpcVideoFrameCapturer> video_capturer_;
 
   // 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_;
 
-  typedef std::map<int, scoped_refptr<media::SharedBuffer> > SharedBuffers;
+  // Shared memory buffers by Id. Each buffer is owned by the corresponding
+  // frame.
   SharedBuffers shared_buffers_;
 
   // Keeps the desired screen resolution so it can be passed to a newly attached
   // desktop session agent.
   ScreenResolution screen_resolution_;
 
   // True if |this| has been connected to the desktop session.
   bool is_desktop_session_connected_;
 
   bool virtual_terminal_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopSessionProxy);
 };
 
 // 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_