content: Split out VideoCaptureMachine from DesktopCaptureDeviceAura

content/browser/media/capture/desktop_capture_device_aura.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 "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 77 matching lines @@
   }
   cursor_bitmap.unlockPixels();
 }
 
 class DesktopVideoCaptureMachine
     : public VideoCaptureMachine,
       public aura::WindowObserver,
       public ui::CompositorObserver,
       public base::SupportsWeakPtr<DesktopVideoCaptureMachine> {
  public:
-  DesktopVideoCaptureMachine(const DesktopMediaID& source);
+  DesktopVideoCaptureMachine(aura::Window* window);
   ~DesktopVideoCaptureMachine() override;
 
   // VideoCaptureFrameSource overrides.
   bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
              const media::VideoCaptureParams& params) override;
   void Stop(const base::Closure& callback) override;
 
   // Implements aura::WindowObserver.
   void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
@@ skipping 42 matching lines @@
 
   // 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::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)
-    : desktop_window_(NULL),
-      timer_(true, true),
-      window_id_(source) {}
+DesktopVideoCaptureMachine::DesktopVideoCaptureMachine(aura::Window* window)
+    : desktop_window_(window),
+      timer_(true, true) {
+  IncrementDesktopCaptureCounter(window->IsRootWindow()
+                                     ? SCREEN_CAPTURER_CREATED
+                                     : WINDOW_CAPTURER_CREATED);
+}
 
 DesktopVideoCaptureMachine::~DesktopVideoCaptureMachine() {}
 
 bool DesktopVideoCaptureMachine::Start(
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_);
-  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.
@@ skipping 103 matching lines @@
     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 (desktop_window_->IsRootWindow()) {
     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 (desktop_window_->IsRootWindow()) {
       IncrementDesktopCaptureCounter(succeeded ? FIRST_SCREEN_CAPTURE_SUCCEEDED
                                                : FIRST_SCREEN_CAPTURE_FAILED);
     } else {
       IncrementDesktopCaptureCounter(succeeded
                                          ? FIRST_WINDOW_CAPTURE_SUCCEEDED
                                          : FIRST_WINDOW_CAPTURE_FAILED);
     }
   }
 }
 
@@ skipping 159 matching lines @@
 }
 
 void DesktopVideoCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
 }  // namespace
 
-DesktopCaptureDeviceAura::DesktopCaptureDeviceAura(
-    const DesktopMediaID& source)
+DesktopCaptureDeviceAura::DesktopCaptureDeviceAura(aura::Window* window)
     : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
-        new DesktopVideoCaptureMachine(source)))) {}
+        new DesktopVideoCaptureMachine(window)))) {}
 
 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);
+  aura::Window* window = content::DesktopMediaID::GetAuraWindowById(source);

[Sergey Ulanov, 2015/03/02 21:58:58]

DesktopMediaID::GetAuraWindowById() is not thread-safe and must be called on the
UI thread, while this code is executed on the device thread. Another related
problem is that |window| may be destroyed between Create() and
DesktopVideoCaptureMachine::Start() (note that Start() adds observer for the
window to get notified when it's destroyed). Sorry, I forgot about it when
reviewing your CL for virtual screens.

I suggest adding SetWindow(window) method in DesktopVideoCaptureMachine and
removing the window parameter from the constructor. Then you can post a task
from DesktopCaptureDeviceAura() to get window ID resolved on the UI thread.
After that, to get virtual screen implemented:
 1. Move DesktopVideoCaptureMachine to a separate file, and maybe rename it to
AuraWindowCaptureMachine.
 2. Add VirtualScreenCaptureDevice class that is the same
DesktopCaptureDeviceAura except it creates a virtual screen.

+  return new DesktopCaptureDeviceAura(window);
 }
 
 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();
 }
 
 }  // namespace content