Do not pass the origin to MediaDevicesDispatcherHost.

content/renderer/media/user_media_client_impl_unittest.cc

 // Copyright (c) 2012 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/renderer/media/user_media_client_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 99 matching lines @@
 const char kFakeVideoInputDeviceId2[] = "fake_video_input 2";
 const char kFakeAudioOutputDeviceId1[] = "fake_audio_output 1";
 
 class MockMediaDevicesDispatcherHost
     : public ::mojom::MediaDevicesDispatcherHost {
  public:
   MockMediaDevicesDispatcherHost() {}
   void EnumerateDevices(bool request_audio_input,
                         bool request_video_input,
                         bool request_audio_output,
-                        const url::Origin& security_origin,
                         EnumerateDevicesCallback callback) override {
     std::vector<std::vector<MediaDeviceInfo>> result(NUM_MEDIA_DEVICE_TYPES);
     if (request_audio_input) {
       result[MEDIA_DEVICE_TYPE_AUDIO_INPUT].push_back(MediaDeviceInfo(
           kFakeAudioInputDeviceId1, "Fake Audio Input 1", "fake_group 1"));
       result[MEDIA_DEVICE_TYPE_AUDIO_INPUT].push_back(MediaDeviceInfo(
           kFakeAudioInputDeviceId2, "Fake Audio Input 2", "fake_group 2"));
     }
     if (request_video_input) {
       result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].push_back(
           MediaDeviceInfo(kFakeVideoInputDeviceId1, "Fake Video Input 1", ""));
       result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].push_back(
           MediaDeviceInfo(kFakeVideoInputDeviceId2, "Fake Video Input 2", ""));
     }
     if (request_audio_output) {
       result[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].push_back(MediaDeviceInfo(
           kFakeAudioOutputDeviceId1, "Fake Audio Input 1", "fake_group 1"));
     }
     std::move(callback).Run(result);
   }
 
   void GetVideoInputCapabilities(
-      const url::Origin& security_origin,
       GetVideoInputCapabilitiesCallback client_callback) override {
     ::mojom::VideoInputDeviceCapabilitiesPtr device =
         ::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kFakeVideoInputDeviceId1;
     device->facing_mode = ::mojom::FacingMode::USER;
     device->formats.push_back(media::VideoCaptureFormat(
         gfx::Size(640, 480), 30.0f, media::PIXEL_FORMAT_I420));
     std::vector<::mojom::VideoInputDeviceCapabilitiesPtr> result;
     result.push_back(std::move(device));
 
     device = ::mojom::VideoInputDeviceCapabilities::New();
     device->device_id = kFakeVideoInputDeviceId2;
     device->facing_mode = ::mojom::FacingMode::ENVIRONMENT;
     device->formats.push_back(media::VideoCaptureFormat(
         gfx::Size(640, 480), 30.0f, media::PIXEL_FORMAT_I420));
     result.push_back(std::move(device));
 
     std::move(client_callback).Run(std::move(result));
   }
 
-  MOCK_METHOD3(SubscribeDeviceChangeNotifications,
-               void(MediaDeviceType type,
-                    uint32_t subscription_id,
-                    const url::Origin& security_origin));
+  MOCK_METHOD2(SubscribeDeviceChangeNotifications,
+               void(MediaDeviceType type, uint32_t subscription_id));
   MOCK_METHOD2(UnsubscribeDeviceChangeNotifications,
                void(MediaDeviceType type, uint32_t subscription_id));
 };
 
 class UserMediaClientImplUnderTest : public UserMediaClientImpl {
  public:
   enum RequestState {
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
@@ skipping 596 matching lines @@
   EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection(
       factory.CreateWebMediaConstraints()));
 
   factory.Reset();
   factory.basic().render_to_associated_sink.SetExact(false);
   EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection(
       factory.CreateWebMediaConstraints()));
 }
 
 TEST_F(UserMediaClientImplTest, ObserveMediaDeviceChanges) {
+  EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications(
+                                             MEDIA_DEVICE_TYPE_AUDIO_INPUT, _));
+  EXPECT_CALL(media_devices_dispatcher_, SubscribeDeviceChangeNotifications(
+                                             MEDIA_DEVICE_TYPE_VIDEO_INPUT, _));
   EXPECT_CALL(
       media_devices_dispatcher_,
-      SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_INPUT, _, _));
-  EXPECT_CALL(
-      media_devices_dispatcher_,
-      SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_VIDEO_INPUT, _, _));
-  EXPECT_CALL(
-      media_devices_dispatcher_,
-      SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _, _));
+      SubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _));
   user_media_client_impl_->SetMediaDeviceChangeObserver(
       blink::WebMediaDeviceChangeObserver(true));
   base::RunLoop().RunUntilIdle();
 
   base::WeakPtr<MediaDevicesEventDispatcher> event_dispatcher =
       MediaDevicesEventDispatcher::GetForRenderFrame(nullptr);
   event_dispatcher->DispatchDevicesChangedEvent(MEDIA_DEVICE_TYPE_AUDIO_INPUT,
                                                 MediaDeviceInfoArray());
   event_dispatcher->DispatchDevicesChangedEvent(MEDIA_DEVICE_TYPE_VIDEO_INPUT,
                                                 MediaDeviceInfoArray());
@@ skipping 120 matching lines @@
       CreateDeviceConstraints(kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints =
       CreateFacingModeConstraints("environment");
   // kFakeVideoInputDeviceId2 has environment facing mode.
   TestValidRequestWithConstraints(audio_constraints, video_constraints,
                                   kFakeAudioInputDeviceId1,
                                   kFakeVideoInputDeviceId2);
 }
 
 }  // namespace content