Use webrtc::DesktopCapturer for screen capturer implementation.

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 "media/video/capture/screen/screen_capture_data.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"
 
 namespace media {
 
 namespace {
 const int kBytesPerPixel = 4;
 }  // namespace
 
 class ScreenCaptureDevice::Core
     : public base::RefCountedThreadSafe<Core>,
-      public ScreenCapturer::Delegate {
+      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) {
     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();
 
-  // ScreenCapturer::Delegate interface. Called by |screen_capturer_| on the
-  // |task_runner_|.
-  virtual void OnCaptureCompleted(
-      scoped_refptr<ScreenCaptureData> capture_data) OVERRIDE;
-  virtual void OnCursorShapeChanged(
-      scoped_ptr<MouseCursorShape> cursor_shape) OVERRIDE;
-
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
 
+  // webrtc::DesktopCapturer::Callback interface
+  virtual webrtc::SharedMemory* CreateSharedMemory(size_t size) OVERRIDE;
+  virtual void OnCaptureCompleted(webrtc::DesktopFrame* frame) OVERRIDE;
+
   // Helper methods that run on the |task_runner_|. Posted from the
   // corresponding public methods.
   void DoAllocate(int frame_rate);
   void DoStart();
   void DoStop();
   void DoDeAllocate();
 
   // Helper to schedule capture tasks.
   void ScheduleCaptureTimer();
 
@@ skipping 18 matching lines @@
 
   // The underlying ScreenCapturer instance used to capture frames.
   scoped_ptr<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_;
-  SkISize frame_size_;
+  webrtc::DesktopSize frame_size_;
   SkBitmap resized_bitmap_;
 
   // True between DoStart() and DoStop(). Can't just check |event_handler_|
   // because |event_handler_| is used on the caller thread.
   bool started_;
 
   // True when we have delayed OnCaptureTimer() task posted on
   // |task_runner_|.
   bool capture_task_posted_;
 
@@ skipping 43 matching lines @@
 }
 
 void ScreenCaptureDevice::Core::DeAllocate() {
   {
     base::AutoLock auto_lock(event_handler_lock_);
     event_handler_ = NULL;
   }
   task_runner_->PostTask(FROM_HERE, base::Bind(&Core::DoDeAllocate, this));
 }
 
+webrtc::SharedMemory*
+ScreenCaptureDevice::Core::CreateSharedMemory(size_t size) {
+  return NULL;
+}
+
 void ScreenCaptureDevice::Core::OnCaptureCompleted(
-    scoped_refptr<ScreenCaptureData> capture_data) {
+    webrtc::DesktopFrame* frame) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(capture_in_progress_);
-  DCHECK(!capture_data->size().isEmpty());
 
   capture_in_progress_ = false;
 
+  if (!frame) {
+    LOG(ERROR) << "Failed to capture a frame.";
+    event_handler_->OnError();
+    return;
+  }
+
+  scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
+
   if (waiting_for_frame_size_) {
-    frame_size_ = capture_data->size();
+    frame_size_ = frame->size();
     waiting_for_frame_size_ = false;
 
     // Inform the EventHandler of the video frame dimensions and format.
     VideoCaptureCapability caps;
     caps.width = frame_size_.width();
     caps.height = frame_size_.height();
     caps.frame_rate = frame_rate_;
     caps.color = VideoCaptureCapability::kARGB;
     caps.expected_capture_delay =
         base::Time::kMillisecondsPerSecond / frame_rate_;
     caps.interlaced = false;
 
     base::AutoLock auto_lock(event_handler_lock_);
     if (event_handler_)
       event_handler_->OnFrameInfo(caps);
   }
 
   if (!started_)
     return;
 
   size_t buffer_size = frame_size_.width() * frame_size_.height() *
-      ScreenCaptureData::kBytesPerPixel;
+      webrtc::DesktopFrame::kBytesPerPixel;
 
-  if (capture_data->size() == frame_size_) {
+  if (frame->size().equals(frame_size_)) {
     // If the captured frame matches the requested size, we don't need to
     // resize it.
     resized_bitmap_.reset();
 
     base::AutoLock auto_lock(event_handler_lock_);
     if (event_handler_) {
       event_handler_->OnIncomingCapturedFrame(
-          capture_data->data(), buffer_size, base::Time::Now(),
-          0, false, false);
+          frame->data(), buffer_size, base::Time::Now(), 0, false, false);
     }
     return;
   }
 
   // In case screen size has changed we need to resize the image. Resized image
   // is stored to |resized_bitmap_|. Only regions of the screen that are
   // changing are copied.
 
-  SkRegion dirty_region = capture_data->dirty_region();
+  webrtc::DesktopRegion dirty_region = frame->updated_region();
 
   if (resized_bitmap_.width() != frame_size_.width() ||
       resized_bitmap_.height() != frame_size_.height()) {
     resized_bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
                               frame_size_.width(), frame_size_.height());
     resized_bitmap_.setIsOpaque(true);
     resized_bitmap_.allocPixels();
-    dirty_region.setRect(SkIRect::MakeSize(frame_size_));
+    dirty_region.SetRect(webrtc::DesktopRect::MakeSize(frame_size_));
   }
 
   float scale_x = static_cast<float>(frame_size_.width()) /
