base::Bind: Convert most of webkit/appcache.

webkit/appcache/appcache_response_unittest.cc

Index: webkit/appcache/appcache_response_unittest.cc
diff --git a/webkit/appcache/appcache_response_unittest.cc b/webkit/appcache/appcache_response_unittest.cc
index ae75a4bf9ab63a703c9b1654da0618a83acd179f..d1dc8f187dc0ade97944445e2d18c915c8b2eaf1 100644
--- a/webkit/appcache/appcache_response_unittest.cc
+++ b/webkit/appcache/appcache_response_unittest.cc
@@ -6,6 +6,9 @@
 #include <string>
 #include <utility>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
@@ -116,10 +119,9 @@ class AppCacheResponseTest : public testing::Test {
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
-    while (!task_stack_.empty()) {
-      delete task_stack_.top().first;
+    while (!task_stack_.empty())
       task_stack_.pop();
-    }
+
     reader_.reset();
     read_buffer_ = NULL;
     read_info_buffer_ = NULL;
@@ -134,8 +136,9 @@ class AppCacheResponseTest : public testing::Test {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
-    MessageLoop::current()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &AppCacheResponseTest::TestFinishedUnwound));
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&AppCacheResponseTest::TestFinishedUnwound,
+                              base::Unretained(this)));
   }
 
   void TestFinishedUnwound() {
@@ -143,12 +146,12 @@ class AppCacheResponseTest : public testing::Test {
     test_finished_event_->Signal();
   }
 
-  void PushNextTask(Task* task) {
-    task_stack_.push(std::pair<Task*, bool>(task, false));
+  void PushNextTask(const base::Closure& task) {
+    task_stack_.push(std::pair<base::Closure, bool>(task, false));
   }
 
-  void PushNextTaskAsImmediate(Task* task) {
-    task_stack_.push(std::pair<Task*, bool>(task, true));
+  void PushNextTaskAsImmediate(const base::Closure& task) {
+    task_stack_.push(std::pair<base::Closure, bool>(task, true));
   }
 
   void ScheduleNextTask() {
@@ -157,13 +160,13 @@ class AppCacheResponseTest : public testing::Test {
       TestFinished();
       return;
     }
-    scoped_ptr<Task> task(task_stack_.top().first);
+    base::Closure task = task_stack_.top().first;
     bool immediate = task_stack_.top().second;
     task_stack_.pop();
     if (immediate)
-      task->Run();
+      task.Run();
     else
-      MessageLoop::current()->PostTask(FROM_HERE, task.release());
+      MessageLoop::current()->PostTask(FROM_HERE, task);
   }
 
   // Wrappers to call AppCacheResponseReader/Writer Read and Write methods
@@ -183,9 +186,8 @@ class AppCacheResponseTest : public testing::Test {
                      IOBuffer* body, int body_len) {
     DCHECK(body);
     scoped_refptr<IOBuffer> body_ref(body);
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::WriteResponseBody,
-        body_ref, body_len));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteResponseBody,
+                            base::Unretained(this), body_ref, body_len));
     WriteResponseHead(head);
   }
 
@@ -309,10 +311,10 @@ class AppCacheResponseTest : public testing::Test {
         GURL(), 0, kNoSuchResponseId));
 
     // Push tasks in reverse order
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadNonExistentData));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadNonExistentInfo));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentData,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentInfo,
+                            base::Unretained(this)));
     ScheduleNextTask();
   }
 
@@ -334,8 +336,8 @@ class AppCacheResponseTest : public testing::Test {
 
   // LoadResponseInfo_Miss ----------------------------------------------------
   void LoadResponseInfo_Miss() {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::LoadResponseInfo_Miss_Verify));
+    PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Miss_Verify,
+                            base::Unretained(this)));
     service_->storage()->LoadResponseInfo(GURL(), 0, kNoSuchResponseId,
                                           storage_delegate_.get());
   }
