Serialize processing of getUserMedia() requests.

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 <algorithm>
 #include <utility>
 
-#include "base/hash.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.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 "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "build/build_config.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/local_media_stream_audio_source.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_constraints_util_video_content.h"
 #include "content/renderer/media/media_stream_constraints_util_video_device.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/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 "media/capture/video_capture_types.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/WebString.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 
 namespace content {
 namespace {
@@ skipping 171 matching lines @@
     default:
       NOTREACHED();
       return blink::WebMediaDeviceInfo::MediaDeviceKindAudioInput;
   }
 }
 
 static int g_next_request_id = 0;
 
 }  // namespace
 
-struct UserMediaClientImpl::RequestSettings {
-  RequestSettings(bool is_processing_user_gesture, url::Origin security_origin)
-      : enable_automatic_audio_output_device_selection(false),
-        is_processing_user_gesture(is_processing_user_gesture),
-        security_origin(security_origin) {}
-  ~RequestSettings() = default;
+// Class for storing information about a Blink request to create a
+// MediaStream.
+class UserMediaClientImpl::UserMediaRequestInfo
+    : public base::SupportsWeakPtr<UserMediaRequestInfo> {
+ public:
+  using ResourcesReady =
+      base::Callback<void(UserMediaRequestInfo* request_info,
+                          MediaStreamRequestResult result,
+                          const blink::WebString& result_name)>;
+  enum class State {
+    NOT_SENT_FOR_GENERATION,
+    SENT_FOR_GENERATION,
+    GENERATED,
+  };
 
-  bool enable_automatic_audio_output_device_selection;
-  bool is_processing_user_gesture;
-  url::Origin security_origin;
+  UserMediaRequestInfo(int request_id,
+                       const blink::WebUserMediaRequest& request,
+                       bool is_processing_user_gesture,
+                       const url::Origin& security_origin);
+
+  int request_id;

[tommi (sloooow) - chröme, 2017/03/21 16:59:34]

lots of public member variables - intentional? Maybe this should be a struct? 
If not, then the variables should have a postfix underscore (and ideally be
private).

Maybe some of the implementation that uses these variables should be moved into
the class?

Also, the convention is to have variables below methods.

[Guido Urdaneta, 2017/03/21 18:41:33]

Updated to be a style-guide compliant class.
Note that the original intent was to move this class from the .h to the .cc and
keep it as close to the original as possible. The change consisted in adding one
field (stream_controls) and renaming an existing one (generated -> state).

+  State state;
+  bool enable_automatic_output_device_selection;
+  blink::WebMediaStream web_stream;
+  blink::WebUserMediaRequest request;
+  StreamControls stream_controls;
+
+  void StartAudioTrack(const blink::WebMediaStreamTrack& track,
+                       bool is_pending);
+
+  blink::WebMediaStreamTrack CreateAndStartVideoTrack(
+      const blink::WebMediaStreamSource& source,
+      const blink::WebMediaConstraints& constraints);
+
+  // Triggers |callback| when all sources used in this request have either
+  // successfully started, or a source has failed to start.
+  void CallbackOnTracksStarted(const ResourcesReady& callback);
+
+  bool HasPendingSources() const;
+
+  // Called when a local audio source has finished (or failed) initializing.
+  void OnAudioSourceStarted(MediaStreamSource* source,
+                            MediaStreamRequestResult result,
+                            const blink::WebString& result_name);
+
+  bool is_processing_user_gesture() const {
+    return is_processing_user_gesture_;
+  }
+
+  const url::Origin& security_origin() const { return security_origin_; }
+
+ private:
+  void OnTrackStarted(MediaStreamSource* source,
+                      MediaStreamRequestResult result,
+                      const blink::WebString& result_name);
+
+  // Cheks if the sources for all tracks have been started and if so,
+  // invoke the |ready_callback_|.  Note that the caller should expect
+  // that |this| might be deleted when the function returns.
+  void CheckAllTracksStarted();
+
+  const bool is_processing_user_gesture_;
+  const url::Origin security_origin_;
+  ResourcesReady ready_callback_;
+  MediaStreamRequestResult request_result_;
+  blink::WebString request_result_name_;
+  // Sources used in this request.
+  std::vector<blink::WebMediaStreamSource> sources_;
+  std::vector<MediaStreamSource*> sources_waiting_for_callback_;
 };
 
 UserMediaClientImpl::UserMediaClientImpl(
     RenderFrame* render_frame,
     PeerConnectionDependencyFactory* dependency_factory,
     std::unique_ptr<MediaStreamDispatcher> media_stream_dispatcher,
     const scoped_refptr<base::TaskRunner>& worker_task_runner)
     : RenderFrameObserver(render_frame),
       dependency_factory_(dependency_factory),
       media_stream_dispatcher_(std::move(media_stream_dispatcher)),
@@ skipping 25 matching lines @@
          render_frame()->GetWebFrame() ==
              static_cast<blink::WebFrame*>(
                  user_media_request.ownerDocument().frame()));
 
   if (RenderThreadImpl::current()) {
     RenderThreadImpl::current()->peer_connection_tracker()->TrackGetUserMedia(
         user_media_request);
   }
 
   int request_id = g_next_request_id++;
