Remove screen capturers from media/video/capture/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/process_util.h"
@@ skipping 119 matching lines @@
 
   return scoped_ptr<InputInjector>(new IpcInputInjector(this));
 }
 
 scoped_ptr<ScreenControls> DesktopSessionProxy::CreateScreenControls() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return scoped_ptr<ScreenControls>(new IpcScreenControls(this));
 }
 
-scoped_ptr<media::ScreenCapturer> DesktopSessionProxy::CreateVideoCapturer() {
+scoped_ptr<webrtc::ScreenCapturer> DesktopSessionProxy::CreateVideoCapturer() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  return scoped_ptr<media::ScreenCapturer>(new IpcVideoFrameCapturer(this));
+  return scoped_ptr<webrtc::ScreenCapturer>(new IpcVideoFrameCapturer(this));
 }
 
 std::string DesktopSessionProxy::GetCapabilities() const {
   // Ask the client to send it's resolution unconditionally.
   return virtual_terminal_ ? kSendInitialResolution : std::string();
 }
 
 void DesktopSessionProxy::SetCapabilities(const std::string& capabilities) {
   // Delay creation of the desktop session until the client screen resolution is
   // received if the desktop session requires the initial screen resolution
@@ skipping 326 matching lines @@
 
   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(frame.Pass());
 }
 
 void DesktopSessionProxy::OnCursorShapeChanged(
-    const media::MouseCursorShape& cursor_shape) {
+    const webrtc::MouseCursorShape& cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  PostCursorShape(scoped_ptr<media::MouseCursorShape>(
-      new media::MouseCursorShape(cursor_shape)));
+  PostCursorShape(scoped_ptr<webrtc::MouseCursorShape>(
+      new webrtc::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_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IpcVideoFrameCapturer::OnCaptureCompleted, video_capturer_,
                  base::Passed(&frame)));
 }
 
 void DesktopSessionProxy::PostCursorShape(
-    scoped_ptr<media::MouseCursorShape> cursor_shape) {
+    scoped_ptr<webrtc::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)));
 }
 
 void DesktopSessionProxy::SendToDesktop(IPC::Message* message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     desktop_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting