Migrate Pipeline & PipelineImpl to PipelineStatusCB.

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2011 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 <string>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/filters.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 39 matching lines @@
 // 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:
   PipelineImplTest()
       : pipeline_(new PipelineImpl(&message_loop_)) {
     pipeline_->Init(
-        NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                    &CallbackHelper::OnEnded),
-        NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                    &CallbackHelper::OnError),
-        static_cast<PipelineStatusCallback*>(NULL));
+        base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
+        base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
+        PipelineStatusCB());
     mocks_.reset(new MockFilterCollection());
 
     // InitializeDemuxer adds overriding expectations for expected non-NULL
     // streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*mocks_->demuxer(), GetStream(_))
         .WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~PipelineImplTest() {
     if (!pipeline_->IsRunning()) {
       return;
     }
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop(PIPELINE_OK));
-    pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                &CallbackHelper::OnStop));
+    pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
+                               base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
 
     mocks_.reset();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
@@ skipping 104 matching lines @@
 
     bool run_build = true;
     if (url.find(kRawMediaScheme) == 0)
       run_build = false;
 
     pipeline_->Start(mocks_->filter_collection(true,
                                                true,
                                                run_build,
                                                build_status),
                      url,
-                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                 &CallbackHelper::OnStart));
+                     base::Bind(&CallbackHelper::OnStart,
+                                base::Unretained(&callbacks_)));
 
     message_loop_.RunAllPending();
   }
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
   }
 
   void CreateVideoStream() {
     video_stream_ = CreateStream(DemuxerStream::VIDEO);
@@ skipping 25 matching lines @@
       EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, _))
           .WillOnce(Invoke(&RunFilterStatusCB));
     }
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
-                    NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                &CallbackHelper::OnSeek));
+                    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_->GetCurrentTime());
     message_loop_.RunAllPending();
     EXPECT_EQ(seek_time, pipeline_->GetCurrentTime());
   }
 
   // Fixture members.
   StrictMock<CallbackHelper> callbacks_;
   MessageLoop message_loop_;
   scoped_refptr<PipelineImpl> pipeline_;
   scoped_ptr<media::MockFilterCollection> mocks_;
   scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream_;
   scoped_refptr<StrictMock<MockDemuxerStream> > video_stream_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineImplTest);
 };
 
 // Test that playback controls methods no-op when the pipeline hasn't been
 // started.
 TEST_F(PipelineImplTest, NotStarted) {
   const base::TimeDelta kZero;
 
   // StrictMock<> will ensure these never get called, and valgrind/purify will
   // make sure the callbacks are instantly deleted.
-  pipeline_->Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                              &CallbackHelper::OnStop));
+  pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
+                             base::Unretained(&callbacks_)));
   pipeline_->Seek(kZero,
-                  NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                              &CallbackHelper::OnSeek));
+                  base::Bind(&CallbackHelper::OnSeek,
+                             base::Unretained(&callbacks_)));
 
   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());
@@ skipping 24 matching lines @@
 
 TEST_F(PipelineImplTest, NeverInitializes) {
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(mocks_->filter_collection(false,
                                              false,
                                              true,
                                              PIPELINE_OK),
                    "",
-                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                               &CallbackHelper::OnStart));
+                   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(PipelineImplTest, RequiredFilterMissing) {
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   // Expect an initialization callback.
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_ERROR_REQUIRED_FILTER_MISSING));
 
   // Create a filter collection with missing filter.
   FilterCollection* collection =
       mocks_->filter_collection(false,
                                 true,
                                 true,
                                 PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
   pipeline_->Start(collection, "",
-                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                               &CallbackHelper::OnStart));
+                   base::Bind(&CallbackHelper::OnStart,
+                              base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
 }
 
 TEST_F(PipelineImplTest, URLNotFound) {
   // TODO(acolwell,fischman): Since OnStart() is getting called with an error
   // code already, OnError() doesn't also need to get called.  Fix the pipeline
   // (and it's consumers!) so that OnError doesn't need to be called after
   // another callback has already reported the error.  Same applies to NoStreams
@@ skipping 412 matching lines @@
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   InSequence s;
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(Invoke(&SendReadErrorToCB));
 
-  pipeline_->Seek(seek_time, NewCallback(
-      reinterpret_cast<CallbackHelper*>(&callbacks_), &CallbackHelper::OnSeek));
+  pipeline_->Seek(seek_time,base::Bind(&CallbackHelper::OnSeek,
+                                       base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineImplTest, StartTimeIsZero) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
   streams.push_back(video_stream());
 
@@ skipping 29 matching lines @@
   EXPECT_TRUE(pipeline_->IsInitialized());
   EXPECT_FALSE(pipeline_->HasAudio());
   EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(kStartTime, pipeline_->GetCurrentTime());
 }
 
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
   FlexibleCallbackRunner(int delayInMs, PipelineStatus status,
-                         PipelineStatusCallback* callback)
+                         const PipelineStatusCB& callback)
       : delayInMs_(delayInMs), status_(status), callback_(callback) {
     if (delayInMs_ < 0) {
-      callback_->Run(status_);
+      callback_.Run(status_);
       return;
     }
   }
   virtual void Run() {
     if (delayInMs_ < 0) return;
     base::PlatformThread::Sleep(delayInMs_);
-    callback_->Run(status_);
+    callback_.Run(status_);
   }
 
  private:
   int delayInMs_;
   PipelineStatus status_;
-  scoped_ptr<PipelineStatusCallback> callback_;
+  PipelineStatusCB callback_;
 };
 
 void TestPipelineStatusNotification(int delayInMs) {
   PipelineStatusNotification note;
   // Arbitrary error value we expect to fish out of the notification after the
   // callback is fired.
   const PipelineStatus expected_error = PIPELINE_ERROR_URL_NOT_FOUND;
   FlexibleCallbackRunner runner(delayInMs, expected_error, note.Callback());
   base::DelegateSimpleThread thread(&runner, "FlexibleCallbackRunner");
   thread.Start();
@@ skipping 12 matching lines @@
   TestPipelineStatusNotification(0);
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(20);
 }
 
 }  // namespace media