-  std::unique_ptr<StreamControls> controls = base::MakeUnique<StreamControls>();
 
   // The value returned by isProcessingUserGesture() is used by the browser to
   // make decisions about the permissions UI. Its value can be lost while
   // switching threads, so saving its value here.
-  RequestSettings request_settings(
-      blink::WebUserGestureIndicator::isProcessingUserGesture(),
-      static_cast<url::Origin>(user_media_request.getSecurityOrigin()));
-  if (user_media_request.audio()) {
+  std::unique_ptr<UserMediaRequestInfo> request_info =
+      base::MakeUnique<UserMediaRequestInfo>(
+          request_id, user_media_request,
+          blink::WebUserGestureIndicator::isProcessingUserGesture(),
+          static_cast<url::Origin>(user_media_request.getSecurityOrigin()));
+  pending_request_infos_.push_back(std::move(request_info));
+  if (!current_request_info_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&UserMediaClientImpl::MaybeProcessNextRequestInfo,
+                              weak_factory_.GetWeakPtr()));
+  }
+}
+
+void UserMediaClientImpl::MaybeProcessNextRequestInfo() {
+  DCHECK(CalledOnValidThread());
+  if (current_request_info_ || pending_request_infos_.empty())
+    return;
+
+  current_request_info_ = std::move(pending_request_infos_.front());
+  pending_request_infos_.pop_front();
+
+  // TODO(guidou): Request audio and video capabilities in parallel.
+  if (current_request_info_->request.audio()) {
     bool request_audio_input_devices = false;
     // TODO(guidou): Implement spec-compliant device selection for audio. See
     // http://crbug.com/623104.
-    CopyConstraintsToTrackControls(user_media_request.audioConstraints(),
-                                   &controls->audio,
-                                   &request_audio_input_devices);
+    CopyConstraintsToTrackControls(
+        current_request_info_->request.audioConstraints(),
+        &current_request_info_->stream_controls.audio,
+        &request_audio_input_devices);
     CopyHotwordAndLocalEchoToStreamControls(
-        user_media_request.audioConstraints(), controls.get());
+        current_request_info_->request.audioConstraints(),
+        &current_request_info_->stream_controls);
     // Check if this input device should be used to select a matching output
     // device for audio rendering.
     GetConstraintValueAsBoolean(
-        user_media_request.audioConstraints(),
+        current_request_info_->request.audioConstraints(),
         &blink::WebMediaTrackConstraintSet::renderToAssociatedSink,
-        &request_settings.enable_automatic_audio_output_device_selection);
+        &current_request_info_->enable_automatic_output_device_selection);
 
     if (request_audio_input_devices) {
       GetMediaDevicesDispatcher()->EnumerateDevices(
           true /* audio_input */, false /* video_input */,
-          false /* audio_output */, request_settings.security_origin,
+          false /* audio_output */, current_request_info_->security_origin(),
           base::Bind(&UserMediaClientImpl::SelectAudioInputDevice,
-                     weak_factory_.GetWeakPtr(), request_id, user_media_request,
-                     base::Passed(&controls), request_settings));
+                     weak_factory_.GetWeakPtr(),
+                     current_request_info_->request));
       return;
     }
   }
 
-  SetupVideoInput(request_id, user_media_request, std::move(controls),
-                  request_settings);
+  SetupVideoInput(current_request_info_->request);
 }
 
 void UserMediaClientImpl::SelectAudioInputDevice(
-    int request_id,
     const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings,
     const EnumerationResult& device_enumeration) {
   DCHECK(CalledOnValidThread());
-  DCHECK(controls->audio.requested);
-  DCHECK(IsDeviceSource(controls->audio.stream_source));
+  if (!IsCurrentRequestInfo(user_media_request))
+    return;
+
+  auto& audio_controls = current_request_info_->stream_controls.audio;
+  DCHECK(audio_controls.requested);
+  DCHECK(IsDeviceSource(audio_controls.stream_source));
 
   if (!PickDeviceId(user_media_request.audioConstraints(),
                     device_enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT],
-                    &controls->audio.device_id)) {
+                    &audio_controls.device_id)) {
     GetUserMediaRequestFailed(user_media_request, MEDIA_DEVICE_NO_HARDWARE, "");
     return;
   }
 
-  SetupVideoInput(request_id, user_media_request, std::move(controls),
-                  request_settings);
+  SetupVideoInput(user_media_request);
 }
 
 void UserMediaClientImpl::SetupVideoInput(
-    int request_id,
-    const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings) {
+    const blink::WebUserMediaRequest& user_media_request) {
+  DCHECK(CalledOnValidThread());
+  if (!IsCurrentRequestInfo(user_media_request))
+    return;
+
   if (!user_media_request.video()) {
-    FinalizeRequestUserMedia(request_id, user_media_request,
-                             std::move(controls), request_settings);
+    GenerateStreamForCurrentRequestInfo();
     return;
   }
+  auto& video_controls = current_request_info_->stream_controls.video;
   InitializeTrackControls(user_media_request.videoConstraints(),
-                          &controls->video);
-  if (IsDeviceSource(controls->video.stream_source)) {
+                          &video_controls);
+  if (IsDeviceSource(video_controls.stream_source)) {
     GetMediaDevicesDispatcher()->GetVideoInputCapabilities(
-        request_settings.security_origin,
+        current_request_info_->security_origin(),
         base::Bind(&UserMediaClientImpl::SelectVideoDeviceSourceSettings,
-                   weak_factory_.GetWeakPtr(), request_id, user_media_request,
-                   base::Passed(&controls), request_settings));
+                   weak_factory_.GetWeakPtr(), user_media_request));
   } else {
     base::PostTaskAndReplyWithResult(
         worker_task_runner_.get(), FROM_HERE,
         base::Bind(&SelectVideoContentCaptureSourceSettings,
                    user_media_request.videoConstraints()),
         base::Bind(
             &UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings,
-            weak_factory_.GetWeakPtr(), request_id, user_media_request,
-            base::Passed(&controls), request_settings));
+            weak_factory_.GetWeakPtr(), user_media_request));
   }
 }
 
 void UserMediaClientImpl::SelectVideoDeviceSourceSettings(
-    int request_id,
     const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings,
     std::vector<::mojom::VideoInputDeviceCapabilitiesPtr>
         video_input_capabilities) {
   DCHECK(CalledOnValidThread());
-  DCHECK(controls->video.requested);
-  DCHECK(IsDeviceSource(controls->video.stream_source));
+  if (!IsCurrentRequestInfo(user_media_request))
+    return;
+
+  DCHECK(current_request_info_->stream_controls.video.requested);
+  DCHECK(IsDeviceSource(
+      current_request_info_->stream_controls.video.stream_source));
 
   VideoDeviceCaptureCapabilities capabilities;
   capabilities.device_capabilities = std::move(video_input_capabilities);
   capabilities.power_line_capabilities = {
       media::PowerLineFrequency::FREQUENCY_DEFAULT,
       media::PowerLineFrequency::FREQUENCY_50HZ,
       media::PowerLineFrequency::FREQUENCY_60HZ};
   capabilities.noise_reduction_capabilities = {rtc::Optional<bool>(),
                                                rtc::Optional<bool>(true),
                                                rtc::Optional<bool>(false)};
-
   base::PostTaskAndReplyWithResult(
       worker_task_runner_.get(), FROM_HERE,
       base::Bind(&SelectVideoDeviceCaptureSourceSettings,
                  std::move(capabilities),
                  user_media_request.videoConstraints()),
       base::Bind(&UserMediaClientImpl::FinalizeSelectVideoDeviceSourceSettings,
-                 weak_factory_.GetWeakPtr(), request_id, user_media_request,
-                 base::Passed(&controls), request_settings));
+                 weak_factory_.GetWeakPtr(), user_media_request));
 }
 
 void UserMediaClientImpl::FinalizeSelectVideoDeviceSourceSettings(
-    int request_id,
     const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings,
     const VideoDeviceCaptureSourceSelectionResult& selection_result) {
   DCHECK(CalledOnValidThread());
+  if (!IsCurrentRequestInfo(user_media_request))
+    return;
+
   if (!selection_result.HasValue()) {
     blink::WebString failed_constraint_name =
         blink::WebString::fromASCII(selection_result.failed_constraint_name());
     MediaStreamRequestResult result =
         failed_constraint_name.isEmpty()
             ? MEDIA_DEVICE_NO_HARDWARE
             : MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
     GetUserMediaRequestFailed(user_media_request, result,
                               failed_constraint_name);
     return;
   }
-  controls->video.device_id = selection_result.device_id();
-  FinalizeRequestUserMedia(request_id, user_media_request, std::move(controls),
-                           request_settings);
+  current_request_info_->stream_controls.video.device_id =
+      selection_result.device_id();
+  GenerateStreamForCurrentRequestInfo();
 }
 
 void UserMediaClientImpl::FinalizeSelectVideoContentSourceSettings(
-    int request_id,
     const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings,
     const VideoContentCaptureSourceSelectionResult& selection_result) {
   DCHECK(CalledOnValidThread());
+  if (!IsCurrentRequestInfo(user_media_request))
+    return;
+
   if (!selection_result.HasValue()) {
     blink::WebString failed_constraint_name =
         blink::WebString::fromASCII(selection_result.failed_constraint_name());
     DCHECK(!failed_constraint_name.isEmpty());
     blink::WebString device_id_constraint_name = blink::WebString::fromASCII(
         user_media_request.videoConstraints().basic().deviceId.name());
     GetUserMediaRequestFailed(user_media_request,
                               MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED,
                               failed_constraint_name);
     return;
   }
-  controls->video.device_id = selection_result.device_id();
-  FinalizeRequestUserMedia(request_id, user_media_request, std::move(controls),
-                           request_settings);
+  current_request_info_->stream_controls.video.device_id =
+      selection_result.device_id();
+  GenerateStreamForCurrentRequestInfo();
 }
 
