Move Renderer permanent callbacks into RendererClient interface.

media/base/pipeline_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 "media/base/pipeline_impl.h"
 
 #include <stddef.h>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 38 matching lines @@
 }
 
 ACTION_P(Stop, pipeline) {
   pipeline->Stop();
 }
 
 ACTION_P2(SetError, pipeline, status) {
   pipeline->SetErrorForTesting(status);
 }
 
-ACTION_P2(SetBufferingState, cb, buffering_state) {
-  cb->Run(buffering_state);
+ACTION_P2(SetBufferingState, renderer_client, buffering_state) {
+  (*renderer_client)->OnBufferingStateChange(buffering_state);
 }
 
 ACTION_TEMPLATE(PostCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p0)) {
   return base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(::std::tr1::get<k>(args), p0));
 }
 
 // TODO(scherkus): even though some filters are initialized on separate
@@ skipping 28 matching lines @@
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   PipelineImplTest()
       : pipeline_(
             new PipelineImpl(message_loop_.task_runner(), new MediaLog())),
         demuxer_(new StrictMock<MockDemuxer>()),
         scoped_renderer_(new StrictMock<MockRenderer>()),
-        renderer_(scoped_renderer_.get()) {
+        renderer_(scoped_renderer_.get()),
+        renderer_client_(nullptr) {
     // SetDemuxerExpectations() adds overriding expectations for expected
     // non-NULL streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_)).WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*demuxer_, GetTimelineOffset())
         .WillRepeatedly(Return(base::Time()));
 
     EXPECT_CALL(*renderer_, GetMediaTime())
         .WillRepeatedly(Return(base::TimeDelta()));
@@ skipping 50 matching lines @@
 
   std::unique_ptr<StrictMock<MockDemuxerStream>> CreateStream(
       DemuxerStream::Type type) {
     std::unique_ptr<StrictMock<MockDemuxerStream>> stream(
         new StrictMock<MockDemuxerStream>(type));
     return stream;
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetRendererExpectations() {
-    EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
-        .WillOnce(DoAll(SaveArg<2>(&statistics_cb_),
-                        SaveArg<3>(&buffering_state_cb_),
-                        SaveArg<4>(&ended_cb_), PostCallback<1>(PIPELINE_OK)));
+    EXPECT_CALL(*renderer_, Initialize(_, _, _))
+        .WillOnce(
+            DoAll(SaveArg<1>(&renderer_client_), PostCallback<2>(PIPELINE_OK)));
     EXPECT_CALL(*renderer_, HasAudio()).WillRepeatedly(Return(audio_stream()));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(video_stream()));
   }
 
   void AddTextStream() {
     EXPECT_CALL(callbacks_, OnAddTextTrack(_, _))
         .WillOnce(Invoke(this, &PipelineImplTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())
         ->AddTextStream(text_stream(),
                         TextTrackConfig(kTextSubtitles, "", "", ""));
@@ skipping 11 matching lines @@
   // after tests have set expectations any filters they wish to use.
   void StartPipelineAndExpect(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
       EXPECT_CALL(*renderer_, SetPlaybackRate(0.0));
       EXPECT_CALL(*renderer_, SetVolume(1.0f));
       EXPECT_CALL(*renderer_, StartPlayingFrom(start_time_))
           .WillOnce(
-              SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
+              SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH));
       EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     }
 
     StartPipeline();
     message_loop_.RunUntilIdle();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
@@ skipping 13 matching lines @@
 
   MockDemuxerStream* video_stream() { return video_stream_.get(); }
 
   FakeTextTrackStream* text_stream() { return text_stream_.get(); }
 
   void ExpectSeek(const base::TimeDelta& seek_time, bool underflowed) {
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     EXPECT_CALL(*renderer_, Flush(_))
-        .WillOnce(DoAll(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-            RunClosure<0>()));
+        .WillOnce(
+            DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
+                  RunClosure<0>()));
     EXPECT_CALL(*renderer_, SetPlaybackRate(_));
     EXPECT_CALL(*renderer_, SetVolume(_));
     EXPECT_CALL(*renderer_, StartPlayingFrom(seek_time))
-        .WillOnce(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
+        .WillOnce(SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
 
     // We expect a successful seek callback followed by a buffering update.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                           base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
   void ExpectSuspend() {
     EXPECT_CALL(*renderer_, SetPlaybackRate(0));
     EXPECT_CALL(*renderer_, Flush(_))
-        .WillOnce(DoAll(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-            RunClosure<0>()));
+        .WillOnce(
+            DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
+                  RunClosure<0>()));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
     EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
   }
 
   void DoSuspend() {
     pipeline_->Suspend(
         base::Bind(&CallbackHelper::OnSuspend, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
 
     // |renderer_| has been deleted, replace it.
     scoped_renderer_.reset(new StrictMock<MockRenderer>()),
         renderer_ = scoped_renderer_.get();
   }
 
   void ExpectResume(const base::TimeDelta& seek_time) {
     SetRendererExpectations();
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*renderer_, SetPlaybackRate(_));
     EXPECT_CALL(*renderer_, SetVolume(_));
     EXPECT_CALL(*renderer_, StartPlayingFrom(seek_time))
-        .WillOnce(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
+        .WillOnce(SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
   }
 
   void DoResume(const base::TimeDelta& seek_time) {
     pipeline_->Resume(
         std::move(scoped_renderer_), seek_time,
         base::Bind(&CallbackHelper::OnResume, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
@@ skipping 36 matching lines @@
   std::unique_ptr<PipelineImpl> pipeline_;
 
   std::unique_ptr<StrictMock<MockDemuxer>> demuxer_;
   std::unique_ptr<StrictMock<MockRenderer>> scoped_renderer_;
   StrictMock<MockRenderer>* renderer_;
   StrictMock<CallbackHelper> text_renderer_callbacks_;
   TextRenderer* text_renderer_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> audio_stream_;
   std::unique_ptr<StrictMock<MockDemuxerStream>> video_stream_;
   std::unique_ptr<FakeTextTrackStream> text_stream_;
-  BufferingStateCB buffering_state_cb_;
-  base::Closure ended_cb_;
-  StatisticsCB statistics_cb_;
+  RendererClient* renderer_client_;
   VideoDecoderConfig video_decoder_config_;
   PipelineMetadata metadata_;
   base::TimeDelta start_time_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineImplTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
@@ skipping 209 matching lines @@
 
   SetDemuxerExpectations(&streams, base::TimeDelta::FromSeconds(3000));
   SetRendererExpectations();
 
   StartPipelineAndExpect(PIPELINE_OK);
 
   // Inject some fake memory usage to verify its cleared after suspend.
   PipelineStatistics stats;
   stats.audio_memory_usage = 12345;
   stats.video_memory_usage = 67890;
-  statistics_cb_.Run(stats);
+  renderer_client_->OnStatisticsUpdate(stats);
   EXPECT_EQ(stats.audio_memory_usage,
             pipeline_->GetStatistics().audio_memory_usage);
   EXPECT_EQ(stats.video_memory_usage,
             pipeline_->GetStatistics().video_memory_usage);
 
   ExpectSuspend();
   DoSuspend();
 
   EXPECT_EQ(pipeline_->GetStatistics().audio_memory_usage, 0);
   EXPECT_EQ(pipeline_->GetStatistics().video_memory_usage, 0);
@@ skipping 77 matching lines @@
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
 
   AddTextStream();
 
   // The ended callback shouldn't run until all renderers have ended.
-  ended_cb_.Run();
+  renderer_client_->OnEnded();
   message_loop_.RunUntilIdle();
 
   EXPECT_CALL(callbacks_, OnEnded());
   text_stream()->SendEosNotification();
   message_loop_.RunUntilIdle();
 }
 
 TEST_F(PipelineImplTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
 
   double playback_rate = 1.0;
   EXPECT_CALL(*renderer_, SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunUntilIdle();
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
   EXPECT_CALL(*renderer_, Flush(_))
       .WillOnce(
-          DoAll(SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+          DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
                 RunClosure<0>()));
 
   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*demuxer_, Stop());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunUntilIdle();
@@ skipping 31 matching lines @@
   base::Callback<void(PipelineStatus)> cb =
       base::Bind(&TestNoCallsAfterError, pipeline_.get(), &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*renderer_, Flush(_))
       .WillOnce(
-          DoAll(SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+          DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
                 RunClosure<0>()));
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
 
   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*demuxer_, Stop());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
@@ skipping 19 matching lines @@
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
   streams.push_back(video_stream());
 
   SetDemuxerExpectations(&streams);
   SetRendererExpectations();
   StartPipelineAndExpect(PIPELINE_OK);
 
   // Simulate underflow.
   EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
-  buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
+  renderer_client_->OnBufferingStateChange(BUFFERING_HAVE_NOTHING);
   message_loop_.RunUntilIdle();
 
   // Seek while underflowed.
   base::TimeDelta expected = base::TimeDelta::FromSeconds(5);
   ExpectSeek(expected, true);
   DoSeek(expected);
 }
 
 TEST_F(PipelineImplTest, PositiveStartTime) {
   start_time_ = base::TimeDelta::FromSeconds(1);
@@ skipping 91 matching lines @@
     MockDemuxerStreamVector streams;
     streams.push_back(audio_stream());
     streams.push_back(video_stream());
     SetDemuxerExpectations(&streams, base::TimeDelta::FromSeconds(3000));
 
     EXPECT_CALL(*renderer_, HasAudio()).WillRepeatedly(Return(true));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(true));
 
     if (state == kInitRenderer) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
+        EXPECT_CALL(*renderer_, Initialize(_, _, _))
             .WillOnce(
-                DoAll(Stop(pipeline_.get()), PostCallback<1>(PIPELINE_OK)));
+                DoAll(Stop(pipeline_.get()), PostCallback<2>(PIPELINE_OK)));
         // Note: OnStart or OnMetadata callback are not called
         // after pipeline is stopped.
       } else {
-        EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
-            .WillOnce(PostCallback<1>(PIPELINE_ERROR_INITIALIZATION_FAILED));
+        EXPECT_CALL(*renderer_, Initialize(_, _, _))
+            .WillOnce(PostCallback<2>(PIPELINE_ERROR_INITIALIZATION_FAILED));
         EXPECT_CALL(callbacks_, OnMetadata(_));
         EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_INITIALIZATION_FAILED));
       }
 
       EXPECT_CALL(*demuxer_, Stop());
       return;
     }
 
-    EXPECT_CALL(*renderer_, Initialize(_, _, _, _, _, _, _))
-        .WillOnce(DoAll(SaveArg<3>(&buffering_state_cb_),
-                        PostCallback<1>(PIPELINE_OK)));
+    EXPECT_CALL(*renderer_, Initialize(_, _, _))
+        .WillOnce(
+            DoAll(SaveArg<1>(&renderer_client_), PostCallback<2>(PIPELINE_OK)));
 
     // If we get here it's a successful initialization.
     EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
     EXPECT_CALL(callbacks_, OnMetadata(_));
 
     EXPECT_CALL(*renderer_, SetPlaybackRate(0.0));
     EXPECT_CALL(*renderer_, SetVolume(1.0f));
     EXPECT_CALL(*renderer_, StartPlayingFrom(base::TimeDelta()))
-        .WillOnce(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
+        .WillOnce(SetBufferingState(&renderer_client_, BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   }
 
   void DoSeek(TeardownState state, StopOrError stop_or_error) {
     SetSeekExpectations(state, stop_or_error);
 
     EXPECT_CALL(*demuxer_, Stop());
 
     pipeline_->Seek(
         base::TimeDelta::FromSeconds(10),
         base::Bind(&CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
   void SetSeekExpectations(TeardownState state, StopOrError stop_or_error) {
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*renderer_, Flush(_))
             .WillOnce(DoAll(
-                SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+                SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
                 Stop(pipeline_.get()), RunClosure<0>()));
         // Note: OnBufferingStateChange or OnSeek callbacks are not called
         // after pipeline is stopped.
       } else {
         EXPECT_CALL(*renderer_, Flush(_))
             .WillOnce(DoAll(
-                SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+                SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
                 SetError(pipeline_.get(), PIPELINE_ERROR_READ),
                 RunClosure<0>()));
         EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
         EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
       }
       return;
     }
 
     EXPECT_CALL(*renderer_, Flush(_))
-        .WillOnce(DoAll(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-            RunClosure<0>()));
+        .WillOnce(
+            DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
+                  RunClosure<0>()));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
 
     if (state == kSeeking) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Seek(_, _))
             .WillOnce(
                 DoAll(Stop(pipeline_.get()), RunCallback<1>(PIPELINE_OK)));
         // Note: OnSeek callback is not called after pipeline is stopped.
       } else {
         EXPECT_CALL(*demuxer_, Seek(_, _))
@@ skipping 23 matching lines @@
     // kSuspended, kSuspending never throw errors, since Resume() is always able
     // to restore the pipeline to a pristine state.
     DoStopOrError(stop_or_error, false);
   }
 
   void SetSuspendExpectations(TeardownState state, StopOrError stop_or_error) {
     EXPECT_CALL(*renderer_, SetPlaybackRate(0));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
     EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
     EXPECT_CALL(*renderer_, Flush(_))
-        .WillOnce(DoAll(
-            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-            RunClosure<0>()));
+        .WillOnce(
+            DoAll(SetBufferingState(&renderer_client_, BUFFERING_HAVE_NOTHING),
+                  RunClosure<0>()));
     if (state == kResuming) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*demuxer_, Seek(_, _))
             .WillOnce(
                 DoAll(Stop(pipeline_.get()), RunCallback<1>(PIPELINE_OK)));
         // Note: OnResume callback is not called after pipeline is stopped.
       } else {
         EXPECT_CALL(*demuxer_, Seek(_, _))
             .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
         EXPECT_CALL(callbacks_, OnResume(PIPELINE_ERROR_READ));
@@ skipping 56 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspending);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspended);
 INSTANTIATE_TEARDOWN_TEST(Error, Resuming);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Suspended);
 
 }  // namespace media