Use webrtc::DesktopCapturer for screen capturer implementation.

remoting/host/desktop_session_proxy.cc

 // 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.
 
 #include "remoting/host/desktop_session_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/process_util.h"
+#include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_macros.h"
-#include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/ipc_audio_capturer.h"
 #include "remoting/host/ipc_input_injector.h"
 #include "remoting/host/ipc_screen_controls.h"
 #include "remoting/host/ipc_video_frame_capturer.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif  // defined(OS_WIN)
 
+const bool kReadOnly = true;
 const char kSendInitialResolution[] = "sendInitialResolution";
 
 namespace remoting {
 
+class DesktopSessionProxy::IpcSharedBufferCore
+    : public base::RefCountedThreadSafe<IpcSharedBufferCore> {
+ public:
+  IpcSharedBufferCore(int id,
+                      base::SharedMemoryHandle handle,
+                      size_t size)
+      : id_(id),
+        shared_memory_(handle, kReadOnly),
+        size_(size) {
+    shared_memory_.Map(size);
+  }
+
+  IpcSharedBufferCore(int id,
+                      base::SharedMemoryHandle handle,
+                      base::ProcessHandle process,
+                      size_t size)
+      : id_(id),
+        shared_memory_(handle, kReadOnly, process),
+        size_(size) {
+    shared_memory_.Map(size);
+  }
+
+  int id() { return id_; }
+  size_t size() { return size_; }
+  void* memory() { return shared_memory_.memory(); }
+  webrtc::SharedMemory::Handle handle() {
+#if defined(OS_WIN)
+    return shared_memory_.handle();
+#else
+    return shared_memory_.handle().fd;
+#endif
+  }
+
+
+ private:
+  virtual ~IpcSharedBufferCore() {}
+  friend class base::RefCountedThreadSafe<IpcSharedBufferCore>;
+
+  int id_;
+  base::SharedMemory shared_memory_;
+  size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(IpcSharedBufferCore);
+};
+
+class DesktopSessionProxy::IpcSharedBuffer : public webrtc::SharedMemory {

[alexeypa (please no reviews), 2013/04/26 21:33:58]

nit: I think it is OK to use the ref-counted class directly here. Its scope is
limited to this .cc file. I.e. it is an implementation detail, not a public
interface.

[Sergey Ulanov, 2013/05/07 22:25:50]

Not sure I understand what you are suggesting here. We need webrtc::SharedMemory
implementation that we can pass to SharedMemoryDesktopFrame, which takes
ownership of the SharedMemory. Alternatively I could create a custom
DesktopFrame that would hold reference to IpcSharedBufferCore, but it would be a
bit more code as I wouldn't be able to reuse SharedMemoryDesktopFrame.

[alexeypa (please no reviews), 2013/05/08 22:24:59]

Nevermind. I did't understand how that code worked.

+ public:
+  IpcSharedBuffer(scoped_refptr<IpcSharedBufferCore> core)
+      : SharedMemory(core->memory(), core->size(),
+                     core->handle(), core->id()),
+        core_(core) {
+  }
+
+ private:
+  scoped_refptr<IpcSharedBufferCore> core_;
+
+  DISALLOW_COPY_AND_ASSIGN(IpcSharedBuffer);
+};
+
 DesktopSessionProxy::DesktopSessionProxy(
     scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control,
     base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
     bool virtual_terminal)
     : audio_capture_task_runner_(audio_capture_task_runner),
       caller_task_runner_(caller_task_runner),
@@ skipping 160 matching lines @@
   if (desktop_process_ != base::kNullProcessHandle) {
     base::CloseProcessHandle(desktop_process_);
     desktop_process_ = base::kNullProcessHandle;
   }
 
   shared_buffers_.clear();
 
   // Generate fake responses to keep the video capturer in sync.
   while (pending_capture_frame_requests_) {
     --pending_capture_frame_requests_;
-    PostCaptureCompleted(scoped_refptr<media::ScreenCaptureData>());
+    PostCaptureCompleted(scoped_ptr<webrtc::DesktopFrame>());
   }
 }
 
 void DesktopSessionProxy::SetAudioCapturer(
     const base::WeakPtr<IpcAudioCapturer>& audio_capturer) {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_ = audio_capturer;
 }
 
 void DesktopSessionProxy::CaptureFrame() {
   if (!caller_task_runner_->BelongsToCurrentThread()) {
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionProxy::CaptureFrame, this));
     return;
   }
 
   if (desktop_channel_) {
     ++pending_capture_frame_requests_;
     SendToDesktop(new ChromotingNetworkDesktopMsg_CaptureFrame());
   } else {
-    PostCaptureCompleted(scoped_refptr<media::ScreenCaptureData>());
+    PostCaptureCompleted(scoped_ptr<webrtc::DesktopFrame>());
   }
 }
 
 void DesktopSessionProxy::SetVideoCapturer(
     const base::WeakPtr<IpcVideoFrameCapturer> video_capturer) {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
   video_capturer_ = video_capturer;
 }
 