-void UserMediaClientImpl::FinalizeRequestUserMedia(
-    int request_id,
-    const blink::WebUserMediaRequest& user_media_request,
-    std::unique_ptr<StreamControls> controls,
-    const RequestSettings& request_settings) {
+void UserMediaClientImpl::GenerateStreamForCurrentRequestInfo() {
   DCHECK(CalledOnValidThread());
+  DCHECK(current_request_info_);
 
-  WebRtcLogMessage(
-      base::StringPrintf("MSI::requestUserMedia. request_id=%d"
-                         ", audio source id=%s"
-                         ", video source id=%s",
-                         request_id, controls->audio.device_id.c_str(),
-                         controls->video.device_id.c_str()));
+  WebRtcLogMessage(base::StringPrintf(
+      "MSI::requestUserMedia. request_id=%d"
+      ", audio source id=%s"
+      ", video source id=%s",
+      current_request_info_->request_id,
+      current_request_info_->stream_controls.audio.device_id.c_str(),
+      current_request_info_->stream_controls.video.device_id.c_str()));
 
-  user_media_requests_.push_back(base::MakeUnique<UserMediaRequestInfo>(
-      request_id, user_media_request,
-      request_settings.enable_automatic_audio_output_device_selection));
-
+  current_request_info_->state =
+      UserMediaRequestInfo::State::SENT_FOR_GENERATION;
   media_stream_dispatcher_->GenerateStream(
-      request_id, weak_factory_.GetWeakPtr(), *controls,
-      request_settings.security_origin,
-      request_settings.is_processing_user_gesture);
+      current_request_info_->request_id, weak_factory_.GetWeakPtr(),
+      current_request_info_->stream_controls,
+      current_request_info_->security_origin(),
+      current_request_info_->is_processing_user_gesture());
 }
 
 void UserMediaClientImpl::cancelUserMediaRequest(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
-  UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
-  if (request) {
+  if (DeleteRequestInfo(user_media_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.
     LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_EXPLICITLY_CANCELLED);
-    DeleteUserMediaRequestInfo(request);
   }
 }
 
 void UserMediaClientImpl::requestMediaDevices(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   UpdateWebRTCMethodCount(WEBKIT_GET_MEDIA_DEVICES);
   DCHECK(CalledOnValidThread());
 
   // |media_devices_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
@@ skipping 37 matching lines @@
 }
 
 // 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;
-
-  UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
-  if (!request_info) {
-    // This can happen if the request is canceled or the frame reloads while
+  if (!IsCurrentRequestInfo(request_id)) {
+    // This can happen if the request is cancelled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     DVLOG(1) << "Request ID not found";
     OnStreamGeneratedForCancelledRequest(audio_array, video_array);
     return;
   }
-  request_info->generated = true;
+  current_request_info_->state = UserMediaRequestInfo::State::GENERATED;
 
   for (const auto* array : {&audio_array, &video_array}) {
     for (const auto& info : *array) {
       WebRtcLogMessage(base::StringPrintf("Request %d for device \"%s\"",
                                           request_id,
                                           info.device.name.c_str()));
     }
   }
 
-  DCHECK(!request_info->request.isNull());
+  DCHECK(!current_request_info_->request.isNull());
   blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
       audio_array.size());
-  CreateAudioTracks(audio_array, request_info->request.audioConstraints(),
-                    &audio_track_vector, request_info);
+  CreateAudioTracks(audio_array,
+                    current_request_info_->request.audioConstraints(),
+                    &audio_track_vector);
 
   blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
       video_array.size());
-  CreateVideoTracks(video_array, request_info->request.videoConstraints(),
-                    &video_track_vector, request_info);
+  CreateVideoTracks(video_array,
+                    current_request_info_->request.videoConstraints(),
+                    &video_track_vector);
 
   blink::WebString webkit_id = blink::WebString::fromUTF8(label);
-  blink::WebMediaStream* web_stream = &(request_info->web_stream);
+  blink::WebMediaStream* web_stream = &(current_request_info_->web_stream);
 
   web_stream->initialize(webkit_id, audio_track_vector, video_track_vector);
   web_stream->setExtraData(new MediaStream());
 
   // Wait for the tracks to be started successfully or to fail.