@@ -353,8 +355,8 @@ class AppCacheResponseTest : public testing::Test {
     //   a. headers
     //   b. body
     // 2. Use LoadResponseInfo to read the response headers back out
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::LoadResponseInfo_Hit_Step2));
+    PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Hit_Step2,
+                            base::Unretained(this)));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
@@ -362,8 +364,8 @@ class AppCacheResponseTest : public testing::Test {
 
   void LoadResponseInfo_Hit_Step2() {
     writer_.reset();
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::LoadResponseInfo_Hit_Verify));
+    PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Hit_Verify,
+                            base::Unretained(this)));
     service_->storage()->LoadResponseInfo(GURL(), 0, written_response_id_,
                                           storage_delegate_.get());
   }
@@ -390,15 +392,14 @@ class AppCacheResponseTest : public testing::Test {
         GetHttpResponseInfoSize(head) + kNumBlocks * kBlockSize;
 
     // Push tasks in reverse order.
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::Verify_AmountWritten,
-        expected_amount_written));
+    PushNextTask(base::Bind(&AppCacheResponseTest::Verify_AmountWritten,
+                            base::Unretained(this), expected_amount_written));
     for (int i = 0; i < kNumBlocks; ++i) {
-      PushNextTask(NewRunnableMethod(
-          this, &AppCacheResponseTest::WriteOneBlock, kNumBlocks - i));
+      PushNextTask(base::Bind(&AppCacheResponseTest::WriteOneBlock,
+                              base::Unretained(this), kNumBlocks - i));
     }
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::WriteResponseHead, head));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteResponseHead,
+                            base::Unretained(this), head));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
@@ -424,22 +425,22 @@ class AppCacheResponseTest : public testing::Test {
     // 6. Attempt to read beyond EOF of a range.
 
     // Push tasks in reverse order
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadRangeFullyBeyondEOF));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadRangePartiallyBeyondEOF));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadPastEOF));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadRange));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadPastEOF));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadAllAtOnce));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadInBlocks));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::WriteOutBlocks));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadRangeFullyBeyondEOF,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadRangePartiallyBeyondEOF,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadPastEOF,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadRange,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadPastEOF,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadAllAtOnce,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadInBlocks,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteOutBlocks,
+                            base::Unretained(this)));
 
     // Get them going.
     ScheduleNextTask();
