Implement WebUserMediaClient::requestSources

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 "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/mock_media_stream_dispatcher.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "content/renderer/media/user_media_client_impl.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.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,
@@ skipping 31 matching lines @@
     state_ = REQUEST_NOT_COMPLETE;
     requestUserMedia(user_media_request);
   }
 
   void RequestMediaDevices() {
     blink::WebMediaDevicesRequest media_devices_request;
     state_ = REQUEST_NOT_COMPLETE;
     requestMediaDevices(media_devices_request);
   }
 
+  void RequestSources() {
+    blink::WebMediaStreamTrackSourcesRequest sources_request;
+    state_ = REQUEST_NOT_COMPLETE;
+    requestSources(sources_request);
+  }
+
   virtual void GetUserMediaRequestSucceeded(
       const blink::WebMediaStream& stream,
       blink::WebUserMediaRequest* request_info) OVERRIDE {
     last_generated_stream_ = stream;
     state_ = REQUEST_SUCCEEDED;
   }
 
   virtual void GetUserMediaRequestFailed(
       blink::WebUserMediaRequest* request_info,
       content::MediaStreamRequestResult result) OVERRIDE {
@@ skipping 12 matching lines @@
     result_name_ = result_name;
   }
 
   virtual void EnumerateDevicesSucceded(
       blink::WebMediaDevicesRequest* request,
       blink::WebVector<blink::WebMediaDeviceInfo>& devices) OVERRIDE {
     state_ = REQUEST_SUCCEEDED;
     last_devices_ = devices;
   }
 
+  virtual void EnumerateSourcesSucceded(
+      blink::WebMediaStreamTrackSourcesRequest* request,
+      blink::WebVector<blink::WebSourceInfo>& sources) OVERRIDE {
+    state_ = REQUEST_SUCCEEDED;
+    last_sources_ = sources;
+  }
+
   virtual MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback) OVERRIDE {
     video_source_ = new MockMediaStreamVideoCapturerSource(device,
                                                            stop_callback,
                                                            factory_);
     return video_source_;
   }
 
   const blink::WebMediaStream& last_generated_stream() {
     return last_generated_stream_;
   }
 
   const blink::WebVector<blink::WebMediaDeviceInfo>& last_devices() {
     return last_devices_;
   }
 
+  const blink::WebVector<blink::WebSourceInfo>& last_sources() {
+    return last_sources_;
+  }
+
   void ClearLastGeneratedStream() {
     last_generated_stream_.reset();
   }
 
   MockMediaStreamVideoCapturerSource* last_created_video_source() const {
     return video_source_;
   }
 
   RequestState request_state() const { return state_; }
   content::MediaStreamRequestResult error_reason() const { return result_; }
   blink::WebString error_name() const { return result_name_; }
 
  private:
   blink::WebMediaStream last_generated_stream_;
   RequestState state_;
   content::MediaStreamRequestResult result_;
   blink::WebString result_name_;
   blink::WebVector<blink::WebMediaDeviceInfo> last_devices_;
+  blink::WebVector<blink::WebSourceInfo> last_sources_;
   PeerConnectionDependencyFactory* factory_;
   MockMediaStreamVideoCapturerSource* video_source_;
 };
 
 class UserMediaClientImplTest : public ::testing::Test {
  public:
   virtual void SetUp() {
     // Create our test object.
     child_process_.reset(new ChildProcess());
     dependency_factory_.reset(new MockPeerConnectionDependencyFactory());
@@ skipping 49 matching lines @@
         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_->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 240 matching lines @@
   video_track->Stop();
   EXPECT_EQ(1, ms_dispatcher_->stop_video_device_counter());
 }
 
 TEST_F(UserMediaClientImplTest, EnumerateMediaDevices) {
   used_media_impl_->RequestMediaDevices();
   FakeMediaStreamDispatcherRequestMediaDevicesComplete();
 
   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.
-  EXPECT_FALSE(used_media_impl_->last_devices()[0].deviceId().isEmpty());
+  const blink::WebMediaDeviceInfo* device =
+      &used_media_impl_->last_devices()[0];
+  EXPECT_FALSE(device->deviceId().isEmpty());
   EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
-            used_media_impl_->last_devices()[0].kind());
-  EXPECT_FALSE(used_media_impl_->last_devices()[0].label().isEmpty());
-  EXPECT_FALSE(used_media_impl_->last_devices()[0].groupId().isEmpty());
+            device->kind());
+  EXPECT_FALSE(device->label().isEmpty());
+  EXPECT_FALSE(device->groupId().isEmpty());
 
   // Audio input device without matched output ID.
-  EXPECT_FALSE(used_media_impl_->last_devices()[1].deviceId().isEmpty());
+  device = &used_media_impl_->last_devices()[1];
+  EXPECT_FALSE(device->deviceId().isEmpty());
   EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
-            used_media_impl_->last_devices()[1].kind());
-  EXPECT_FALSE(used_media_impl_->last_devices()[1].label().isEmpty());
-  EXPECT_FALSE(used_media_impl_->last_devices()[1].groupId().isEmpty());
+            device->kind());
+  EXPECT_FALSE(device->label().isEmpty());
+  EXPECT_FALSE(device->groupId().isEmpty());
 
-  // Video input device.
-  EXPECT_FALSE(used_media_impl_->last_devices()[2].deviceId().isEmpty());
+  // Video input devices.
+  device = &used_media_impl_->last_devices()[2];
+  EXPECT_FALSE(device->deviceId().isEmpty());
   EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
-            used_media_impl_->last_devices()[2].kind());
-  EXPECT_FALSE(used_media_impl_->last_devices()[2].label().isEmpty());
-  EXPECT_TRUE(used_media_impl_->last_devices()[2].groupId().isEmpty());
+            device->kind());
+  EXPECT_FALSE(device->label().isEmpty());
+  EXPECT_TRUE(device->groupId().isEmpty());
+
+  device = &used_media_impl_->last_devices()[3];
+  EXPECT_FALSE(device->deviceId().isEmpty());
+  EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
+            device->kind());
+  EXPECT_FALSE(device->label().isEmpty());
+  EXPECT_TRUE(device->groupId().isEmpty());
 
   // Audio output device.
-  EXPECT_FALSE(used_media_impl_->last_devices()[3].deviceId().isEmpty());
+  device = &used_media_impl_->last_devices()[4];
+  EXPECT_FALSE(device->deviceId().isEmpty());
   EXPECT_EQ(blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
-            used_media_impl_->last_devices()[3].kind());
-  EXPECT_FALSE(used_media_impl_->last_devices()[3].label().isEmpty());
-  EXPECT_FALSE(used_media_impl_->last_devices()[3].groupId().isEmpty());
+            device->kind());
+  EXPECT_FALSE(device->label().isEmpty());
+  EXPECT_FALSE(device->groupId().isEmpty());
 
   // Verfify group IDs.
   EXPECT_TRUE(used_media_impl_->last_devices()[0].groupId().equals(
-                  used_media_impl_->last_devices()[3].groupId()));
+                  used_media_impl_->last_devices()[4].groupId()));
   EXPECT_FALSE(used_media_impl_->last_devices()[1].groupId().equals(
-                   used_media_impl_->last_devices()[3].groupId()));
+                   used_media_impl_->last_devices()[4].groupId()));
+}
+
+TEST_F(UserMediaClientImplTest, EnumerateSources) {
+  used_media_impl_->RequestSources();
+  FakeMediaStreamDispatcherRequestSourcesComplete();
+
+  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());
+
+  // 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());
 }
 
 }  // namespace content