-  request_info->CallbackOnTracksStarted(
+  current_request_info_->CallbackOnTracksStarted(
       base::Bind(&UserMediaClientImpl::OnCreateNativeTracksCompleted,
                  weak_factory_.GetWeakPtr(), label));
 }
 
 void UserMediaClientImpl::OnStreamGeneratedForCancelledRequest(
     const StreamDeviceInfoArray& audio_array,
     const StreamDeviceInfoArray& video_array) {
   // Only stop the device if the device is not used in another MediaStream.
   for (StreamDeviceInfoArray::const_iterator device_it = audio_array.begin();
        device_it != audio_array.end(); ++device_it) {
@@ skipping 29 matching lines @@
   for (auto it = pending_local_sources_.begin();
        it != pending_local_sources_.end(); ++it) {
     MediaStreamSource* const source_extra_data =
         static_cast<MediaStreamSource*>((*it).getExtraData());
     if (source_extra_data != source)
       continue;
     if (result == MEDIA_DEVICE_OK)
       local_sources_.push_back((*it));
     pending_local_sources_.erase(it);
 
-    NotifyAllRequestsOfAudioSourceStarted(source, result, result_name);
+    NotifyCurrentRequestInfoOfAudioSourceStarted(source, result, result_name);
     return;
   }
   NOTREACHED();
 }
 
-void UserMediaClientImpl::NotifyAllRequestsOfAudioSourceStarted(
+void UserMediaClientImpl::NotifyCurrentRequestInfoOfAudioSourceStarted(
     MediaStreamSource* source,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
-  // Since a request object that receives the OnAudioSourceStarted event,
-  // might get deleted and removed from the |user_media_requests_| array while
-  // we iterate through it, we need to jump through this hoop here, copy
-  // pointers to the objects we're notifying and avoid using
-  // user_media_requests_ as we iterate+notify.
-  std::vector<UserMediaRequestInfo*> requests;
-  requests.reserve(user_media_requests_.size());
-  for (const auto& request : user_media_requests_)
-    requests.push_back(request.get());
-  for (auto* request : requests)
-    request->OnAudioSourceStarted(source, result, result_name);
+  // The only request possibly being processed is |current_request_info_|.
+  if (current_request_info_)
+    current_request_info_->OnAudioSourceStarted(source, result, result_name);
 }
 
 void UserMediaClientImpl::FinalizeEnumerateDevices(
     blink::WebMediaDevicesRequest request,
     const EnumerationResult& result) {
   DCHECK_EQ(static_cast<size_t>(NUM_MEDIA_DEVICE_TYPES), result.size());
 
   blink::WebVector<blink::WebMediaDeviceInfo> devices(
       result[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size() +
       result[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size() +
@@ skipping 12 matching lines @@
 
   EnumerateDevicesSucceded(&request, devices);
 }
 
 // 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) {
-    // This can happen if the request is canceled or the frame reloads while
+  if (!IsCurrentRequestInfo(request_id)) {
+    // This can happen if the request is cancelled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
-    DVLOG(1) << "Request ID not found";
     return;
   }
 
-  GetUserMediaRequestFailed(request_info->request, result, "");
-  DeleteUserMediaRequestInfo(request_info);
+  GetUserMediaRequestFailed(current_request_info_->request, result, "");
+  DeleteRequestInfo(current_request_info_->request);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void UserMediaClientImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "UserMediaClientImpl::OnDeviceStopped("
            << "{device_id = " << device_info.device.id << "})";
@@ skipping 93 matching lines @@
   DCHECK(CalledOnValidThread());
   content::MediaStreamVideoCapturerSource* ret =
       new content::MediaStreamVideoCapturerSource(stop_callback, device,
                                                   render_frame());
   return ret;
 }
 
 void UserMediaClientImpl::CreateVideoTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
-    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
-    UserMediaRequestInfo* request) {
+    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks) {
   DCHECK(CalledOnValidThread());
+  DCHECK(current_request_info_);
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   for (size_t i = 0; i < devices.size(); ++i) {
     blink::WebMediaStreamSource source =
         InitializeVideoSourceObject(devices[i], constraints);
     (*webkit_tracks)[i] =
-        request->CreateAndStartVideoTrack(source, constraints);
+        current_request_info_->CreateAndStartVideoTrack(source, constraints);
   }
 }
 
 void UserMediaClientImpl::CreateAudioTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
-    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks,
-    UserMediaRequestInfo* request) {
+    blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks) {
   DCHECK(CalledOnValidThread());
+  DCHECK(current_request_info_);
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   StreamDeviceInfoArray overridden_audio_array = devices;
-  if (!request->enable_automatic_output_device_selection) {
+  if (!current_request_info_->enable_automatic_output_device_selection) {
     // If the GetUserMedia request did not explicitly set the constraint
     // kMediaStreamRenderToAssociatedSink, the output device parameters must
     // be removed.
     for (auto& device_info : overridden_audio_array) {
       device_info.device.matched_output_device_id = "";
       device_info.device.matched_output =
           MediaStreamDevice::AudioDeviceParameters();
     }
   }
 
   for (size_t i = 0; i < overridden_audio_array.size(); ++i) {
     bool is_pending = false;
     blink::WebMediaStreamSource source = InitializeAudioSourceObject(
         overridden_audio_array[i], constraints, &is_pending);
     (*webkit_tracks)[i].initialize(source);
-    request->StartAudioTrack((*webkit_tracks)[i], is_pending);
+    current_request_info_->StartAudioTrack((*webkit_tracks)[i], is_pending);
   }
 }
 
 void UserMediaClientImpl::OnCreateNativeTracksCompleted(
     const std::string& label,
-    UserMediaRequestInfo* request,
+    UserMediaRequestInfo* request_info,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DCHECK(CalledOnValidThread());
-  DVLOG(1) << "UserMediaClientImpl::OnCreateNativeTracksComplete("
-           << "{request_id = " << request->request_id << "} "
-           << "{result = " << result << "})";
-
   if (result == content::MEDIA_DEVICE_OK) {
-    GetUserMediaRequestSucceeded(request->web_stream, request->request);
+    GetUserMediaRequestSucceeded(request_info->web_stream,
+                                 request_info->request);
     media_stream_dispatcher_->OnStreamStarted(label);
   } else {
-    GetUserMediaRequestFailed(request->request, result, result_name);
+    GetUserMediaRequestFailed(request_info->request, result, result_name);
 
     blink::WebVector<blink::WebMediaStreamTrack> tracks;
-    request->web_stream.audioTracks(tracks);
+    request_info->web_stream.audioTracks(tracks);
     for (auto& web_track : tracks) {
       MediaStreamTrack* track = MediaStreamTrack::GetTrack(web_track);
       if (track)
         track->Stop();
     }
-    request->web_stream.videoTracks(tracks);
+    request_info->web_stream.videoTracks(tracks);
     for (auto& web_track : tracks) {
       MediaStreamTrack* track = MediaStreamTrack::GetTrack(web_track);
       if (track)
         track->Stop();
     }
   }
 
-  DeleteUserMediaRequestInfo(request);
+  DeleteRequestInfo(request_info->request);
 }
 
 void UserMediaClientImpl::OnDeviceOpened(
     int request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
   DVLOG(1) << "UserMediaClientImpl::OnDeviceOpened("
            << request_id << ", " << label << ")";
   NOTIMPLEMENTED();
 }
 
 void UserMediaClientImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "UserMediaClientImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void UserMediaClientImpl::DevicesChanged(
     MediaDeviceType type,
     const MediaDeviceInfoArray& device_infos) {
   if (!media_device_change_observer_.isNull())
     media_device_change_observer_.didChangeMediaDevices();
 }
 
 void UserMediaClientImpl::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
-    blink::WebUserMediaRequest request_info) {
+    blink::WebUserMediaRequest request) {
   // Completing the getUserMedia request can lead to that the RenderFrame and
   // the UserMediaClientImpl is destroyed if the JavaScript code request the
   // frame to be destroyed within the scope of the callback. Therefore,
   // post a task to complete the request with a clean stack.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded,
-                 weak_factory_.GetWeakPtr(), stream, request_info));
+                 weak_factory_.GetWeakPtr(), stream, request));
 }
 
 void UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
