Migrate Pipeline & PipelineImpl to PipelineStatusCB.

media/base/pipeline_impl_unittest.cc

Index: media/base/pipeline_impl_unittest.cc
diff --git a/media/base/pipeline_impl_unittest.cc b/media/base/pipeline_impl_unittest.cc
index 42496a30966726a3d196cf104cc5243a8110c25e..67aa6e16df31257349b36df34653729176ac483d 100644
--- a/media/base/pipeline_impl_unittest.cc
+++ b/media/base/pipeline_impl_unittest.cc
@@ -4,6 +4,7 @@
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
@@ -63,11 +64,9 @@ class PipelineImplTest : public ::testing::Test {
   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
@@ -87,8 +86,8 @@ class PipelineImplTest : public ::testing::Test {
 
     // 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();
@@ -213,8 +212,8 @@ class PipelineImplTest : public ::testing::Test {
                                                run_build,
                                                build_status),
                      url,
-                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                                 &CallbackHelper::OnStart));
+                     base::Bind(&CallbackHelper::OnStart,
+                                base::Unretained(&callbacks_)));
 
     message_loop_.RunAllPending();
   }
@@ -260,8 +259,8 @@ class PipelineImplTest : public ::testing::Test {
 
   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());
@@ -288,11 +287,11 @@ TEST_F(PipelineImplTest, NotStarted) {
 
   // 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());
@@ -337,8 +336,8 @@ TEST_F(PipelineImplTest, NeverInitializes) {
                                              true,
                                              PIPELINE_OK),
                    "",
-                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
-                               &CallbackHelper::OnStart));
+                   base::Bind(&CallbackHelper::OnStart,
+                              base::Unretained(&callbacks_)));
   message_loop_.RunAllPending();
 
   EXPECT_FALSE(pipeline_->IsInitialized());
@@ -365,8 +364,8 @@ TEST_F(PipelineImplTest, RequiredFilterMissing) {
                                 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());
@@ -799,8 +798,8 @@ TEST_F(PipelineImplTest, ErrorDuringSeek) {
   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();
@@ -850,23 +849,23 @@ TEST_F(PipelineImplTest, StartTimeIsNonZero) {
 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) {