Enables using the magnification API for screen capturing on Windows under a Finch experiment.

content/browser/media/capture/desktop_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 "content/browser/media/capture/desktop_capture_device.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "media/base/video_util.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_and_cursor_composer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
@@ skipping 23 matching lines @@
 }  // namespace
 
 class DesktopCaptureDevice::Core
     : public base::RefCountedThreadSafe<Core>,
       public webrtc::DesktopCapturer::Callback {
  public:
   Core(scoped_refptr<base::SequencedTaskRunner> task_runner,
        scoped_ptr<webrtc::DesktopCapturer> capturer,
        DesktopMediaID::Type type);
 
+  Core(scoped_ptr<base::Thread> thread,
+       scoped_ptr<webrtc::DesktopCapturer> capturer,
+       DesktopMediaID::Type type);
+
   // Implementation of VideoCaptureDevice methods.
   void AllocateAndStart(const media::VideoCaptureParams& params,
                         scoped_ptr<Client> client);
   void StopAndDeAllocate();
 
   void SetNotificationWindowId(gfx::NativeViewId window_id);
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
@@ skipping 18 matching lines @@
   void OnCaptureTimer();
 
   // Captures a frame and schedules timer for the next one.
   void CaptureFrameAndScheduleNext();
 
   // Captures a single frame.
   void DoCapture();
 
   void DoSetNotificationWindowId(gfx::NativeViewId window_id);
 
+  // The thread on which the capturer is running.
+  scoped_ptr<base::Thread> thread_;
+
   // Task runner used for capturing operations.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // The underlying DesktopCapturer instance used to capture frames.
   scoped_ptr<webrtc::DesktopCapturer> desktop_capturer_;
 
   // The device client which proxies device events to the controller. Accessed
   // on the task_runner_ thread.
   scoped_ptr<Client> client_;
 
@@ skipping 32 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : task_runner_(task_runner),
       desktop_capturer_(capturer.Pass()),
       capture_task_posted_(false),
       capture_in_progress_(false),
       capturer_type_(type) {
 }
 
+DesktopCaptureDevice::Core::Core(scoped_ptr<base::Thread> thread,

[Sergey Ulanov, 2014/05/05 20:10:06]

Same as with DesktopCaptureDevice, better to avoid overriding constructor, and
it's easy to avoid it here. E.g. it's error prone when adding initializers for
new class members.

+                                 scoped_ptr<webrtc::DesktopCapturer> capturer,
+                                 DesktopMediaID::Type type)
+    : thread_(thread.Pass()),
+      task_runner_(thread_->message_loop_proxy()),
+      desktop_capturer_(capturer.Pass()),
+      capture_task_posted_(false),
+      capture_in_progress_(false),
+      capturer_type_(type) {
+}
+
 DesktopCaptureDevice::Core::~Core() {
 }
 
 void DesktopCaptureDevice::Core::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   DCHECK_GT(params.requested_format.frame_size.GetArea(), 0);
   DCHECK_GT(params.requested_format.frame_rate, 0);
 
   task_runner_->PostTask(
@@ skipping 233 matching lines @@
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK(window_id);
   desktop_capturer_->SetExcludedWindow(window_id);
 }
 
 // static
 scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
     const DesktopMediaID& source) {
   scoped_refptr<base::SequencedWorkerPool> blocking_pool =
       BrowserThread::GetBlockingPool();
   scoped_refptr<base::SequencedTaskRunner> task_runner =

[Sergey Ulanov, 2014/05/05 20:10:06]

There is no point creating task runner if it's not used. Move this inside the if
block where the constructor is called?

       blocking_pool->GetSequencedTaskRunner(
           blocking_pool->GetSequenceToken());
+  scoped_ptr<base::Thread> ui_thread;
 
   webrtc::DesktopCaptureOptions options =
       webrtc::DesktopCaptureOptions::CreateDefault();
   // Leave desktop effects enabled during WebRTC captures.
   options.set_disable_effects(false);
 
   scoped_ptr<webrtc::DesktopCapturer> capturer;
 
   switch (source.type) {
     case DesktopMediaID::TYPE_SCREEN: {
       scoped_ptr<webrtc::ScreenCapturer> screen_capturer;
+
+#if defined(OS_WIN)
+    bool magnification_allowed = base::FieldTrialList::FindFullName(

[Sergey Ulanov, 2014/05/05 20:10:06]

indent 2 spaces.

+        "ScreenCaptureUseMagnification") == "Enabled";
+
+    if (magnification_allowed) {
+      // The magnification capturer requires running on a dedicated UI thread.
+      ui_thread.reset(new base::Thread("screenCaptureUIThread"));
+      base::Thread::Options thread_options(base::MessageLoop::TYPE_UI, 0);
+      ui_thread->StartWithOptions(thread_options);
+      task_runner.reset();
+
+      options.set_allow_use_magnification_api(true);
+    }
+#endif
+
       screen_capturer.reset(webrtc::ScreenCapturer::Create(options));
       if (screen_capturer && screen_capturer->SelectScreen(source.id)) {
         capturer.reset(new webrtc::DesktopAndCursorComposer(
             screen_capturer.release(),
             webrtc::MouseCursorMonitor::CreateForScreen(options, source.id)));
         IncrementDesktopCaptureCounter(SCREEN_CAPTURER_CREATED);
       }
       break;
     }
 
@@ skipping 10 matching lines @@
       break;
     }
 
     default: {
       NOTREACHED();
     }
   }
 
   scoped_ptr<media::VideoCaptureDevice> result;
   if (capturer) {
-    result.reset(
-        new DesktopCaptureDevice(task_runner, capturer.Pass(), source.type));
+    if (task_runner.get()) {

[Sergey Ulanov, 2014/05/05 20:10:06]

if (!ui_thread)

+      result.reset(
+          new DesktopCaptureDevice(task_runner, capturer.Pass(), source.type));
+    } else {
+      result.reset(new DesktopCaptureDevice(
+          ui_thread.Pass(), capturer.Pass(), source.type));
+    }
   }
 
   return result.Pass();
 }
 
 DesktopCaptureDevice::DesktopCaptureDevice(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : core_(new Core(task_runner, capturer.Pass(), type)) {
 }
 
+DesktopCaptureDevice::DesktopCaptureDevice(
+    scoped_ptr<base::Thread> thread,
+    scoped_ptr<webrtc::DesktopCapturer> capturer,
+    DesktopMediaID::Type type)
+    : core_(new Core(thread.Pass(), capturer.Pass(), type)) {
+}
+
 DesktopCaptureDevice::~DesktopCaptureDevice() {
   StopAndDeAllocate();
 }
 
 void DesktopCaptureDevice::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<Client> client) {
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void DesktopCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 void DesktopCaptureDevice::SetNotificationWindowId(
     gfx::NativeViewId window_id) {
   core_->SetNotificationWindowId(window_id);
 }
 
 }  // namespace content