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_.RunUntilIdle();
     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_.RunUntilIdle();
   }
 
   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_.RunUntilIdle();
     DeliverRemainingAudio();
   }
 
   void Play() {
     renderer_->Play(NewExpectedClosure());
     renderer_->SetPlaybackRate(1.0f);
   }
 
   void Preroll(base::TimeDelta preroll_time) {
     next_timestamp_ = preroll_time;
@@ skipping 46 matching lines @@
   // |size| bytes were consumed.
   //
   // |muted| is optional and if passed will get set if the byte value of
   // the consumed data is muted audio.
   bool ConsumeBufferedData(uint32 size, bool* muted) {
     scoped_array<uint8> buffer(new uint8[size]);
     uint32 bytes_per_frame = (decoder_->bits_per_channel() / 8) *
         ChannelLayoutToChannelCount(decoder_->channel_layout());
     uint32 requested_frames = size / bytes_per_frame;
     uint32 frames_read = renderer_->FillBuffer(
-        buffer.get(), requested_frames, base::TimeDelta());
+        buffer.get(), requested_frames, 0);
 
     if (frames_read > 0 && muted) {
       *muted = (buffer[0] == kMutedAudio);
     }
     return (frames_read == requested_frames);
   }
 
   uint32 bytes_buffered() {
     return renderer_->algorithm_->bytes_buffered();
   }
@@ skipping 15 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 52 matching lines @@
   EXPECT_CALL(*decoder_, Read(_));
   EXPECT_TRUE(ConsumeBufferedData(bytes_buffered(), NULL));
 }
 
 TEST_F(AudioRendererImplTest, EndOfStream) {
   Initialize();
   Preroll();
   Play();
 
   // Drain internal buffer, we should have a pending read.
+  int audio_bytes_filled = bytes_buffered();
   EXPECT_CALL(*decoder_, Read(_));
-  EXPECT_TRUE(ConsumeBufferedData(bytes_buffered(), NULL));
+  EXPECT_TRUE(ConsumeBufferedData(audio_bytes_filled, NULL));
+
+  // Check and clear |earliest_end_time_| so the ended event fires on the next
+  // ConsumeBufferedData() call.
+  base::TimeDelta audio_play_time = base::TimeDelta::FromMicroseconds(
+      audio_bytes_filled * base::Time::kMicrosecondsPerSecond /
+      static_cast<float>(renderer_->audio_parameters_.GetBytesPerSecond()));
+  base::TimeDelta time_until_ended =
+      renderer_->earliest_end_time_ - base::Time::Now();
+  EXPECT_TRUE(time_until_ended > base::TimeDelta());
+  EXPECT_TRUE(time_until_ended <= audio_play_time);
+  renderer_->earliest_end_time_ = base::Time();
 
   // Fulfill the read with an end-of-stream packet, we shouldn't report ended
   // nor have a read until we drain the internal buffer.
   DeliverEndOfStream();
 
   // Drain internal buffer, now we should report ended.
   EXPECT_CALL(*this, OnEnded());
   EXPECT_TRUE(ConsumeBufferedData(bytes_buffered(), NULL));
 }
 
@@ skipping 67 matching lines @@
 
   // Deliver another end of stream buffer and attempt to read to make sure
   // we're truly at the end of stream.
   //
   // TODO(scherkus): fix AudioRendererImpl and AudioRendererAlgorithmBase to
   // stop reading after receiving an end of stream buffer. It should have also
   // fired the ended callback http://crbug.com/106641
   DeliverEndOfStream();
   EXPECT_CALL(*this, OnEnded());
 
+  // Clear |earliest_end_time_| so ended fires on the next ConsumeBufferedData()
+  // call.
+  renderer_->earliest_end_time_ = base::Time();
+
   EXPECT_FALSE(ConsumeBufferedData(kDataSize, &muted));
   EXPECT_FALSE(muted);
 }
 
 TEST_F(AudioRendererImplTest, Underflow_ResumeFromCallback) {
   Initialize();
   Preroll();
   Play();
 
   // Drain internal buffer, we should have a pending read.
@@ skipping 48 matching lines @@
   EXPECT_TRUE(ConsumeBufferedData(bytes_buffered() / 2, NULL));
 
   renderer_->Pause(NewExpectedClosure());
 
   AbortPendingRead();
 
   Preroll(base::TimeDelta::FromSeconds(1));
 }
 
 }  // namespace media