Allow transitioning to HAVE_METADATA before pipeline initialization completes.

media/base/pipeline_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ skipping 60 matching lines @@
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD1(OnStart, void(PipelineStatus));
   MOCK_METHOD1(OnSeek, void(PipelineStatus));
   MOCK_METHOD0(OnStop, void());
   MOCK_METHOD1(OnEnded, void(PipelineStatus));
   MOCK_METHOD1(OnError, void(PipelineStatus));
+  MOCK_METHOD1(OnReadyState, void(Pipeline::ReadyState));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
@@ skipping 119 matching lines @@
                           RunPipelineStatusCB()));
     }
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
+      EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHaveMetadata));
       EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
 
       if (audio_stream_) {
         EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
         EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
         // Startup sequence.
         EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
             .WillOnce(RunPipelineStatusCB());
         EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
             .WillOnce(RunClosure());
       }
+      EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHavePrerolled));
     }
 
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnReadyState,
+                   base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
+    EXPECT_CALL(*video_stream_, video_decoder_config())
+        .WillRepeatedly(ReturnRef(video_decoder_config_));
   }
 
   MockDemuxerStream* audio_stream() {
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
@@ skipping 17 matching lines @@
       EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
           .WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Preroll(seek_time, _))
           .WillOnce(RunPipelineStatusCB());
       EXPECT_CALL(*mocks_->video_renderer(), Play(_))
           .WillOnce(RunClosure());
     }
 
+    EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHavePrerolled));
+
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
                     base::Bind(&CallbackHelper::OnSeek,
                                base::Unretained(&callbacks_)));
 
     // We expect the time to be updated only after the seek has completed.
     EXPECT_NE(seek_time, pipeline_->GetMediaTime());
     message_loop_.RunAllPending();
     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<Pipeline> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
+  VideoDecoderConfig video_decoder_config_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineTest, NotStarted) {
   const base::TimeDelta kZero;
 
@@ skipping 32 matching lines @@
   // Don't execute the callback passed into Initialize().
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _));
 
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnReadyState,
+                   base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, RequiredFilterMissing) {
   // Create a filter collection with missing filter.
   scoped_ptr<FilterCollection> collection(mocks_->Create());
   collection->SetDemuxer(NULL);
 
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
   pipeline_->Start(
       collection.Pass(),
       base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
       base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-      base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+      base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+      base::Bind(&CallbackHelper::OnReadyState,
+                 base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
@@ skipping 456 matching lines @@
 
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
       .WillOnce(RunClosure());
   EXPECT_CALL(*mocks_->audio_renderer(), Preroll(seek_time, _))
       .WillOnce(RunPipelineStatusCB());
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
       .WillOnce(RunClosure());
 
+  EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHavePrerolled));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
   EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 
   // Now that the seek is complete, verify that time updates advance the current
   // time.
   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
   audio_time_cb_.Run(new_time, new_time);
 
@@ skipping 124 matching lines @@
   // see http://crbug.com/110228
   void DoInitialize(TeardownState state, StopOrError stop_or_error) {
     PipelineStatus expected_status =
         SetInitializeExpectations(state, stop_or_error);
 
     EXPECT_CALL(callbacks_, OnStart(expected_status));
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnReadyState,
+                   base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   PipelineStatus SetInitializeExpectations(TeardownState state,
                                            StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kInitDemuxer) {
@@ skipping 71 matching lines @@
       EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
       EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
       return status;
     }
 
     EXPECT_CALL(*mocks_->video_renderer(),
                 Initialize(_, _, _, _, _, _, _, _, _, _))
         .WillOnce(RunPipelineStatusCB2());
 
+    EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHaveMetadata));
+
     // If we get here it's a successful initialization.
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
     EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
         .WillOnce(RunPipelineStatusCB());
     EXPECT_CALL(*mocks_->video_renderer(), Preroll(base::TimeDelta(), _))
         .WillOnce(RunPipelineStatusCB());
 
     EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
         .WillOnce(RunClosure());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
         .WillOnce(RunClosure());
 
+    if (status == PIPELINE_OK)
+      EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHavePrerolled));
+
     return status;
   }
 
   void ExpectSeekStop(TeardownState state) {
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kPausing) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
@@ skipping 33 matching lines @@
 
     if (state == kStarting) {
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
           .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_)).WillOnce(RunClosure());
     }
 
     EXPECT_CALL(*mocks_->video_renderer(), Play(_)).WillOnce(RunClosure());
 
+    EXPECT_CALL(callbacks_, OnReadyState(Pipeline::kHavePrerolled));
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
     ExpectStop();
   }
 
   void ExpectSeekError(TeardownState state) {
     SetSeekErrorExpectations(state);
 
     // Executed after the error is raised.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
     EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
@@ skipping 122 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media