Reland of Use mojo support for Blink devicechange event.

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 14 matching lines @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
+using testing::_;
+
 namespace content {
 
 class MockMediaStreamVideoCapturerSource : public MockMediaStreamVideoSource {
  public:
   MockMediaStreamVideoCapturerSource(
       const StreamDeviceInfo& device,
       const SourceStoppedCallback& stop_callback,
       PeerConnectionDependencyFactory* factory)
   : MockMediaStreamVideoSource(false) {
     SetDeviceInfo(device);
     SetStopCallback(stop_callback);
   }
 };
 
 class MockMediaDevicesDispatcherHost
     : public ::mojom::MediaDevicesDispatcherHost {
  public:
-  MockMediaDevicesDispatcherHost() : binding_(this) {}
+  MockMediaDevicesDispatcherHost() {}
   void EnumerateDevices(bool request_audio_input,
                         bool request_video_input,
                         bool request_audio_output,
                         const url::Origin& security_origin,
                         const 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(
           "fake_audio_input 1", "Fake Audio Input 1", "fake_group 1"));
       result[MEDIA_DEVICE_TYPE_AUDIO_INPUT].push_back(MediaDeviceInfo(
@@ skipping 11 matching lines @@
     }
     callback.Run(result);
   }
 
   MOCK_METHOD3(SubscribeDeviceChangeNotifications,
                void(MediaDeviceType type,
                     uint32_t subscription_id,
                     const url::Origin& security_origin));
   MOCK_METHOD2(UnsubscribeDeviceChangeNotifications,
                void(MediaDeviceType type, uint32_t subscription_id));
-
-  ::mojom::MediaDevicesDispatcherHostPtr CreateInterfacePtrAndBind() {
-    return binding_.CreateInterfacePtrAndBind();
-  }
-
- private:
-  mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_;
 };
 
 class UserMediaClientImplUnderTest : public UserMediaClientImpl {
  public:
   enum RequestState {
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
     REQUEST_FAILED,
   };
@@ skipping 133 matching lines @@
   content::MediaStreamRequestResult result_;
   blink::WebString result_name_;
   blink::WebVector<blink::WebMediaDeviceInfo> last_devices_;
   PeerConnectionDependencyFactory* factory_;
   bool create_source_that_fails_;
   MockMediaStreamVideoCapturerSource* video_source_;
 };
 
 class UserMediaClientImplTest : public ::testing::Test {
  public:
+  UserMediaClientImplTest()
+      : binding_user_media(&media_devices_dispatcher_),
+        binding_event_dispatcher_(&media_devices_dispatcher_) {}
+
   void SetUp() override {
     // Create our test object.
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
     ms_dispatcher_ = new MockMediaStreamDispatcher();
     used_media_impl_.reset(new UserMediaClientImplUnderTest(
         dependency_factory_.get(),
         std::unique_ptr<MediaStreamDispatcher>(ms_dispatcher_)));
     used_media_impl_->SetMediaDevicesDispatcherForTesting(
-        media_devices_dispatcher_.CreateInterfacePtrAndBind());
+        binding_user_media.CreateInterfacePtrAndBind());
+    base::WeakPtr<MediaDevicesEventDispatcher> event_dispatcher =
+        MediaDevicesEventDispatcher::GetForRenderFrame(nullptr);
+    event_dispatcher->SetMediaDevicesDispatcherForTesting(
+        binding_event_dispatcher_.CreateInterfacePtrAndBind());
   }
 
   void TearDown() override {
+    MediaDevicesEventDispatcher::GetForRenderFrame(nullptr)->OnDestruct();
     used_media_impl_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   void LoadNewDocumentInFrame() {
     used_media_impl_->WillCommitProvisionalLoad();
   }
 
   blink::WebMediaStream RequestLocalMediaStream() {
     used_media_impl_->RequestUserMedia();
@@ skipping 57 matching lines @@
         ms_dispatcher_->audio_input_request_id());
     used_media_impl_->DeleteRequest(ms_dispatcher_->audio_input_request_id());
     return result;
   }
 
  protected:
   base::MessageLoop message_loop_;
   std::unique_ptr<ChildProcess> child_process_;
   MockMediaStreamDispatcher* ms_dispatcher_;  // Owned by |used_media_impl_|.
   MockMediaDevicesDispatcherHost media_devices_dispatcher_;
+  mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_user_media;
+  mojo::Binding<::mojom::MediaDevicesDispatcherHost> binding_event_dispatcher_;
+
   std::unique_ptr<UserMediaClientImplUnderTest> used_media_impl_;
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
 };
 
 TEST_F(UserMediaClientImplTest, GenerateMediaStream) {
   // Generate a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
 }
 
 // Test that the same source object is used if two MediaStreams are generated
@@ skipping 302 matching lines @@
   EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection(
       factory.CreateWebMediaConstraints()));
 
   factory.Reset();
   factory.basic().renderToAssociatedSink.setExact(false);
   EXPECT_FALSE(AudioRequestHasAutomaticDeviceSelection(
       factory.CreateWebMediaConstraints()));
 }
 
 TEST_F(UserMediaClientImplTest, ObserveMediaDeviceChanges) {
-  // For a null UserMediaRequest (no audio requested), we expect false.
-  EXPECT_EQ(0U, ms_dispatcher_->NumDeviceChangeSubscribers());
+  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, _, _));
   used_media_impl_->SetMediaDeviceChangeObserver();
-  EXPECT_EQ(1U, ms_dispatcher_->NumDeviceChangeSubscribers());
-  used_media_impl_->OnDevicesChanged();
+  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());
+  event_dispatcher->DispatchDevicesChangedEvent(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT,
+                                                MediaDeviceInfoArray());
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_CALL(media_devices_dispatcher_, UnsubscribeDeviceChangeNotifications(
+                                             MEDIA_DEVICE_TYPE_AUDIO_INPUT, _));
+  EXPECT_CALL(media_devices_dispatcher_, UnsubscribeDeviceChangeNotifications(
+                                             MEDIA_DEVICE_TYPE_VIDEO_INPUT, _));
+  EXPECT_CALL(
+      media_devices_dispatcher_,
+      UnsubscribeDeviceChangeNotifications(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _));
   used_media_impl_->RemoveMediaDeviceChangeObserver();
-  EXPECT_EQ(0U, ms_dispatcher_->NumDeviceChangeSubscribers());
-  used_media_impl_->OnDevicesChanged();
+  base::RunLoop().RunUntilIdle();
 }
 
 // This test what happens if the audio stream has same id with video stream.
 TEST_F(UserMediaClientImplTest, AudioVideoWithSameId) {
   ms_dispatcher_->TestSameId();
 
   // Generate a stream with both audio and video.
   blink::WebMediaStream mixed_desc = RequestLocalMediaStream();
 
   // Remove video track. This should trigger
   // UserMediaClientImpl::OnLocalSourceStopped, and has video track to be
   // removed from its |local_sources_|.
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   mixed_desc.videoTracks(video_tracks);
   MediaStreamTrack* video_track = MediaStreamTrack::GetTrack(video_tracks[0]);
   video_track->Stop();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
   EXPECT_EQ(0, ms_dispatcher_->stop_audio_device_counter());
 
   // Now we load a new document in the web frame. If in the above Stop() call,
   // UserMediaClientImpl accidentally removed audio track, then video track will
   // be removed again here, which is incorrect.
   LoadNewDocumentInFrame();
   blink::WebHeap::collectAllGarbageForTesting();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
   EXPECT_EQ(1, ms_dispatcher_->stop_audio_device_counter());
 }
 
 }  // namespace content