Hook up fake-device and fake-ui flags for getdisplayMedia()

This CL hooks up use-fake-device-for-media-stream and
use-fake-ui-for-media-stream flags for getdisplayMedia() calls for enabling
testing in the future.
- Use fake-ui chooses a default device. If fake-device is specified, that takes
priority.
- Fake-device type can be modified by flag args.

Bug: 326740
Change-Id: I4e97941743fa2149f88bc3714beb4d833da42e48
Reviewed-on: https://chromium-review.googlesource.com/1177448Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Christian Fremerey <chfremer@chromium.org>
Commit-Queue: Emircan Uysaler <emircan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584121}

content/browser/renderer_host/media/in_process_video_capture_device_launcher.cc

@@ -4,6 +4,10 @@
 
 #include "content/browser/renderer_host/media/in_process_video_capture_device_launcher.h"
 
+#include <utility>
+#include <vector>
+
+#include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
@@ -11,8 +15,12 @@
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_dependencies.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/desktop_media_id.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/media_switches.h"
+#include "media/capture/video/fake_video_capture_device.h"
+#include "media/capture/video/fake_video_capture_device_factory.h"
 #include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h"
 #include "media/capture/video/video_capture_device_client.h"
@@ -22,7 +30,6 @@
 
 #if defined(ENABLE_SCREEN_CAPTURE)
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
-#include "content/public/browser/desktop_media_id.h"
 #if defined(OS_ANDROID)
 #include "content/browser/media/capture/screen_capture_device_android.h"
 #else
@@ -142,6 +149,18 @@ void InProcessVideoCaptureDeviceLauncher::LaunchDeviceAsync(
         break;
       }
 
