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

NOTRY=true
NOTREECHECKS=true
BUG=https://code.google.com/p/webrtc/issues/detail?id=2789

Review URL: https://codereview.chromium.org/268123003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@269444 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 77 insertions, 37 deletions

diff --git a/content/browser/media/capture/desktop_capture_device.cc b/content/browser/media/capture/desktop_capture_device.cc
index f5c5c65..446e9e2 100644
--- a/content/browser/media/capture/desktop_capture_device.cc
+++ b/content/browser/media/capture/desktop_capture_device.cc
@@ -7,11 +7,13 @@
 #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"
@@ -52,6 +54,7 @@ class DesktopCaptureDevice::Core
       public webrtc::DesktopCapturer::Callback {
  public:
   Core(scoped_refptr<base::SequencedTaskRunner> task_runner,
+       scoped_ptr<base::Thread> thread,
        scoped_ptr<webrtc::DesktopCapturer> capturer,
        DesktopMediaID::Type type);
 
@@ -96,6 +99,9 @@ class DesktopCaptureDevice::Core
   // Task runner used for capturing operations.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
+  // The thread on which the capturer is running.
+  scoped_ptr<base::Thread> thread_;
+
   // The underlying DesktopCapturer instance used to capture frames.
   scoped_ptr<webrtc::DesktopCapturer> desktop_capturer_;
 
@@ -136,13 +142,18 @@ class DesktopCaptureDevice::Core
 
 DesktopCaptureDevice::Core::Core(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
+    scoped_ptr<base::Thread> thread,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     DesktopMediaID::Type type)
     : task_runner_(task_runner),
+      thread_(thread.Pass()),
       desktop_capturer_(capturer.Pass()),
       capture_task_posted_(false),
       capture_in_progress_(false),
       capturer_type_(type) {
+  DCHECK(!task_runner_.get() || !thread_.get());
+  if (thread_.get())
+    task_runner_ = thread_->message_loop_proxy();
 }
 
 DesktopCaptureDevice::Core::~Core() {
@@ -396,11 +407,7 @@ void DesktopCaptureDevice::Core::DoSetNotificationWindowId(
 // static
 scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
     const DesktopMediaID& source) {
-  scoped_refptr<base::SequencedWorkerPool> blocking_pool =
-      BrowserThread::GetBlockingPool();
-  scoped_refptr<base::SequencedTaskRunner> task_runner =
-      blocking_pool->GetSequencedTaskRunner(
-          blocking_pool->GetSequenceToken());
+  scoped_ptr<base::Thread> ui_thread;
 
   webrtc::DesktopCaptureOptions options =
       webrtc::DesktopCaptureOptions::CreateDefault();
@@ -412,6 +419,22 @@ scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
   switch (source.type) {
     case DesktopMediaID::TYPE_SCREEN: {
       scoped_ptr<webrtc::ScreenCapturer> screen_capturer;
+
+#if defined(OS_WIN)
+      bool magnification_allowed =
+          base::FieldTrialList::FindFullName("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);
+
+        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(
@@ -442,20 +465,20 @@ scoped_ptr<media::VideoCaptureDevice> DesktopCaptureDevice::Create(
 
   scoped_ptr<media::VideoCaptureDevice> result;
   if (capturer) {
-    result.reset(
-        new DesktopCaptureDevice(task_runner, capturer.Pass(), source.type));
+    scoped_refptr<base::SequencedTaskRunner> task_runner;
+    if (!ui_thread.get()) {
+      scoped_refptr<base::SequencedWorkerPool> blocking_pool =
+          BrowserThread::GetBlockingPool();
+      task_runner = blocking_pool->GetSequencedTaskRunner(
+          blocking_pool->GetSequenceToken());
+    }
+    result.reset(new DesktopCaptureDevice(
+        task_runner, 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() {
   StopAndDeAllocate();
 }
@@ -475,4 +498,12 @@ void DesktopCaptureDevice::SetNotificationWindowId(
   core_->SetNotificationWindowId(window_id);
 }
 
+DesktopCaptureDevice::DesktopCaptureDevice(
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    scoped_ptr<base::Thread> thread,
+    scoped_ptr<webrtc::DesktopCapturer> capturer,
+    DesktopMediaID::Type type)
+    : core_(new Core(task_runner, thread.Pass(), capturer.Pass(), type)) {
+}
+
 }  // namespace content
diff --git a/content/browser/media/capture/desktop_capture_device.h b/content/browser/media/capture/desktop_capture_device.h
index af16bda..9fb8ca41 100644
--- a/content/browser/media/capture/desktop_capture_device.h
+++ b/content/browser/media/capture/desktop_capture_device.h
@@ -14,6 +14,7 @@
 
 namespace base {
 class SequencedTaskRunner;
+class Thread;
 }  // namespace base
 
 namespace webrtc {
@@ -33,9 +34,6 @@ class CONTENT_EXPORT DesktopCaptureDevice : public media::VideoCaptureDevice {
   static scoped_ptr<media::VideoCaptureDevice> Create(
       const DesktopMediaID& source);
 
-  DesktopCaptureDevice(scoped_refptr<base::SequencedTaskRunner> task_runner,
-                       scoped_ptr<webrtc::DesktopCapturer> desktop_capturer,
-                       DesktopMediaID::Type type);
   virtual ~DesktopCaptureDevice();
 
   // VideoCaptureDevice interface.
@@ -47,7 +45,15 @@ class CONTENT_EXPORT DesktopCaptureDevice : public media::VideoCaptureDevice {
   void SetNotificationWindowId(gfx::NativeViewId window_id);
 
  private:
+  friend class DesktopCaptureDeviceTest;
   class Core;
+
+  // Either |task_runner| or |thread| should be non-NULL, but not both.
+  DesktopCaptureDevice(scoped_refptr<base::SequencedTaskRunner> task_runner,
+                       scoped_ptr<base::Thread> thread,
+                       scoped_ptr<webrtc::DesktopCapturer> desktop_capturer,
+                       DesktopMediaID::Type type);
+
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopCaptureDevice);
diff --git a/content/browser/media/capture/desktop_capture_device_unittest.cc b/content/browser/media/capture/desktop_capture_device_unittest.cc
index 683f060..0c1a360 100644
--- a/content/browser/media/capture/desktop_capture_device_unittest.cc
+++ b/content/browser/media/capture/desktop_capture_device_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -132,18 +133,28 @@ class FakeScreenCapturer : public webrtc::ScreenCapturer {
   bool generate_inverted_frames_;
 };
 
+}  // namespace
+
 class DesktopCaptureDeviceTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     worker_pool_ = new base::SequencedWorkerPool(3, "TestCaptureThread");
   }
 
+  void CreateScreenCaptureDevice(scoped_ptr<webrtc::DesktopCapturer> capturer) {
+    capture_device_.reset(new DesktopCaptureDevice(
+        worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()),
+        thread_.Pass(),
+        capturer.Pass(),
+        DesktopMediaID::TYPE_SCREEN));
+  }
+
  protected:
   scoped_refptr<base::SequencedWorkerPool> worker_pool_;
+  scoped_ptr<base::Thread> thread_;
+  scoped_ptr<DesktopCaptureDevice> capture_device_;
 };
 
-}  // namespace
-
 // There is currently no screen capturer implementation for ozone. So disable
 // the test that uses a real screen-capturer instead of FakeScreenCapturer.
 // http://crbug.com/260318
@@ -155,10 +166,8 @@ class DesktopCaptureDeviceTest : public testing::Test {
 TEST_F(DesktopCaptureDeviceTest, MAYBE_Capture) {
   scoped_ptr<webrtc::DesktopCapturer> capturer(
       webrtc::ScreenCapturer::Create());
-  DesktopCaptureDevice capture_device(
-      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()),
-      capturer.Pass(),
-      DesktopMediaID::TYPE_SCREEN);
+  CreateScreenCaptureDevice(capturer.Pass());
+
   media::VideoCaptureFormat format;
   base::WaitableEvent done_event(false, false);
   int frame_size;
@@ -175,10 +184,10 @@ TEST_F(DesktopCaptureDeviceTest, MAYBE_Capture) {
   capture_params.requested_format.frame_rate = kFrameRate;
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.allow_resolution_change = false;
-  capture_device.AllocateAndStart(
+  capture_device_->AllocateAndStart(
       capture_params, client.PassAs<media::VideoCaptureDevice::Client>());
   EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
-  capture_device.StopAndDeAllocate();
+  capture_device_->StopAndDeAllocate();
 
   EXPECT_GT(format.frame_size.width(), 0);
   EXPECT_GT(format.frame_size.height(), 0);
@@ -194,10 +203,7 @@ TEST_F(DesktopCaptureDeviceTest, MAYBE_Capture) {
 TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeConstantResolution) {
   FakeScreenCapturer* mock_capturer = new FakeScreenCapturer();
 
-  DesktopCaptureDevice capture_device(
-      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()),
-      scoped_ptr<webrtc::DesktopCapturer>(mock_capturer),
-      DesktopMediaID::TYPE_SCREEN);
+  CreateScreenCaptureDevice(scoped_ptr<webrtc::DesktopCapturer>(mock_capturer));
 
   media::VideoCaptureFormat format;
   base::WaitableEvent done_event(false, false);
@@ -217,7 +223,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeConstantResolution) {
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.allow_resolution_change = false;
 
-  capture_device.AllocateAndStart(
+  capture_device_->AllocateAndStart(
       capture_params, client.PassAs<media::VideoCaptureDevice::Client>());
 
   // Capture at least two frames, to ensure that the source frame size has
@@ -226,7 +232,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeConstantResolution) {
   done_event.Reset();
   EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
 
-  capture_device.StopAndDeAllocate();
+  capture_device_->StopAndDeAllocate();
 
   EXPECT_EQ(kTestFrameWidth1, format.frame_size.width());
   EXPECT_EQ(kTestFrameHeight1, format.frame_size.height());
@@ -242,10 +248,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeConstantResolution) {
 TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeVariableResolution) {
   FakeScreenCapturer* mock_capturer = new FakeScreenCapturer();
 
-  DesktopCaptureDevice capture_device(
-      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()),
-      scoped_ptr<webrtc::DesktopCapturer>(mock_capturer),
-      DesktopMediaID::TYPE_SCREEN);
+  CreateScreenCaptureDevice(scoped_ptr<webrtc::DesktopCapturer>(mock_capturer));
 
   media::VideoCaptureFormat format;
   base::WaitableEvent done_event(false, false);
@@ -263,7 +266,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeVariableResolution) {
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   capture_params.allow_resolution_change = false;
 
-  capture_device.AllocateAndStart(
+  capture_device_->AllocateAndStart(
       capture_params, client.PassAs<media::VideoCaptureDevice::Client>());
 
   // Capture at least three frames, to ensure that the source frame size has
@@ -274,7 +277,7 @@ TEST_F(DesktopCaptureDeviceTest, ScreenResolutionChangeVariableResolution) {
   done_event.Reset();
   EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
 
-  capture_device.StopAndDeAllocate();
+  capture_device_->StopAndDeAllocate();
 
   EXPECT_EQ(kTestFrameWidth1, format.frame_size.width());
   EXPECT_EQ(kTestFrameHeight1, format.frame_size.height());