Revert of Remove MediaStreamTrack.getSources().

content/renderer/media/user_media_client_impl.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 <utility>
 #include <vector>
@@ skipping 18 matching lines @@
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/processed_local_audio_source.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaDeviceInfo.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrackSourcesRequest.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 namespace content {
 namespace {
 
 void CopyVector(const blink::WebVector<blink::WebString>& source,
                 std::vector<std::string>* destination) {
   for (const auto& web_string : source) {
     destination->push_back(web_string.utf8());
@@ skipping 90 matching lines @@
     case MEDIA_DEVICE_TYPE_VIDEO_INPUT:
       return blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput;
     case MEDIA_DEVICE_TYPE_AUDIO_OUTPUT:
       return blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput;
     default:
       NOTREACHED();
       return blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput;
   }
 }
 
+blink::WebSourceInfo::VideoFacingMode ToVideoFacingMode(
+    const std::string& device_label) {
+#if defined(OS_ANDROID)
+  if (device_label.find("front") != std::string::npos) {
+    return blink::WebSourceInfo::VideoFacingModeUser;
+  } else if (device_label.find("back") != std::string::npos) {
+    return blink::WebSourceInfo::VideoFacingModeEnvironment;
+  }
+#endif
+  return blink::WebSourceInfo::VideoFacingModeNone;
+}
+
 static int g_next_request_id = 0;
 
 }  // namespace
 
 UserMediaClientImpl::UserMediaClientImpl(
     RenderFrame* render_frame,
     PeerConnectionDependencyFactory* dependency_factory,
     std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher)
     : RenderFrameObserver(render_frame),
       dependency_factory_(dependency_factory),
@@ skipping 117 matching lines @@
   if (!media_devices_request.isNull())
     security_origin = media_devices_request.getSecurityOrigin();
 
   GetMediaDevicesDispatcher()->EnumerateDevices(
       true /* audio input */, true /* video input */, true /* audio output */,
       security_origin,
       base::Bind(&UserMediaClientImpl::FinalizeEnumerateDevices,
                  weak_factory_.GetWeakPtr(), media_devices_request));
 }
 
+void UserMediaClientImpl::requestSources(
+    const blink::WebMediaStreamTrackSourcesRequest& sources_request) {
+  // We don't call UpdateWebRTCMethodCount() here to track the API count in UMA
+  // stats. This is instead counted in MediaStreamTrack::getSources in blink.
+  DCHECK(CalledOnValidThread());
+
+  // |sources_request| can't be mocked, so in tests it will be empty (the
+  // underlying pointer is null). In order to use this function in a test we
+  // need to check if it isNull.
+  url::Origin security_origin;
+  if (!sources_request.isNull())
+    security_origin = sources_request.origin();
+
+  GetMediaDevicesDispatcher()->EnumerateDevices(
+      true /* audio input */, true /* video input */, false /* audio output */,
+      security_origin, base::Bind(&UserMediaClientImpl::FinalizeGetSources,
+                                  weak_factory_.GetWeakPtr(), sources_request));
+}
+
 void UserMediaClientImpl::setMediaDeviceChangeObserver(
     const blink::WebMediaDeviceChangeObserver& observer) {
   media_device_change_observer_ = observer;
 
   if (media_device_change_observer_.isNull()) {
     media_stream_dispatcher_->CancelDeviceChangeNotifications(
         weak_factory_.GetWeakPtr());
   } else {
     url::Origin origin = observer.getSecurityOrigin();
     media_stream_dispatcher_->SubscribeToDeviceChangeNotifications(
@@ skipping 92 matching lines @@
       devices[index++].initialize(
           blink::WebString::fromUTF8(device_info.device_id), device_kind,
           blink::WebString::fromUTF8(device_info.label),
           blink::WebString::fromUTF8(device_info.group_id));
     }
   }
 
   EnumerateDevicesSucceded(&request, devices);
 }
 
+void UserMediaClientImpl::FinalizeGetSources(
+    blink::WebMediaStreamTrackSourcesRequest request,
+    const EnumerationResult& result) {
+  DCHECK_EQ(static_cast<size_t>(NUM_MEDIA_DEVICE_TYPES), result.size());
+
+  blink::WebVector<blink::WebSourceInfo> sources(
+      result[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size() +
+      result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size());
+  size_t index = 0;
+  for (const auto& device_info : result[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
+    sources[index++].initialize(
+        blink::WebString::fromUTF8(device_info.device_id),
+        blink::WebSourceInfo::SourceKindAudio,
+        blink::WebString::fromUTF8(device_info.label),
+        blink::WebSourceInfo::VideoFacingModeNone);
+  }
+
+  for (const auto& device_info : result[MEDIA_DEVICE_TYPE_VIDEO_INPUT]) {
+    sources[index++].initialize(
+        blink::WebString::fromUTF8(device_info.device_id),
+        blink::WebSourceInfo::SourceKindVideo,
+        blink::WebString::fromUTF8(device_info.label),
+        ToVideoFacingMode(device_info.label));
+  }
+
+  EnumerateSourcesSucceded(&request, sources);
+}
+
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
 void UserMediaClientImpl::OnStreamGenerationFailed(
     int request_id,
     MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "UserMediaClientImpl::OnStreamGenerationFailed("
            << request_id << ")";
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
@@ skipping 307 matching lines @@
   NOTREACHED();
   request_info.requestFailed();
 }
 
 void UserMediaClientImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
 
+void UserMediaClientImpl::EnumerateSourcesSucceded(
+    blink::WebMediaStreamTrackSourcesRequest* request,
+    blink::WebVector<blink::WebSourceInfo>& sources) {
+  request->requestSucceeded(sources);
+}
+
 const blink::WebMediaStreamSource* UserMediaClientImpl::FindLocalSource(
     const StreamDeviceInfo& device) const {
   for (LocalStreamSources::const_iterator it = local_sources_.begin();
        it != local_sources_.end(); ++it) {
     MediaStreamSource* const source =
         static_cast<MediaStreamSource*>(it->getExtraData());
     const StreamDeviceInfo& active_device = source->device_info();
     if (IsSameDevice(active_device, device)) {
       return &(*it);
     }
@@ skipping 235 matching lines @@
 
 bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   return !sources_waiting_for_callback_.empty();
 }
 
 void UserMediaClientImpl::OnDestruct() {
   delete this;
 }
 
 }  // namespace content