Fix getUserMedia so that failure is reported for invalid audio sources.

content/renderer/media/user_media_client_impl_unittest.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 <memory>
 #include <utility>
@@ skipping 188 matching lines @@
       blink::WebMediaDevicesRequest* request,
       blink::WebVector<blink::WebMediaDeviceInfo>& devices) override {
     state_ = REQUEST_SUCCEEDED;
     last_devices_ = devices;
   }
 
   void SetCreateSourceThatFails(bool should_fail) {
     create_source_that_fails_ = should_fail;
   }
 
+  static void SignalSourceReady(
+      const MediaStreamSource::ConstraintsCallback& source_ready,
+      MediaStreamSource* source) {
+    source_ready.Run(source, MEDIA_DEVICE_OK, "");
+  }
+
   MediaStreamAudioSource* CreateAudioSource(
       const StreamDeviceInfo& device,
-      const blink::WebMediaConstraints& constraints) override {
+      const blink::WebMediaConstraints& constraints,
+      const MediaStreamSource::ConstraintsCallback& source_ready) override {
     MediaStreamAudioSource* source;
     if (create_source_that_fails_) {
       class FailedAtLifeAudioSource : public MediaStreamAudioSource {
        public:
         FailedAtLifeAudioSource() : MediaStreamAudioSource(true) {}
         ~FailedAtLifeAudioSource() override {}
        protected:
         bool EnsureSourceIsStarted() override {
           return false;
         }
       };
       source = new FailedAtLifeAudioSource();
     } else {
       source = new MediaStreamAudioSource(true);
     }
     source->SetDeviceInfo(device);
+
+    if (!create_source_that_fails_) {
+      // RunUntilIdle is required for this task to complete.
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&UserMediaClientImplUnderTest::SignalSourceReady,
+                     source_ready, source));
+    }
+
     return source;
   }
 
   MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback) override {
     video_source_ = new MockMediaStreamVideoCapturerSource(device,
                                                            stop_callback,
                                                            factory_);
     return video_source_;
@@ skipping 101 matching lines @@
     EXPECT_NE(audio_tracks[0].id(), video_tracks[0].id());
     return desc;
   }
 
   void FakeMediaStreamDispatcherRequestUserMediaComplete() {
     // Audio request ID is used as the shared request ID.
     user_media_client_impl_->OnStreamGenerated(
         ms_dispatcher_->audio_input_request_id(),
         ms_dispatcher_->stream_label(), ms_dispatcher_->audio_input_array(),
         ms_dispatcher_->video_array());
+    base::RunLoop().RunUntilIdle();
   }
 
   void StartMockedVideoSource() {
     MockMediaStreamVideoCapturerSource* video_source =
         user_media_client_impl_->last_created_video_source();
     if (video_source->SourceHasAttemptedToStart())
       video_source->StartMockedSource();
   }
 
   void FailToStartMockedVideoSource() {
@@ skipping 514 matching lines @@
   blink::WebMediaConstraints audio_constraints = CreateDeviceConstraints(
       nullptr, kInvalidDeviceId, kInvalidDeviceId, kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints = CreateDeviceConstraints(
       nullptr, kInvalidDeviceId, kInvalidDeviceId, kFakeVideoInputDeviceId1);
   TestValidRequestWithDeviceConstraints(audio_constraints, video_constraints,
                                         kFakeAudioInputDeviceId1,
                                         kFakeVideoInputDeviceId1);
 }
 
 }  // namespace content