Reland of Use spec-compliant algorithm to select video devices in getUserMedia.

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 27 matching lines @@
 
 blink::WebMediaConstraints CreateDefaultConstraints() {
   MockConstraintFactory factory;
   factory.AddAdvanced();
   return factory.CreateWebMediaConstraints();
 }
 
 blink::WebMediaConstraints CreateDeviceConstraints(
     const char* basic_exact_value,
     const char* basic_ideal_value = nullptr,
-    const char* advanced_exact_value = nullptr,
-    const char* advanced_ideal_value = nullptr) {
+    const char* advanced_exact_value = nullptr) {
   MockConstraintFactory factory;
   blink::WebMediaTrackConstraintSet basic;
   if (basic_exact_value) {
     factory.basic().deviceId.setExact(
         blink::WebString::fromUTF8(basic_exact_value));
   }
   if (basic_ideal_value) {
     blink::WebString value = blink::WebString::fromUTF8(basic_ideal_value);
     factory.basic().deviceId.setIdeal(
         blink::WebVector<blink::WebString>(&value, 1));
   }
 
   auto& advanced = factory.AddAdvanced();
   if (advanced_exact_value) {
     blink::WebString value = blink::WebString::fromUTF8(advanced_exact_value);
     advanced.deviceId.setExact(value);
   }
-  if (advanced_ideal_value) {
-    blink::WebString value = blink::WebString::fromUTF8(advanced_ideal_value);
-    advanced.deviceId.setIdeal(blink::WebVector<blink::WebString>(&value, 1));
+
+  return factory.CreateWebMediaConstraints();
+}
+
+blink::WebMediaConstraints CreateFacingModeConstraints(
+    const char* basic_exact_value,
+    const char* basic_ideal_value = nullptr,
+    const char* advanced_exact_value = nullptr) {
+  MockConstraintFactory factory;
+  if (basic_exact_value) {
+    factory.basic().facingMode.setExact(
+        blink::WebString::fromUTF8(basic_exact_value));
+  }
+  if (basic_ideal_value) {
+    blink::WebString value = blink::WebString::fromUTF8(basic_ideal_value);
+    factory.basic().deviceId.setIdeal(
+        blink::WebVector<blink::WebString>(&value, 1));
+  }
+
+  auto& advanced = factory.AddAdvanced();
+  if (advanced_exact_value) {
+    blink::WebString value = blink::WebString::fromUTF8(advanced_exact_value);
+    advanced.deviceId.setExact(value);
   }
 
   return factory.CreateWebMediaConstraints();
 }
 
 class MockMediaStreamVideoCapturerSource : public MockMediaStreamVideoSource {
  public:
   MockMediaStreamVideoCapturerSource(
       const StreamDeviceInfo& device,
       const SourceStoppedCallback& stop_callback,
@@ skipping 33 matching lines @@
       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"));
     }
     callback.Run(result);
   }
 
+  void GetVideoInputCapabilities(
+      const url::Origin& security_origin,
+      const 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));
+
+    client_callback.Run(std::move(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));
-  MOCK_METHOD2(GetVideoInputCapabilities,
-               void(const url::Origin& security_origin,
-                    const GetVideoInputCapabilitiesCallback& client_callback));
 };
 
 class UserMediaClientImplUnderTest : public UserMediaClientImpl {
  public:
   enum RequestState {
     REQUEST_NOT_STARTED,
     REQUEST_NOT_COMPLETE,
     REQUEST_SUCCEEDED,
     REQUEST_FAILED,
   };
 
   UserMediaClientImplUnderTest(
       PeerConnectionDependencyFactory* dependency_factory,
       std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher)
-      : UserMediaClientImpl(NULL,
+      : UserMediaClientImpl(nullptr,
                             dependency_factory,
-                            std::move(media_stream_dispatcher)),
+                            std::move(media_stream_dispatcher),
+                            base::ThreadTaskRunnerHandle::Get()),
         state_(REQUEST_NOT_STARTED),
         result_(NUM_MEDIA_REQUEST_RESULTS),
         result_name_(""),
         factory_(dependency_factory),
         create_source_that_fails_(false),
-        video_source_(NULL) {}
+        video_source_(nullptr) {}
 
   void RequestUserMediaForTest(
       const blink::WebUserMediaRequest& user_media_request) {
     state_ = REQUEST_NOT_COMPLETE;
     requestUserMedia(user_media_request);
     base::RunLoop().RunUntilIdle();
   }
 
   void RequestUserMediaForTest() {
     blink::WebUserMediaRequest user_media_request =
@@ skipping 218 matching lines @@
                                                      null_constraints);
     user_media_client_impl_->RequestUserMediaForTest(request);
     bool result =
         user_media_client_impl_->UserMediaRequestHasAutomaticDeviceSelection(
             ms_dispatcher_->audio_input_request_id());
     user_media_client_impl_->DeleteRequest(
         ms_dispatcher_->audio_input_request_id());
     return result;
   }
 
