Move screen capturers from remoting/capturer to media/video/capturer/screen

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/single_thread_task_runner.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_macros.h"
-#include "remoting/capturer/capture_data.h"
+#include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/ipc_audio_capturer.h"
 #include "remoting/host/ipc_event_executor.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"
 
@@ skipping 28 matching lines @@
 }
 
 scoped_ptr<EventExecutor> DesktopSessionProxy::CreateEventExecutor(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return scoped_ptr<EventExecutor>(new IpcEventExecutor(this));
 }
 
-scoped_ptr<VideoFrameCapturer> DesktopSessionProxy::CreateVideoCapturer(
+scoped_ptr<media::ScreenCapturer> DesktopSessionProxy::CreateVideoCapturer(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!video_capture_task_runner_.get());
 
   video_capture_task_runner_ = capture_task_runner;
-  return scoped_ptr<VideoFrameCapturer>(new IpcVideoFrameCapturer(this));
+  return scoped_ptr<media::ScreenCapturer>(new IpcVideoFrameCapturer(this));
 }
 
 bool DesktopSessionProxy::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DesktopSessionProxy, message)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_AudioPacket,
                         OnAudioPacket)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CaptureCompleted,
@@ skipping 82 matching lines @@
 
 #if defined(OS_WIN)
   desktop_process_.Close();
 #endif  // defined(OS_WIN)
 
   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<CaptureData>());
+    PostCaptureCompleted(scoped_refptr<media::ScreenCaptureData>());
   }
 }
 
 void DesktopSessionProxy::StartAudioCapturer(IpcAudioCapturer* audio_capturer) {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
   DCHECK(audio_capturer_ == NULL);
 
   audio_capturer_ = audio_capturer;
 }
 
@@ skipping 94 matching lines @@
 void DesktopSessionProxy::StartEventExecutor(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   client_clipboard_ = client_clipboard.Pass();
 }
 
 DesktopSessionProxy::~DesktopSessionProxy() {
 }
 
-scoped_refptr<SharedBuffer> DesktopSessionProxy::GetSharedBuffer(int id) {
+scoped_refptr<media::SharedBuffer> DesktopSessionProxy::GetSharedBuffer(
+    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<SharedBuffer>();
+    return scoped_refptr<media::SharedBuffer>();
   }
 }
 
 void DesktopSessionProxy::OnAudioPacket(const std::string& serialized_packet) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Parse the serialized audio packet. No further validation is done since
   // the message was send by more privileged process.
   scoped_ptr<AudioPacket> packet(new AudioPacket());
   if (!packet->ParseFromString(serialized_packet)) {
     LOG(ERROR) << "Failed to parse AudioPacket.";
     return;
   }
 
   PostAudioPacket(packet.Pass());
 }
 
 void DesktopSessionProxy::OnCreateSharedBuffer(
     int id,
     IPC::PlatformFileForTransit handle,
     uint32 size) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  scoped_refptr<SharedBuffer> shared_buffer;
+  scoped_refptr<media::SharedBuffer> shared_buffer;
 
 #if defined(OS_WIN)
-  shared_buffer = new SharedBuffer(id, handle, desktop_process_, size);
+  shared_buffer = new media::SharedBuffer(id, handle, desktop_process_, size);
 #elif defined(OS_POSIX)
-  shared_buffer = new SharedBuffer(id, handle, size);
+  shared_buffer = new media::SharedBuffer(id, handle, size);
 #else
 #error Unsupported platform.
 #endif
 
   // Check if the buffer has been successfully mapped.
   bool mapped = shared_buffer->ptr() != NULL;
   if (!mapped) {
 #if defined(OS_WIN)
     LOG(ERROR) << "Failed to map a shared buffer: id=" << id
                << ", handle=" << handle
@@ skipping 21 matching lines @@
   // Drop the cached reference to the buffer.
   shared_buffers_.erase(id);
 }
 
 void DesktopSessionProxy::OnCaptureCompleted(
     const SerializedCapturedData& serialized_data) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Assume that |serialized_data| is well formed because it was received from
   // a more privileged process.
-  scoped_refptr<CaptureData> capture_data;
-  scoped_refptr<SharedBuffer> shared_buffer =
+  scoped_refptr<media::ScreenCaptureData> capture_data;
+  scoped_refptr<media::SharedBuffer> shared_buffer =
       GetSharedBuffer(serialized_data.shared_buffer_id);
   CHECK(shared_buffer);
 
-  capture_data = new CaptureData(reinterpret_cast<uint8*>(shared_buffer->ptr()),
-                                 serialized_data.bytes_per_row,
-                                 serialized_data.dimensions);
+  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);
 
   if (!serialized_data.dirty_region.empty()) {
     capture_data->mutable_dirty_region().setRects(
         &serialized_data.dirty_region[0],
         serialized_data.dirty_region.size());
   }
 
   --pending_capture_frame_requests_;
   PostCaptureCompleted(capture_data);
 }
 
 void DesktopSessionProxy::OnCursorShapeChanged(
-    const MouseCursorShape& cursor_shape) {
+    const media::MouseCursorShape& cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  PostCursorShape(
-      scoped_ptr<MouseCursorShape>(new MouseCursorShape(cursor_shape)));
+  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.";
@@ skipping 10 matching lines @@
         FROM_HERE, base::Bind(&DesktopSessionProxy::PostAudioPacket,
                               this, base::Passed(&packet)));
     return;
   }
 
   if (audio_capturer_)
     audio_capturer_->OnAudioPacket(packet.Pass());
 }
 
 void DesktopSessionProxy::PostCaptureCompleted(
-    scoped_refptr<CaptureData> capture_data) {
+    scoped_refptr<media::ScreenCaptureData> capture_data) {
   if (!video_capture_task_runner_->BelongsToCurrentThread()) {
     video_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionProxy::PostCaptureCompleted,
                               this, capture_data));
     return;
   }
 
   if (video_capturer_)
     video_capturer_->OnCaptureCompleted(capture_data);
 }
 
 void DesktopSessionProxy::PostCursorShape(
-    scoped_ptr<MouseCursorShape> cursor_shape) {
+    scoped_ptr<media::MouseCursorShape> cursor_shape) {
   if (!video_capture_task_runner_->BelongsToCurrentThread()) {
     video_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionProxy::PostCursorShape,
                               this, base::Passed(&cursor_shape)));
     return;
   }
 
   if (video_capturer_)
     video_capturer_->OnCursorShapeChanged(cursor_shape.Pass());
 }
 
 void DesktopSessionProxy::SendToDesktop(IPC::Message* message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     desktop_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 }  // namespace remoting