@@ -449,8 +450,8 @@ class AppCacheResponseTest : public testing::Test {
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
-      PushNextTask(NewRunnableMethod(
-          this, &AppCacheResponseTest::WriteOneBlock, kNumBlocks - i));
+      PushNextTask(base::Bind(&AppCacheResponseTest::WriteOneBlock,
+                              base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
@@ -467,15 +468,15 @@ class AppCacheResponseTest : public testing::Test {
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
-      PushNextTask(NewRunnableMethod(
-          this, &AppCacheResponseTest::ReadOneBlock, kNumBlocks - i));
+      PushNextTask(base::Bind(&AppCacheResponseTest::ReadOneBlock,
+                              base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlock(int block_number) {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::VerifyOneBlock, block_number));
+    PushNextTask(base::Bind(&AppCacheResponseTest::VerifyOneBlock,
+                            base::Unretained(this), block_number));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
 
@@ -485,8 +486,8 @@ class AppCacheResponseTest : public testing::Test {
   }
 
   void ReadAllAtOnce() {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::VerifyAllAtOnce));
+    PushNextTask(base::Bind(&AppCacheResponseTest::VerifyAllAtOnce,
+                            base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     int big_size = kNumBlocks * kBlockSize;
@@ -509,8 +510,8 @@ class AppCacheResponseTest : public testing::Test {
   }
 
   void ReadRange() {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::VerifyRange));
+    PushNextTask(base::Bind(&AppCacheResponseTest::VerifyRange,
+                            base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     reader_->SetReadRange(kBlockSize, kBlockSize);
@@ -523,8 +524,8 @@ class AppCacheResponseTest : public testing::Test {
   }
 
   void ReadRangePartiallyBeyondEOF() {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheResponseTest::VerifyRangeBeyondEOF));
+    PushNextTask(base::Bind(&AppCacheResponseTest::VerifyRangeBeyondEOF,
+                            base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     reader_->SetReadRange(kBlockSize, kNumBlocks * kBlockSize);
@@ -553,10 +554,12 @@ class AppCacheResponseTest : public testing::Test {
     // 2. Read and verify several blocks in similarly chaining reads.
 
     // Push tasks in reverse order
-    PushNextTaskAsImmediate(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadInBlocksImmediately));
-    PushNextTaskAsImmediate(NewRunnableMethod(
-       this, &AppCacheResponseTest::WriteOutBlocksImmediately));
+    PushNextTaskAsImmediate(
+        base::Bind(&AppCacheResponseTest::ReadInBlocksImmediately,
+                   base::Unretained(this)));
+    PushNextTaskAsImmediate(
+        base::Bind(&AppCacheResponseTest::WriteOutBlocksImmediately,
+                   base::Unretained(this)));
 
     // Get them going.
     ScheduleNextTask();
@@ -566,8 +569,9 @@ class AppCacheResponseTest : public testing::Test {
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
-      PushNextTaskAsImmediate(NewRunnableMethod(
-          this, &AppCacheResponseTest::WriteOneBlock, kNumBlocks - i));
+      PushNextTaskAsImmediate(
+          base::Bind(&AppCacheResponseTest::WriteOneBlock,
+                     base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
@@ -577,16 +581,17 @@ class AppCacheResponseTest : public testing::Test {
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
-      PushNextTaskAsImmediate(NewRunnableMethod(
-          this, &AppCacheResponseTest::ReadOneBlockImmediately,
+      PushNextTaskAsImmediate(
+          base::Bind(&AppCacheResponseTest::ReadOneBlockImmediately,
+                     base::Unretained(this),
           kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlockImmediately(int block_number) {
-    PushNextTaskAsImmediate(NewRunnableMethod(
-        this, &AppCacheResponseTest::VerifyOneBlock, block_number));
+    PushNextTaskAsImmediate(base::Bind(&AppCacheResponseTest::VerifyOneBlock,
+                                       base::Unretained(this), block_number));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
 
@@ -602,10 +607,10 @@ class AppCacheResponseTest : public testing::Test {
     should_delete_writer_in_completion_callback_ = true;
     writer_deletion_count_down_ = kNumBlocks;
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadInBlocks));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::WriteOutBlocks));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadInBlocks,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteOutBlocks,
+                            base::Unretained(this)));
     ScheduleNextTask();
   }
 
@@ -614,12 +619,12 @@ class AppCacheResponseTest : public testing::Test {
     // 1. Write a few blocks normally.
     // 2. Start a write, delete with it pending.
     // 3. Start a read, delete with it pending.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::ReadThenDelete));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::WriteThenDelete));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheResponseTest::WriteOutBlocks));
+    PushNextTask(base::Bind(&AppCacheResponseTest::ReadThenDelete,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteThenDelete,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::WriteOutBlocks,
+                            base::Unretained(this)));
     ScheduleNextTask();
   }
 
@@ -640,8 +645,9 @@ class AppCacheResponseTest : public testing::Test {
     reader_.reset();
 
     // Wait a moment to verify no callbacks.
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        NewRunnableMethod(this, &AppCacheResponseTest::VerifyNoCallbacks),
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, base::Bind(&AppCacheResponseTest::VerifyNoCallbacks,
+                              base::Unretained(this)),
         10);
   }
 
@@ -656,7 +662,7 @@ class AppCacheResponseTest : public testing::Test {
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   scoped_ptr<MockStorageDelegate> storage_delegate_;
   scoped_ptr<MockAppCacheService> service_;
-  std::stack<std::pair<Task*, bool> > task_stack_;
+  std::stack<std::pair<base::Closure, bool> > task_stack_;
 
   scoped_ptr<AppCacheResponseReader> reader_;
   scoped_refptr<HttpResponseInfoIOBuffer> read_info_buffer_;
@@ -718,7 +724,3 @@ TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
 }
 
 }  // namespace appcache
-
-// AppCacheResponseTest is expected to always live longer than the
-// runnable methods.  This lets us call NewRunnableMethod on its instances.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheResponseTest);