Implement WebUserMediaClient::requestSources

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 <utility>
 
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/peer_connection_tracker.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.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/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 CopyStreamConstraints(const blink::WebMediaConstraints& constraints,
                            StreamOptions::Constraints* mandatory,
                            StreamOptions::Constraints* optional) {
   blink::WebVector<blink::WebMediaConstraint> mandatory_constraints;
@@ skipping 15 matching lines @@
 
 static int g_next_request_id  = 0;
 
 }  // namespace
 
 struct UserMediaClientImpl::MediaDevicesRequestInfo {
   MediaDevicesRequestInfo(const blink::WebMediaDevicesRequest& request,
                           int audio_input_request_id,
                           int video_input_request_id,
                           int audio_output_request_id)
-      : request(request),
+      : media_devices_request(request),
         audio_input_request_id(audio_input_request_id),
         video_input_request_id(video_input_request_id),
         audio_output_request_id(audio_output_request_id),
         has_audio_input_returned(false),
         has_video_input_returned(false),
         has_audio_output_returned(false) {}
 
-  blink::WebMediaDevicesRequest request;
+  MediaDevicesRequestInfo(
+      const blink::WebMediaStreamTrackSourcesRequest& request,
+      int audio_input_request_id,
+      int video_input_request_id)
+      : sources_request(request),
+        audio_input_request_id(audio_input_request_id),
+        video_input_request_id(video_input_request_id),
+        audio_output_request_id(-1),
+        has_audio_input_returned(false),
+        has_video_input_returned(false),
+        has_audio_output_returned(false) {}
+
+  bool IsSourcesRequest() {
+    // We can't check isNull() on |media_devices_request| and |sources_request|,
+    // because in unit tests they will always be null.
+    return audio_output_request_id == -1;
+  }
+
+  blink::WebMediaDevicesRequest media_devices_request;
+  blink::WebMediaStreamTrackSourcesRequest sources_request;
   int audio_input_request_id;
   int video_input_request_id;
   int audio_output_request_id;
   bool has_audio_input_returned;
   bool has_video_input_returned;
   bool has_audio_output_returned;
   StreamDeviceInfoArray audio_input_devices;
   StreamDeviceInfoArray video_input_devices;
   StreamDeviceInfoArray audio_output_devices;
 };
@@ skipping 169 matching lines @@
 void UserMediaClientImpl::cancelMediaDevicesRequest(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   DCHECK(CalledOnValidThread());
   MediaDevicesRequestInfo* request =
       FindMediaDevicesRequestInfo(media_devices_request);
   if (!request)
     return;
   CancelAndDeleteMediaDevicesRequest(request);
 }
 
+void UserMediaClientImpl::requestSources(
+    const blink::WebMediaStreamTrackSourcesRequest& sources_request) {
+  // This is counted for UMA stats in MediaStreamTrack::getSources in blink.

[perkj_chrome, 2014/09/12 12:35:33]

I don't understand this comment and I am not sure its relevant. Remove or
explain.

[Henrik Grunell, 2014/09/12 12:59:31]

Another shot at explaining.

+  DCHECK(CalledOnValidThread());
+
+  int audio_input_request_id = g_next_request_id++;
+  int video_input_request_id = g_next_request_id++;
+
+  // |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.
+  GURL security_origin;
+  if (!sources_request.isNull())
+    security_origin = GURL(sources_request.origin().utf8());
+
+  DVLOG(1) << "UserMediaClientImpl::requestSources("
+           << audio_input_request_id
+           << ", " << video_input_request_id
+           << ", " << security_origin.spec() << ")";
+
+  media_devices_requests_.push_back(new MediaDevicesRequestInfo(
+      sources_request,
+      audio_input_request_id,
+      video_input_request_id));
+
+  media_stream_dispatcher_->EnumerateDevices(
+      audio_input_request_id,
+      weak_factory_.GetWeakPtr(),
+      MEDIA_DEVICE_AUDIO_CAPTURE,
+      security_origin);
+
+  media_stream_dispatcher_->EnumerateDevices(
+      video_input_request_id,
+      weak_factory_.GetWeakPtr(),
+      MEDIA_DEVICE_VIDEO_CAPTURE,
+      security_origin);
+}
+
 // Callback from MediaStreamDispatcher.
 // The requested stream have been generated by the MediaStreamDispatcher.
 void UserMediaClientImpl::OnStreamGenerated(
     int request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "UserMediaClientImpl::OnStreamGenerated stream:" << label;
 
@@ skipping 56 matching lines @@
       media_stream_dispatcher_->StopStreamDevice(*device_it);
   }
 
   for (StreamDeviceInfoArray::const_iterator device_it = video_array.begin();
        device_it != video_array.end(); ++device_it) {
     if (!FindLocalSource(*device_it))
       media_stream_dispatcher_->StopStreamDevice(*device_it);
   }
 }
 