+      if (desktop_id.id == DesktopMediaID::kFakeId) {
+        start_capture_closure = base::BindOnce(
+            &InProcessVideoCaptureDeviceLauncher::
+                DoStartFakeDisplayCaptureOnDeviceThread,
+            base::Unretained(this), desktop_id, params,
+            CreateDeviceClient(media::VideoCaptureBufferType::kSharedMemory,
+                               kMaxNumberOfBuffers, std::move(receiver),
+                               std::move(receiver_on_io_thread)),
+            std::move(after_start_capture_callback));
+        break;
+      }
+
 #if !defined(OS_ANDROID)
       if (desktop_id.type == DesktopMediaID::TYPE_WEB_CONTENTS) {
         after_start_capture_callback = base::BindOnce(
@@ -371,4 +390,40 @@ void InProcessVideoCaptureDeviceLauncher::DoStartDesktopCaptureOnDeviceThread(
 
 #endif  // defined(ENABLE_SCREEN_CAPTURE)
 
+void InProcessVideoCaptureDeviceLauncher::
+    DoStartFakeDisplayCaptureOnDeviceThread(
+        const DesktopMediaID& desktop_id,
+        const media::VideoCaptureParams& params,
+        std::unique_ptr<media::VideoCaptureDeviceClient> device_client,
+        ReceiveDeviceCallback result_callback) {
+  DCHECK(device_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(DesktopMediaID::kFakeId, desktop_id.id);
+
+  auto fake_device_factory =
+      std::make_unique<media::FakeVideoCaptureDeviceFactory>();
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  if (command_line &&
+      command_line->HasSwitch(switches::kUseFakeDeviceForMediaStream)) {
+    std::vector<media::FakeVideoCaptureDeviceSettings> config;
+    media::FakeVideoCaptureDeviceFactory::
+        ParseFakeDevicesConfigFromOptionsString(
+            command_line->GetSwitchValueASCII(
+                switches::kUseFakeDeviceForMediaStream),
+            &config);
+    fake_device_factory->SetToCustomDevicesConfig(config);
+  }
+  media::VideoCaptureDeviceDescriptors device_descriptors;
+  fake_device_factory->GetDeviceDescriptors(&device_descriptors);
+  if (device_descriptors.empty()) {
+    LOG(ERROR) << "Cannot start with no fake device config";
+    std::move(result_callback).Run(nullptr);
+    return;
+  }
+  auto video_capture_device =
+      fake_device_factory->CreateDevice(device_descriptors.front());
+  video_capture_device->AllocateAndStart(params, std::move(device_client));
+  std::move(result_callback).Run(std::move(video_capture_device));
+}
+
 }  // namespace content

content/browser/renderer_host/media/in_process_video_capture_device_launcher.h

@@ -5,6 +5,9 @@
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_IN_PROCESS_VIDEO_CAPTURE_DEVICE_LAUNCHER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_IN_PROCESS_VIDEO_CAPTURE_DEVICE_LAUNCHER_H_
 
+#include <memory>
+#include <string>
+
 #include "base/single_thread_task_runner.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_provider.h"
@@ -84,6 +87,12 @@ class InProcessVideoCaptureDeviceLauncher : public VideoCaptureDeviceLauncher {
       std::unique_ptr<media::VideoCaptureDeviceClient> client,
       ReceiveDeviceCallback result_callback);
 
+  void DoStartFakeDisplayCaptureOnDeviceThread(
+      const DesktopMediaID& desktop_id,
+      const media::VideoCaptureParams& params,
+      std::unique_ptr<media::VideoCaptureDeviceClient> client,
+      ReceiveDeviceCallback result_callback);
+
   const scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
   media::VideoCaptureSystem* const video_capture_system_;
   State state_;

content/browser/renderer_host/media/media_stream_manager.cc

@@ -10,6 +10,7 @@
 #include <algorithm>
 #include <cctype>
 #include <list>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -42,6 +43,7 @@
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/desktop_media_id.h"
 #include "content/public/browser/desktop_streams_registry.h"
 #include "content/public/browser/media_observer.h"
 #include "content/public/browser/render_process_host.h"
@@ -56,6 +58,8 @@
 #include "media/base/channel_layout.h"
 #include "media/base/media_switches.h"
 #include "media/capture/video/create_video_capture_device_factory.h"
+#include "media/capture/video/fake_video_capture_device.h"
+#include "media/capture/video/fake_video_capture_device_factory.h"
 #include "media/capture/video/video_capture_system_impl.h"
 #include "services/video_capture/public/uma/video_capture_service_event.h"
 #include "url/gurl.h"
@@ -186,6 +190,48 @@ MediaStreamType AdjustAudioStreamTypeBasedOnCommandLineSwitches(
                                               : MEDIA_NO_SERVICE;
 }
 
+// Returns DesktopMediaID with fake initializers if
+// |kUseFakeDeviceForMediaStream| is set. Returns the default DesktopMediaID
+// otherwise.
+DesktopMediaID FindDesktopMediaIDFromFakeDeviceConfig() {
+  // TODO(emircan): When getDisplayMedia() accepts constraints, pick
+  // the corresponding type.
+  DesktopMediaID media_id =
+      DesktopMediaID(DesktopMediaID::TYPE_SCREEN, DesktopMediaID::kNullId);
+
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  if (command_line &&
+      command_line->HasSwitch(switches::kUseFakeDeviceForMediaStream)) {
+    std::vector<media::FakeVideoCaptureDeviceSettings> config;
+    media::FakeVideoCaptureDeviceFactory::
+        ParseFakeDevicesConfigFromOptionsString(
+            command_line->GetSwitchValueASCII(
+                switches::kUseFakeDeviceForMediaStream),
+            &config);
+    if (config.empty())
+      return media_id;
+
+    DesktopMediaID::Type desktop_media_type = DesktopMediaID::TYPE_NONE;
+    switch (config[0].display_media_type) {
+      case media::FakeVideoCaptureDevice::DisplayMediaType::ANY:
+        desktop_media_type = DesktopMediaID::TYPE_SCREEN;
+        break;
+      case media::FakeVideoCaptureDevice::DisplayMediaType::MONITOR:
+        desktop_media_type = DesktopMediaID::TYPE_SCREEN;
+        break;
+      case media::FakeVideoCaptureDevice::DisplayMediaType::WINDOW:
+        desktop_media_type = DesktopMediaID::TYPE_WINDOW;
+        break;
+      case media::FakeVideoCaptureDevice::DisplayMediaType::BROWSER:
+        desktop_media_type = DesktopMediaID::TYPE_WEB_CONTENTS;
+        break;
+    }
+    media_id = DesktopMediaID(desktop_media_type, DesktopMediaID::kFakeId);
+  }
+  return media_id;
+}
+
 }  // namespace
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
@@ -1041,12 +1087,12 @@ void MediaStreamManager::PostRequestToUI(
     devices.reserve(devices.size() + video_devices.size());
     devices.insert(devices.end(), video_devices.begin(), video_devices.end());
 
-    // We cannot select a display device without user action, therefore add a
-    // fake one for tests.
     if (request->video_type() == MEDIA_DISPLAY_VIDEO_CAPTURE) {
       DCHECK(devices.empty());
+      DesktopMediaID media_id = FindDesktopMediaIDFromFakeDeviceConfig();
       devices.push_back(MediaStreamDevice(MEDIA_DISPLAY_VIDEO_CAPTURE,
-                                          "Fake id", "Fake name"));
+                                          media_id.ToString(),
+                                          media_id.ToString()));
     }
     std::unique_ptr<FakeMediaStreamUIProxy> fake_ui = fake_ui_factory_.Run();
     fake_ui->SetAvailableDevices(devices);

content/public/browser/desktop_media_id.cc

@@ -77,6 +77,11 @@ namespace content {
 const char kScreenPrefix[] = "screen";
 const char kWindowPrefix[] = "window";
 
+// static
+const DesktopMediaID::Id DesktopMediaID::kNullId = 0;
+// static
+const DesktopMediaID::Id DesktopMediaID::kFakeId = -3;
+
 #if defined(USE_AURA)
 
 // static

content/public/browser/desktop_media_id.h

@@ -28,9 +28,9 @@ struct CONTENT_EXPORT DesktopMediaID {
   typedef intptr_t Id;
 
   // Represents an "unset" value for either |id| or |aura_id|.
-  static const Id kNullId = 0;
+  static const Id kNullId;
   // Represents a fake id to create a dummy capturer for autotests.
-  static const Id kFakeId = -3;
+  static const Id kFakeId;
 
 #if defined(USE_AURA)
   // Assigns integer identifier to the |window| and returns its DesktopMediaID.

media/capture/video/fake_video_capture_device.h

@@ -9,6 +9,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/threading/thread_checker.h"
 #include "media/capture/video/video_capture_device.h"
@@ -52,6 +53,8 @@ class FakeVideoCaptureDevice : public VideoCaptureDevice {
     USE_CLIENT_PROVIDED_BUFFERS
   };
 
+  enum class DisplayMediaType { ANY, MONITOR, WINDOW, BROWSER };
+
   FakeVideoCaptureDevice(
       const VideoCaptureFormats& supported_formats,
       std::unique_ptr<FrameDelivererFactory> frame_deliverer_factory,

media/capture/video/fake_video_capture_device_factory.cc

@@ -5,7 +5,6 @@
 #include "media/capture/video/fake_video_capture_device_factory.h"
 
 #include <array>
-#include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ -259,6 +258,8 @@ void FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
   std::vector<gfx::Size> resolutions = ArrayToVector(kDefaultResolutions);
   std::vector<float> frame_rates = ArrayToVector(kDefaultFrameRates);
   int device_count = kDefaultDeviceCount;
+  FakeVideoCaptureDevice::DisplayMediaType display_media_type =
+      FakeVideoCaptureDevice::DisplayMediaType::ANY;
 
   while (option_tokenizer.GetNext()) {
     std::vector<std::string> param =
@@ -322,6 +323,17 @@ void FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
       }
       LOG(WARNING) << "Unknown config " << param.back();
       return;
+    } else if (base::EqualsCaseInsensitiveASCII(param.front(),
+                                                "display-media-type")) {
+      if (base::EqualsCaseInsensitiveASCII(param.back(), "any")) {
+        display_media_type = FakeVideoCaptureDevice::DisplayMediaType::ANY;
+      } else if (base::EqualsCaseInsensitiveASCII(param.back(), "monitor")) {
+        display_media_type = FakeVideoCaptureDevice::DisplayMediaType::MONITOR;
+      } else if (base::EqualsCaseInsensitiveASCII(param.back(), "window")) {
+        display_media_type = FakeVideoCaptureDevice::DisplayMediaType::WINDOW;
+      } else if (base::EqualsCaseInsensitiveASCII(param.back(), "browser")) {
+        display_media_type = FakeVideoCaptureDevice::DisplayMediaType::BROWSER;
+      }
     }
   }
 
@@ -333,6 +345,7 @@ void FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
     settings.device_id = base::StringPrintf(kDefaultDeviceIdMask, device_index);
     AppendAllCombinationsToFormatsContainer(
         pixel_formats, resolutions, frame_rates, &settings.supported_formats);
+    settings.display_media_type = display_media_type;
     config->push_back(settings);
   }
 }

