Rewrite media::Pipeline state transition machinery.

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 24 matching lines @@
 // Demuxer properties.
 static const int kTotalBytes = 1024;
 static const int kBufferedBytes = 1024;
 static const int kBitrate = 1234;
 
 ACTION_P(SetDemuxerProperties, duration) {
   arg0->SetTotalBytes(kTotalBytes);
   arg0->SetDuration(duration);
 }
 
+ACTION_P2(Stop, pipeline, stop_cb) {
+  pipeline->Stop(stop_cb);
+}
+
+ACTION_P2(SetError, pipeline, status) {
+  pipeline->SetErrorForTesting(status);
+}
+
 ACTION(RunPipelineStatusCB1) {
   arg1.Run(PIPELINE_OK);
 }
 
 ACTION_P(RunPipelineStatusCB1WithStatus, status) {
   arg1.Run(status);
 }
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
@@ skipping 28 matching lines @@
     // streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*mocks_->demuxer(), GetStream(_))
         .WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~PipelineTest() {
-    if (!pipeline_->IsRunning()) {
-      return;
-    }
-
     // Shutdown sequence.
-    if (pipeline_->IsInitialized()) {
+    if (pipeline_->IsRunning()) {
       EXPECT_CALL(*mocks_->demuxer(), Stop(_))
           .WillOnce(RunClosure());
 
       if (audio_stream_) {
-        EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))

[scherkus (not reviewing), 2012/07/28 02:26:07]

Note lack of Pause/Flush prior to Stop!

-            .WillOnce(RunClosure());
-        EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
             .WillOnce(RunClosure());
       }
 
       if (video_stream_) {
-        EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
-            .WillOnce(RunClosure());
-        EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
-            .WillOnce(RunClosure());
         EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
             .WillOnce(RunClosure());
       }
     }
 
-    // Expect a stop callback if we were started.
+    // Stop() callbacks are always executed regardless of run state.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
 
     pipeline_ = NULL;
     mocks_.reset();
   }
 
  protected:
@@ skipping 111 matching lines @@
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
         .WillOnce(RunPipelineStatusCB1());
+    EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(_));
 
     if (audio_stream_) {
       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(RunPipelineStatusCB1());
+      EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(_));
+      EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(_));

[scherkus (not reviewing), 2012/07/28 02:26:07]

note new calls to SPR/SV()

       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
           .WillOnce(RunClosure());
     }
 
     if (video_stream_) {
       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(RunPipelineStatusCB1());
+      EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(_));
       EXPECT_CALL(*mocks_->video_renderer(), Play(_))
           .WillOnce(RunClosure());
     }
 
     // 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());
   }
 
+  void SetupErrorTest() {
+    CreateAudioStream();
+    MockDemuxerStreamVector streams;
+    streams.push_back(audio_stream());
+
+    InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
+    InitializeAudioDecoder(audio_stream());
+    InitializeAudioRenderer();
+    InitializePipeline(PIPELINE_OK);
+  }
+
   // 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_;
 
  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;
 
   EXPECT_FALSE(pipeline_->IsRunning());
-  EXPECT_FALSE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 
   // Setting should still work.
   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
   pipeline_->SetPlaybackRate(-1.0f);
   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
   pipeline_->SetPlaybackRate(1.0f);
   EXPECT_EQ(1.0f, pipeline_->GetPlaybackRate());
 
@@ skipping 10 matching lines @@
 
   EXPECT_EQ(0, pipeline_->GetTotalBytes());
 
   // Should always get set to zero.
   gfx::Size size(1, 1);
   pipeline_->GetNaturalVideoSize(&size);
   EXPECT_EQ(0, size.width());
   EXPECT_EQ(0, size.height());
 }
 
-TEST_F(PipelineTest, NeverInitializes) {

[scherkus (not reviewing), 2012/07/28 02:26:07]

this test hangs with the new pipeline because inside StopTask() we see that
IsTransitioning() is true, so we don't forcibly try to tear things down

I'm fine with that because I don't like living in a world where we have to deal
with cb's that might never execute or even worse execute after we've stopped +
shut everything down

[acolwell GONE FROM CHROMIUM, 2012/07/30 18:33:10]

Doesn't this essentially test the case where the pipeline gets shutdown before
the Demuxer was able to successfully connect to a server or the connection is
REALLY slow? If so don't we want to make sure that we can shutdown properly?

-  // Don't execute the callback passed into Initialize().
-  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _));
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  // 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_)));
-  message_loop_.RunAllPending();
-
-  EXPECT_FALSE(pipeline_->IsInitialized());
-
-  // 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_)));
   message_loop_.RunAllPending();
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, NoStreams) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
       .WillOnce(RunPipelineStatusCB1());
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
       .WillOnce(RunClosure());
 
   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
-  EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_FALSE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, VideoStream) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, AudioVideoStream) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, Seek) {
   CreateAudioStream();
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   // Initialize then seek!
   InitializePipeline(PIPELINE_OK);
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
   ExpectSeek(expected);
   DoSeek(expected);
 }
 
