Move getUserMedia finish to "when audio track configured".

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 232 matching lines @@
   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,
       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();
+      FailedAtLifeAudioSource* source = new FailedAtLifeAudioSource();
+      source->SetDeviceInfo(device);
+      return source;
     } else {
-      source = new MediaStreamAudioSource(true);
-    }
-    source->SetDeviceInfo(device);
+      class GeneratingAudioSource : public MediaStreamAudioSource {

[Guido Urdaneta, 2017/04/06 13:18:57]

Normally, I would request this class to be defined somewhere else, but in this
case it is more consistent with the existing code to define it here.

[hta - Chromium, 2017/04/06 13:57:52]

Acknowledged.

I thought about merging FailedAtLifeAudioSource and GeneratingAudioSource and
making a separate MockAudioSource object with parameters, but then I decided to
follow the existing pattern instead.
 

+       public:
+        GeneratingAudioSource() : MediaStreamAudioSource(true) {
+          SetFormat(
+              media::AudioParameters(media::AudioParameters::AUDIO_PCM_LINEAR,
+                                     media::CHANNEL_LAYOUT_MONO, 8000, 8, 1));
+        }
+        ~GeneratingAudioSource() override {}
+        void InjectAudio() {
+          std::unique_ptr<media::AudioBus> data =
+              media::AudioBus::Create(GetAudioParameters());
+          DeliverDataToTracks(*data, base::TimeTicks());
+        }
+        bool ConnectToTrack(
+            const blink::WebMediaStreamTrack& blink_track) override {
+          bool result = MediaStreamAudioSource::ConnectToTrack(blink_track);
+          // Queue a task to inject an audio sample after other stuff finishes.
+          // RunUntilIdle is required for this task to complete.
+          // We assume that "source" will survive long enough that it's safe
+          // to use base::Unretained.
+          base::ThreadTaskRunnerHandle::Get()->PostTask(
+              FROM_HERE, base::Bind(&GeneratingAudioSource::InjectAudio,
+                                    base::Unretained(this)));
+          return result;
+        }
+      };
 
-    if (!create_source_that_fails_) {
-      // RunUntilIdle is required for this task to complete.
+      GeneratingAudioSource* source = new GeneratingAudioSource();
+      source->SetDeviceInfo(device);
+      // Queue a task to inform about the source being ready.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&UserMediaClientImplUnderTest::SignalSourceReady,
                      source_ready, source));
+      return 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 66 matching lines @@
   }
 
   void LoadNewDocumentInFrame() {
     user_media_client_impl_->WillCommitProvisionalLoad();
   }
 
   blink::WebMediaStream RequestLocalMediaStream() {
     user_media_client_impl_->RequestUserMediaForTest();
     FakeMediaStreamDispatcherRequestUserMediaComplete();
     StartMockedVideoSource();
-
     EXPECT_EQ(UserMediaClientImplUnderTest::REQUEST_SUCCEEDED,
               user_media_client_impl_->request_state());
 
     blink::WebMediaStream desc =
         user_media_client_impl_->last_generated_stream();
     content::MediaStream* native_stream =
         content::MediaStream::GetMediaStream(desc);
     if (!native_stream) {
       ADD_FAILURE();
       return desc;
@@ skipping 549 matching lines @@
       CreateDeviceConstraints(kFakeAudioInputDeviceId1);
   blink::WebMediaConstraints video_constraints =
       CreateFacingModeConstraints("environment");
   // kFakeVideoInputDeviceId2 has environment facing mode.
   TestValidRequestWithConstraints(audio_constraints, video_constraints,
                                   kFakeAudioInputDeviceId1,
                                   kFakeVideoInputDeviceId2);
 }
 
 }  // namespace content