Revert "Remove MediaStreamTrack.getSources()."

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 10 matching lines @@
 #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"
 
 using testing::_;
 
 namespace content {
 
 class MockMediaStreamVideoCapturerSource : public MockMediaStreamVideoSource {
  public:
@@ skipping 75 matching lines @@
     blink::WebUserMediaRequest user_media_request;
     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);
+  }
+
   void SetMediaDeviceChangeObserver() {
     blink::WebMediaDeviceChangeObserver observer(true);
     setMediaDeviceChangeObserver(observer);
   }
 
   void RemoveMediaDeviceChangeObserver() {
     setMediaDeviceChangeObserver(blink::WebMediaDeviceChangeObserver());
   }
 
   void GetUserMediaRequestSucceeded(
@@ skipping 13 matching lines @@
     result_name_ = result_name;
   }
 
   void EnumerateDevicesSucceded(
       blink::WebMediaDevicesRequest* request,
       blink::WebVector<blink::WebMediaDeviceInfo>& devices) override {
     state_ = REQUEST_SUCCEEDED;
     last_devices_ = devices;
   }
 
+  void EnumerateSourcesSucceded(
+      blink::WebMediaStreamTrackSourcesRequest* request,
+      blink::WebVector<blink::WebSourceInfo>& sources) override {
+    state_ = REQUEST_SUCCEEDED;
+    last_sources_ = sources;
+  }
+
   void SetCreateSourceThatFails(bool should_fail) {
     create_source_that_fails_ = should_fail;
   }
 
   MediaStreamAudioSource* CreateAudioSource(
       const StreamDeviceInfo& device,
       const blink::WebMediaConstraints& constraints) override {
     MediaStreamAudioSource* source;
     if (create_source_that_fails_) {
       class FailedAtLifeAudioSource : public MediaStreamAudioSource {
@@ skipping 23 matching lines @@
   }
 
   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_; }
@@ skipping 10 matching lines @@
     auto* request = FindUserMediaRequestInfo(request_id);
     DeleteUserMediaRequestInfo(request);
   }
 
  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_;
   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_) {}
@@ skipping 376 matching lines @@
   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()[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();
+  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::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::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.
   // Currently we expect it to be false due to a suspected bug in the
   // device-matching code causing issues with some sound adapters.
@@ skipping 75 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