Implement GetUserMedia device ID constraint processing in the renderer.

content/browser/renderer_host/media/media_stream_manager.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/browser/renderer_host/media/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 686 matching lines @@
                                     const std::string& device_id,
                                     MediaStreamType type,
                                     const url::Origin& security_origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DVLOG(1) << "OpenDevice ({page_request_id = " << page_request_id <<  "})";
   StreamControls controls;
   if (IsAudioInputMediaType(type)) {
     controls.audio.requested = true;
-    controls.audio.device_ids.push_back(device_id);
+    controls.audio.device_id = device_id;
   } else if (IsVideoMediaType(type)) {
     controls.video.requested = true;
-    controls.video.device_ids.push_back(device_id);
+    controls.video.device_id = device_id;
   } else {
     NOTREACHED();
   }
   DeviceRequest* request =
       new DeviceRequest(requester, render_process_id, render_frame_id,
                         page_request_id, security_origin,
                         false,  // user gesture
                         MEDIA_OPEN_DEVICE_PEPPER_ONLY, controls, salt);
 
   const std::string& label = AddRequest(request);
@@ skipping 65 matching lines @@
           (stream_type == MEDIA_DEVICE_AUDIO_CAPTURE ? "audio" : "video"),
           device.device_id.c_str(), device.label.c_str())
           .c_str());
 }
 
 bool MediaStreamManager::PickDeviceId(const std::string& salt,
                                       const url::Origin& security_origin,
                                       const TrackControls& controls,
                                       const MediaDeviceInfoArray& devices,
                                       std::string* device_id) const {
-  if (!controls.device_ids.empty()) {
-    if (controls.device_ids.size() > 1) {
-      LOG(ERROR) << "Only one required device ID is supported";
-      return false;
-    }
-    const std::string& candidate_id = controls.device_ids[0];
-    if (!GetDeviceIDFromHMAC(salt, security_origin, candidate_id, devices,
-                             device_id)) {
-      LOG(WARNING) << "Invalid mandatory capture ID = " << candidate_id;
-      return false;
-    }
+  if (controls.device_id.empty())
     return true;
+
+  if (!GetDeviceIDFromHMAC(salt, security_origin, controls.device_id, devices,
+                           device_id)) {
+    LOG(WARNING) << "Invalid device ID = " << controls.device_id;
+    return false;
   }
-  // We don't have a required ID. Look at the alternates.
-  for (const std::string& candidate_id : controls.alternate_device_ids) {
-    if (GetDeviceIDFromHMAC(salt, security_origin, candidate_id, devices,
-                            device_id)) {
-      return true;
-    } else {
-      LOG(WARNING) << "Invalid optional capture ID = " << candidate_id;
-    }
-  }
-  return true;  // If we get here, device_id is empty.
+  return true;
 }
 
 bool MediaStreamManager::GetRequestedDeviceCaptureId(
     const DeviceRequest* request,
     MediaStreamType type,
     const MediaDeviceInfoArray& devices,
     std::string* device_id) const {
   if (type == MEDIA_DEVICE_AUDIO_CAPTURE) {
     return PickDeviceId(request->salt, request->security_origin,
                         request->controls.audio, devices, device_id);
@@ skipping 226 matching lines @@
            << request->controls.video.requested
            << " device id = " << video_device_id;
   return true;
 }
 
 bool MediaStreamManager::SetupTabCaptureRequest(DeviceRequest* request) {
   DCHECK(request->audio_type() == MEDIA_TAB_AUDIO_CAPTURE ||
          request->video_type() == MEDIA_TAB_VIDEO_CAPTURE);
 
   std::string capture_device_id;
-  if (!request->controls.audio.device_ids.empty()) {
-    capture_device_id = request->controls.audio.device_ids[0];
-  } else if (!request->controls.video.device_ids.empty()) {
-    capture_device_id = request->controls.video.device_ids[0];
+  if (!request->controls.audio.device_id.empty()) {
+    capture_device_id = request->controls.audio.device_id;
+  } else if (!request->controls.video.device_id.empty()) {
+    capture_device_id = request->controls.video.device_id;
   } else {
     return false;
   }
 
   // Customize controls for a WebContents based capture.
   content::WebContentsMediaCaptureId web_id;
   bool has_valid_device_id =
       WebContentsMediaCaptureId::Parse(capture_device_id, &web_id);
   if (!has_valid_device_id ||
       (request->audio_type() != MEDIA_TAB_AUDIO_CAPTURE &&
@@ skipping 31 matching lines @@
     LOG(ERROR) << "Invalid screen capture request.";
     return false;
   }
 
   std::string video_device_id;
   if (request->video_type() == MEDIA_DESKTOP_VIDEO_CAPTURE) {
     const std::string& video_stream_source =
         request->controls.video.stream_source;
 
     if (video_stream_source == kMediaStreamSourceDesktop &&
-        !request->controls.video.device_ids.empty()) {
-      video_device_id = request->controls.video.device_ids[0];
+        !request->controls.video.device_id.empty()) {
+      video_device_id = request->controls.video.device_id;
     }
   }
 
   const std::string audio_device_id =
       request->audio_type() == MEDIA_DESKTOP_AUDIO_CAPTURE ? video_device_id
                                                            : "";
 
   request->CreateUIRequest(audio_device_id, video_device_id);
   return true;
 }
@@ skipping 619 matching lines @@
     }
   }
 }
 
 void MediaStreamManager::SetGenerateStreamCallbackForTesting(
     GenerateStreamTestCallback test_callback) {
   generate_stream_test_callback_ = test_callback;
 }
 
 }  // namespace content