Move screen capturers to remoting/capturer.

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/base/capture_data.h"
+#include "remoting/capturer/capture_data.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/ipc_video_frame_capturer.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif  // defined(OS_WIN)
 
@@ skipping 270 matching lines @@
   capture_data = new CaptureData(
       planes, serialized_data.dimensions,
       static_cast<media::VideoFrame::Format>(serialized_data.pixel_format));
   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());
+    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 std::string& serialized_cursor_shape) {
+    const MouseCursorShape& cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-
-  scoped_ptr<protocol::CursorShapeInfo> cursor_shape(
-      new protocol::CursorShapeInfo());
-  if (!cursor_shape->ParseFromString(serialized_cursor_shape)) {
-    LOG(ERROR) << "Failed to parse protocol::CursorShapeInfo.";
-    return;
-  }
-
-  PostCursorShape(cursor_shape.Pass());
+  PostCursorShape(cursor_shape);
 }
 
 void DesktopSessionProxy::OnInjectClipboardEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   protocol::ClipboardEvent event;
   if (!event.ParseFromString(serialized_event)) {
     LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
     return;
@@ skipping 10 matching lines @@
         FROM_HERE, base::Bind(&DesktopSessionProxy::PostCaptureCompleted,
                               this, capture_data));
     return;
   }
 
   if (video_capturer_)
     video_capturer_->OnCaptureCompleted(capture_data);
 }
 
 void DesktopSessionProxy::PostCursorShape(
-    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
+    const 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)));
+                              this, cursor_shape));
     return;
   }
 
   if (video_capturer_)
-    video_capturer_->OnCursorShapeChanged(cursor_shape.Pass());
+    video_capturer_->OnCursorShapeChanged(cursor_shape);
 }
 
 void DesktopSessionProxy::SendToDesktop(IPC::Message* message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     desktop_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 }  // namespace remoting