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

webkit/media/buffered_data_source_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 <algorithm>
 
 #include "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::AtLeast;
-using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;

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

sanity check: can we remove any more?

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

Done.

 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::NiceMock;
 using ::testing::WithArgs;
 
 using WebKit::WebFrame;
 using WebKit::WebString;
 using WebKit::WebURLError;
@@ skipping 37 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
 };
 
 class MockBufferedResourceLoader : public BufferedResourceLoader {
  public:
   MockBufferedResourceLoader()
       : BufferedResourceLoader(GURL(), 0, 0, kThresholdDefer,
                                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());
   MOCK_METHOD0(network_activity, bool());
   MOCK_METHOD0(url, const GURL&());
   MOCK_METHOD0(GetBufferedFirstBytePosition, int64());
   MOCK_METHOD0(GetBufferedLastBytePosition, int64());
 
  protected:
   ~MockBufferedResourceLoader() {}
@@ skipping 14 matching lines @@
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
   }
 
   void ExpectCreateAndStartResourceLoader(int start_error) {
     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,
                          &BufferedDataSourceTest::InvokeStartCallback)));
   }
 
   void InitializeDataSource(const char* url, int error,
                             bool partial_response, int64 instance_size,
                             NetworkState networkState) {
     // Saves the url first.
@@ skipping 28 matching lines @@
 
         // Create and start. Make sure Start() is called on the new loader.
         ExpectCreateAndStartResourceLoader(net::OK);
 
         // Update initialization variable since we know the second loader will
         // return OK.
         initialized_ok = true;
       }
     }
 
-    // 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));
 
     // range_supported() return true if we expect to get a partial response.
     ON_CALL(*loader_, range_supported())
         .WillByDefault(Return(partial_response));
 
     ON_CALL(*loader_, url())
         .WillByDefault(ReturnRef(gurl_));
     media::PipelineStatus expected_init_status = media::PIPELINE_OK;
@@ skipping 38 matching lines @@
     if (loader_) {
       InSequence s;
       EXPECT_CALL(*loader_, Stop());
     }
 
     data_source_->Stop(media::NewExpectedClosure());
     message_loop_->RunAllPending();
   }
 
   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) {
     EXPECT_TRUE(loader_);
 
     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)));
 
     // The read has succeeded, so read callback will be called.
     EXPECT_CALL(*this, ReadCallback(read_size));
 
     data_source_->Read(
         position, size, buffer_,
         base::Bind(&BufferedDataSourceTest::ReadCallback,
                    base::Unretained(this)));
     message_loop_->RunAllPending();
 
     // Make sure data is correct.
     EXPECT_EQ(0,
               memcmp(buffer_, data_ + static_cast<int>(position), read_size));
   }
 
   void ReadDataSourceHang(int64 position, int size) {
     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,
                    base::Unretained(this)));
     message_loop_->RunAllPending();
 
     // Now expect the read to return after aborting the data source.
     EXPECT_CALL(*this, ReadCallback(_));
     EXPECT_CALL(*loader_, Stop());
     data_source_->Abort();
     message_loop_->RunAllPending();
 
     // The loader has now been stopped. Set this to null so that when the
     // DataSource is stopped, it does not expect a call to stop the loader.
     loader_ = NULL;
   }
 
   void ReadDataSourceMiss(int64 position, int size, int start_error) {
     EXPECT_TRUE(loader_);
 
     // 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)));
       EXPECT_CALL(*loader_, Stop());
     }
 
     // 2. Then the current loader will be stop and destroyed.
     NiceMock<MockBufferedResourceLoader> *new_loader =
         new NiceMock<MockBufferedResourceLoader>();
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .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)));
 
     if (start_error == net::OK) {
       EXPECT_CALL(*new_loader, range_supported())
           .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)));
 
       EXPECT_CALL(*this, ReadCallback(size));
     } else {
       // 4b. The read callback is called with an error because Start() on the
       // new loader returned an error.
       EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
     }
 
     data_source_->Read(
         position, size, buffer_,
         base::Bind(&BufferedDataSourceTest::ReadCallback,
                    base::Unretained(this)));
     message_loop_->RunAllPending();
 
     // Make sure data is correct.
     if (start_error == net::OK)
       EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
 
     loader_ = new_loader;
   }
 
   void ReadDataSourceFailed(int64 position, int size, int error) {
     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)));
 
     // 2. Host will then receive an error.
     EXPECT_CALL(*loader_, Stop());
 
     // 3. The read has failed, so read callback will be called.
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
 
     data_source_->Read(
         position, size, buffer_,
         base::Bind(&BufferedDataSourceTest::ReadCallback,
                    base::Unretained(this)));
 
     message_loop_->RunAllPending();
   }
 
   BufferedResourceLoader* InvokeCacheMissCreateResourceLoader(int64 start,
                                                               int64 end) {
     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)));
 
     EXPECT_CALL(*new_loader, range_supported())
         .WillRepeatedly(Return(loader_->range_supported()));
 
     int error = net::ERR_FAILED;
     if (cache_miss_count_ < kMaxCacheMissesBeforeFailTest) {
       cache_miss_count_++;
       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)));
 
     loader_ = new_loader;
     return new_loader;
   }
 
   void ReadDataSourceAlwaysCacheMiss(int64 position, int size) {
     cache_miss_count_ = 0;
 
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillRepeatedly(Invoke(
             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)));
 
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
 
     data_source_->Read(
         position, size, buffer_,
         base::Bind(&BufferedDataSourceTest::ReadCallback,
                    base::Unretained(this)));
@@ skipping 126 matching lines @@
 }
 
 TEST_F(BufferedDataSourceTest, AbortDuringPendingRead) {
   InitializeDataSource(kFileUrl, net::OK, true, 1024, LOADED);
 
   // Setup a way to verify that Read() is not called on the loader.
   // We are doing this to make sure that the ReadTask() is still on
   // 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.
   data_source_->Read(
       0, 10, buffer_,
       base::Bind(&BufferedDataSourceTest::ReadCallback,
                  base::Unretained(static_cast<BufferedDataSourceTest*>(this))));
 
   // Call Abort() with the read pending.
   EXPECT_CALL(*this, ReadCallback(-1));
@@ skipping 209 matching lines @@
   message_loop_->RunAllPending();
 
   // Verify loader changed but still has same bitrate.
   EXPECT_NE(old_loader, data_source_->loader().get());
   EXPECT_EQ(2.0f, loader_playback_rate());
 
   StopDataSource();
 }
 
 }  // namespace webkit_media