media/capture/video/fake_video_capture_device_factory.h

@@ -5,6 +5,12 @@
 #ifndef MEDIA_CAPTURE_VIDEO_FAKE_VIDEO_CAPTURE_DEVICE_FACTORY_H_
 #define MEDIA_CAPTURE_VIDEO_FAKE_VIDEO_CAPTURE_DEVICE_FACTORY_H_
 
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "media/capture/video/fake_video_capture_device.h"
 #include "media/capture/video/video_capture_device_factory.h"
 
@@ -19,6 +25,7 @@ struct CAPTURE_EXPORT FakeVideoCaptureDeviceSettings {
   FakeVideoCaptureDevice::DeliveryMode delivery_mode;
   VideoCaptureFormats supported_formats;
   FakePhotoDeviceConfig photo_device_config;
+  FakeVideoCaptureDevice::DisplayMediaType display_media_type;
 };
 
 // Implementation of VideoCaptureDeviceFactory that creates fake devices

media/capture/video/fake_video_capture_device_unittest.cc

@@ -474,6 +474,7 @@ struct CommandLineTestData {
   std::string switch_value_string;
   float expected_fps;
   size_t expected_device_count;
+  FakeVideoCaptureDevice::DisplayMediaType expected_display_media_type;
   std::vector<VideoPixelFormat> expected_pixel_formats;
 };
 