+void UserMediaClientImpl::FinalizeEnumerateDevices(
+    MediaDevicesRequestInfo* request) {
+  // All devices are ready for copying. We use a hashed audio output device id
+  // as the group id for input and output audio devices. If an input device
+  // doesn't have an associated output device, we use the input device's own id.
+  // We don't support group id for video devices, that's left empty.
+  blink::WebVector<blink::WebMediaDeviceInfo>
+      devices(request->audio_input_devices.size() +
+              request->video_input_devices.size() +
+              request->audio_output_devices.size());
+  for (size_t i = 0; i  < request->audio_input_devices.size(); ++i) {
+    const MediaStreamDevice& device = request->audio_input_devices[i].device;
+    DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
+    std::string group_id = base::UintToString(base::Hash(
+        !device.matched_output_device_id.empty() ?
+            device.matched_output_device_id :
+            device.id));
+    devices[i].initialize(
+        blink::WebString::fromUTF8(device.id),
+        blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
+        blink::WebString::fromUTF8(device.name),
+        blink::WebString::fromUTF8(group_id));
+  }
+  size_t offset = request->audio_input_devices.size();
+  for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
+    const MediaStreamDevice& device = request->video_input_devices[i].device;
+    DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE);
+    devices[offset + i].initialize(
+        blink::WebString::fromUTF8(device.id),
+        blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
+        blink::WebString::fromUTF8(device.name),
+        blink::WebString());
+  }
+  offset += request->video_input_devices.size();
+  for (size_t i = 0; i  < request->audio_output_devices.size(); ++i) {
+    const MediaStreamDevice& device = request->audio_output_devices[i].device;
+    DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_OUTPUT);
+    devices[offset + i].initialize(
+        blink::WebString::fromUTF8(device.id),
+        blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
+        blink::WebString::fromUTF8(device.name),
+        blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
+  }
+
+  EnumerateDevicesSucceded(&request->media_devices_request, devices);
+  CancelAndDeleteMediaDevicesRequest(request);
+}
+
+void UserMediaClientImpl::FinalizeEnumerateSources(
+    MediaDevicesRequestInfo* request) {
+  blink::WebVector<blink::WebSourceInfo>
+      sources(request->audio_input_devices.size() +
+              request->video_input_devices.size());
+  for (size_t i = 0; i  < request->audio_input_devices.size(); ++i) {
+    const MediaStreamDevice& device = request->audio_input_devices[i].device;
+    DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
+    std::string group_id = base::UintToString(base::Hash(
+        !device.matched_output_device_id.empty() ?
+            device.matched_output_device_id :
+            device.id));
+    sources[i].initialize(blink::WebString::fromUTF8(device.id),
+                          blink::WebSourceInfo::SourceKindAudio,
+                          blink::WebString::fromUTF8(device.name),
+                          blink::WebSourceInfo::VideoFacingModeNone);
+  }
+  size_t offset = request->audio_input_devices.size();
+  for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
+    const MediaStreamDevice& device = request->video_input_devices[i].device;
+    DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE);
+    blink::WebSourceInfo::VideoFacingMode video_facing;
+    switch (device.video_facing) {
+      case MEDIA_VIDEO_FACING_USER:
+        video_facing = blink::WebSourceInfo::VideoFacingModeUser;
+        break;
+      case MEDIA_VIDEO_FACING_ENVIRONMENT:
+        video_facing = blink::WebSourceInfo::VideoFacingModeEnvironment;
+        break;
+      default:
+        video_facing = blink::WebSourceInfo::VideoFacingModeNone;
+    }
+    sources[offset + i].initialize(blink::WebString::fromUTF8(device.id),
+                                   blink::WebSourceInfo::SourceKindVideo,
+                                   blink::WebString::fromUTF8(device.name),
+                                   video_facing);
+  }
+
+  EnumerateSourcesSucceded(&request->sources_request, sources);
+  CancelAndDeleteMediaDevicesRequest(request);
+}
+
 // 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 182 matching lines @@
     request->video_input_devices = device_array;
   } else {
     DCHECK_EQ(request->audio_output_request_id, request_id);
     request->has_audio_output_returned = true;
     DCHECK(request->audio_output_devices.empty());
     request->audio_output_devices = device_array;
   }
 
   if (!request->has_audio_input_returned ||
       !request->has_video_input_returned ||
-      !request->has_audio_output_returned) {
+      (!request->IsSourcesRequest() && !request->has_audio_output_returned)) {
     // Wait for the rest of the devices to complete.
     return;
   }
 