@@ skipping 49 matching lines @@
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   client_clipboard_ = client_clipboard.Pass();
 }
 
 void DesktopSessionProxy::SetScreenResolution(
     const ScreenResolution& resolution) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  if (!resolution.IsValid())
+  if (!resolution.IsEmpty())
     return;
 
   screen_resolution_ = resolution;
 
   // Connect to the desktop session if it is not done yet.
   if (!is_desktop_session_connected_) {
     is_desktop_session_connected_ = true;
     if (desktop_session_connector_) {
       desktop_session_connector_->ConnectTerminal(this, screen_resolution_,
                                                   virtual_terminal_);
@@ skipping 16 matching lines @@
 
   if (desktop_session_connector_ && is_desktop_session_connected_)
     desktop_session_connector_->DisconnectTerminal(this);
 
   if (desktop_process_ != base::kNullProcessHandle) {
     base::CloseProcessHandle(desktop_process_);
     desktop_process_ = base::kNullProcessHandle;
   }
 }
 
-scoped_refptr<media::SharedBuffer> DesktopSessionProxy::GetSharedBuffer(
-    int id) {
+scoped_refptr<DesktopSessionProxy::IpcSharedBufferCore>
+DesktopSessionProxy::GetSharedBufferCore(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   SharedBuffers::const_iterator i = shared_buffers_.find(id);
   if (i != shared_buffers_.end()) {
     return i->second;
   } else {
     LOG(ERROR) << "Failed to find the shared buffer " << id;
-    return scoped_refptr<media::SharedBuffer>();
+    return NULL;
   }
 }
 
 void DesktopSessionProxy::OnAudioPacket(const std::string& serialized_packet) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Parse a serialized audio packet. No further validation is done since
   // the message was sent by more privileged process.
   scoped_ptr<AudioPacket> packet(new AudioPacket());
   if (!packet->ParseFromString(serialized_packet)) {
     LOG(ERROR) << "Failed to parse AudioPacket.";
     return;
   }
 
   // Pass a captured audio packet to |audio_capturer_|.
   audio_capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&IpcAudioCapturer::OnAudioPacket, audio_capturer_,
                             base::Passed(&packet)));
 }
 
 void DesktopSessionProxy::OnCreateSharedBuffer(
     int id,
     IPC::PlatformFileForTransit handle,
     uint32 size) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  scoped_refptr<media::SharedBuffer> shared_buffer;
+  scoped_refptr<IpcSharedBufferCore> shared_buffer;
 
 #if defined(OS_WIN)
-  shared_buffer = new media::SharedBuffer(id, handle, desktop_process_, size);
+  shared_buffer = new IpcSharedBufferCore(id, handle, desktop_process_, size);
 #elif defined(OS_POSIX)
-  shared_buffer = new media::SharedBuffer(id, handle, size);
+  shared_buffer = new IpcSharedBufferCore(id, handle, size);
 #else
 #error Unsupported platform.
 #endif
 
   // Check if the buffer has been successfully mapped.
-  bool mapped = shared_buffer->ptr() != NULL;
+  bool mapped = shared_buffer->memory() != NULL;
   if (!mapped) {
 #if defined(OS_WIN)
     LOG(ERROR) << "Failed to map a shared buffer: id=" << id
                << ", handle=" << handle
                << ", size=" << size;
 #elif defined(OS_POSIX)
     LOG(ERROR) << "Failed to map a shared buffer: id=" << id
                << ", handle.fd=" << handle.fd
                << ", size=" << size;
 #endif
   }
 
   if (mapped &&
       !shared_buffers_.insert(std::make_pair(id, shared_buffer)).second) {
     LOG(ERROR) << "Duplicate shared buffer id " << id << " encountered";
   }