-      capture_data->size().width();
+      frame->size().width();
   float scale_y = static_cast<float>(frame_size_.height()) /
-      capture_data->size().height();
+      frame->size().height();
   float scale;
   float x, y;
   // Center the image in case aspect ratio is different.
   if (scale_x > scale_y) {
     scale = scale_y;
     x = (scale_x - scale_y) / scale * frame_size_.width() / 2.0;
     y = 0.f;
   } else {
     scale = scale_x;
     x = 0.f;
     y = (scale_y - scale_x) / scale * frame_size_.height() / 2.0;
   }
 
   // Create skia device and canvas that draw to |resized_bitmap_|.
   SkDevice device(resized_bitmap_);
   SkCanvas canvas(&device);
   canvas.scale(scale, scale);
 
-  int source_stride = capture_data->stride();
-  for (SkRegion::Iterator i(dirty_region); !i.done(); i.next()) {
+  int source_stride = frame->stride();
+  for (webrtc::DesktopRegion::Iterator i(dirty_region); !i.IsAtEnd();
+       i.Advance()) {
     SkBitmap source_bitmap;
     source_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                             i.rect().width(), i.rect().height(),
                             source_stride);
     source_bitmap.setIsOpaque(true);
     source_bitmap.setPixels(
-        capture_data->data() + i.rect().top() * source_stride +
-        i.rect().left() * ScreenCaptureData::kBytesPerPixel);
+        frame->data() + i.rect().top() * source_stride +
+        i.rect().left() * webrtc::DesktopFrame::kBytesPerPixel);
     canvas.drawBitmap(source_bitmap, i.rect().left() + x / scale,
                       i.rect().top() + y / scale, NULL);
   }
 
   base::AutoLock auto_lock(event_handler_lock_);
   if (event_handler_) {
     event_handler_->OnIncomingCapturedFrame(
         reinterpret_cast<uint8*>(resized_bitmap_.getPixels()), buffer_size,
         base::Time::Now(), 0, false, false);
   }
 }
 
-void ScreenCaptureDevice::Core::OnCursorShapeChanged(
-    scoped_ptr<MouseCursorShape> cursor_shape) {
-  // TODO(sergeyu): Store mouse cursor shape and then render it to each captured
-  // frame. crbug.com/173265 .
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
-}
-
 void ScreenCaptureDevice::Core::DoAllocate(int frame_rate) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   frame_rate_ = frame_rate;
 
   // Create and start frame 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
@@ skipping 53 matching lines @@
 
   if (!started_)
     return;
 
   // Schedule a task for the next frame.
   ScheduleCaptureTimer();
   DoCapture();
 }
 
 void ScreenCaptureDevice::Core::DoCapture() {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!capture_in_progress_);
 
   capture_in_progress_ = true;
-  screen_capturer_->CaptureFrame();
+  screen_capturer_->Capture(webrtc::DesktopRegion());
 
-  // Assume that ScreenCapturer always calls OnCaptureCompleted()
-  // callback before it returns.
-  //
-  // TODO(sergeyu): Fix ScreenCapturer to return video frame
-  // synchronously instead of using Delegate interface.
+  // Currently only synchronous implementations of DesktopCapturer are
+  // supported.
   DCHECK(!capture_in_progress_);
 }
 
 ScreenCaptureDevice::ScreenCaptureDevice(
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : core_(new Core(task_runner)) {
   name_.device_name = "Screen";
 }
 
 ScreenCaptureDevice::~ScreenCaptureDevice() {
@@ skipping 21 matching lines @@
 
 void ScreenCaptureDevice::DeAllocate() {
   core_->DeAllocate();
 }
 
 const VideoCaptureDevice::Name& ScreenCaptureDevice::device_name() {
   return name_;
 }
 
 }  // namespace media