media/base/pipeline_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/stl_util.h"
  10 #include "base/test/simple_test_tick_clock.h"
  11 #include "base/threading/simple_thread.h"
  12 #include "base/time/clock.h"
  13 #include "media/base/clock.h"
  14 #include "media/base/fake_text_track_stream.h"
  15 #include "media/base/gmock_callback_support.h"
  16 #include "media/base/media_log.h"
  17 #include "media/base/mock_filters.h"
  18 #include "media/base/pipeline.h"
  19 #include "media/base/test_helpers.h"
  20 #include "media/base/text_renderer.h"
  21 #include "media/base/text_track_config.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23 #include "ui/gfx/size.h"
  24
  25 using ::testing::_;
  26 using ::testing::DeleteArg;
  27 using ::testing::DoAll;
  28 // TODO(scherkus): Remove InSequence after refactoring Pipeline.
  29 using ::testing::InSequence;
  30 using ::testing::Invoke;
  31 using ::testing::InvokeWithoutArgs;
  32 using ::testing::Mock;
  33 using ::testing::NotNull;
  34 using ::testing::Return;
  35 using ::testing::SaveArg;
  36 using ::testing::StrictMock;
  37 using ::testing::WithArg;
  38
  39 namespace media {
  40
  41 // Demuxer properties.
  42 const int kTotalBytes = 1024;
  43
  44 ACTION_P(SetDemuxerProperties, duration) {
  45   arg0->SetTotalBytes(kTotalBytes);
  46   arg0->SetDuration(duration);
  47 }
  48
  49 ACTION_P2(Stop, pipeline, stop_cb) {
  50   pipeline->Stop(stop_cb);
  51 }
  52
  53 ACTION_P2(SetError, pipeline, status) {
  54   pipeline->SetErrorForTesting(status);
  55 }
  56
  57 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
  58 // also lets us test for missing callbacks.
  59 class CallbackHelper {
  60  public:
  61   CallbackHelper() {}
  62   virtual ~CallbackHelper() {}
  63
  64   MOCK_METHOD1(OnStart, void(PipelineStatus));
  65   MOCK_METHOD1(OnSeek, void(PipelineStatus));
  66   MOCK_METHOD0(OnStop, void());
  67   MOCK_METHOD0(OnEnded, void());
  68   MOCK_METHOD1(OnError, void(PipelineStatus));
  69   MOCK_METHOD1(OnBufferingState, void(Pipeline::BufferingState));
  70   MOCK_METHOD0(OnDurationChange, void());
  71
  72  private:
  73   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
  74 };
  75
  76 // TODO(scherkus): even though some filters are initialized on separate
  77 // threads these test aren't flaky... why?  It's because filters' Initialize()
  78 // is executed on |message_loop_| and the mock filters instantly call
  79 // InitializationComplete(), which keeps the pipeline humming along.  If
  80 // either filters don't call InitializationComplete() immediately or filter
  81 // initialization is moved to a separate thread this test will become flaky.
  82 class PipelineTest : public ::testing::Test {
  83  public:
  84   PipelineTest()
  85       : pipeline_(new Pipeline(message_loop_.message_loop_proxy(),
  86                                new MediaLog())),
  87         filter_collection_(new FilterCollection()),
  88         demuxer_(new MockDemuxer()) {
  89     filter_collection_->SetDemuxer(demuxer_.get());
  90
  91     video_renderer_ = new MockVideoRenderer();
  92     scoped_ptr<VideoRenderer> video_renderer(video_renderer_);
  93     filter_collection_->SetVideoRenderer(video_renderer.Pass());
  94
  95     audio_renderer_ = new MockAudioRenderer();
  96     scoped_ptr<AudioRenderer> audio_renderer(audio_renderer_);
  97     filter_collection_->SetAudioRenderer(audio_renderer.Pass());
  98
  99     text_renderer_ = new TextRenderer(
 100                          message_loop_.message_loop_proxy(),
 101                          base::Bind(&PipelineTest::OnAddTextTrack,
 102                                     base::Unretained(this)));
 103     scoped_ptr<TextRenderer> text_renderer(text_renderer_);
 104     filter_collection_->SetTextRenderer(text_renderer.Pass());
 105
 106     // InitializeDemuxer() adds overriding expectations for expected non-NULL
 107     // streams.
 108     DemuxerStream* null_pointer = NULL;
 109     EXPECT_CALL(*demuxer_, GetStream(_))
 110         .WillRepeatedly(Return(null_pointer));
 111
 112     EXPECT_CALL(*demuxer_, GetStartTime())
 113         .WillRepeatedly(Return(base::TimeDelta()));
 114   }
 115
 116   virtual ~PipelineTest() {
 117     if (!pipeline_ || !pipeline_->IsRunning())
 118       return;
 119
 120     ExpectStop();
 121
 122     // The mock demuxer doesn't stop the fake text track stream,
 123     // so just stop it manually.
 124     if (text_stream_) {
 125       text_stream_->Stop();
 126       message_loop_.RunUntilIdle();
 127     }
 128
 129     // Expect a stop callback if we were started.
 130     EXPECT_CALL(callbacks_, OnStop());
 131     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
 132                                base::Unretained(&callbacks_)));
 133     message_loop_.RunUntilIdle();
 134   }
 135
 136  protected:
 137   // Sets up expectations to allow the demuxer to initialize.
 138   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
 139   void InitializeDemuxer(MockDemuxerStreamVector* streams,
 140                          const base::TimeDelta& duration) {
 141     EXPECT_CALL(callbacks_, OnDurationChange());
 142     EXPECT_CALL(*demuxer_, Initialize(_, _, _))
 143         .WillOnce(DoAll(SetDemuxerProperties(duration),
 144                         RunCallback<1>(PIPELINE_OK)));
 145
 146     // Configure the demuxer to return the streams.
 147     for (size_t i = 0; i < streams->size(); ++i) {
 148       DemuxerStream* stream = (*streams)[i];
 149       EXPECT_CALL(*demuxer_, GetStream(stream->type()))
 150           .WillRepeatedly(Return(stream));
 151     }
 152   }
 153
 154   void InitializeDemuxer(MockDemuxerStreamVector* streams) {
 155     // Initialize with a default non-zero duration.
 156     InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10));
 157   }
 158
 159   scoped_ptr<StrictMock<MockDemuxerStream> > CreateStream(
 160       DemuxerStream::Type type) {
 161     scoped_ptr<StrictMock<MockDemuxerStream> > stream(
 162         new StrictMock<MockDemuxerStream>(type));
 163     return stream.Pass();
 164   }
 165
 166   // Sets up expectations to allow the video renderer to initialize.
 167   void InitializeVideoRenderer(DemuxerStream* stream) {
 168     EXPECT_CALL(*video_renderer_, Initialize(stream, _, _, _, _, _, _, _, _))
 169         .WillOnce(RunCallback<1>(PIPELINE_OK));
 170     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
 171
 172     // Startup sequence.
 173     EXPECT_CALL(*video_renderer_, Preroll(demuxer_->GetStartTime(), _))
 174         .WillOnce(RunCallback<1>(PIPELINE_OK));
 175     EXPECT_CALL(*video_renderer_, Play(_))
 176         .WillOnce(RunClosure<0>());
 177   }
 178
 179   // Sets up expectations to allow the audio renderer to initialize.
 180   void InitializeAudioRenderer(DemuxerStream* stream,
 181                                bool disable_after_init_cb) {
 182     if (disable_after_init_cb) {
 183       EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _, _))
 184           .WillOnce(DoAll(RunCallback<1>(PIPELINE_OK),
 185                           WithArg<6>(RunClosure<0>())));  // |disabled_cb|.
 186     } else {
 187       EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _, _))
 188           .WillOnce(DoAll(SaveArg<4>(&audio_time_cb_),
 189                           RunCallback<1>(PIPELINE_OK)));
 190     }
 191   }
 192
 193   void AddTextStream() {
 194     EXPECT_CALL(*this, OnAddTextTrack(_,_))
 195         .WillOnce(Invoke(this, &PipelineTest::DoOnAddTextTrack));
 196     static_cast<DemuxerHost*>(pipeline_.get())->AddTextStream(text_stream(),
 197                               TextTrackConfig(kTextSubtitles, "", "", ""));
 198   }
 199
 200   // Sets up expectations on the callback and initializes the pipeline.  Called
 201   // after tests have set expectations any filters they wish to use.
 202   void InitializePipeline(PipelineStatus start_status) {
 203     EXPECT_CALL(callbacks_, OnStart(start_status));
 204
 205     if (start_status == PIPELINE_OK) {
 206       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
 207
 208       if (audio_stream_) {
 209         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
 210         EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
 211
 212         // Startup sequence.
 213         EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
 214             .WillOnce(RunCallback<1>(PIPELINE_OK));
 215         EXPECT_CALL(*audio_renderer_, Play(_))
 216             .WillOnce(RunClosure<0>());
 217       }
 218       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 219     }
 220
 221     pipeline_->Start(
 222         filter_collection_.Pass(),
 223         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
 224         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
 225         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
 226         base::Bind(&CallbackHelper::OnBufferingState,
 227                    base::Unretained(&callbacks_)),
 228         base::Bind(&CallbackHelper::OnDurationChange,
 229                    base::Unretained(&callbacks_)));
 230     message_loop_.RunUntilIdle();
 231   }
 232
 233   void CreateAudioStream() {
 234     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
 235   }
 236
 237   void CreateVideoStream() {
 238     video_stream_ = CreateStream(DemuxerStream::VIDEO);
 239     video_stream_->set_video_decoder_config(video_decoder_config_);
 240   }
 241
 242   void CreateTextStream() {
 243     scoped_ptr<FakeTextTrackStream> text_stream(new FakeTextTrackStream);
 244     text_stream_ = text_stream.Pass();
 245   }
 246
 247   MockDemuxerStream* audio_stream() {
 248     return audio_stream_.get();
 249   }
 250
 251   MockDemuxerStream* video_stream() {
 252     return video_stream_.get();
 253   }
 254
 255   FakeTextTrackStream* text_stream() {
 256     return text_stream_.get();
 257   }
 258
 259   void ExpectSeek(const base::TimeDelta& seek_time) {
 260     // Every filter should receive a call to Seek().
 261     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
 262         .WillOnce(RunCallback<1>(PIPELINE_OK));
 263
 264     if (audio_stream_) {
 265       EXPECT_CALL(*audio_renderer_, Pause(_))
 266           .WillOnce(RunClosure<0>());
 267       EXPECT_CALL(*audio_renderer_, Flush(_))
 268           .WillOnce(RunClosure<0>());
 269       EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
 270           .WillOnce(RunCallback<1>(PIPELINE_OK));
 271       EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
 272       EXPECT_CALL(*audio_renderer_, SetVolume(_));
 273       EXPECT_CALL(*audio_renderer_, Play(_))
 274           .WillOnce(RunClosure<0>());
 275     }
 276
 277     if (video_stream_) {
 278       EXPECT_CALL(*video_renderer_, Pause(_))
 279           .WillOnce(RunClosure<0>());
 280       EXPECT_CALL(*video_renderer_, Flush(_))
 281           .WillOnce(RunClosure<0>());
 282       EXPECT_CALL(*video_renderer_, Preroll(seek_time, _))
 283           .WillOnce(RunCallback<1>(PIPELINE_OK));
 284       EXPECT_CALL(*video_renderer_, SetPlaybackRate(_));
 285       EXPECT_CALL(*video_renderer_, Play(_))
 286           .WillOnce(RunClosure<0>());
 287     }
 288
 289     EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 290
 291     // We expect a successful seek callback.
 292     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
 293   }
 294
 295   void DoSeek(const base::TimeDelta& seek_time) {
 296     pipeline_->Seek(seek_time,
 297                     base::Bind(&CallbackHelper::OnSeek,
 298                                base::Unretained(&callbacks_)));
 299
 300     // We expect the time to be updated only after the seek has completed.
 301     EXPECT_NE(seek_time, pipeline_->GetMediaTime());
 302     message_loop_.RunUntilIdle();
 303     EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
 304   }
 305
 306   void ExpectStop() {
 307     if (demuxer_)
 308       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
 309
 310     if (audio_stream_)
 311       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
 312
 313     if (video_stream_)
 314       EXPECT_CALL(*video_renderer_, Stop(_)).WillOnce(RunClosure<0>());
 315   }
 316
 317   MOCK_METHOD2(OnAddTextTrack, void(const TextTrackConfig&,
 318                                     const AddTextTrackDoneCB&));
 319
 320   void DoOnAddTextTrack(const TextTrackConfig& config,
 321                         const AddTextTrackDoneCB& done_cb) {
 322     scoped_ptr<TextTrack> text_track(new MockTextTrack);
 323     done_cb.Run(text_track.Pass());
 324   }
 325
 326   // Fixture members.
 327   StrictMock<CallbackHelper> callbacks_;
 328   base::SimpleTestTickClock test_tick_clock_;
 329   base::MessageLoop message_loop_;
 330   scoped_ptr<Pipeline> pipeline_;
 331
 332   scoped_ptr<FilterCollection> filter_collection_;
 333   scoped_ptr<MockDemuxer> demuxer_;
 334   MockVideoRenderer* video_renderer_;
 335   MockAudioRenderer* audio_renderer_;
 336   StrictMock<CallbackHelper> text_renderer_callbacks_;
 337   TextRenderer* text_renderer_;
 338   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
 339   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
 340   scoped_ptr<FakeTextTrackStream> text_stream_;
 341   AudioRenderer::TimeCB audio_time_cb_;
 342   VideoDecoderConfig video_decoder_config_;
 343
 344  private:
 345   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
 346 };
 347
 348 // Test that playback controls methods no-op when the pipeline hasn't been
 349 // started.
 350 TEST_F(PipelineTest, NotStarted) {
 351   const base::TimeDelta kZero;
 352
 353   EXPECT_FALSE(pipeline_->IsRunning());
 354   EXPECT_FALSE(pipeline_->HasAudio());
 355   EXPECT_FALSE(pipeline_->HasVideo());
 356
 357   // Setting should still work.
 358   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
 359   pipeline_->SetPlaybackRate(-1.0f);
 360   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
 361   pipeline_->SetPlaybackRate(1.0f);
 362   EXPECT_EQ(1.0f, pipeline_->GetPlaybackRate());
 363
 364   // Setting should still work.
 365   EXPECT_EQ(1.0f, pipeline_->GetVolume());
 366   pipeline_->SetVolume(-1.0f);
 367   EXPECT_EQ(1.0f, pipeline_->GetVolume());
 368   pipeline_->SetVolume(0.0f);
 369   EXPECT_EQ(0.0f, pipeline_->GetVolume());
 370
 371   EXPECT_TRUE(kZero == pipeline_->GetMediaTime());
 372   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 373   EXPECT_TRUE(kZero == pipeline_->GetMediaDuration());
 374
 375   EXPECT_EQ(0, pipeline_->GetTotalBytes());
 376
 377   // Should always get set to zero.
 378   gfx::Size size(1, 1);
 379   pipeline_->GetNaturalVideoSize(&size);
 380   EXPECT_EQ(0, size.width());
 381   EXPECT_EQ(0, size.height());
 382 }
 383
 384 TEST_F(PipelineTest, NeverInitializes) {
 385   // Don't execute the callback passed into Initialize().
 386   EXPECT_CALL(*demuxer_, Initialize(_, _, _));
 387
 388   // This test hangs during initialization by never calling
 389   // InitializationComplete().  StrictMock<> will ensure that the callback is
 390   // never executed.
 391   pipeline_->Start(
 392         filter_collection_.Pass(),
 393         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
 394         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
 395         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
 396         base::Bind(&CallbackHelper::OnBufferingState,
 397                    base::Unretained(&callbacks_)),
 398         base::Bind(&CallbackHelper::OnDurationChange,
 399                    base::Unretained(&callbacks_)));
 400   message_loop_.RunUntilIdle();
 401
 402
 403   // Because our callback will get executed when the test tears down, we'll
 404   // verify that nothing has been called, then set our expectation for the call
 405   // made during tear down.
 406   Mock::VerifyAndClear(&callbacks_);
 407   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 408 }
 409
 410 TEST_F(PipelineTest, URLNotFound) {
 411   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
 412       .WillOnce(RunCallback<1>(PIPELINE_ERROR_URL_NOT_FOUND));
 413   EXPECT_CALL(*demuxer_, Stop(_))
 414       .WillOnce(RunClosure<0>());
 415
 416   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
 417 }
 418
 419 TEST_F(PipelineTest, NoStreams) {
 420   EXPECT_CALL(*demuxer_, Initialize(_, _, _))
 421       .WillOnce(RunCallback<1>(PIPELINE_OK));
 422   EXPECT_CALL(*demuxer_, Stop(_))
 423       .WillOnce(RunClosure<0>());
 424
 425   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
 426 }
 427
 428 TEST_F(PipelineTest, AudioStream) {
 429   CreateAudioStream();
 430   MockDemuxerStreamVector streams;
 431   streams.push_back(audio_stream());
 432
 433   InitializeDemuxer(&streams);
 434   InitializeAudioRenderer(audio_stream(), false);
 435
 436   InitializePipeline(PIPELINE_OK);
 437   EXPECT_TRUE(pipeline_->HasAudio());
 438   EXPECT_FALSE(pipeline_->HasVideo());
 439 }
 440
 441 TEST_F(PipelineTest, VideoStream) {
 442   CreateVideoStream();
 443   MockDemuxerStreamVector streams;
 444   streams.push_back(video_stream());
 445
 446   InitializeDemuxer(&streams);
 447   InitializeVideoRenderer(video_stream());
 448
 449   InitializePipeline(PIPELINE_OK);
 450   EXPECT_FALSE(pipeline_->HasAudio());
 451   EXPECT_TRUE(pipeline_->HasVideo());
 452 }
 453
 454 TEST_F(PipelineTest, AudioVideoStream) {
 455   CreateAudioStream();
 456   CreateVideoStream();
 457   MockDemuxerStreamVector streams;
 458   streams.push_back(audio_stream());
 459   streams.push_back(video_stream());
 460
 461   InitializeDemuxer(&streams);
 462   InitializeAudioRenderer(audio_stream(), false);
 463   InitializeVideoRenderer(video_stream());
 464
 465   InitializePipeline(PIPELINE_OK);
 466   EXPECT_TRUE(pipeline_->HasAudio());
 467   EXPECT_TRUE(pipeline_->HasVideo());
 468 }
 469
 470 TEST_F(PipelineTest, VideoTextStream) {
 471   CreateVideoStream();
 472   CreateTextStream();
 473   MockDemuxerStreamVector streams;
 474   streams.push_back(video_stream());
 475
 476   InitializeDemuxer(&streams);
 477   InitializeVideoRenderer(video_stream());
 478
 479   InitializePipeline(PIPELINE_OK);
 480   EXPECT_FALSE(pipeline_->HasAudio());
 481   EXPECT_TRUE(pipeline_->HasVideo());
 482
 483   AddTextStream();
 484   message_loop_.RunUntilIdle();
 485 }
 486
 487 TEST_F(PipelineTest, VideoAudioTextStream) {
 488   CreateVideoStream();
 489   CreateAudioStream();
 490   CreateTextStream();
 491   MockDemuxerStreamVector streams;
 492   streams.push_back(video_stream());
 493   streams.push_back(audio_stream());
 494
 495   InitializeDemuxer(&streams);
 496   InitializeVideoRenderer(video_stream());
 497   InitializeAudioRenderer(audio_stream(), false);
 498
 499   InitializePipeline(PIPELINE_OK);
 500   EXPECT_TRUE(pipeline_->HasAudio());
 501   EXPECT_TRUE(pipeline_->HasVideo());
 502
 503   AddTextStream();
 504   message_loop_.RunUntilIdle();
 505 }
 506
 507 TEST_F(PipelineTest, Seek) {
 508   CreateAudioStream();
 509   CreateVideoStream();
 510   CreateTextStream();
 511   MockDemuxerStreamVector streams;
 512   streams.push_back(audio_stream());
 513   streams.push_back(video_stream());
 514
 515   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
 516   InitializeAudioRenderer(audio_stream(), false);
 517   InitializeVideoRenderer(video_stream());
 518
 519   // Initialize then seek!
 520   InitializePipeline(PIPELINE_OK);
 521
 522   AddTextStream();
 523   message_loop_.RunUntilIdle();
 524
 525   // Every filter should receive a call to Seek().
 526   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
 527   ExpectSeek(expected);
 528   DoSeek(expected);
 529 }
 530
 531 TEST_F(PipelineTest, SetVolume) {
 532   CreateAudioStream();
 533   MockDemuxerStreamVector streams;
 534   streams.push_back(audio_stream());
 535
 536   InitializeDemuxer(&streams);
 537   InitializeAudioRenderer(audio_stream(), false);
 538
 539   // The audio renderer should receive a call to SetVolume().
 540   float expected = 0.5f;
 541   EXPECT_CALL(*audio_renderer_, SetVolume(expected));
 542
 543   // Initialize then set volume!
 544   InitializePipeline(PIPELINE_OK);
 545   pipeline_->SetVolume(expected);
 546 }
 547
 548 TEST_F(PipelineTest, Properties) {
 549   CreateVideoStream();
 550   MockDemuxerStreamVector streams;
 551   streams.push_back(video_stream());
 552
 553   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 554   InitializeDemuxer(&streams, kDuration);
 555   InitializeVideoRenderer(video_stream());
 556
 557   InitializePipeline(PIPELINE_OK);
 558   EXPECT_EQ(kDuration.ToInternalValue(),
 559             pipeline_->GetMediaDuration().ToInternalValue());
 560   EXPECT_EQ(kTotalBytes, pipeline_->GetTotalBytes());
 561   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 562 }
 563
 564 TEST_F(PipelineTest, GetBufferedTimeRanges) {
 565   CreateVideoStream();
 566   MockDemuxerStreamVector streams;
 567   streams.push_back(video_stream());
 568
 569   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 570   InitializeDemuxer(&streams, kDuration);
 571   InitializeVideoRenderer(video_stream());
 572
 573   InitializePipeline(PIPELINE_OK);
 574
 575   EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
 576
 577   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 578   pipeline_->AddBufferedByteRange(0, kTotalBytes / 8);
 579   EXPECT_TRUE(pipeline_->DidLoadingProgress());
 580   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 581   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
 582   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
 583   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 584   pipeline_->AddBufferedTimeRange(base::TimeDelta(), kDuration / 8);
 585   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
 586   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 587
 588   base::TimeDelta kSeekTime = kDuration / 2;
 589   ExpectSeek(kSeekTime);
 590   DoSeek(kSeekTime);
 591
 592   EXPECT_TRUE(pipeline_->DidLoadingProgress());
 593   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 594   pipeline_->AddBufferedByteRange(kTotalBytes / 2,
 595                                   kTotalBytes / 2 + kTotalBytes / 8);
 596   EXPECT_TRUE(pipeline_->DidLoadingProgress());
 597   EXPECT_FALSE(pipeline_->DidLoadingProgress());
 598   EXPECT_EQ(2u, pipeline_->GetBufferedTimeRanges().size());
 599   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
 600   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 601   EXPECT_EQ(kDuration / 2, pipeline_->GetBufferedTimeRanges().start(1));
 602   EXPECT_EQ(kDuration / 2 + kDuration / 8,
 603             pipeline_->GetBufferedTimeRanges().end(1));
 604
 605   pipeline_->AddBufferedTimeRange(kDuration / 4, 3 * kDuration / 8);
 606   EXPECT_EQ(base::TimeDelta(), pipeline_->GetBufferedTimeRanges().start(0));
 607   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 608   EXPECT_EQ(kDuration / 4, pipeline_->GetBufferedTimeRanges().start(1));
 609   EXPECT_EQ(3* kDuration / 8, pipeline_->GetBufferedTimeRanges().end(1));
 610   EXPECT_EQ(kDuration / 2, pipeline_->GetBufferedTimeRanges().start(2));
 611   EXPECT_EQ(kDuration / 2 + kDuration / 8,
 612             pipeline_->GetBufferedTimeRanges().end(2));
 613 }
 614
 615 TEST_F(PipelineTest, DisableAudioRenderer) {
 616   CreateAudioStream();
 617   CreateVideoStream();
 618   MockDemuxerStreamVector streams;
 619   streams.push_back(audio_stream());
 620   streams.push_back(video_stream());
 621
 622   InitializeDemuxer(&streams);
 623   InitializeAudioRenderer(audio_stream(), false);
 624   InitializeVideoRenderer(video_stream());
 625
 626   InitializePipeline(PIPELINE_OK);
 627   EXPECT_TRUE(pipeline_->HasAudio());
 628   EXPECT_TRUE(pipeline_->HasVideo());
 629
 630   EXPECT_CALL(*demuxer_, OnAudioRendererDisabled());
 631   pipeline_->OnAudioDisabled();
 632
 633   // Verify that ended event is fired when video ends.
 634   EXPECT_CALL(callbacks_, OnEnded());
 635   pipeline_->OnVideoRendererEnded();
 636 }
 637
 638 TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
 639   CreateAudioStream();
 640   CreateVideoStream();
 641   MockDemuxerStreamVector streams;
 642   streams.push_back(audio_stream());
 643   streams.push_back(video_stream());
 644
 645   InitializeDemuxer(&streams);
 646   InitializeAudioRenderer(audio_stream(), true);
 647   InitializeVideoRenderer(video_stream());
 648
 649   EXPECT_CALL(*demuxer_, OnAudioRendererDisabled());
 650
 651   InitializePipeline(PIPELINE_OK);
 652   EXPECT_FALSE(pipeline_->HasAudio());
 653   EXPECT_TRUE(pipeline_->HasVideo());
 654
 655   // Verify that ended event is fired when video ends.
 656   EXPECT_CALL(callbacks_, OnEnded());
 657   pipeline_->OnVideoRendererEnded();
 658 }
 659
 660 TEST_F(PipelineTest, EndedCallback) {
 661   CreateAudioStream();
 662   CreateVideoStream();
 663   CreateTextStream();
 664   MockDemuxerStreamVector streams;
 665   streams.push_back(audio_stream());
 666   streams.push_back(video_stream());
 667
 668   InitializeDemuxer(&streams);
 669   InitializeAudioRenderer(audio_stream(), false);
 670   InitializeVideoRenderer(video_stream());
 671   InitializePipeline(PIPELINE_OK);
 672
 673   AddTextStream();
 674
 675   // The ended callback shouldn't run until all renderers have ended.
 676   pipeline_->OnAudioRendererEnded();
 677   message_loop_.RunUntilIdle();
 678
 679   pipeline_->OnVideoRendererEnded();
 680   message_loop_.RunUntilIdle();
 681
 682   EXPECT_CALL(callbacks_, OnEnded());
 683   text_stream()->SendEosNotification();
 684   message_loop_.RunUntilIdle();
 685 }
 686
 687 TEST_F(PipelineTest, AudioStreamShorterThanVideo) {
 688   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
 689
 690   CreateAudioStream();
 691   CreateVideoStream();
 692   MockDemuxerStreamVector streams;
 693   streams.push_back(audio_stream());
 694   streams.push_back(video_stream());
 695
 696   // Replace the clock so we can simulate wallclock time advancing w/o using
 697   // Sleep().
 698   pipeline_->SetClockForTesting(new Clock(&test_tick_clock_));
 699
 700   InitializeDemuxer(&streams, duration);
 701   InitializeAudioRenderer(audio_stream(), false);
 702   InitializeVideoRenderer(video_stream());
 703   InitializePipeline(PIPELINE_OK);
 704
 705   EXPECT_EQ(0, pipeline_->GetMediaTime().ToInternalValue());
 706
 707   float playback_rate = 1.0f;
 708   EXPECT_CALL(*video_renderer_, SetPlaybackRate(playback_rate));
 709   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
 710   pipeline_->SetPlaybackRate(playback_rate);
 711   message_loop_.RunUntilIdle();
 712
 713   InSequence s;
 714
 715   // Verify that the clock doesn't advance since it hasn't been started by
 716   // a time update from the audio stream.
 717   int64 start_time = pipeline_->GetMediaTime().ToInternalValue();
 718   test_tick_clock_.Advance(base::TimeDelta::FromMilliseconds(100));
 719   EXPECT_EQ(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 720
 721   // Signal end of audio stream.
 722   pipeline_->OnAudioRendererEnded();
 723   message_loop_.RunUntilIdle();
 724
 725   // Verify that the clock advances.
 726   start_time = pipeline_->GetMediaTime().ToInternalValue();
 727   test_tick_clock_.Advance(base::TimeDelta::FromMilliseconds(100));
 728   EXPECT_GT(pipeline_->GetMediaTime().ToInternalValue(), start_time);
 729
 730   // Signal end of video stream and make sure OnEnded() callback occurs.
 731   EXPECT_CALL(callbacks_, OnEnded());
 732   pipeline_->OnVideoRendererEnded();
 733 }
 734
 735 TEST_F(PipelineTest, ErrorDuringSeek) {
 736   CreateAudioStream();
 737   MockDemuxerStreamVector streams;
 738   streams.push_back(audio_stream());
 739
 740   InitializeDemuxer(&streams);
 741   InitializeAudioRenderer(audio_stream(), false);
 742   InitializePipeline(PIPELINE_OK);
 743
 744   float playback_rate = 1.0f;
 745   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
 746   pipeline_->SetPlaybackRate(playback_rate);
 747   message_loop_.RunUntilIdle();
 748
 749   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 750
 751   // Preroll() isn't called as the demuxer errors out first.
 752   EXPECT_CALL(*audio_renderer_, Pause(_))
 753       .WillOnce(RunClosure<0>());
 754   EXPECT_CALL(*audio_renderer_, Flush(_))
 755       .WillOnce(RunClosure<0>());
 756   EXPECT_CALL(*audio_renderer_, Stop(_))
 757       .WillOnce(RunClosure<0>());
 758
 759   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
 760       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
 761   EXPECT_CALL(*demuxer_, Stop(_))
 762       .WillOnce(RunClosure<0>());
 763
 764   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
 765                                         base::Unretained(&callbacks_)));
 766   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
 767   message_loop_.RunUntilIdle();
 768 }
 769
 770 // Invoked function OnError. This asserts that the pipeline does not enqueue
 771 // non-teardown related tasks while tearing down.
 772 static void TestNoCallsAfterError(
 773     Pipeline* pipeline, base::MessageLoop* message_loop,
 774     PipelineStatus /* status */) {
 775   CHECK(pipeline);
 776   CHECK(message_loop);
 777
 778   // When we get to this stage, the message loop should be empty.
 779   EXPECT_TRUE(message_loop->IsIdleForTesting());
 780
 781   // Make calls on pipeline after error has occurred.
 782   pipeline->SetPlaybackRate(0.5f);
 783   pipeline->SetVolume(0.5f);
 784
 785   // No additional tasks should be queued as a result of these calls.
 786   EXPECT_TRUE(message_loop->IsIdleForTesting());
 787 }
 788
 789 TEST_F(PipelineTest, NoMessageDuringTearDownFromError) {
 790   CreateAudioStream();
 791   MockDemuxerStreamVector streams;
 792   streams.push_back(audio_stream());
 793
 794   InitializeDemuxer(&streams);
 795   InitializeAudioRenderer(audio_stream(), false);
 796   InitializePipeline(PIPELINE_OK);
 797
 798   // Trigger additional requests on the pipeline during tear down from error.
 799   base::Callback<void(PipelineStatus)> cb = base::Bind(
 800       &TestNoCallsAfterError, pipeline_.get(), &message_loop_);
 801   ON_CALL(callbacks_, OnError(_))
 802       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 803
 804   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 805
 806   // Seek() isn't called as the demuxer errors out first.
 807   EXPECT_CALL(*audio_renderer_, Pause(_))
 808       .WillOnce(RunClosure<0>());
 809   EXPECT_CALL(*audio_renderer_, Flush(_))
 810       .WillOnce(RunClosure<0>());
 811   EXPECT_CALL(*audio_renderer_, Stop(_))
 812       .WillOnce(RunClosure<0>());
 813
 814   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
 815       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
 816   EXPECT_CALL(*demuxer_, Stop(_))
 817       .WillOnce(RunClosure<0>());
 818
 819   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
 820                                         base::Unretained(&callbacks_)));
 821   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
 822   message_loop_.RunUntilIdle();
 823 }
 824
 825 TEST_F(PipelineTest, StartTimeIsZero) {
 826   CreateVideoStream();
 827   MockDemuxerStreamVector streams;
 828   streams.push_back(video_stream());
 829
 830   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 831   InitializeDemuxer(&streams, kDuration);
 832   InitializeVideoRenderer(video_stream());
 833
 834   InitializePipeline(PIPELINE_OK);
 835   EXPECT_FALSE(pipeline_->HasAudio());
 836   EXPECT_TRUE(pipeline_->HasVideo());
 837
 838   EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 839 }
 840
 841 TEST_F(PipelineTest, StartTimeIsNonZero) {
 842   const base::TimeDelta kStartTime = base::TimeDelta::FromSeconds(4);
 843   const base::TimeDelta kDuration = base::TimeDelta::FromSeconds(100);
 844
 845   EXPECT_CALL(*demuxer_, GetStartTime())
 846       .WillRepeatedly(Return(kStartTime));
 847
 848   CreateVideoStream();
 849   MockDemuxerStreamVector streams;
 850   streams.push_back(video_stream());
 851
 852   InitializeDemuxer(&streams, kDuration);
 853   InitializeVideoRenderer(video_stream());
 854
 855   InitializePipeline(PIPELINE_OK);
 856   EXPECT_FALSE(pipeline_->HasAudio());
 857   EXPECT_TRUE(pipeline_->HasVideo());
 858
 859   EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 860 }
 861
 862 static void RunTimeCB(const AudioRenderer::TimeCB& time_cb,
 863                        int time_in_ms,
 864                        int max_time_in_ms) {
 865   time_cb.Run(base::TimeDelta::FromMilliseconds(time_in_ms),
 866               base::TimeDelta::FromMilliseconds(max_time_in_ms));
 867 }
 868
 869 TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
 870   CreateAudioStream();
 871   MockDemuxerStreamVector streams;
 872   streams.push_back(audio_stream());
 873
 874   InitializeDemuxer(&streams);
 875   InitializeAudioRenderer(audio_stream(), false);
 876   InitializePipeline(PIPELINE_OK);
 877
 878   float playback_rate = 1.0f;
 879   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
 880   pipeline_->SetPlaybackRate(playback_rate);
 881   message_loop_.RunUntilIdle();
 882
 883   // Provide an initial time update so that the pipeline transitions out of the
 884   // "waiting for time update" state.
 885   audio_time_cb_.Run(base::TimeDelta::FromMilliseconds(100),
 886                      base::TimeDelta::FromMilliseconds(500));
 887
 888   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 889
 890   // Arrange to trigger a time update while the demuxer is in the middle of
 891   // seeking. This update should be ignored by the pipeline and the clock should
 892   // not get updated.
 893   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
 894   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
 895       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
 896                       RunCallback<1>(PIPELINE_OK)));
 897
 898   EXPECT_CALL(*audio_renderer_, Pause(_))
 899       .WillOnce(RunClosure<0>());
 900   EXPECT_CALL(*audio_renderer_, Flush(_))
 901       .WillOnce(RunClosure<0>());
 902   EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
 903       .WillOnce(RunCallback<1>(PIPELINE_OK));
 904   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
 905   EXPECT_CALL(*audio_renderer_, SetVolume(_));
 906   EXPECT_CALL(*audio_renderer_, Play(_))
 907       .WillOnce(RunClosure<0>());
 908
 909   EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 910   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
 911   DoSeek(seek_time);
 912
 913   EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 914
 915   // Now that the seek is complete, verify that time updates advance the current
 916   // time.
 917   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
 918   audio_time_cb_.Run(new_time, new_time);
 919
 920   EXPECT_EQ(pipeline_->GetMediaTime(), new_time);
 921 }
 922
 923 static void DeletePipeline(scoped_ptr<Pipeline> pipeline) {
 924   // |pipeline| will go out of scope.
 925 }
 926
 927 TEST_F(PipelineTest, DeleteAfterStop) {
 928   CreateAudioStream();
 929   MockDemuxerStreamVector streams;
 930   streams.push_back(audio_stream());
 931   InitializeDemuxer(&streams);
 932   InitializeAudioRenderer(audio_stream(), false);
 933   InitializePipeline(PIPELINE_OK);
 934
 935   ExpectStop();
 936
 937   Pipeline* pipeline = pipeline_.get();
 938   pipeline->Stop(base::Bind(&DeletePipeline, base::Passed(&pipeline_)));
 939   message_loop_.RunUntilIdle();
 940 }
 941
 942 class PipelineTeardownTest : public PipelineTest {
 943  public:
 944   enum TeardownState {
 945     kInitDemuxer,
 946     kInitAudioRenderer,
 947     kInitVideoRenderer,
 948     kPausing,
 949     kFlushing,
 950     kSeeking,
 951     kPrerolling,
 952     kStarting,
 953     kPlaying,
 954   };
 955
 956   enum StopOrError {
 957     kStop,
 958     kError,
 959     kErrorAndStop,
 960   };
 961
 962   PipelineTeardownTest() {}
 963   virtual ~PipelineTeardownTest() {}
 964
 965   void RunTest(TeardownState state, StopOrError stop_or_error) {
 966     switch (state) {
 967       case kInitDemuxer:
 968       case kInitAudioRenderer:
 969       case kInitVideoRenderer:
 970         DoInitialize(state, stop_or_error);
 971         break;
 972
 973       case kPausing:
 974       case kFlushing:
 975       case kSeeking:
 976       case kPrerolling:
 977       case kStarting:
 978         DoInitialize(state, stop_or_error);
 979         DoSeek(state, stop_or_error);
 980         break;
 981
 982       case kPlaying:
 983         DoInitialize(state, stop_or_error);
 984         DoStopOrError(stop_or_error);
 985         break;
 986     }
 987   }
 988
 989  private:
 990   // TODO(scherkus): We do radically different things whether teardown is
 991   // invoked via stop vs error. The teardown path should be the same,
 992   // see http://crbug.com/110228
 993   void DoInitialize(TeardownState state, StopOrError stop_or_error) {
 994     PipelineStatus expected_status =
 995         SetInitializeExpectations(state, stop_or_error);
 996
 997     EXPECT_CALL(callbacks_, OnStart(expected_status));
 998     pipeline_->Start(
 999         filter_collection_.Pass(),
1000         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
1001         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
1002         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
1003         base::Bind(&CallbackHelper::OnBufferingState,
1004                    base::Unretained(&callbacks_)),
1005         base::Bind(&CallbackHelper::OnDurationChange,
1006                    base::Unretained(&callbacks_)));
1007     message_loop_.RunUntilIdle();
1008   }
1009
1010   PipelineStatus SetInitializeExpectations(TeardownState state,
1011                                            StopOrError stop_or_error) {
1012     PipelineStatus status = PIPELINE_OK;
1013     base::Closure stop_cb = base::Bind(
1014         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
1015
1016     if (state == kInitDemuxer) {
1017       if (stop_or_error == kStop) {
1018         EXPECT_CALL(*demuxer_, Initialize(_, _, _))
1019             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
1020                             RunCallback<1>(PIPELINE_OK)));
1021         EXPECT_CALL(callbacks_, OnStop());
1022       } else {
1023         status = DEMUXER_ERROR_COULD_NOT_OPEN;
1024         EXPECT_CALL(*demuxer_, Initialize(_, _, _))
1025             .WillOnce(RunCallback<1>(status));
1026       }
1027
1028       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
1029       return status;
1030     }
1031
1032     CreateAudioStream();
1033     CreateVideoStream();
1034     MockDemuxerStreamVector streams;
1035     streams.push_back(audio_stream());
1036     streams.push_back(video_stream());
1037     InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
1038
1039     if (state == kInitAudioRenderer) {
1040       if (stop_or_error == kStop) {
1041         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
1042             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
1043                             RunCallback<1>(PIPELINE_OK)));
1044         EXPECT_CALL(callbacks_, OnStop());
1045       } else {
1046         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
1047         EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
1048             .WillOnce(RunCallback<1>(status));
1049       }
1050
1051       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
1052       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1053       return status;
1054     }
1055
1056     EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _, _))
1057         .WillOnce(RunCallback<1>(PIPELINE_OK));
1058
1059     if (state == kInitVideoRenderer) {
1060       if (stop_or_error == kStop) {
1061         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
1062             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
1063                             RunCallback<1>(PIPELINE_OK)));
1064         EXPECT_CALL(callbacks_, OnStop());
1065       } else {
1066         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
1067         EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
1068             .WillOnce(RunCallback<1>(status));
1069       }
1070
1071       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
1072       EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1073       EXPECT_CALL(*video_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1074       return status;
1075     }
1076
1077     EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _, _))
1078         .WillOnce(RunCallback<1>(PIPELINE_OK));
1079
1080     EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
1081
1082     // If we get here it's a successful initialization.
1083     EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
1084         .WillOnce(RunCallback<1>(PIPELINE_OK));
1085     EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
1086         .WillOnce(RunCallback<1>(PIPELINE_OK));
1087
1088     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
1089     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
1090     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
1091
1092     EXPECT_CALL(*audio_renderer_, Play(_))
1093         .WillOnce(RunClosure<0>());
1094     EXPECT_CALL(*video_renderer_, Play(_))
1095         .WillOnce(RunClosure<0>());
1096
1097     if (status == PIPELINE_OK)
1098       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
1099
1100     return status;
1101   }
1102
1103   void DoSeek(TeardownState state, StopOrError stop_or_error) {
1104     InSequence s;
1105     PipelineStatus status = SetSeekExpectations(state, stop_or_error);
1106
1107     EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
1108     EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1109     EXPECT_CALL(*video_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1110     EXPECT_CALL(callbacks_, OnSeek(status));
1111
1112     if (status == PIPELINE_OK) {
1113       EXPECT_CALL(callbacks_, OnStop());
1114     }
1115
1116     pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
1117         &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
1118     message_loop_.RunUntilIdle();
1119   }
1120
1121   PipelineStatus SetSeekExpectations(TeardownState state,
1122                                      StopOrError stop_or_error) {
1123     PipelineStatus status = PIPELINE_OK;
1124     base::Closure stop_cb = base::Bind(
1125         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
1126
1127     if (state == kPausing) {
1128       if (stop_or_error == kStop) {
1129         EXPECT_CALL(*audio_renderer_, Pause(_))
1130             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
1131       } else {
1132         status = PIPELINE_ERROR_READ;
1133         EXPECT_CALL(*audio_renderer_, Pause(_)).WillOnce(
1134             DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
1135       }
1136
1137       return status;
1138     }
1139
1140     EXPECT_CALL(*audio_renderer_, Pause(_)).WillOnce(RunClosure<0>());
1141     EXPECT_CALL(*video_renderer_, Pause(_)).WillOnce(RunClosure<0>());
1142
1143     if (state == kFlushing) {
1144       if (stop_or_error == kStop) {
1145         EXPECT_CALL(*audio_renderer_, Flush(_))
1146             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
1147       } else {
1148         status = PIPELINE_ERROR_READ;
1149         EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(
1150             DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
1151       }
1152
1153       return status;
1154     }
1155
1156     EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
1157     EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
1158
1159     if (state == kSeeking) {
1160       if (stop_or_error == kStop) {
1161         EXPECT_CALL(*demuxer_, Seek(_, _))
1162             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
1163                             RunCallback<1>(PIPELINE_OK)));
1164       } else {
1165         status = PIPELINE_ERROR_READ;
1166         EXPECT_CALL(*demuxer_, Seek(_, _))
1167             .WillOnce(RunCallback<1>(status));
1168       }
1169
1170       return status;
1171     }
1172
1173     EXPECT_CALL(*demuxer_, Seek(_, _))
1174         .WillOnce(RunCallback<1>(PIPELINE_OK));
1175
1176     if (state == kPrerolling) {
1177       if (stop_or_error == kStop) {
1178         EXPECT_CALL(*audio_renderer_, Preroll(_, _))
1179             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
1180                             RunCallback<1>(PIPELINE_OK)));
1181       } else {
1182         status = PIPELINE_ERROR_READ;
1183         EXPECT_CALL(*audio_renderer_, Preroll(_, _))
1184             .WillOnce(RunCallback<1>(status));
1185       }
1186
1187       return status;
1188     }
1189
1190     EXPECT_CALL(*audio_renderer_, Preroll(_, _))
1191         .WillOnce(RunCallback<1>(PIPELINE_OK));
1192     EXPECT_CALL(*video_renderer_, Preroll(_, _))
1193         .WillOnce(RunCallback<1>(PIPELINE_OK));
1194
1195     // Playback rate and volume are updated prior to starting.
1196     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
1197     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
1198     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
1199
1200     if (state == kStarting) {
1201       if (stop_or_error == kStop) {
1202         EXPECT_CALL(*audio_renderer_, Play(_))
1203             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
1204       } else {
1205         status = PIPELINE_ERROR_READ;
1206         EXPECT_CALL(*audio_renderer_, Play(_)).WillOnce(
1207             DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
1208       }
1209       return status;
1210     }
1211
1212     NOTREACHED() << "State not supported: " << state;
1213     return status;
1214   }
1215
1216   void DoStopOrError(StopOrError stop_or_error) {
1217     InSequence s;
1218
1219     EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
1220     EXPECT_CALL(*audio_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1221     EXPECT_CALL(*video_renderer_, Stop(_)).WillOnce(RunClosure<0>());
1222
1223     switch (stop_or_error) {
1224       case kStop:
1225         EXPECT_CALL(callbacks_, OnStop());
1226         pipeline_->Stop(base::Bind(
1227             &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
1228         break;
1229
1230       case kError:
1231         EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
1232         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
1233         break;
1234
1235       case kErrorAndStop:
1236         EXPECT_CALL(callbacks_, OnStop());
1237         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
1238         pipeline_->Stop(base::Bind(
1239             &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
1240         break;
1241     }
1242
1243     message_loop_.RunUntilIdle();
1244   }
1245
1246   DISALLOW_COPY_AND_ASSIGN(PipelineTeardownTest);
1247 };
1248
1249 #define INSTANTIATE_TEARDOWN_TEST(stop_or_error, state) \
1250     TEST_F(PipelineTeardownTest, stop_or_error##_##state) { \
1251       RunTest(k##state, k##stop_or_error); \
1252     }
1253
1254 INSTANTIATE_TEARDOWN_TEST(Stop, InitDemuxer);
1255 INSTANTIATE_TEARDOWN_TEST(Stop, InitAudioRenderer);
1256 INSTANTIATE_TEARDOWN_TEST(Stop, InitVideoRenderer);
1257 INSTANTIATE_TEARDOWN_TEST(Stop, Pausing);
1258 INSTANTIATE_TEARDOWN_TEST(Stop, Flushing);
1259 INSTANTIATE_TEARDOWN_TEST(Stop, Seeking);
1260 INSTANTIATE_TEARDOWN_TEST(Stop, Prerolling);
1261 INSTANTIATE_TEARDOWN_TEST(Stop, Starting);
1262 INSTANTIATE_TEARDOWN_TEST(Stop, Playing);
1263
1264 INSTANTIATE_TEARDOWN_TEST(Error, InitDemuxer);
1265 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
1266 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
1267 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
1268 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
1269 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
1270 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
1271 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
1272 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
1273
1274 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
1275
1276 }  // namespace media