Finish the base::Bind migration for webkit/media.

webkit/media/buffered_data_source_unittest.cc

Index: webkit/media/buffered_data_source_unittest.cc
diff --git a/webkit/media/buffered_data_source_unittest.cc b/webkit/media/buffered_data_source_unittest.cc
index ce14c7abc03f5fc126a8230c894bd2c3df67803f..83a7e8dd250f2778de752068c0300597f828ca5f 100644
--- a/webkit/media/buffered_data_source_unittest.cc
+++ b/webkit/media/buffered_data_source_unittest.cc
@@ -21,7 +21,6 @@
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::AtLeast;
-using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
@@ -84,12 +83,12 @@ class MockBufferedResourceLoader : public BufferedResourceLoader {
                                0, 0, new media::MediaLog()) {
   }
 
-  MOCK_METHOD3(Start, void(net::OldCompletionCallback* read_callback,
+  MOCK_METHOD3(Start, void(const net::CompletionCallback& read_callback,
                            const base::Closure& network_callback,
                            WebFrame* frame));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD4(Read, void(int64 position, int read_size, uint8* buffer,
-                          net::OldCompletionCallback* callback));
+                          const net::CompletionCallback& callback));
   MOCK_METHOD0(content_length, int64());
   MOCK_METHOD0(instance_size, int64());
   MOCK_METHOD0(range_supported, bool());
@@ -124,7 +123,7 @@ class BufferedDataSourceTest : public testing::Test {
     EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
         .WillOnce(Return(loader_.get()));
 
-    EXPECT_CALL(*loader_, Start(NotNull(), _, NotNull()))
+    EXPECT_CALL(*loader_, Start(_, _, NotNull()))
         .WillOnce(
             DoAll(Assign(&error_, start_error),
                   Invoke(this,
@@ -173,11 +172,6 @@ class BufferedDataSourceTest : public testing::Test {
       }
     }
 
-    // Attach a static function that deletes the memory referred by the
-    // "callback" parameter.
-    ON_CALL(*loader_, Read(_, _, _ , _))
-        .WillByDefault(DeleteArg<3>());
-
     ON_CALL(*loader_, instance_size())
         .WillByDefault(Return(instance_size));
 
@@ -236,20 +230,18 @@ class BufferedDataSourceTest : public testing::Test {
   }
 
   void InvokeStartCallback(
-      net::OldCompletionCallback* callback,
+      const net::CompletionCallback& callback,
       const base::Closure& network_callback,

[scherkus (not reviewing), 2011/12/01 17:42:18]

net callback -> callback
closure -> net callback

nothing actionable here but I wonder if we can think of a better naming scheme
later

[Ami GONE FROM CHROMIUM, 2011/12/01 18:11:26]

Done.

       WebFrame* frame) {
-    callback->RunWithParams(Tuple1<int>(error_));
-    delete callback;
+    callback.Run(error_);
     // TODO(hclam): Save network_callback.
   }
 
   void InvokeReadCallback(int64 position, int size, uint8* buffer,
-                          net::OldCompletionCallback* callback) {
+                          const net::CompletionCallback& callback) {
     if (error_ > 0)
       memcpy(buffer, data_ + static_cast<int>(position), error_);
-    callback->RunWithParams(Tuple1<int>(error_));
-    delete callback;
+    callback.Run(error_);
   }
 
   void ReadDataSourceHit(int64 position, int size, int read_size) {
@@ -257,7 +249,7 @@ class BufferedDataSourceTest : public testing::Test {
 
     InSequence s;
     // Expect the read is delegated to the resource loader.
-    EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
+    EXPECT_CALL(*loader_, Read(position, size, NotNull(), _))
         .WillOnce(DoAll(Assign(&error_, read_size),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
@@ -280,7 +272,7 @@ class BufferedDataSourceTest : public testing::Test {
     EXPECT_TRUE(loader_);
 
     // Expect a call to read, but the call never returns.
-    EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()));
+    EXPECT_CALL(*loader_, Read(position, size, NotNull(), _));
     data_source_->Read(
         position, size, buffer_,
         base::Bind(&BufferedDataSourceTest::ReadCallback,
@@ -304,7 +296,7 @@ class BufferedDataSourceTest : public testing::Test {
     // 1. Reply with a cache miss for the read.
     {
       InSequence s;
-      EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
+      EXPECT_CALL(*loader_, Read(position, size, NotNull(), _))
           .WillOnce(DoAll(Assign(&error_, net::ERR_CACHE_MISS),
                           Invoke(this,
                                  &BufferedDataSourceTest::InvokeReadCallback)));
@@ -318,7 +310,7 @@ class BufferedDataSourceTest : public testing::Test {
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started.
-    EXPECT_CALL(*new_loader, Start(NotNull(), _, NotNull()))
+    EXPECT_CALL(*new_loader, Start(_, _, NotNull()))
         .WillOnce(DoAll(Assign(&error_, start_error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
@@ -328,7 +320,7 @@ class BufferedDataSourceTest : public testing::Test {
           .WillRepeatedly(Return(loader_->range_supported()));
 
       // 4a. Then again a read request is made to the new loader.
-      EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
+      EXPECT_CALL(*new_loader, Read(position, size, NotNull(), _))
           .WillOnce(DoAll(Assign(&error_, size),
                           Invoke(this,
                                  &BufferedDataSourceTest::InvokeReadCallback)));
@@ -357,7 +349,7 @@ class BufferedDataSourceTest : public testing::Test {
     EXPECT_TRUE(loader_);
 
     // 1. Expect the read is delegated to the resource loader.
-    EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
+    EXPECT_CALL(*loader_, Read(position, size, NotNull(), _))
         .WillOnce(DoAll(Assign(&error_, error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
@@ -381,7 +373,7 @@ class BufferedDataSourceTest : public testing::Test {
     NiceMock<MockBufferedResourceLoader>* new_loader =
         new NiceMock<MockBufferedResourceLoader>();
 
-    EXPECT_CALL(*new_loader, Start(NotNull(), _, NotNull()))
+    EXPECT_CALL(*new_loader, Start(_, _, NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
@@ -395,7 +387,7 @@ class BufferedDataSourceTest : public testing::Test {
       error = net::ERR_CACHE_MISS;
     }
 
-    EXPECT_CALL(*new_loader, Read(start, _, NotNull(), NotNull()))
+    EXPECT_CALL(*new_loader, Read(start, _, NotNull(), _))
         .WillOnce(DoAll(Assign(&error_, error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
@@ -412,7 +404,7 @@ class BufferedDataSourceTest : public testing::Test {
             this,
             &BufferedDataSourceTest::InvokeCacheMissCreateResourceLoader));
 
-    EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
+    EXPECT_CALL(*loader_, Read(position, size, NotNull(), _))
         .WillOnce(DoAll(Assign(&error_, net::ERR_CACHE_MISS),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
@@ -559,8 +551,7 @@ TEST_F(BufferedDataSourceTest, AbortDuringPendingRead) {
   // the message loop queue when Abort() is called.
   bool read_called = false;
   ON_CALL(*loader_, Read(_, _, _ , _))
-      .WillByDefault(DoAll(Assign(&read_called, true),
-                           DeleteArg<3>()));
+      .WillByDefault(Assign(&read_called, true));
 
   // Initiate a Read() on the data source, but don't allow the
   // message loop to run.