@@ -506,10 +507,16 @@ TEST_F(FakeVideoCaptureDeviceFactoryTest, DeviceWithNoSupportedFormats) {
 
 // Tests that the FakeVideoCaptureDeviceFactory delivers the expected number
 // of devices and formats when being configured using command-line switches.
-TEST_P(FakeVideoCaptureDeviceFactoryTest, FrameRateAndDeviceCount) {
+TEST_P(FakeVideoCaptureDeviceFactoryTest,
+       FrameRateAndDeviceCountAndDisplayMediaType) {
   std::vector<FakeVideoCaptureDeviceSettings> config;
   FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
       GetParam().switch_value_string, &config);
+  for (const auto settings : config) {
+    EXPECT_EQ(GetParam().expected_display_media_type,
+              settings.display_media_type);
+  }
+
   video_capture_device_factory_->SetToCustomDevicesConfig(config);
   video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
   EXPECT_EQ(GetParam().expected_device_count, descriptors_->size());
@@ -551,28 +558,52 @@ TEST_P(FakeVideoCaptureDeviceFactoryTest, FrameRateAndDeviceCount) {
 INSTANTIATE_TEST_CASE_P(
     ,
     FakeVideoCaptureDeviceFactoryTest,
-    Values(CommandLineTestData{"fps=-1", 5, 1u, {PIXEL_FORMAT_I420}},
+    Values(CommandLineTestData{"fps=-1",
+                               5,
+                               1u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
+                               {PIXEL_FORMAT_I420}},
            CommandLineTestData{"fps=29.97,device-count=1",
                                29.97f,
                                1u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
                                {PIXEL_FORMAT_I420}},
            CommandLineTestData{"fps=60,device-count=2",
                                60,
                                2u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16}},
            CommandLineTestData{"fps=1000,device-count=-1",
                                60,
                                1u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
                                {PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=4",
                                20,
                                4u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
                                 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=4,ownership=client",
                                20,
                                4u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
                                 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
-           CommandLineTestData{"device-count=0", 20, 0u, {PIXEL_FORMAT_I420}}));
+           CommandLineTestData{"device-count=0",
+                               20,
+                               0u,
+                               FakeVideoCaptureDevice::DisplayMediaType::ANY,
+                               {PIXEL_FORMAT_I420}},
+           CommandLineTestData{"display-media-type=window",
+                               20,
+                               1u,
+                               FakeVideoCaptureDevice::DisplayMediaType::WINDOW,
+                               {PIXEL_FORMAT_I420}},
+           CommandLineTestData{
+               "display-media-type=browser,fps=60",
+               60,
+               1u,
+               FakeVideoCaptureDevice::DisplayMediaType::BROWSER,
+               {PIXEL_FORMAT_I420}}));
 };  // namespace media