Add new device ID unit tests to UserMediaClientImpl.

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>
@@ skipping 222 matching lines @@
   WillCommitProvisionalLoad();
 }
 
 void UserMediaClientImpl::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());
+  DCHECK(!user_media_request.isNull());
+  // ownerDocument may be null if we are in a test.
+  // In that case, it's OK to not check frame().
+  DCHECK(user_media_request.ownerDocument().isNull() ||
+         render_frame()->GetWebFrame() ==
+             static_cast<blink::WebFrame*>(
+                 user_media_request.ownerDocument().frame()));

[hbos_chromium, 2016/12/05 16:30:31]

I take it that this is still needed even though the other test-specific code
path was removed?

[Guido Urdaneta, 2016/12/05 17:23:52]

For some definition of needed :)
It doesn't seem to hurt.

 
   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>();
 
-  // |user_media_request| can't be mocked. So in order to test at all we check
-  // if it isNull.
-  // TODO(guidou): Remove this test-specific code path.
-  if (user_media_request.isNull()) {
-    // We are in a test.
-    controls->audio.requested = true;
-    controls->video.requested = true;
+  bool enable_automatic_output_device_selection = false;
+  bool request_audio_input_devices = false;
+  if (user_media_request.audio()) {
+    CopyConstraintsToTrackControls(user_media_request.audioConstraints(),
+                                   &controls->audio,
+                                   &request_audio_input_devices);
+    CopyHotwordAndLocalEchoToStreamControls(
+        user_media_request.audioConstraints(), controls.get());
+    // Check if this input device should be used to select a matching output
+    // device for audio rendering.
+    GetConstraintValueAsBoolean(
+        user_media_request.audioConstraints(),
+        &blink::WebMediaTrackConstraintSet::renderToAssociatedSink,
+        &enable_automatic_output_device_selection);
+  }
+  bool request_video_input_devices = false;
+  if (user_media_request.video()) {
+    CopyConstraintsToTrackControls(user_media_request.videoConstraints(),
+                                   &controls->video,
+                                   &request_video_input_devices);
+  }
+
+  url::Origin security_origin = user_media_request.getSecurityOrigin();
+  if (request_audio_input_devices || request_video_input_devices) {
+    GetMediaDevicesDispatcher()->EnumerateDevices(
+        request_audio_input_devices, request_video_input_devices,
+        false /* request_audio_output_devices */, security_origin,
+        base::Bind(&UserMediaClientImpl::SelectUserMediaDevice,
+                   weak_factory_.GetWeakPtr(), request_id, user_media_request,
+                   base::Passed(&controls),
+                   enable_automatic_output_device_selection, security_origin));
+  } else {
     FinalizeRequestUserMedia(
         request_id, user_media_request, std::move(controls),
-        false /* automatic_output_device_selection */, url::Origin());
-  } else {
-    // ownerDocument may be null if we are in a test.
-    // In that case, it's OK to not check frame().
-    DCHECK(user_media_request.ownerDocument().isNull() ||
-           render_frame()->GetWebFrame() ==
-               static_cast<blink::WebFrame*>(
-                   user_media_request.ownerDocument().frame()));
-
-    bool enable_automatic_output_device_selection = false;
-    bool request_audio_input_devices = false;
-    if (user_media_request.audio()) {
-      CopyConstraintsToTrackControls(user_media_request.audioConstraints(),
-                                     &controls->audio,
-                                     &request_audio_input_devices);
-      CopyHotwordAndLocalEchoToStreamControls(
-          user_media_request.audioConstraints(), controls.get());
-      // Check if this input device should be used to select a matching output
-      // device for audio rendering.
-      GetConstraintValueAsBoolean(
-          user_media_request.audioConstraints(),
-          &blink::WebMediaTrackConstraintSet::renderToAssociatedSink,
-          &enable_automatic_output_device_selection);
-    }
-    bool request_video_input_devices = false;
-    if (user_media_request.video()) {
-      CopyConstraintsToTrackControls(user_media_request.videoConstraints(),
-                                     &controls->video,
-                                     &request_video_input_devices);
-    }
-
-    url::Origin security_origin = user_media_request.getSecurityOrigin();
-    if (request_audio_input_devices || request_video_input_devices) {
-      GetMediaDevicesDispatcher()->EnumerateDevices(
-          request_audio_input_devices, request_video_input_devices,
-          false /* request_audio_output_devices */, security_origin,
-          base::Bind(&UserMediaClientImpl::SelectUserMediaDevice,
-                     weak_factory_.GetWeakPtr(), request_id, user_media_request,
-                     base::Passed(&controls),
-                     enable_automatic_output_device_selection,
-                     security_origin));
-    } else {
-      FinalizeRequestUserMedia(
-          request_id, user_media_request, std::move(controls),
-          enable_automatic_output_device_selection, security_origin);
-    }
+        enable_automatic_output_device_selection, security_origin);
   }
 }
 
 void UserMediaClientImpl::SelectUserMediaDevice(
     int request_id,
     const blink::WebUserMediaRequest& user_media_request,
     std::unique_ptr<StreamControls> controls,
     bool enable_automatic_output_device_selection,
     const url::Origin& security_origin,
     const EnumerationResult& device_enumeration) {
@@ skipping 121 matching lines @@
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled 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;
 
-  // WebUserMediaRequest don't have an implementation in unit tests.
-  // Therefore we need to check for isNull here and initialize the
-  // constraints.
-  blink::WebUserMediaRequest* request = &(request_info->request);
-  blink::WebMediaConstraints audio_constraints;
-  blink::WebMediaConstraints video_constraints;
-  if (request->isNull()) {
-    audio_constraints.initialize();
-    video_constraints.initialize();
-  } else {
-    audio_constraints = request->audioConstraints();
-    video_constraints = request->videoConstraints();
-  }
-
+  DCHECK(!request_info->request.isNull());
   blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
       audio_array.size());
-  CreateAudioTracks(audio_array, audio_constraints, &audio_track_vector,
-                    request_info);
+  CreateAudioTracks(audio_array, request_info->request.audioConstraints(),
+                    &audio_track_vector, request_info);
 
   blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
       video_array.size());
-  CreateVideoTracks(video_array, video_constraints, &video_track_vector,
-                    request_info);
+  CreateVideoTracks(video_array, request_info->request.videoConstraints(),
+                    &video_track_vector, request_info);
 
   blink::WebString webkit_id = base::UTF8ToUTF16(label);
   blink::WebMediaStream* web_stream = &(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(
@@ skipping 612 matching lines @@
 
 bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   return !sources_waiting_for_callback_.empty();
 }
 
 void UserMediaClientImpl::OnDestruct() {
   delete this;
 }
 
 }  // namespace content