-
-  // Notify the desktop process that the buffer has been seen and can now be
-  // safely deleted if needed.
-  SendToDesktop(new ChromotingNetworkDesktopMsg_SharedBufferCreated(id));
 }
 
 void DesktopSessionProxy::OnReleaseSharedBuffer(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Drop the cached reference to the buffer.
   shared_buffers_.erase(id);
 }
 
 void DesktopSessionProxy::OnCaptureCompleted(
-    const SerializedCapturedData& serialized_data) {
+    const SerializedDesktopFrame& serialized_frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  // Assume that |serialized_data| is well formed because it was received from
+  // Assume that |serialized_frame| is well formed because it was received from

[alexeypa (please no reviews), 2013/04/26 21:33:58]

nit: well-formed

[Sergey Ulanov, 2013/05/07 22:25:50]

Done.

   // a more privileged process.
-  scoped_refptr<media::ScreenCaptureData> capture_data;
-  scoped_refptr<media::SharedBuffer> shared_buffer =
-      GetSharedBuffer(serialized_data.shared_buffer_id);
-  CHECK(shared_buffer);
+  scoped_refptr<IpcSharedBufferCore> shared_buffer_core =
+      GetSharedBufferCore(serialized_frame.shared_buffer_id);
+  CHECK(shared_buffer_core);
 
-  capture_data = new media::ScreenCaptureData(
-      reinterpret_cast<uint8*>(shared_buffer->ptr()),
-      serialized_data.bytes_per_row,
-      serialized_data.dimensions);
-  capture_data->set_capture_time_ms(serialized_data.capture_time_ms);
-  capture_data->set_client_sequence_number(
-      serialized_data.client_sequence_number);
-  capture_data->set_dpi(serialized_data.dpi);
-  capture_data->set_shared_buffer(shared_buffer);
+  scoped_ptr<webrtc::DesktopFrame> frame(
+      new webrtc::SharedMemoryDesktopFrame(
+          serialized_frame.dimensions, serialized_frame.bytes_per_row,
+          new IpcSharedBuffer(shared_buffer_core)));
+  frame->set_capture_time_ms(serialized_frame.capture_time_ms);
+  frame->set_dpi(serialized_frame.dpi);
 
-  if (!serialized_data.dirty_region.empty()) {
-    capture_data->mutable_dirty_region().setRects(
-        &serialized_data.dirty_region[0],
-        serialized_data.dirty_region.size());
+  for (size_t i = 0; i < serialized_frame.dirty_region.size(); ++i) {
+    frame->mutable_updated_region()->AddRect(serialized_frame.dirty_region[i]);
   }
 
   --pending_capture_frame_requests_;
-  PostCaptureCompleted(capture_data);
+  PostCaptureCompleted(frame.Pass());
 }
 
 void DesktopSessionProxy::OnCursorShapeChanged(
     const media::MouseCursorShape& cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   PostCursorShape(scoped_ptr<media::MouseCursorShape>(
       new media::MouseCursorShape(cursor_shape)));
 }
 
 void DesktopSessionProxy::OnInjectClipboardEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (client_clipboard_) {
     protocol::ClipboardEvent event;
     if (!event.ParseFromString(serialized_event)) {
       LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
       return;
     }
 
     client_clipboard_->InjectClipboardEvent(event);
   }
 }
 
 void DesktopSessionProxy::PostCaptureCompleted(
-    scoped_refptr<media::ScreenCaptureData> capture_data) {
+    scoped_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IpcVideoFrameCapturer::OnCaptureCompleted, video_capturer_,
-                 capture_data));
+                 base::Passed(&frame)));
 }
 
 void DesktopSessionProxy::PostCursorShape(
     scoped_ptr<media::MouseCursorShape> cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IpcVideoFrameCapturer::OnCursorShapeChanged, video_capturer_,
                  base::Passed(&cursor_shape)));
@@ skipping 10 matching lines @@
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting