content: Split out VideoCaptureMachine from DesktopCaptureDeviceAura

content/browser/media/capture/aura_window_capture_machine.cc

 // Copyright 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 "content/browser/media/capture/desktop_capture_device_aura.h"
+#include "content/browser/media/capture/aura_window_capture_machine.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/media/capture/content_video_capture_device_core.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/common/gpu/client/gl_helper.h"
@@ skipping 66 matching lines @@
         int color_v = clip_byte(((color_r * 112 + color_g * -94 +
                                   color_b * -18 + 128) >> 8) + 128);
         uplane[x / 2] = alpha_blend(alpha, color_u, uplane[x / 2]);
         vplane[x / 2] = alpha_blend(alpha, color_v, vplane[x / 2]);
       }
     }
   }
   cursor_bitmap.unlockPixels();
 }
 
-class DesktopVideoCaptureMachine
-    : public VideoCaptureMachine,
-      public aura::WindowObserver,
-      public ui::CompositorObserver,
-      public base::SupportsWeakPtr<DesktopVideoCaptureMachine> {
- public:
-  DesktopVideoCaptureMachine(const DesktopMediaID& source);
-  ~DesktopVideoCaptureMachine() override;
+void CopyOutputFinishedForVideo(
+    base::TimeTicks start_time,
+    const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
+    const scoped_refptr<media::VideoFrame>& target,
+    const SkBitmap& cursor_bitmap,
+    const gfx::Point& cursor_position,
+    scoped_ptr<cc::SingleReleaseCallback> release_callback,
+    bool result) {
+  if (!cursor_bitmap.isNull())
+    RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position);
+  release_callback->Run(0, false);
+  capture_frame_cb.Run(target, start_time, result);
+}
 
-  // VideoCaptureFrameSource overrides.
-  bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
-             const media::VideoCaptureParams& params) override;
-  void Stop(const base::Closure& callback) override;
+void RunSingleReleaseCallback(scoped_ptr<cc::SingleReleaseCallback> cb,
+                              uint32 sync_point) {
+  cb->Run(sync_point, false);
+}
 
-  // Implements aura::WindowObserver.
-  void OnWindowBoundsChanged(aura::Window* window,
-                             const gfx::Rect& old_bounds,
-                             const gfx::Rect& new_bounds) override;
-  void OnWindowDestroyed(aura::Window* window) override;
-  void OnWindowAddedToRootWindow(aura::Window* window) override;
-  void OnWindowRemovingFromRootWindow(aura::Window* window,
-                                      aura::Window* new_root) override;
+}  // namespace
 
-  // Implements ui::CompositorObserver.
-  void OnCompositingDidCommit(ui::Compositor* compositor) override {}
-  void OnCompositingStarted(ui::Compositor* compositor,
-                            base::TimeTicks start_time) override {}
-  void OnCompositingEnded(ui::Compositor* compositor) override;
-  void OnCompositingAborted(ui::Compositor* compositor) override {}
-  void OnCompositingLockStateChanged(ui::Compositor* compositor) override {}
-  void OnCompositingShuttingDown(ui::Compositor* compositor) override {}
-
- private:
-  // Captures a frame.
-  // |dirty| is false for timer polls and true for compositor updates.
-  void Capture(bool dirty);
-
-  // Update capture size. Must be called on the UI thread.
-  void UpdateCaptureSize();
-
-  // Response callback for cc::Layer::RequestCopyOfOutput().
-  void DidCopyOutput(
-      scoped_refptr<media::VideoFrame> video_frame,
-      base::TimeTicks start_time,
-      const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
-      scoped_ptr<cc::CopyOutputResult> result);
-
-  // A helper which does the real work for DidCopyOutput. Returns true if
-  // succeeded.
-  bool ProcessCopyOutputResponse(
-      scoped_refptr<media::VideoFrame> video_frame,
-      base::TimeTicks start_time,
-      const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
-      scoped_ptr<cc::CopyOutputResult> result);
-
-  // Helper function to update cursor state.
-  // |region_in_frame| defines where the desktop is rendered in the captured
-  // frame.
-  // Returns the current cursor position in captured frame.
-  gfx::Point UpdateCursorState(const gfx::Rect& region_in_frame);
-
-  // Clears cursor state.
-  void ClearCursorState();
-
-  // The window associated with the desktop.
-  aura::Window* desktop_window_;
-
-  // The timer that kicks off period captures.
-  base::Timer timer_;
-
-  // The id of the window being captured.
-  DesktopMediaID window_id_;
-
-  // Makes all the decisions about which frames to copy, and how.
-  scoped_refptr<ThreadSafeCaptureOracle> oracle_proxy_;
-
-  // The capture parameters for this capture.
-  media::VideoCaptureParams capture_params_;
-
-  // YUV readback pipeline.
-  scoped_ptr<content::ReadbackYUVInterface> yuv_readback_pipeline_;
-
-  // Cursor state.
-  ui::Cursor last_cursor_;
-  gfx::Size desktop_size_when_cursor_last_updated_;
-  gfx::Point cursor_hot_point_;
-  SkBitmap scaled_cursor_bitmap_;
-
-  // TODO(jiayl): Remove power_save_blocker_ when there is an API to keep the
-  // screen from sleeping for the drive-by web.
-  scoped_ptr<PowerSaveBlocker> power_save_blocker_;
-
-  DISALLOW_COPY_AND_ASSIGN(DesktopVideoCaptureMachine);
-};
-
-DesktopVideoCaptureMachine::DesktopVideoCaptureMachine(
-    const DesktopMediaID& source)
+AuraWindowCaptureMachine::AuraWindowCaptureMachine()
     : desktop_window_(NULL),
       timer_(true, true),
-      window_id_(source) {}
+      screen_capture_(false) {}
 
-DesktopVideoCaptureMachine::~DesktopVideoCaptureMachine() {}
+AuraWindowCaptureMachine::~AuraWindowCaptureMachine() {}
 
-bool DesktopVideoCaptureMachine::Start(
+bool AuraWindowCaptureMachine::Start(
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_);
+  // The window might be destroyed between SetWindow() and Start().
   if (!desktop_window_)
     return false;
 
   // If the associated layer is already destroyed then return failure.
   ui::Layer* layer = desktop_window_->layer();
   if (!layer)
     return false;
 
   DCHECK(oracle_proxy.get());
   oracle_proxy_ = oracle_proxy;
   capture_params_ = params;
 
   // Update capture size.
   UpdateCaptureSize();
 
-  // Start observing window events.
-  desktop_window_->AddObserver(this);
-
   // Start observing compositor updates.
   if (desktop_window_->GetHost())
     desktop_window_->GetHost()->compositor()->AddObserver(this);
 
   power_save_blocker_.reset(
       PowerSaveBlocker::Create(
           PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
           PowerSaveBlocker::kReasonOther,
           "DesktopCaptureDevice is running").release());
 
   // Starts timer.
   timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(),
-               base::Bind(&DesktopVideoCaptureMachine::Capture, AsWeakPtr(),
+               base::Bind(&AuraWindowCaptureMachine::Capture, AsWeakPtr(),
                           false));
 
   return true;
 }
 
-void DesktopVideoCaptureMachine::Stop(const base::Closure& callback) {
+void AuraWindowCaptureMachine::Stop(const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   power_save_blocker_.reset();
 
   // Stop observing compositor and window events.
   if (desktop_window_) {
     aura::WindowTreeHost* window_host = desktop_window_->GetHost();
     // In the host destructor the compositor is destroyed before the window.
     if (window_host && window_host->compositor())
       window_host->compositor()->RemoveObserver(this);
     desktop_window_->RemoveObserver(this);
     desktop_window_ = NULL;
   }
 
   // Stop timer.
   timer_.Stop();
 
   callback.Run();
 }
 
-void DesktopVideoCaptureMachine::UpdateCaptureSize() {
+void AuraWindowCaptureMachine::SetWindow(aura::Window* window) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DCHECK(!desktop_window_);
+  desktop_window_ = window;
+
+  // Start observing window events.
+  desktop_window_->AddObserver(this);
+
+  // We must store this for the UMA reporting in DidCopyOutput() as
+  // desktop_window_ might be destroyed at that point.
+  screen_capture_ = window->IsRootWindow();
+  IncrementDesktopCaptureCounter(screen_capture_ ? SCREEN_CAPTURER_CREATED
+                                                 : WINDOW_CAPTURER_CREATED);
+}
+
+void AuraWindowCaptureMachine::UpdateCaptureSize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (oracle_proxy_.get() && desktop_window_) {
      ui::Layer* layer = desktop_window_->layer();
      oracle_proxy_->UpdateCaptureSize(ui::ConvertSizeToPixel(
          layer, layer->bounds().size()));
   }
   ClearCursorState();
 }
 
-void DesktopVideoCaptureMachine::Capture(bool dirty) {
+void AuraWindowCaptureMachine::Capture(bool dirty) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Do not capture if the desktop window is already destroyed.
   if (!desktop_window_)
     return;
 
   scoped_refptr<media::VideoFrame> frame;
   ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
   const VideoCaptureOracle::Event event =
       dirty ? VideoCaptureOracle::kCompositorUpdate
             : VideoCaptureOracle::kTimerPoll;
   if (oracle_proxy_->ObserveEventAndDecideCapture(
           event, gfx::Rect(), start_time, &frame, &capture_frame_cb)) {
     scoped_ptr<cc::CopyOutputRequest> request =
         cc::CopyOutputRequest::CreateRequest(
-            base::Bind(&DesktopVideoCaptureMachine::DidCopyOutput,
+            base::Bind(&AuraWindowCaptureMachine::DidCopyOutput,
                        AsWeakPtr(), frame, start_time, capture_frame_cb));
     gfx::Rect window_rect = gfx::Rect(desktop_window_->bounds().width(),
                                       desktop_window_->bounds().height());
     request->set_area(window_rect);
     desktop_window_->layer()->RequestCopyOfOutput(request.Pass());
   }
 }
 
-void CopyOutputFinishedForVideo(
-    base::TimeTicks start_time,
-    const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
-    const scoped_refptr<media::VideoFrame>& target,
-    const SkBitmap& cursor_bitmap,
-    const gfx::Point& cursor_position,
-    scoped_ptr<cc::SingleReleaseCallback> release_callback,
-    bool result) {
-  if (!cursor_bitmap.isNull())
-    RenderCursorOnVideoFrame(target, cursor_bitmap, cursor_position);
-  release_callback->Run(0, false);
-  capture_frame_cb.Run(target, start_time, result);
-}
-
-void RunSingleReleaseCallback(scoped_ptr<cc::SingleReleaseCallback> cb,
-                              uint32 sync_point) {
-  cb->Run(sync_point, false);
-}
-
-void DesktopVideoCaptureMachine::DidCopyOutput(
+void AuraWindowCaptureMachine::DidCopyOutput(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
   static bool first_call = true;
 
   bool succeeded = ProcessCopyOutputResponse(
       video_frame, start_time, capture_frame_cb, result.Pass());
 
   base::TimeDelta capture_time = base::TimeTicks::Now() - start_time;
 
   // The two UMA_ blocks must be put in its own scope since it creates a static
   // variable which expected constant histogram name.
-  if (window_id_.type == DesktopMediaID::TYPE_SCREEN) {
+  if (screen_capture_) {
     UMA_HISTOGRAM_TIMES(kUmaScreenCaptureTime, capture_time);
   } else {
     UMA_HISTOGRAM_TIMES(kUmaWindowCaptureTime, capture_time);
   }
 
   if (first_call) {
     first_call = false;
-    if (window_id_.type == DesktopMediaID::TYPE_SCREEN) {
+    if (screen_capture_) {
       IncrementDesktopCaptureCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED
                                                : FIRST_SCREEN_CAPTURE_FAILED);
     } else {
       IncrementDesktopCaptureCounter(succeeded
                                          ? FIRST_WINDOW_CAPTURE_SUCCEEDED
                                          : FIRST_WINDOW_CAPTURE_FAILED);
     }
   }
 }
 
-bool DesktopVideoCaptureMachine::ProcessCopyOutputResponse(
+bool AuraWindowCaptureMachine::ProcessCopyOutputResponse(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (result->IsEmpty() || result->size().IsEmpty() || !desktop_window_)
     return false;
 
   if (capture_params_.requested_format.pixel_format ==
@@ skipping 68 matching lines @@
       base::Bind(&CopyOutputFinishedForVideo,
                  start_time,
                  capture_frame_cb,
                  video_frame,
                  scaled_cursor_bitmap_,
                  cursor_position_in_frame,
                  base::Passed(&release_callback)));
   return true;
 }
 
-gfx::Point DesktopVideoCaptureMachine::UpdateCursorState(
+gfx::Point AuraWindowCaptureMachine::UpdateCursorState(
     const gfx::Rect& region_in_frame) {
   const gfx::Rect desktop_bounds = desktop_window_->layer()->bounds();
   if (desktop_bounds.IsEmpty()) {
     // Return early to prevent divide-by-zero in calculations below.
     ClearCursorState();
     return gfx::Point();
   }
 
   gfx::NativeCursor cursor =
       desktop_window_->GetHost()->last_cursor();
@@ skipping 30 matching lines @@
       desktop_window_->layer(), cursor_hot_point_);
   cursor_position.Offset(-desktop_bounds.x() - hot_point_in_dip.x(),
                          -desktop_bounds.y() - hot_point_in_dip.y());
   return gfx::Point(
       region_in_frame.x() + cursor_position.x() * region_in_frame.width() /
           desktop_bounds.width(),
       region_in_frame.y() + cursor_position.y() * region_in_frame.height() /
           desktop_bounds.height());
 }
 
-void DesktopVideoCaptureMachine::ClearCursorState() {
+void AuraWindowCaptureMachine::ClearCursorState() {
   last_cursor_ = ui::Cursor();
   desktop_size_when_cursor_last_updated_ = gfx::Size();
   cursor_hot_point_ = gfx::Point();
   scaled_cursor_bitmap_.reset();
 }
 
-void DesktopVideoCaptureMachine::OnWindowBoundsChanged(
+void AuraWindowCaptureMachine::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   DCHECK(desktop_window_ && window == desktop_window_);
 
   // Post task to update capture size on UI thread.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-      &DesktopVideoCaptureMachine::UpdateCaptureSize, AsWeakPtr()));
+      &AuraWindowCaptureMachine::UpdateCaptureSize, AsWeakPtr()));
 }
 
-void DesktopVideoCaptureMachine::OnWindowDestroyed(aura::Window* window) {
+void AuraWindowCaptureMachine::OnWindowDestroyed(aura::Window* window) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Stop(base::Bind(&base::DoNothing));
 
   oracle_proxy_->ReportError("OnWindowDestroyed()");
 }
 
-void DesktopVideoCaptureMachine::OnWindowAddedToRootWindow(
+void AuraWindowCaptureMachine::OnWindowAddedToRootWindow(
     aura::Window* window) {
   DCHECK(window == desktop_window_);
   window->GetHost()->compositor()->AddObserver(this);
 }
 
-void DesktopVideoCaptureMachine::OnWindowRemovingFromRootWindow(
+void AuraWindowCaptureMachine::OnWindowRemovingFromRootWindow(
     aura::Window* window,
     aura::Window* new_root) {
   DCHECK(window == desktop_window_);
   window->GetHost()->compositor()->RemoveObserver(this);
 }
 
-void DesktopVideoCaptureMachine::OnCompositingEnded(
+void AuraWindowCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-      &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true));
-}
-
-}  // namespace
-
-DesktopCaptureDeviceAura::DesktopCaptureDeviceAura(
-    const DesktopMediaID& source)
-    : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
-        new DesktopVideoCaptureMachine(source)))) {}
-
-DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() {
-  DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying.";
-}
-
-// static
-media::VideoCaptureDevice* DesktopCaptureDeviceAura::Create(
-    const DesktopMediaID& source) {
-  IncrementDesktopCaptureCounter(source.type == DesktopMediaID::TYPE_SCREEN
-                                     ? SCREEN_CAPTURER_CREATED
-                                     : WINDOW_CAPTURER_CREATED);
-  return new DesktopCaptureDeviceAura(source);
-}
-
-void DesktopCaptureDeviceAura::AllocateAndStart(
-    const media::VideoCaptureParams& params,
-    scoped_ptr<Client> client) {
-  DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
-  core_->AllocateAndStart(params, client.Pass());
-}
-
-void DesktopCaptureDeviceAura::StopAndDeAllocate() {
-  core_->StopAndDeAllocate();
+      &AuraWindowCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
 }  // namespace content