-  void TestValidRequestWithDeviceConstraints(
+  void TestValidRequestWithConstraints(
       const blink::WebMediaConstraints& audio_constraints,
       const blink::WebMediaConstraints& video_constraints,
       const std::string& expected_audio_device_id,
       const std::string& expected_video_device_id) {
     DCHECK(!audio_constraints.isNull());
     DCHECK(!video_constraints.isNull());
     blink::WebUserMediaRequest request =
         blink::WebUserMediaRequest::createForTesting(audio_constraints,
                                                      video_constraints);
     user_media_client_impl_->RequestUserMediaForTest(request);
@@ skipping 427 matching lines @@
   user_media_client_impl_->RequestUserMediaForTest(request);
   EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_FAILED,
             user_media_client_impl_->request_state());
 }
 
 TEST_F(UserMediaClientImplTest, CreateWithMandatoryValidDeviceIds) {
   blink::WebMediaConstraints audio_constraints =
       CreateDeviceConstraints(kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints =
       CreateDeviceConstraints(kFakeVideoInputDeviceId1);
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        kFakeAudioInputDeviceId1,
-                                        kFakeVideoInputDeviceId1);
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  kFakeAudioInputDeviceId1,
+                                  kFakeVideoInputDeviceId1);
 }
 
 TEST_F(UserMediaClientImplTest, CreateWithBasicIdealValidDeviceId) {
   blink::WebMediaConstraints audio_constraints =
       CreateDeviceConstraints(nullptr, kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints =
       CreateDeviceConstraints(nullptr, kFakeVideoInputDeviceId1);
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        kFakeAudioInputDeviceId1,
-                                        kFakeVideoInputDeviceId1);
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  kFakeAudioInputDeviceId1,
+                                  kFakeVideoInputDeviceId1);
 }
 
 TEST_F(UserMediaClientImplTest, CreateWithAdvancedExactValidDeviceId) {
   blink::WebMediaConstraints audio_constraints =
       CreateDeviceConstraints(nullptr, nullptr, kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints = CreateDeviceConstraints(
       nullptr, nullptr, kFakeVideoInputDeviceId1);
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        kFakeAudioInputDeviceId1,
-                                        kFakeVideoInputDeviceId1);
-}
-
-TEST_F(UserMediaClientImplTest, CreateWithAdvancedIdealValidDeviceId) {
-  blink::WebMediaConstraints audio_constraints = CreateDeviceConstraints(
-      nullptr, nullptr, nullptr, kFakeAudioInputDeviceId1);
-  blink::WebMediaConstraints video_constraints = CreateDeviceConstraints(
-      nullptr, nullptr, nullptr, kFakeVideoInputDeviceId1);
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        kFakeAudioInputDeviceId1,
-                                        kFakeVideoInputDeviceId1);
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  kFakeAudioInputDeviceId1,
+                                  kFakeVideoInputDeviceId1);
 }
 
 TEST_F(UserMediaClientImplTest, CreateWithAllOptionalInvalidDeviceId) {
-  blink::WebMediaConstraints audio_constraints = CreateDeviceConstraints(
-      nullptr, kInvalidDeviceId, kInvalidDeviceId, kInvalidDeviceId);
-  blink::WebMediaConstraints video_constraints = CreateDeviceConstraints(
-      nullptr, kInvalidDeviceId, kInvalidDeviceId, kInvalidDeviceId);
-  // MockMediaStreamDispatcher uses empty string as default device ID.
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        std::string(), std::string());
+  blink::WebMediaConstraints audio_constraints =
+      CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId);
+  blink::WebMediaConstraints video_constraints =
+      CreateDeviceConstraints(nullptr, kInvalidDeviceId, kInvalidDeviceId);
+  // MockMediaStreamDispatcher uses empty string as default audio device ID.
+  // MockMediaDevicesDispatcher uses the first device in the enumeration as
+  // default video device ID.
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  std::string(), kFakeVideoInputDeviceId1);
 }
 
-TEST_F(UserMediaClientImplTest,
-       CreateWithAdvancedIdealValidOtherOptionalInvalidDeviceId) {
-  blink::WebMediaConstraints audio_constraints = CreateDeviceConstraints(
-      nullptr, kInvalidDeviceId, kInvalidDeviceId, kFakeAudioInputDeviceId1);
-  blink::WebMediaConstraints video_constraints = CreateDeviceConstraints(
-      nullptr, kInvalidDeviceId, kInvalidDeviceId, kFakeVideoInputDeviceId1);
-  TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
-                                        kFakeAudioInputDeviceId1,
-                                        kFakeVideoInputDeviceId1);
+TEST_F(UserMediaClientImplTest, CreateWithFacingModeUser) {
+  blink::WebMediaConstraints audio_constraints =
+      CreateDeviceConstraints(kFakeAudioInputDeviceId1);
+  blink::WebMediaConstraints video_constraints =
+      CreateFacingModeConstraints("user");
+  // kFakeVideoInputDeviceId1 has user facing mode.
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  kFakeAudioInputDeviceId1,
+                                  kFakeVideoInputDeviceId1);
+}
+
+TEST_F(UserMediaClientImplTest, CreateWithFacingModeEnvironment) {
+  blink::WebMediaConstraints audio_constraints =
+      CreateDeviceConstraints(kFakeAudioInputDeviceId1);
+  blink::WebMediaConstraints video_constraints =
+      CreateFacingModeConstraints("environment");
+  // kFakeVideoInputDeviceId2 has environment facing mode.
+  TestValidRequestWithConstraints(audio_constraints, video_constraints,
+                                  kFakeAudioInputDeviceId1,
+                                  kFakeVideoInputDeviceId2);
 }
 
 }  // namespace content