-    blink::WebUserMediaRequest request_info) {
+    blink::WebUserMediaRequest request) {
   DVLOG(1) << "UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded";
   LogUserMediaRequestResult(MEDIA_DEVICE_OK);
-  request_info.requestSucceeded(stream);
+  DeleteRequestInfo(request);
+  request.requestSucceeded(stream);
 }
 
 void UserMediaClientImpl::GetUserMediaRequestFailed(
-    blink::WebUserMediaRequest request_info,
+    blink::WebUserMediaRequest request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   // Completing the getUserMedia request can lead to that the RenderFrame and
   // the UserMediaClientImpl is destroyed if the JavaScript code request the
   // frame to be destroyed within the scope of the callback. Therefore,
   // post a task to complete the request with a clean stack.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&UserMediaClientImpl::DelayedGetUserMediaRequestFailed,
-                 weak_factory_.GetWeakPtr(), request_info, result,
-                 result_name));
+                 weak_factory_.GetWeakPtr(), request, result, result_name));
 }
 
 void UserMediaClientImpl::DelayedGetUserMediaRequestFailed(
-    blink::WebUserMediaRequest request_info,
+    blink::WebUserMediaRequest request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   LogUserMediaRequestResult(result);
+  DeleteRequestInfo(request);
   switch (result) {
     case MEDIA_DEVICE_OK:
     case NUM_MEDIA_REQUEST_RESULTS:
       NOTREACHED();
       return;
     case MEDIA_DEVICE_PERMISSION_DENIED:
-      request_info.requestDenied();
+      request.requestDenied();
       return;
     case MEDIA_DEVICE_PERMISSION_DISMISSED:
-      request_info.requestFailedUASpecific("PermissionDismissedError");
+      request.requestFailedUASpecific("PermissionDismissedError");
       return;
     case MEDIA_DEVICE_INVALID_STATE:
-      request_info.requestFailedUASpecific("InvalidStateError");
+      request.requestFailedUASpecific("InvalidStateError");
       return;
     case MEDIA_DEVICE_NO_HARDWARE:
-      request_info.requestFailedUASpecific("DevicesNotFoundError");
+      request.requestFailedUASpecific("DevicesNotFoundError");
       return;
     case MEDIA_DEVICE_INVALID_SECURITY_ORIGIN:
-      request_info.requestFailedUASpecific("InvalidSecurityOriginError");
+      request.requestFailedUASpecific("InvalidSecurityOriginError");
       return;
     case MEDIA_DEVICE_TAB_CAPTURE_FAILURE:
-      request_info.requestFailedUASpecific("TabCaptureError");
+      request.requestFailedUASpecific("TabCaptureError");
       return;
     case MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE:
-      request_info.requestFailedUASpecific("ScreenCaptureError");
+      request.requestFailedUASpecific("ScreenCaptureError");
       return;
     case MEDIA_DEVICE_CAPTURE_FAILURE:
-      request_info.requestFailedUASpecific("DeviceCaptureError");
+      request.requestFailedUASpecific("DeviceCaptureError");
       return;
     case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
-      request_info.requestFailedConstraint(result_name);
+      request.requestFailedConstraint(result_name);
       return;
     case MEDIA_DEVICE_TRACK_START_FAILURE:
-      request_info.requestFailedUASpecific("TrackStartError");
+      request.requestFailedUASpecific("TrackStartError");
       return;
     case MEDIA_DEVICE_NOT_SUPPORTED:
-      request_info.requestFailedUASpecific("MediaDeviceNotSupported");
+      request.requestFailedUASpecific("MediaDeviceNotSupported");
       return;
     case MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN:
-      request_info.requestFailedUASpecific("MediaDeviceFailedDueToShutdown");
+      request.requestFailedUASpecific("MediaDeviceFailedDueToShutdown");
       return;
     case MEDIA_DEVICE_KILL_SWITCH_ON:
-      request_info.requestFailedUASpecific("MediaDeviceKillSwitchOn");
+      request.requestFailedUASpecific("MediaDeviceKillSwitchOn");
       return;
   }
   NOTREACHED();
-  request_info.requestFailed();
+  request.requestFailed();
 }
 
 void UserMediaClientImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
 
 const blink::WebMediaStreamSource* UserMediaClientImpl::FindLocalSource(
     const LocalStreamSources& sources,
@@ skipping 43 matching lines @@
       return true;
     }
   }
 
   // Check if the source was pending.
   for (LocalStreamSources::iterator device_it = pending_local_sources_.begin();
        device_it != pending_local_sources_.end(); ++device_it) {
     if (IsSameSource(*device_it, source)) {
       MediaStreamSource* const source_extra_data =
           static_cast<MediaStreamSource*>(source.getExtraData());
-      NotifyAllRequestsOfAudioSourceStarted(
+      NotifyCurrentRequestInfoOfAudioSourceStarted(
           source_extra_data, MEDIA_DEVICE_TRACK_START_FAILURE,
           "Failed to access audio capture device");
       pending_local_sources_.erase(device_it);
       return true;
     }
   }
 
   return false;
 }
 