-  // All devices are ready for copying. We use a hashed audio output device id
-  // as the group id for input and output audio devices. If an input device
-  // doesn't have an associated output device, we use the input device's own id.
-  // We don't support group id for video devices, that's left empty.
-  blink::WebVector<blink::WebMediaDeviceInfo>
-      devices(request->audio_input_devices.size() +
-              request->video_input_devices.size() +
-              request->audio_output_devices.size());
-  for (size_t i = 0; i  < request->audio_input_devices.size(); ++i) {
-    const MediaStreamDevice& device = request->audio_input_devices[i].device;
-    DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_CAPTURE);
-    std::string group_id = base::UintToString(base::Hash(
-        !device.matched_output_device_id.empty() ?
-            device.matched_output_device_id :
-            device.id));
-    devices[i].initialize(
-        blink::WebString::fromUTF8(device.id),
-        blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
-        blink::WebString::fromUTF8(device.name),
-        blink::WebString::fromUTF8(group_id));
-  }
-  size_t offset = request->audio_input_devices.size();
-  for (size_t i = 0; i  < request->video_input_devices.size(); ++i) {
-    const MediaStreamDevice& device = request->video_input_devices[i].device;
-    DCHECK_EQ(device.type, MEDIA_DEVICE_VIDEO_CAPTURE);
-    devices[offset + i].initialize(
-        blink::WebString::fromUTF8(device.id),
-        blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
-        blink::WebString::fromUTF8(device.name),
-        blink::WebString());
-  }
-  offset += request->video_input_devices.size();
-  for (size_t i = 0; i  < request->audio_output_devices.size(); ++i) {
-    const MediaStreamDevice& device = request->audio_output_devices[i].device;
-    DCHECK_EQ(device.type, MEDIA_DEVICE_AUDIO_OUTPUT);
-    devices[offset + i].initialize(
-        blink::WebString::fromUTF8(device.id),
-        blink::WebMediaDeviceInfo::MediaDeviceKindAudioOutput,
-        blink::WebString::fromUTF8(device.name),
-        blink::WebString::fromUTF8(base::UintToString(base::Hash(device.id))));
-  }
-
-  EnumerateDevicesSucceded(&request->request, devices);
-  CancelAndDeleteMediaDevicesRequest(request);
+  if (request->IsSourcesRequest())
+    FinalizeEnumerateSources(request);
+  else
+    FinalizeEnumerateDevices(request);
 }
 
 void UserMediaClientImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
   DVLOG(1) << "UserMediaClientImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
@@ skipping 68 matching lines @@
       break;
   }
 }
 
 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->extraData());
     const StreamDeviceInfo& active_device = source->device_info();
     if (active_device.device.id == device.device.id &&
         active_device.device.type == device.device.type &&
         active_device.session_id == device.session_id) {
@@ skipping 72 matching lines @@
     }
   }
   return NULL;
 }
 
 UserMediaClientImpl::MediaDevicesRequestInfo*
 UserMediaClientImpl::FindMediaDevicesRequestInfo(
     const blink::WebMediaDevicesRequest& request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
-    if ((*it)->request == request)
+    if ((*it)->media_devices_request == request)
       return (*it);
   }
   return NULL;
 }
 
 void UserMediaClientImpl::CancelAndDeleteMediaDevicesRequest(
     MediaDevicesRequestInfo* request) {
   MediaDevicesRequests::iterator it = media_devices_requests_.begin();
   for (; it != media_devices_requests_.end(); ++it) {
     if ((*it) == request) {
@@ skipping 165 matching lines @@
       return;
     }
   }
 }
 
 bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   return !sources_waiting_for_callback_.empty();
 }
 
 }  // namespace content