Move getUserMedia finish to "when audio track configured".

content/renderer/media/media_stream_audio_unittest.cc

 // Copyright 2016 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 <stdint.h>
 
 #include "base/atomicops.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "content/public/renderer/media_stream_audio_sink.h"
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
+#include "media/base/bind_to_current_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebHeap.h"
 
 namespace content {
 
 namespace {
 
 constexpr int kSampleRate = 8000;
 constexpr int kBufferSize = kSampleRate / 100;
@@ skipping 203 matching lines @@
   base::subtle::Atomic32 audio_is_silent_;
   bool was_ended_;
   EnableState enable_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMediaStreamAudioSink);
 };
 
 }  // namespace
 
 class MediaStreamAudioTest : public ::testing::Test {
+ public:
+  void CallbackFunction() { callback_is_called_ = true; }
+
  protected:
   void SetUp() override {
     blink_audio_source_.initialize(blink::WebString::fromUTF8("audio_id"),
                                    blink::WebMediaStreamSource::TypeAudio,
                                    blink::WebString::fromUTF8("audio_track"),
                                    false /* remote */);
     blink_audio_track_.initialize(blink_audio_source_.id(),
                                   blink_audio_source_);
   }
 
   void TearDown() override {
     blink_audio_track_.reset();
     blink_audio_source_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   FakeMediaStreamAudioSource* source() const {
     return static_cast<FakeMediaStreamAudioSource*>(
         MediaStreamAudioSource::From(blink_audio_source_));
   }
 
   MediaStreamAudioTrack* track() const {
     return MediaStreamAudioTrack::From(blink_audio_track_);
   }
 
   blink::WebMediaStreamSource blink_audio_source_;
   blink::WebMediaStreamTrack blink_audio_track_;
 
   base::MessageLoop message_loop_;
+
+  bool callback_is_called_ = false;
 };
 
 // Tests that a simple source-->track-->sink connection and audio data flow
 // works.
 TEST_F(MediaStreamAudioTest, BasicUsage) {
   // Create the source, but it should not be started yet.
   ASSERT_FALSE(source());
   blink_audio_source_.setExtraData(new FakeMediaStreamAudioSource());
   ASSERT_TRUE(source());
   EXPECT_FALSE(source()->was_started());
@@ skipping 165 matching lines @@
   // The first track and sink should not have been affected by changing the
   // enabled state of the second track and sink. They should still be disabled,
   // with silent audio being consumed at the sink.
   EXPECT_EQ(FakeMediaStreamAudioSink::WAS_DISABLED, sink.enable_state());
   EXPECT_TRUE(sink.is_audio_silent());
 
   MediaStreamAudioTrack::From(another_blink_track)->RemoveSink(&another_sink);
   track()->RemoveSink(&sink);
 }
 
+// Tests that a callback is fired when initialization completes on a track.
+TEST_F(MediaStreamAudioTest, CallbackOnTrackInitialization) {
+  // Create a source, connect it to track, and connect the track to a
+  // sink.
+  blink_audio_source_.setExtraData(new FakeMediaStreamAudioSource());
+  ASSERT_TRUE(source());
+  EXPECT_TRUE(source()->ConnectToTrack(blink_audio_track_));
+  ASSERT_TRUE(track());
+  FakeMediaStreamAudioSink sink;
+  ASSERT_TRUE(!sink.params().IsValid());
+  track()->AddSink(&sink);
+  // The test callback is not thread-safe, so needs to be called on the
+  // current thread, not the thread from which it is triggered.
+  track()->SetFormatConfiguredCallback(media::BindToCurrentLoop(base::Bind(
+      &MediaStreamAudioTest::CallbackFunction, base::Unretained(this))));
+  EXPECT_FALSE(callback_is_called_);
+  // Wait until valid parameters are propagated to the sink, and then confirm
+  // the parameters are correct at the track and the sink.
+  while (!sink.params().IsValid())
+    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  // Since the callback is waiting to run on this thread, we have to run
+  // an event loop.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(callback_is_called_);
+  track()->RemoveSink(&sink);
+}
+
 }  // namespace content