Remove screen capturers from media/video/capture/screen.

media/video/capture/screen/screen_capture_device.cc

 // Copyright (c) 2013 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 "media/video/capture/screen/screen_capture_device.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/synchronization/lock.h"
-#include "media/video/capture/screen/mouse_cursor_shape.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/mouse_cursor_shape.h"
+#include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 namespace media {
 
 namespace {
 const int kBytesPerPixel = 4;
 }  // namespace
 
 class ScreenCaptureDevice::Core
     : public base::RefCountedThreadSafe<Core>,
       public webrtc::DesktopCapturer::Callback {
  public:
   explicit Core(scoped_refptr<base::SequencedTaskRunner> task_runner);
 
   // Helper used in tests to supply a fake capturer.
-  void SetScreenCapturerForTest(scoped_ptr<ScreenCapturer> capturer) {
+  void SetScreenCapturerForTest(scoped_ptr<webrtc::ScreenCapturer> capturer) {
     screen_capturer_ = capturer.Pass();
   }
 
   // Implementation of VideoCaptureDevice methods.
   void Allocate(int width, int height,
                 int frame_rate,
                 EventHandler* event_handler);
   void Start();
   void Stop();
   void DeAllocate();
@@ skipping 29 matching lines @@
   // |event_handler_lock_| must be locked whenever |event_handler_| is used.
   // It's necessary because DeAllocate() needs to reset it on the calling thread
   // to ensure that the event handler is not called once DeAllocate() returns.
   base::Lock event_handler_lock_;
   EventHandler* event_handler_;
 
   // Frame rate specified to Allocate().
   int frame_rate_;
 
   // The underlying ScreenCapturer instance used to capture frames.
-  scoped_ptr<ScreenCapturer> screen_capturer_;
+  scoped_ptr<webrtc::ScreenCapturer> screen_capturer_;
 
   // After Allocate() is called we need to call OnFrameInfo() method of the
   // |event_handler_| to specify the size of the frames this capturer will
   // produce. In order to get screen size from |screen_capturer_| we need to
   // capture at least one frame. Once screen size is known it's stored in
   // |frame_size_|.
   bool waiting_for_frame_size_;
   webrtc::DesktopSize frame_size_;
   SkBitmap resized_bitmap_;
 
@@ skipping 175 matching lines @@
         base::Time::Now(), 0, false, false);
   }
 }
 
 void ScreenCaptureDevice::Core::DoAllocate(int frame_rate) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   frame_rate_ = frame_rate;
 
   // Create and start frame capturer.
+  if (!screen_capturer_) {
 #if defined(OS_CHROMEOS) && !defined(ARCH_CPU_ARMEL)
-  // ScreenCapturerX11 polls by default, due to poor driver support for DAMAGE.
-  // ChromeOS' drivers [can be patched to] support DAMAGE properly, so use it.
-  // However ARM driver seems to not support this properly, so disable it for
-  // ARM. See http://crbug.com/230105.
-  if (!screen_capturer_)
-    screen_capturer_ = ScreenCapturer::CreateWithXDamage(true);
+    // ScreenCapturerX11 polls by default, due to poor driver support for
+    // DAMAGE. ChromeOS' drivers [can be patched to] support DAMAGE properly, so
+    // use it. However ARM driver seems to not support this properly, so disable
+    // it for ARM. See http://crbug.com/230105.
+    screen_capturer_.reset(webrtc::ScreenCapturer::CreateWithXDamage(true));
 #elif defined(OS_WIN)
-  // ScreenCapturerWin disables Aero by default. We don't want it disabled for
-  // WebRTC screen capture, though.
-  if (!screen_capturer_)
-    screen_capturer_ = ScreenCapturer::CreateWithDisableAero(false);
+    // ScreenCapturerWin disables Aero by default. We don't want it disabled for
+    // WebRTC screen capture, though.
+    screen_capturer_.reset(
+        webrtc::ScreenCapturer::CreateWithDisableAero(false));
 #else
-  if (!screen_capturer_)
-    screen_capturer_ = ScreenCapturer::Create();
+    screen_capturer_.reset(webrtc::ScreenCapturer::Create());
 #endif
+  }
+
   if (screen_capturer_)
     screen_capturer_->Start(this);
 
   // Capture first frame, so that we can call OnFrameInfo() callback.
   waiting_for_frame_size_ = true;
   DoCapture();
 }
 
 void ScreenCaptureDevice::Core::DoStart() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
@@ skipping 53 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : core_(new Core(task_runner)) {
   name_.device_name = "Screen";
 }
 
 ScreenCaptureDevice::~ScreenCaptureDevice() {
   DeAllocate();
 }
 
 void ScreenCaptureDevice::SetScreenCapturerForTest(
-  scoped_ptr<ScreenCapturer> capturer) {
+  scoped_ptr<webrtc::ScreenCapturer> capturer) {
   core_->SetScreenCapturerForTest(capturer.Pass());
 }
 
 void ScreenCaptureDevice::Allocate(int width, int height,
                               int frame_rate,
                               EventHandler* event_handler) {
   core_->Allocate(width, height, frame_rate, event_handler);
 }
 
 void ScreenCaptureDevice::Start() {
   core_->Start();
 }
 
 void ScreenCaptureDevice::Stop() {
   core_->Stop();
 }
 
 void ScreenCaptureDevice::DeAllocate() {
   core_->DeAllocate();
 }
 
 const VideoCaptureDevice::Name& ScreenCaptureDevice::device_name() {
   return name_;
 }
 
 }  // namespace media