Add support for a virtual display on ChromeOS

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/sys_info.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"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/power_save_blocker.h"
 #include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/display_observer.h"
 #include "ui/gfx/screen.h"
 
+#if defined(USE_ASH)
+#include "ash/display/display_controller.h"

[piman, 2015/02/24 01:58:29]

content/ is not allowed to depend on ash/

+#include "ash/shell.h"
+#include "ui/display/chromeos/display_configurator.h"
+#endif
+
 namespace content {
 
 namespace {
 
 int clip_byte(int x) {
   return std::max(0, std::min(x, 255));
 }
 
 int alpha_blend(int alpha, int src, int dst) {
   return (src * alpha + dst * (255 - alpha)) / 255;
@@ skipping 43 matching lines @@
       }
     }
   }
   cursor_bitmap.unlockPixels();
 }
 
 class DesktopVideoCaptureMachine
     : public VideoCaptureMachine,
       public aura::WindowObserver,
       public ui::CompositorObserver,
+      public gfx::DisplayObserver,
       public base::SupportsWeakPtr<DesktopVideoCaptureMachine> {
  public:
   DesktopVideoCaptureMachine(const DesktopMediaID& source);
   ~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,
                              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;
 
   // 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 {}
 
+  // Implements gfx::DisplayObserver.
+  void OnDisplayAdded(const gfx::Display& new_display) override;
+  void OnDisplayRemoved(const gfx::Display& old_display) override {}
+  void OnDisplayMetricsChanged(const gfx::Display& display,
+                               uint32_t changed_metrics) 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(
@@ skipping 11 matching lines @@
       scoped_ptr<cc::CopyOutputResult> result);
 
   // Helper function to update cursor state.
   // |region_in_frame| defines the desktop bound 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();
 
+  // Start the capture after setup.
+  void StartCapture();
+
   // 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.
@@ skipping 18 matching lines @@
 };
 
 DesktopVideoCaptureMachine::DesktopVideoCaptureMachine(
     const DesktopMediaID& source)
     : desktop_window_(NULL),
       timer_(true, true),
       window_id_(source) {}
 
 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;
-
+void DesktopVideoCaptureMachine::StartCapture() {
   // 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,
       "DesktopCaptureDevice is running").release());
 
   // Starts timer.
   timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(),
                base::Bind(&DesktopVideoCaptureMachine::Capture, AsWeakPtr(),
                           false));
+}
+
+bool DesktopVideoCaptureMachine::Start(

[Sergey Ulanov, 2015/02/23 23:16:12]

Can the virtual-screen logic be moved out of this class? I think it can be
implemented as follows:
  - Change DesktopVideoCaptureMachine constructor to take aura::Window instead
of DesktopMediaID.
  - Change DesktopCaptureDeviceAura constructor to take aura::Window instead of
DesktopMediaID.
  - Add a new class called e.g. VirtualScreenCapturer that implements
media::VideoCaptureDevice and wraps DesktopCaptureDeviceAura, which actually
captures frames.

That way you will need fewer ifdefs and the code will be easier to read.

[oshima, 2015/02/24 19:43:21]

and please move ash code from content/.

[robert.bradford, 2015/03/03 19:58:00]

I've started working on the non virtual display refactoring here:
https://codereview.chromium.org/974513002/

+    const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
+    const media::VideoCaptureParams& params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  capture_params_ = params;
+  DCHECK(oracle_proxy.get());
+  oracle_proxy_ = oracle_proxy;
+
+#if defined(USE_ASH)

[oshima, 2015/02/24 19:43:21]

no USE_ASH in content/. You probably should just use OS_CHROMEOS because this
won't work on win ash.

+  // Window for virtual display is available asynchronously after request. The
+  // DisplayObserver on the screen will be notified of the new display and
+  // Window and start the capture.
+  if (window_id_.type == DesktopMediaID::TYPE_AURA_VIRTUAL_SCREEN) {
+    DCHECK(base::SysInfo::IsRunningOnChromeOS());
+    ui::DisplayConfigurator* configurator =
+        ash::Shell::GetInstance()->display_configurator();
+    gfx::Screen::GetNativeScreen()->AddObserver(this);
+    configurator->EnableVirtualDisplay(make_scoped_ptr(
+        new ui::DisplayMode(params.requested_format.frame_size, false, 60)));
+    return true;
+  }
+#else
+  desktop_window_ = content::DesktopMediaID::GetAuraWindowById(window_id_);
+#endif
+
+  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;
+
+  StartCapture();
 
   return true;
 }
 
 void DesktopVideoCaptureMachine::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;
   }
 
+#if defined(USE_ASH)
+  if (window_id_.type == DesktopMediaID::TYPE_AURA_VIRTUAL_SCREEN) {
+    gfx::Screen::GetNativeScreen()->RemoveObserver(this);
+    ash::Shell::GetInstance()->display_configurator()->DisableVirtualDisplay();
+  }
+#endif
+
   // Stop timer.
   timer_.Stop();
 
   callback.Run();
 }
 
 void DesktopVideoCaptureMachine::UpdateCaptureSize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (oracle_proxy_.get() && desktop_window_) {
      ui::Layer* layer = desktop_window_->layer();
@@ skipping 243 matching lines @@
   DCHECK(window == desktop_window_);
   window->GetHost()->compositor()->RemoveObserver(this);
 }
 
 void DesktopVideoCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &DesktopVideoCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
+void DesktopVideoCaptureMachine::OnDisplayAdded(
+    const gfx::Display& new_display) {
+#if defined(USE_ASH)
+  DCHECK(base::SysInfo::IsRunningOnChromeOS());
+  ui::DisplayConfigurator* configurator =
+      ash::Shell::GetInstance()->display_configurator();
+  int64 display_id = configurator->GetVirtualDisplayId();
+
+  if (display_id == new_display.id()) {
+    desktop_window_ = ash::Shell::GetInstance()
+                          ->display_controller()
+                          ->GetRootWindowForDisplayId(display_id);
+
+    // We only need the observer for a short time.
+    gfx::Screen::GetNativeScreen()->RemoveObserver(this);
+
+    if (desktop_window_ && desktop_window_->layer()) {
+      StartCapture();
+    } else {
+      Stop(base::Bind(&base::DoNothing));
+    }
+  }
+}
+#endif
 }  // namespace
 
 DesktopCaptureDeviceAura::DesktopCaptureDeviceAura(
     const DesktopMediaID& source)
     : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
         new DesktopVideoCaptureMachine(source)))) {}
 
 DesktopCaptureDeviceAura::~DesktopCaptureDeviceAura() {
   DVLOG(2) << "DesktopCaptureDeviceAura@" << this << " destroying.";
 }
@@ skipping 12 matching lines @@
     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