+TEST_F(PipelineTest, Stop_DuringStart) {
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB1()));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(RunClosure());
+
+  // Start and stop callback should fire.
+  EXPECT_CALL(callbacks_, OnStop());
+  InitializePipeline(PIPELINE_OK);
+}
+
+TEST_F(PipelineTest, Stop_DuringPause) {
+  SetupErrorTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek and stop callbacks should fire.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+  EXPECT_CALL(callbacks_, OnStop());
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringFlush) {
+  SetupErrorTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek and stop callbacks should fire.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+  EXPECT_CALL(callbacks_, OnStop());
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringSeek) {
+  SetupErrorTest();
+  base::Closure stop_cb = base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_));
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                      RunPipelineStatusCB1WithStatus(PIPELINE_OK)));
+  EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
+      .WillOnce(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek and stop callbacks should fire.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
+  EXPECT_CALL(callbacks_, OnStop());
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Stop_DuringPlayback) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Stop callback should fire but nothing else.
+  EXPECT_CALL(callbacks_, OnStop());
+  pipeline_->Stop(base::Bind(
+      &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringStart) {
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(RunClosure());
+
+  // Start callback should fire with error but nothing else.
+  InitializePipeline(PIPELINE_ERROR_READ);
+}
+
+TEST_F(PipelineTest, Error_DuringPause) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek callback should fire with error but nothing else.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringFlush) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek callback should fire with error but nothing else.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringSeek) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
+      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Seek callback fire with error but nothing else.
+  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
+  pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
+      &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringPlayback) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // Error callback should fire but nothing else.
+  EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
+  pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
+  message_loop_.RunAllPending();
+}
+
+TEST_F(PipelineTest, Error_DuringStop) {
+  SetupErrorTest();
+
+  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
+      .WillOnce(DoAll(SetError(pipeline_, PIPELINE_ERROR_READ), RunClosure()));
+  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+
+  // No error callback should fire.
+  EXPECT_CALL(callbacks_, OnStop());
+  pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
+                             base::Unretained(&callbacks_)));
+  message_loop_.RunAllPending();
+}
+
 TEST_F(PipelineTest, SetVolume) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
 
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
   InitializePipeline(PIPELINE_OK);
   pipeline_->SetVolume(expected);
 }
 
 TEST_F(PipelineTest, Properties) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_EQ(kDuration.ToInternalValue(),
             pipeline_->GetMediaDuration().ToInternalValue());
   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 }
 
 TEST_F(PipelineTest, GetBufferedTimeRanges) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
 
   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   pipeline_->AddBufferedByteRange(0, kTotalBytes / 8);
   EXPECT_TRUE(pipeline_->DidLoadingProgress());
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
@@ skipping 35 matching lines @@
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_TRUE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*mocks_->demuxer(), OnAudioRendererDisabled());
   pipeline_->OnAudioDisabled();
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
@@ skipping 10 matching lines @@
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer(true);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   EXPECT_CALL(*mocks_->demuxer(),
               OnAudioRendererDisabled());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnRendererEnded();
 }
 
@@ skipping 91 matching lines @@
 
   // Signal end of video stream and make sure OnEnded() callback occurs.
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   pipeline_->OnRendererEnded();
 }
 
-TEST_F(PipelineTest, ErrorDuringSeek) {

[scherkus (not reviewing), 2012/07/28 02:26:07]

test moved up above

-  CreateAudioStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-
-  InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
-  InitializeAudioDecoder(audio_stream());
-  InitializeAudioRenderer();
-  InitializePipeline(PIPELINE_OK);
-
-  float playback_rate = 1.0f;
-  EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
-  EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
-  pipeline_->SetPlaybackRate(playback_rate);
-  message_loop_.RunAllPending();
-
-  base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
-
-  // Seek() isn't called as the demuxer errors out first.
-  EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(RunClosure());
-  EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(RunPipelineStatusCB1WithStatus(PIPELINE_ERROR_READ));
-  EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
-
-  pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
-                                        base::Unretained(&callbacks_)));
-  EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
-  message_loop_.RunAllPending();
-}
-
 // Invoked function OnError. This asserts that the pipeline does not enqueue
 // non-teardown related tasks while tearing down.
 static void TestNoCallsAfterError(
     Pipeline* pipeline, MessageLoop* message_loop,
     PipelineStatus /* status */) {
   CHECK(pipeline);
   CHECK(message_loop);
 
   // When we get to this stage, the message loop should be empty.
   message_loop->AssertIdle();
@@ skipping 47 matching lines @@
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 }
 
 TEST_F(PipelineTest, StartTimeIsNonZero) {
   const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 
   EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
       .WillRepeatedly(Return(kStartTime));
 
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
   InitializeDemuxer(&streams, kDuration);
   InitializeVideoDecoder(video_stream());
   InitializeVideoRenderer();
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 }
 
 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
                        int time_in_ms,
                        int max_time_in_ms) {
   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
@@ skipping 23 matching lines @@
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Arrange to trigger a time update while the demuxer is in the middle of
   // seeking. This update should be ignored by the pipeline and the clock should
   // not get updated.
   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
                       RunPipelineStatusCB1()));
+  EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
 
   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(RunPipelineStatusCB1());
+  EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
+  EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(_));
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
       .WillOnce(RunClosure());
 
   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.
@@ skipping 50 matching lines @@
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(0));
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(base::TimeDelta::FromMilliseconds(20));
 }
 
 }  // namespace media