Implement getMediaDevices.

content/renderer/media/media_stream_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/media_stream_impl.h"
 
 #include <utility>
 
+#include "base/command_line.h"

[mcasas, 2014/05/27 12:08:23]

Needed?

[Henrik Grunell, 2014/05/27 15:33:54]

No, thanks.

 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/public/common/content_switches.h"

[mcasas, 2014/05/27 12:08:23]

Needed?

[Henrik Grunell, 2014/05/27 15:33:54]

Nope. Removed.

 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_renderer.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/rtc_video_renderer.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/media/webrtc_local_audio_renderer.h"
 #include "content/renderer/media/webrtc_logging.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/audio_hardware_config.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/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 
 namespace content {
 namespace {
 
 void CopyStreamConstraints(const blink::WebMediaConstraints& constraints,
                            StreamOptions::Constraints* mandatory,
@@ skipping 33 matching lines @@
     MediaStreamDispatcher* media_stream_dispatcher,
     PeerConnectionDependencyFactory* dependency_factory)
     : RenderViewObserver(render_view),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(media_stream_dispatcher) {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
 }
 
+// TODO(grunell): Device enumeration should probably be moved to its own class
+// here or at other places in the code.
+struct MediaStreamImpl::MediaDevicesRequestInfo {
+  MediaDevicesRequestInfo(blink::WebMediaDevicesRequest request,
+                          int audio_input_request_id,
+                          int video_input_request_id)
+      : request(request),
+        audio_input_request_id(audio_input_request_id),
+        video_input_request_id(video_input_request_id),
+        has_audio_input_returned(false),
+        has_video_input_returned(false) {}
+
+  blink::WebMediaDevicesRequest request;
+  int audio_input_request_id;
+  int video_input_request_id;
+  bool has_audio_input_returned;
+  bool has_video_input_returned;
+  StreamDeviceInfoArray audio_input_devices;

[mcasas, 2014/05/27 12:08:23]

I think this struct should be made a class
since it has these two ScopedVectors inside.

[Henrik Grunell, 2014/05/27 15:33:54]

What do you motivate that with, it's not clear to me. I think it's still only
access/set data.

+  StreamDeviceInfoArray video_input_devices;
+};
+
 void MediaStreamImpl::requestUserMedia(
     const blink::WebUserMediaRequest& user_media_request) {
   // Save histogram data so we can see how much GetUserMedia is used.
   // The histogram counts the number of calls to the JS API
   // webGetUserMedia.
   UpdateWebRTCMethodCount(WEBKIT_GET_USER_MEDIA);
   DCHECK(CalledOnValidThread());
 
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
@@ skipping 85 matching lines @@
   DCHECK(CalledOnValidThread());
   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
   if (request) {
     // We can't abort the stream generation process.
     // Instead, erase the request. Once the stream is generated we will stop the
     // stream if the request does not exist.
     DeleteUserMediaRequestInfo(request);
   }
 }
 
+void MediaStreamImpl::requestMediaDevices(
+    const blink::WebMediaDevicesRequest& media_devices_request) {
+  // TODO(grunell): UMA stats?
+  DCHECK(CalledOnValidThread());
+
+  int audio_input_request_id = g_next_request_id++;
+  int video_input_request_id = g_next_request_id++;
+  GURL security_origin =
+      GURL(media_devices_request.securityOrigin().toString());
+
+  media_devices_requests_.push_back(new MediaDevicesRequestInfo(
+      media_devices_request, audio_input_request_id, video_input_request_id));
+
+  media_stream_dispatcher_->EnumerateDevices(
+      audio_input_request_id,
+      AsWeakPtr(),
+      MEDIA_DEVICE_AUDIO_CAPTURE,
+      security_origin);
+
+  media_stream_dispatcher_->EnumerateDevices(
+      video_input_request_id,
+      AsWeakPtr(),
+      MEDIA_DEVICE_VIDEO_CAPTURE,
+      security_origin);
+}
+
+void MediaStreamImpl::cancelMediaDevicesRequest(
+    const blink::WebMediaDevicesRequest& media_devices_request) {
+  DCHECK(CalledOnValidThread());
+  MediaDevicesRequestInfo* request =
+      FindMediaDevicesRequestInfo(media_devices_request);
+  if (request) {

[mcasas, 2014/05/27 12:08:23]

if (!request)
  return;

[Henrik Grunell, 2014/05/27 15:33:54]

Done.

+    // Cancel device enumeration.
+    media_stream_dispatcher_->StopEnumerateDevices(
+        request->audio_input_request_id,
+        AsWeakPtr());
+    media_stream_dispatcher_->StopEnumerateDevices(
+        request->video_input_request_id,
+        AsWeakPtr());
+    DeleteMediaDevicesRequestInfo(request);
+  }
+}
+
 blink::WebMediaStream MediaStreamImpl::GetMediaStream(
     const GURL& url) {
   return blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url);
 }
 
 bool MediaStreamImpl::IsMediaStream(const GURL& url) {
   blink::WebMediaStream web_stream(
       blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
 
   return (!web_stream.isNull() &&
@@ skipping 321 matching lines @@
     GetUserMediaRequestSucceeded(request->web_stream, &request->request);
   else
     GetUserMediaRequestFailed(&request->request, result);
 
   DeleteUserMediaRequestInfo(request);
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated("

[mcasas, 2014/05/27 12:08:23]

Nit: fits in one line.

[Henrik Grunell, 2014/05/27 15:33:54]

Done.

            << request_id << ")";
-  NOTIMPLEMENTED();
+
+  MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
+  DCHECK(request);
+
+  if (request_id == request->audio_input_request_id) {
+    request->has_audio_input_returned = true;
+    DCHECK(request->audio_input_devices.empty());
+    request->audio_input_devices = device_array;
+  } else {
+    DCHECK(request_id == request->video_input_request_id);
+    request->has_video_input_returned = true;
+    DCHECK(request->video_input_devices.empty());
+    request->video_input_devices = device_array;
+  }
+
+  if (!request->has_audio_input_returned ||
+      !request->has_video_input_returned) {
+    // Wait for the rest of the devices to complete.
+    return;
+  }
+
+  // Both audio and video devices are ready for copying.
+  // TODO(grunell): Add support for output devices and group id.
+  blink::WebVector<blink::WebMediaDeviceInfo>
+      devices(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);
+    devices[i].initialize(blink::WebString::fromUTF8(device.id),
+                          blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput,
+                          blink::WebString::fromUTF8(device.name),
+                          blink::WebString());
+  }
+  size_t audio_size = 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[audio_size + i].initialize(
+        blink::WebString::fromUTF8(device.id),
+        blink::WebMediaDeviceInfo::MediaDeviceKindVideoInput,
+        blink::WebString::fromUTF8(device.name),
+        blink::WebString());
+  }
+  request->request.requestSucceeded(devices);
+
+  // Cancel device enumeration.
+  media_stream_dispatcher_->StopEnumerateDevices(

[perkj_chrome, 2014/05/27 11:57:23]

This is so silly. Can't we just change this now? 

[Henrik Grunell, 2014/05/27 15:33:54]

Seems pepper doesn't use the request as notification. Removed.

+      request->audio_input_request_id,
+      AsWeakPtr());
+  media_stream_dispatcher_->StopEnumerateDevices(
+      request->video_input_request_id,
+      AsWeakPtr());
+
+  DeleteMediaDevicesRequestInfo(request);
 }
 
 void MediaStreamImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
   DVLOG(1) << "MediaStreamImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
@@ skipping 93 matching lines @@
   UserMediaRequests::iterator it = user_media_requests_.begin();
   for (; it != user_media_requests_.end(); ++it) {
     if ((*it) == request) {
       user_media_requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
+MediaStreamImpl::MediaDevicesRequestInfo*
+MediaStreamImpl::FindMediaDevicesRequestInfo(
+    int request_id) {
+  MediaDevicesRequests::iterator it = media_devices_requests_.begin();
+  for (; it != media_devices_requests_.end(); ++it) {
+    if ((*it)->audio_input_request_id == request_id ||
+        (*it)->video_input_request_id == request_id) {
+      return (*it);
+    }
+  }
+  return NULL;
+}
+
+MediaStreamImpl::MediaDevicesRequestInfo*
+MediaStreamImpl::FindMediaDevicesRequestInfo(
+    const blink::WebMediaDevicesRequest& request) {
+  MediaDevicesRequests::iterator it = media_devices_requests_.begin();

[mcasas, 2014/05/27 12:08:23]

I know this is copy-modified from previous code but
what about:

MediaDevicesRequests::iterator found =
    std::find(media_devices_requests_.begin(),
              media_devices_requests_.end(),
              request);
return (found != media_devices_requests_.end()) ? (*found) : NULL;

and perhaps even consider changing the return type to 
const MediaDevicesRequests::iterator& without much ado.

[Henrik Grunell, 2014/05/27 15:33:54]

It's a ScopedVector, can't use std::find.

+  for (; it != media_devices_requests_.end(); ++it) {
+    if ((*it)->request == request)
+      return (*it);
+  }
+  return NULL;
+}
+
+void MediaStreamImpl::DeleteMediaDevicesRequestInfo(
+    MediaDevicesRequestInfo* request) {
+  MediaDevicesRequests::iterator it = media_devices_requests_.begin();
+  for (; it != media_devices_requests_.end(); ++it) {
+    if ((*it) == request) {
+      media_devices_requests_.erase(it);
+      return;
+    }
+  }
+  NOTREACHED();
+}
+
 void MediaStreamImpl::FrameDetached(blink::WebFrame* frame) {
   // Do same thing as FrameWillClose.
   FrameWillClose(frame);
 }
 
 void MediaStreamImpl::FrameWillClose(blink::WebFrame* frame) {
   // Loop through all UserMediaRequests and find the requests that belong to the
   // frame that is being closed.
   UserMediaRequests::iterator request_it = user_media_requests_.begin();
   while (request_it != user_media_requests_.end()) {
@@ skipping 222 matching lines @@
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content