Do not pass the origin to MediaDevicesDispatcherHost.

content/browser/renderer_host/media/media_devices_dispatcher_host_unittest.cc

 // Copyright 2016 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/renderer_host/media/media_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <queue>
@@ skipping 53 matching lines @@
   ::mojom::MediaDevicesListenerPtr CreateInterfacePtrAndBind() {
     return binding_.CreateInterfacePtrAndBind();
   }
 
  private:
   mojo::Binding<::mojom::MediaDevicesListener> binding_;
 };
 
 }  // namespace
 
-class MediaDevicesDispatcherHostTest : public testing::Test {
+class MediaDevicesDispatcherHostTest : public testing::TestWithParam<GURL> {
  public:
   MediaDevicesDispatcherHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        origin_(GURL("https://test.com")) {
+        origin_(GetParam()) {
     // Make sure we use fake devices to avoid long delays.
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kUseFakeDeviceForMediaStream,
         base::StringPrintf("device-count=%zu, video-input-default-id=%s",
                            kNumFakeVideoDevices, kDefaultVideoDeviceID));
     audio_manager_.reset(
         new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get()));
     audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get());
     media_stream_manager_ =
         base::MakeUnique<MediaStreamManager>(audio_system_.get());
 
     host_ = base::MakeUnique<MediaDevicesDispatcherHost>(
         kProcessId, kRenderId, browser_context_.GetMediaDeviceIDSalt(),
         media_stream_manager_.get());
+    host_->SetSecurityOriginForTesting(origin_);
   }
 
   void SetUp() override {
     base::RunLoop run_loop;
     MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
     media_stream_manager_->media_devices_manager()->EnumerateDevices(
         devices_to_enumerate,
@@ skipping 47 matching lines @@
 
   void EnumerateDevicesAndWaitForResult(bool enumerate_audio_input,
                                         bool enumerate_video_input,
                                         bool enumerate_audio_output,
                                         bool permission_override_value = true) {
     host_->SetPermissionChecker(base::MakeUnique<MediaDevicesPermissionChecker>(
         permission_override_value));
     base::RunLoop run_loop;
     host_->EnumerateDevices(
         enumerate_audio_input, enumerate_video_input, enumerate_audio_output,
-        origin_, base::Bind(&MediaDevicesDispatcherHostTest::DevicesEnumerated,
-                            base::Unretained(this), run_loop.QuitClosure()));
+        base::Bind(&MediaDevicesDispatcherHostTest::DevicesEnumerated,
+                   base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
 
     ASSERT_FALSE(enumerated_devices_.empty());
     if (enumerate_audio_input)
       EXPECT_FALSE(enumerated_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].empty());
     if (enumerate_video_input)
       EXPECT_FALSE(enumerated_devices_[MEDIA_DEVICE_TYPE_VIDEO_INPUT].empty());
     if (enumerate_audio_output)
       EXPECT_FALSE(enumerated_devices_[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].empty());
 
@@ skipping 77 matching lines @@
       if (!DoesNotContainLabels(device_infos))
         return false;
     }
     return true;
   }
 
   void SubscribeAndWaitForResult(bool has_permission) {
     host_->SetPermissionChecker(
         base::MakeUnique<MediaDevicesPermissionChecker>(has_permission));
     uint32_t subscription_id = 0u;
-    uint32_t unique_origin_subscription_id = 1u;
-    url::Origin origin(GURL("http://localhost"));
-    url::Origin unique_origin;
     for (size_t i = 0; i < NUM_MEDIA_DEVICE_TYPES; ++i) {
       MediaDeviceType type = static_cast<MediaDeviceType>(i);
-      host_->SubscribeDeviceChangeNotifications(type, subscription_id, origin);
+      host_->SubscribeDeviceChangeNotifications(type, subscription_id);
       MockMediaDevicesListener device_change_listener;
       host_->SetDeviceChangeListenerForTesting(
           device_change_listener.CreateInterfacePtrAndBind());
       MediaDeviceInfoArray changed_devices;
       EXPECT_CALL(device_change_listener,
                   OnDevicesChanged(type, subscription_id, testing::_))
           .WillRepeatedly(SaveArg<2>(&changed_devices));
-      // The subscription with unique origin is ignored, so it should not get
-      // notifications.
-      EXPECT_CALL(
-          device_change_listener,
-          OnDevicesChanged(type, unique_origin_subscription_id, testing::_))
-          .Times(0);
 
       // Simulate device-change notification
       MediaDeviceInfoArray updated_devices = {
           {"fake_device_id", "fake_label", "fake_group"}};
       host_->OnDevicesChanged(type, updated_devices);
       base::RunLoop().RunUntilIdle();
       host_->UnsubscribeDeviceChangeNotifications(type, subscription_id);
 
       if (has_permission)
         EXPECT_TRUE(DoesContainLabels(changed_devices));
@@ skipping 13 matching lines @@
   std::unique_ptr<media::AudioManager, media::AudioManagerDeleter>
       audio_manager_;
   std::unique_ptr<media::AudioSystem> audio_system_;
   content::TestBrowserContext browser_context_;
   MediaDeviceEnumeration physical_devices_;
   url::Origin origin_;
 
   std::vector<MediaDeviceInfoArray> enumerated_devices_;
 };
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevices) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevices) {
   EnumerateDevicesAndWaitForResult(true, false, false);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevices) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevices) {
   EnumerateDevicesAndWaitForResult(false, true, false);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevices) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevices) {
   EnumerateDevicesAndWaitForResult(false, false, true);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAllDevices) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAllDevices) {
   EnumerateDevicesAndWaitForResult(true, true, true);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevicesNoAccess) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevicesNoAccess) {
   EnumerateDevicesAndWaitForResult(true, false, false, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevicesNoAccess) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevicesNoAccess) {
   EnumerateDevicesAndWaitForResult(false, true, false, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevicesNoAccess) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevicesNoAccess) {
   EnumerateDevicesAndWaitForResult(false, false, true, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAllDevicesNoAccess) {
+TEST_P(MediaDevicesDispatcherHostTest, EnumerateAllDevicesNoAccess) {
   EnumerateDevicesAndWaitForResult(true, true, true, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, SubscribeDeviceChange) {
+TEST_P(MediaDevicesDispatcherHostTest, SubscribeDeviceChange) {
   SubscribeAndWaitForResult(true);
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, SubscribeDeviceChangeNoAccess) {
+TEST_P(MediaDevicesDispatcherHostTest, SubscribeDeviceChangeNoAccess) {
   SubscribeAndWaitForResult(false);
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, EnumerateAllDevicesUniqueOrigin) {
-  EXPECT_CALL(*this, UniqueOriginCallback(testing::_)).Times(0);
-  host_->EnumerateDevices(
-      true, true, true, url::Origin(),
-      base::Bind(&MediaDevicesDispatcherHostTest::UniqueOriginCallback,
-                 base::Unretained(this)));
-  base::RunLoop().RunUntilIdle();
-
-  // Verify that the callback for a valid origin does get called.
-  base::RunLoop run_loop;
-  EXPECT_CALL(*this, ValidOriginCallback(testing::_))
-      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  host_->EnumerateDevices(
-      true, true, true, url::Origin(GURL("http://localhost")),
-      base::Bind(&MediaDevicesDispatcherHostTest::ValidOriginCallback,
-                 base::Unretained(this)));
-  run_loop.Run();
-}
-
-TEST_F(MediaDevicesDispatcherHostTest, GetVideoInputCapabilities) {
+TEST_P(MediaDevicesDispatcherHostTest, GetVideoInputCapabilities) {
   base::RunLoop run_loop;
   EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback())
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
   host_->GetVideoInputCapabilities(
-      origin_,
       base::Bind(
           &MediaDevicesDispatcherHostTest::VideoInputCapabilitiesCallback,
           base::Unretained(this)));
   run_loop.Run();
 }
 
-TEST_F(MediaDevicesDispatcherHostTest, GetVideoInputCapabilitiesUniqueOrigin) {
-  base::RunLoop run_loop;
-  EXPECT_CALL(*this, MockVideoInputCapabilitiesCallback())
-      .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  host_->GetVideoInputCapabilities(
-      url::Origin(), base::Bind(&MediaDevicesDispatcherHostTest::
-                                    VideoInputCapabilitiesUniqueOriginCallback,
-                                base::Unretained(this)));
-  run_loop.Run();
-}
-
+INSTANTIATE_TEST_CASE_P(,
+                        MediaDevicesDispatcherHostTest,
+                        testing::Values(GURL(), GURL("https://test.com")));
 };  // namespace content