-UserMediaClientImpl::UserMediaRequestInfo*
-UserMediaClientImpl::FindUserMediaRequestInfo(int request_id) {
+bool UserMediaClientImpl::IsCurrentRequestInfo(int request_id) const {
   DCHECK(CalledOnValidThread());
-  for (auto& r : user_media_requests_) {
-    if (r->request_id == request_id)
-      return r.get();
-  }
-  return nullptr;
+  return current_request_info_ &&
+         current_request_info_->request_id == request_id;
 }
 
-UserMediaClientImpl::UserMediaRequestInfo*
-UserMediaClientImpl::FindUserMediaRequestInfo(
-    const blink::WebUserMediaRequest& request) {
+bool UserMediaClientImpl::IsCurrentRequestInfo(
+    const blink::WebUserMediaRequest& request) const {
   DCHECK(CalledOnValidThread());
-  for (auto& r : user_media_requests_) {
-    if (r->request == request)
-      return r.get();
-  }
-  return nullptr;
+  return current_request_info_ && current_request_info_->request == request;
 }
 
-void UserMediaClientImpl::DeleteUserMediaRequestInfo(
-    UserMediaRequestInfo* request) {
+bool UserMediaClientImpl::DeleteRequestInfo(
+    const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
-  auto new_end =
-      std::remove_if(user_media_requests_.begin(), user_media_requests_.end(),
-                     [&](std::unique_ptr<UserMediaRequestInfo>& r) {
-                       return r.get() == request;
-                     });
-  DCHECK(new_end != user_media_requests_.end());
-  user_media_requests_.erase(new_end, user_media_requests_.end());
+  if (current_request_info_ &&
+      current_request_info_->request == user_media_request) {
+    current_request_info_.reset();
+    if (!pending_request_infos_.empty()) {
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&UserMediaClientImpl::MaybeProcessNextRequestInfo,
+                     weak_factory_.GetWeakPtr()));
+    }
+    return true;
+  }
+
+  for (auto it = pending_request_infos_.begin();
+       it != pending_request_infos_.end(); ++it) {
+    if ((*it)->request == user_media_request) {
+      pending_request_infos_.erase(it);
+      return true;
+    }
+  }
+
+  return false;
 }
 
 void UserMediaClientImpl::DeleteAllUserMediaRequests() {
-  UserMediaRequests::iterator request_it = user_media_requests_.begin();
-  while (request_it != user_media_requests_.end()) {
-    DVLOG(1) << "UserMediaClientImpl@" << this
-             << "::DeleteAllUserMediaRequests: "
-             << "Cancel user media request " << (*request_it)->request_id;
+  if (current_request_info_) {
     // If the request is not generated, it means that a request
     // has been sent to the MediaStreamDispatcher to generate a stream
     // but MediaStreamDispatcher has not yet responded and we need to cancel
     // the request.
-    if (!(*request_it)->generated) {
-      DCHECK(!(*request_it)->HasPendingSources());
-      media_stream_dispatcher_->CancelGenerateStream(
-          (*request_it)->request_id, weak_factory_.GetWeakPtr());
-      LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED);
-    } else {
-      DCHECK((*request_it)->HasPendingSources());
+    if (current_request_info_->state ==
+        UserMediaRequestInfo::State::GENERATED) {
+      DCHECK(current_request_info_->HasPendingSources());
       LogUserMediaRequestWithNoResult(
           MEDIA_STREAM_REQUEST_PENDING_MEDIA_TRACKS);
+    } else {
+      DCHECK(!current_request_info_->HasPendingSources());
+      if (current_request_info_->state ==
+          UserMediaRequestInfo::State::SENT_FOR_GENERATION) {
+        media_stream_dispatcher_->CancelGenerateStream(
+            current_request_info_->request_id, weak_factory_.GetWeakPtr());
+      }
+      LogUserMediaRequestWithNoResult(MEDIA_STREAM_REQUEST_NOT_GENERATED);
     }
-    request_it = user_media_requests_.erase(request_it);
+    current_request_info_.reset();
+    pending_request_infos_.clear();
   }
 }
 
 void UserMediaClientImpl::WillCommitProvisionalLoad() {
   // Cancel all outstanding UserMediaRequests.
   DeleteAllUserMediaRequests();
 
   // Loop through all current local sources and stop the sources.
   LocalStreamSources::iterator sources_it = local_sources_.begin();
   while (sources_it != local_sources_.end()) {
@@ skipping 38 matching lines @@
 const ::mojom::MediaDevicesDispatcherHostPtr&
 UserMediaClientImpl::GetMediaDevicesDispatcher() {
   if (!media_devices_dispatcher_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&media_devices_dispatcher_));
   }
 
   return media_devices_dispatcher_;
 }
 
+base::Optional<bool>
+UserMediaClientImpl::AutomaticOutputDeviceSelectionEnabledForCurrentRequest() {
+  if (!current_request_info_)
+    return base::Optional<bool>();
+
+  return base::Optional<bool>(
+      current_request_info_->enable_automatic_output_device_selection);
+}
+
+void UserMediaClientImpl::OnDestruct() {
+  delete this;
+}
+
 UserMediaClientImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     const blink::WebUserMediaRequest& request,
-    bool enable_automatic_output_device_selection)
+    bool is_processing_user_gesture,
+    const url::Origin& security_origin)
     : request_id(request_id),
