Move OnDecoderInitDone() from decoder to pipeline thread.

media/filters/audio_renderer_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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/gtest_prod_util.h"
+#include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "media/base/data_buffer.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
@@ skipping 33 matching lines @@
         .Times(AnyNumber());
     EXPECT_CALL(*decoder_, channel_layout())
         .Times(AnyNumber());
     EXPECT_CALL(*decoder_, samples_per_second())
         .Times(AnyNumber());
 
     decoders_.push_back(decoder_);
   }
 
   virtual ~AudioRendererImplTest() {
+    message_loop_.RunAllPending();
     renderer_->Stop(NewExpectedClosure());
   }
 
   void SetSupportedAudioDecoderProperties() {
     ON_CALL(*decoder_, bits_per_channel())
         .WillByDefault(Return(16));
     ON_CALL(*decoder_, channel_layout())
         .WillByDefault(Return(CHANNEL_LAYOUT_MONO));
     ON_CALL(*decoder_, samples_per_second())
         .WillByDefault(Return(44100));
@@ skipping 23 matching lines @@
   void OnAudioTimeCallback(
       base::TimeDelta current_time, base::TimeDelta max_time) {
     CHECK(current_time <= max_time);
   }
 
   void Initialize() {
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
         .WillOnce(RunPipelineStatusCB1(PIPELINE_OK));
 
     InitializeWithStatus(PIPELINE_OK);
+    message_loop_.RunAllPending();
   }
 
   void InitializeWithStatus(PipelineStatus expected) {
     renderer_->Initialize(
         demuxer_stream_,
         decoders_,
         NewExpectedStatusCB(expected),
         base::Bind(&AudioRendererImplTest::OnStatistics,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnUnderflow,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnAudioTimeCallback,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnEnded,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnDisabled,
                    base::Unretained(this)),
         base::Bind(&AudioRendererImplTest::OnError,
                    base::Unretained(this)));
   }
 
   void Preroll() {
     // Fill entire buffer to complete prerolling.
     EXPECT_CALL(*decoder_, Read(_));
     renderer_->Preroll(base::TimeDelta(), NewPrerollCB());
     EXPECT_CALL(*this, OnPrerollComplete(PIPELINE_OK));
+    message_loop_.RunAllPending();
     DeliverRemainingAudio();
   }
 
   void Play() {
     renderer_->Play(NewExpectedClosure());
     renderer_->SetPlaybackRate(1.0f);
   }
 
   void Preroll(base::TimeDelta preroll_time) {
     next_timestamp_ = preroll_time;
@@ skipping 82 matching lines @@
     renderer_->ResumeAfterUnderflow(false);
   }
 
   // Fixture members.
   scoped_refptr<AudioRendererImpl> renderer_;
   scoped_refptr<MockDemuxerStream> demuxer_stream_;
   scoped_refptr<MockAudioDecoder> decoder_;
   AudioRendererImpl::AudioDecoderList decoders_;
   AudioDecoder::ReadCB read_cb_;
   base::TimeDelta next_timestamp_;
+  MessageLoop message_loop_;
 
  private:
   void SaveReadCallback(const AudioDecoder::ReadCB& callback) {
     CHECK(read_cb_.is_null()) << "Overlapping reads are not permitted";
     read_cb_ = callback;
   }
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
 
@@ skipping 209 matching lines @@
   EXPECT_TRUE(ConsumeBufferedData(bytes_buffered() / 2, NULL));
 
   renderer_->Pause(NewExpectedClosure());
 
   AbortPendingRead();
 
   Preroll(base::TimeDelta::FromSeconds(1));
 }
 
 }  // namespace media