Migrate MediaDevices.enumerateDevices to Mojo

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>
+#include <vector>
 
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
+#include "content/common/media/media_devices.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/mock_constraint_factory.h"
 #include "content/renderer/media/mock_media_stream_dispatcher.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#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/WebMediaStreamTrackSourcesRequest.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"
 
 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) {}
+  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(
+          "fake_audio_input 2", "Fake Audio Input 2", "fake_group 2"));
+    }
+    if (request_video_input) {
+      result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].push_back(
+          MediaDeviceInfo("fake_video_input 1", "Fake Video Input 1", ""));
+      result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].push_back(
+          MediaDeviceInfo("fake_video_input 2", "Fake Video Input 2", ""));
+    }
+    if (request_audio_output) {
+      result[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].push_back(MediaDeviceInfo(
+          "fake_audio_output 1", "Fake Audio Input 1", "fake_group 1"));
+    }
+    callback.Run(result);
+  }
+
+  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,
   };
 
   UserMediaClientImplUnderTest(
@@ skipping 157 matching lines @@
 class UserMediaClientImplTest : public ::testing::Test {
  public:
   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());
   }
 
   void TearDown() override {
     used_media_impl_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   void LoadNewDocumentInFrame() {
     used_media_impl_->WillCommitProvisionalLoad();
   }
@@ skipping 27 matching lines @@
 
   void FakeMediaStreamDispatcherRequestUserMediaComplete() {
     // Audio request ID is used as the shared request ID.
     used_media_impl_->OnStreamGenerated(
         ms_dispatcher_->audio_input_request_id(),
         ms_dispatcher_->stream_label(),
         ms_dispatcher_->audio_input_array(),
         ms_dispatcher_->video_array());
   }
 
-  void FakeMediaStreamDispatcherRequestMediaDevicesComplete() {
-    // There may be repeated replies due to device or configuration changes.
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->audio_input_request_id(),
-        ms_dispatcher_->audio_input_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->audio_input_request_id(),
-        ms_dispatcher_->audio_input_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->audio_output_request_id(),
-        ms_dispatcher_->audio_output_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->audio_output_request_id(),
-        ms_dispatcher_->audio_output_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->video_request_id(),
-        ms_dispatcher_->video_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->video_request_id(),
-        ms_dispatcher_->video_array());
-  }
-
-  void FakeMediaStreamDispatcherRequestSourcesComplete() {
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->audio_input_request_id(),
-        ms_dispatcher_->audio_input_array());
-    used_media_impl_->OnDevicesEnumerated(
-        ms_dispatcher_->video_request_id(),
-        ms_dispatcher_->video_array());
-  }
-
   void StartMockedVideoSource() {
     MockMediaStreamVideoCapturerSource* video_source =
         used_media_impl_->last_created_video_source();
     if (video_source->SourceHasAttemptedToStart())
       video_source->StartMockedSource();
   }
 
   void FailToStartMockedVideoSource() {
     MockMediaStreamVideoCapturerSource* video_source =
         used_media_impl_->last_created_video_source();
@@ skipping 12 matching lines @@
     bool result = used_media_impl_->UserMediaRequestHasAutomaticDeviceSelection(
         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_;
   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 214 matching lines @@
 
   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());
 }
 
 TEST_F(UserMediaClientImplTest, EnumerateMediaDevices) {
   used_media_impl_->RequestMediaDevices();
-  FakeMediaStreamDispatcherRequestMediaDevicesComplete();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED,
             used_media_impl_->request_state());
   EXPECT_EQ(static_cast<size_t>(5), used_media_impl_->last_devices().size());
 
   // Audio input device with matched output ID.
   const blink::WebMediaDeviceInfo* device =
       &used_media_impl_->last_devices()[0];
   EXPECT_FALSE(device->deviceId().isEmpty());
   EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
@@ skipping 34 matching lines @@
 
   // Verfify group IDs.
   EXPECT_TRUE(used_media_impl_->last_devices()[0].groupId().equals(
                   used_media_impl_->last_devices()[4].groupId()));
   EXPECT_FALSE(used_media_impl_->last_devices()[1].groupId().equals(
                    used_media_impl_->last_devices()[4].groupId()));
 }
 
 TEST_F(UserMediaClientImplTest, EnumerateSources) {
   used_media_impl_->RequestSources();
-  FakeMediaStreamDispatcherRequestSourcesComplete();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED,
             used_media_impl_->request_state());
   EXPECT_EQ(static_cast<size_t>(4), used_media_impl_->last_sources().size());
 
   // Audio input devices.
   const blink::WebSourceInfo* source = &used_media_impl_->last_sources()[0];
   EXPECT_FALSE(source->id().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::SourceKindAudio, source->kind());
   EXPECT_FALSE(source->label().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeNone, source->facing());
 
   source = &used_media_impl_->last_sources()[1];
   EXPECT_FALSE(source->id().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::SourceKindAudio, source->kind());
   EXPECT_FALSE(source->label().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeNone, source->facing());
 
   // Video input device user facing.
   source = &used_media_impl_->last_sources()[2];
   EXPECT_FALSE(source->id().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::SourceKindVideo, source->kind());
   EXPECT_FALSE(source->label().isEmpty());
-  EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeUser, source->facing());
+  EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeNone, source->facing());
 
   // Video input device environment facing.
   source = &used_media_impl_->last_sources()[3];
   EXPECT_FALSE(source->id().isEmpty());
   EXPECT_EQ(blink::WebSourceInfo::SourceKindVideo, source->kind());
   EXPECT_FALSE(source->label().isEmpty());
-  EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeEnvironment, source->facing());
+  EXPECT_EQ(blink::WebSourceInfo::VideoFacingModeNone, source->facing());
 }
 
 TEST_F(UserMediaClientImplTest, RenderToAssociatedSinkConstraint) {
   // For a null UserMediaRequest (no audio requested), we expect false.
   used_media_impl_->RequestUserMedia();
   EXPECT_FALSE(used_media_impl_->UserMediaRequestHasAutomaticDeviceSelection(
       ms_dispatcher_->audio_input_request_id()));
   used_media_impl_->DeleteRequest(ms_dispatcher_->audio_input_request_id());
 
   // If audio is requested, but no constraint, it should be true.
@@ skipping 54 matching lines @@
   // 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