Move Pipeline permanent callbacks into Pipeline::Client 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 59 matching lines @@
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
 // either filters don't call InitializationComplete() immediately or filter
 // initialization is moved to a separate thread this test will become flaky.
 class PipelineImplTest : public ::testing::Test {
  public:
   // Used for setting expectations on pipeline callbacks.  Using a StrictMock
   // also lets us test for missing callbacks.
-  class CallbackHelper {
+  class CallbackHelper : public Pipeline::Client {
    public:
     CallbackHelper() {}
     virtual ~CallbackHelper() {}
 
     MOCK_METHOD1(OnStart, void(PipelineStatus));
     MOCK_METHOD1(OnSeek, void(PipelineStatus));
     MOCK_METHOD1(OnSuspend, void(PipelineStatus));
     MOCK_METHOD1(OnResume, void(PipelineStatus));
     MOCK_METHOD0(OnStop, void());
+
+    // Pipeline::Client overrides.
+    MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD0(OnEnded, void());
-    MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD1(OnMetadata, void(PipelineMetadata));
     MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
     MOCK_METHOD0(OnDurationChange, void());
+    MOCK_METHOD2(OnAddTextTrack,
+                 void(const TextTrackConfig&, const AddTextTrackDoneCB&));
+    MOCK_METHOD0(OnWaitingForDecryptionKey, void());
 
    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>()),
@@ skipping 72 matching lines @@
   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_, HasAudio()).WillRepeatedly(Return(audio_stream()));
     EXPECT_CALL(*renderer_, HasVideo()).WillRepeatedly(Return(video_stream()));
   }
 
   void AddTextStream() {
-    EXPECT_CALL(*this, OnAddTextTrack(_, _))
+    EXPECT_CALL(callbacks_, OnAddTextTrack(_, _))
         .WillOnce(Invoke(this, &PipelineImplTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())
         ->AddTextStream(text_stream(),
                         TextTrackConfig(kTextSubtitles, "", "", ""));
     message_loop_.RunUntilIdle();
   }
 
   void StartPipeline() {
-    EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
+    EXPECT_CALL(callbacks_, OnWaitingForDecryptionKey()).Times(0);
     pipeline_->Start(
-        demuxer_.get(), std::move(scoped_renderer_),
-        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnBufferingStateChange,
-                   base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnDurationChange,
-                   base::Unretained(&callbacks_)),
-        base::Bind(&PipelineImplTest::OnAddTextTrack, base::Unretained(this)),
-        base::Bind(&PipelineImplTest::OnWaitingForDecryptionKey,
-                   base::Unretained(this)));
+        demuxer_.get(), std::move(scoped_renderer_), &callbacks_,
+        base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)));
   }
 
   // Sets up expectations on the callback and initializes the pipeline. Called
   // 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));
@@ skipping 107 matching lines @@
       EXPECT_CALL(*demuxer_, Stop());
   }
 
   void ExpectPipelineStopAndDestroyPipeline() {
     // After the Pipeline is stopped, it could be destroyed any time. Always
     // destroy the pipeline immediately after OnStop() to test this.
     EXPECT_CALL(callbacks_, OnStop())
         .WillOnce(Invoke(this, &PipelineImplTest::DestroyPipeline));
   }
 
-  MOCK_METHOD2(OnAddTextTrack,
-               void(const TextTrackConfig&, const AddTextTrackDoneCB&));
-  MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
-
   void DoOnAddTextTrack(const TextTrackConfig& config,
                         const AddTextTrackDoneCB& done_cb) {
     std::unique_ptr<TextTrack> text_track(new MockTextTrack);
     done_cb.Run(std::move(text_track));
   }
 
   void RunBufferedTimeRangesTest(const base::TimeDelta duration) {
     EXPECT_EQ(0u, pipeline_->GetBufferedTimeRanges().size());
     EXPECT_FALSE(pipeline_->DidLoadingProgress());
     Ranges<base::TimeDelta> ranges;
@@ skipping 812 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