-      generated(false),
-      enable_automatic_output_device_selection(
-          enable_automatic_output_device_selection),
+      state(State::NOT_SENT_FOR_GENERATION),
+      enable_automatic_output_device_selection(false),
       request(request),
+      is_processing_user_gesture_(is_processing_user_gesture),
+      security_origin_(security_origin),
       request_result_(MEDIA_DEVICE_OK),
-      request_result_name_("") {
-}
-
-UserMediaClientImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
-  DVLOG(1) << "~UserMediaRequestInfo";
-}
+      request_result_name_("") {}
 
 void UserMediaClientImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     bool is_pending) {
   DCHECK(track.source().getType() == blink::WebMediaStreamSource::TypeAudio);
   MediaStreamAudioSource* native_source =
       MediaStreamAudioSource::From(track.source());
   // Add the source as pending since OnTrackStarted will expect it to be there.
   sources_waiting_for_callback_.push_back(native_source);
 
@@ skipping 67 matching lines @@
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   // Check if we're waiting to be notified of this source.  If not, then we'll
   // ignore the notification.
   auto found = std::find(sources_waiting_for_callback_.begin(),
                          sources_waiting_for_callback_.end(), source);
   if (found != sources_waiting_for_callback_.end())
     OnTrackStarted(source, result, result_name);
 }
 
-void UserMediaClientImpl::OnDestruct() {
-  delete this;
-}
-
 }  // namespace content