Create abstract interface for media::Pipeline.

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 "media/base/pipeline.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 79 matching lines @@
     MOCK_METHOD1(OnError, void(PipelineStatus));
     MOCK_METHOD1(OnMetadata, void(PipelineMetadata));
     MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
     MOCK_METHOD0(OnDurationChange, void());
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
   };
 
   PipelineTest()
-      : pipeline_(new Pipeline(message_loop_.task_runner(),
-                               new MediaLog())),
+      : pipeline_(
+            new PipelineImpl(message_loop_.task_runner(), new MediaLog())),
         demuxer_(new StrictMock<MockDemuxer>()),
         scoped_renderer_(new StrictMock<MockRenderer>()),
         renderer_(scoped_renderer_.get()) {
     // 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())
@@ skipping 74 matching lines @@
   void AddTextStream() {
     EXPECT_CALL(*this, OnAddTextTrack(_,_))
         .WillOnce(Invoke(this, &PipelineTest::DoOnAddTextTrack));
     static_cast<DemuxerHost*>(pipeline_.get())->AddTextStream(text_stream(),
                               TextTrackConfig(kTextSubtitles, "", "", ""));
     message_loop_.RunUntilIdle();
   }
 
   void StartPipeline() {
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
+    scoped_ptr<Renderer> renderer = std::move(scoped_renderer_);
     pipeline_->Start(
-        demuxer_.get(), std::move(scoped_renderer_),
+        demuxer_.get(), &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(&PipelineTest::OnAddTextTrack, base::Unretained(this)),
         base::Bind(&PipelineTest::OnWaitingForDecryptionKey,
@@ skipping 100 matching lines @@
     EXPECT_CALL(*renderer_, SetPlaybackRate(_));
     EXPECT_CALL(*renderer_, SetVolume(_));
     EXPECT_CALL(*renderer_, StartPlayingFrom(seek_time))
         .WillOnce(
             SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
   }
 
   void DoResume(const base::TimeDelta& seek_time) {
+    scoped_ptr<Renderer> renderer = std::move(scoped_renderer_);
     pipeline_->Resume(
-        std::move(scoped_renderer_), seek_time,
+        &renderer, seek_time,
         base::Bind(&CallbackHelper::OnResume, base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
   void DestroyPipeline() {
     // In real code Pipeline could be destroyed on a different thread. All weak
     // pointers must have been invalidated before the stop callback returns.
     DCHECK(!pipeline_->HasWeakPtrsForTesting());
     pipeline_.reset();
   }
@@ skipping 17 matching lines @@
   void DoOnAddTextTrack(const TextTrackConfig& config,
                         const AddTextTrackDoneCB& done_cb) {
     scoped_ptr<TextTrack> text_track(new MockTextTrack);
     done_cb.Run(std::move(text_track));
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   base::SimpleTestTickClock test_tick_clock_;
   base::MessageLoop message_loop_;
-  scoped_ptr<Pipeline> pipeline_;
+  scoped_ptr<PipelineImpl> pipeline_;
 
   scoped_ptr<StrictMock<MockDemuxer> > demuxer_;
   scoped_ptr<StrictMock<MockRenderer> > scoped_renderer_;
   StrictMock<MockRenderer>* renderer_;
   StrictMock<CallbackHelper> text_renderer_callbacks_;
   TextRenderer* text_renderer_;
   scoped_ptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   scoped_ptr<FakeTextTrackStream> text_stream_;
   BufferingStateCB buffering_state_cb_;
@@ skipping 359 matching lines @@
   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();
 }
 
 // Invoked function OnError. This asserts that the pipeline does not enqueue
 // non-teardown related tasks while tearing down.
-static void TestNoCallsAfterError(
-    Pipeline* pipeline, base::MessageLoop* message_loop,
-    PipelineStatus /* status */) {
+static void TestNoCallsAfterError(PipelineImpl* pipeline,
+                                  base::MessageLoop* message_loop,
+                                  PipelineStatus /* status */) {
   CHECK(pipeline);
   CHECK(message_loop);
 
   // When we get to this stage, the message loop should be empty.
   EXPECT_TRUE(message_loop->IsIdleForTesting());
 
   // Make calls on pipeline after error has occurred.
   pipeline->SetPlaybackRate(0.5);
   pipeline->SetVolume(0.5f);
 
@@ skipping 407 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