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

webkit/appcache/appcache_response_unittest.cc

 // Copyright (c) 2010 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 <stack>
 #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"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/mock_appcache_service.h"
@@ skipping 90 matching lines @@
     should_delete_reader_in_completion_callback_ = false;
     should_delete_writer_in_completion_callback_ = false;
     reader_deletion_count_down_ = 0;
     writer_deletion_count_down_ = 0;
     read_callback_was_called_ = false;
     write_callback_was_called_ = false;
   }
 
   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();

[csilv, 2011/11/10 23:47:02]

(commentary: too bad std::stack doesn't have a clear() method)

-    }
+
     reader_.reset();
     read_buffer_ = NULL;
     read_info_buffer_ = NULL;
     writer_.reset();
     write_buffer_ = NULL;
     write_info_buffer_ = NULL;
     storage_delegate_.reset();
     service_.reset();
   }
 
   void TestFinished() {
     // 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() {
     TearDownTest();
     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() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     if (task_stack_.empty()) {
       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
 
   void WriteBasicResponse() {
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
     static const char* kHttpBody = "Hello";
     scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBody));
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
     WriteResponse(MakeHttpResponseInfo(raw_headers), body, strlen(kHttpBody));
   }
 
   int basic_response_size() { return 5; }  // should match kHttpBody above
 
   void WriteResponse(net::HttpResponseInfo* head,
                      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);
   }
 
   void WriteResponseHead(net::HttpResponseInfo* head) {
     EXPECT_FALSE(writer_->IsWritePending());
     expected_write_result_ = GetHttpResponseInfoSize(head);
     write_info_buffer_ = new HttpResponseInfoIOBuffer(head);
     writer_->WriteInfo(write_info_buffer_, &write_info_callback_);
   }
 
@@ skipping 103 matching lines @@
 
   // ReadNonExistentResponse -------------------------------------------
   void ReadNonExistentResponse() {
     // 1. Attempt to ReadInfo
     // 2. Attempt to ReadData
 
     reader_.reset(service_->storage()->CreateResponseReader(
         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();
   }
 
   void ReadNonExistentInfo() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_info_buffer_ = new HttpResponseInfoIOBuffer();
     reader_->ReadInfo(read_info_buffer_, &read_info_callback_);
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   void ReadNonExistentData() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
     reader_->ReadData(read_buffer_, kBlockSize, &read_callback_);
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   // 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());
   }
 
   void LoadResponseInfo_Miss_Verify() {
     EXPECT_EQ(kNoSuchResponseId, storage_delegate_->loaded_info_id_);
     EXPECT_TRUE(!storage_delegate_->loaded_info_.get());
     TestFinished();
   }
 
   // LoadResponseInfo_Hit ----------------------------------------------------
   void LoadResponseInfo_Hit() {
     // This tests involves multiple async steps.
     // 1. Write a response headers and body to storage
     //   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();
   }
 
   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());
   }
 
   void LoadResponseInfo_Hit_Verify() {
     EXPECT_EQ(written_response_id_, storage_delegate_->loaded_info_id_);
     EXPECT_TRUE(storage_delegate_->loaded_info_.get());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         storage_delegate_->loaded_info_->http_response_info()));
     EXPECT_EQ(basic_response_size(),
               storage_delegate_->loaded_info_->response_data_size());
     TestFinished();
   }
 
   // AmountWritten ----------------------------------------------------
 
   void AmountWritten() {
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0\0";
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
     net::HttpResponseInfo* head = MakeHttpResponseInfo(raw_headers);
     int expected_amount_written =
         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();
     ScheduleNextTask();
   }
 
   void Verify_AmountWritten(int expected_amount_written) {
     EXPECT_EQ(expected_amount_written, writer_->amount_written());
     TestFinished();
   }
 
 
   // WriteThenVariouslyReadResponse -------------------------------------------
 
   void WriteThenVariouslyReadResponse() {
     // This tests involves multiple async steps.
     // 1. First, write a large body using multiple writes, we don't bother
     //    with a response head for this test.
     // 2. Read the entire body, using multiple reads
     // 3. Read the entire body, using one read.
     // 4. Attempt to read beyond the EOF.
     // 5. Read just a range.
     // 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();
   }
 
   void WriteOutBlocks() {
     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();
   }
 
   void WriteOneBlock(int block_number) {
     scoped_refptr<IOBuffer> io_buffer(
         new IOBuffer(kBlockSize));
     FillData(block_number, io_buffer->data(), kBlockSize);
     WriteResponseBody(io_buffer, kBlockSize);
   }
 
   void ReadInBlocks() {
     writer_.reset();
     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);
   }
 
   void VerifyOneBlock(int block_number) {
     EXPECT_TRUE(CheckData(block_number, read_buffer_->data(), kBlockSize));
     ScheduleNextTask();
   }
 
   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;
     ReadResponseBody(new IOBuffer(big_size), big_size);
   }
 
   void VerifyAllAtOnce() {
     char* p = read_buffer_->data();
     for (int i = 0; i < kNumBlocks; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     ScheduleNextTask();
   }
 
   void ReadPastEOF() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
     expected_read_result_ = 0;
     reader_->ReadData(
         read_buffer_, kBlockSize, &read_callback_);
   }
 
   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);
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
 
   void VerifyRange() {
     EXPECT_TRUE(CheckData(2, read_buffer_->data(), kBlockSize));
     ScheduleNextTask();  // ReadPastEOF is scheduled next
   }
 
   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);
     ReadResponseBody(new IOBuffer(kNumBlocks * kBlockSize),
                      kNumBlocks * kBlockSize);
     expected_read_result_ = (kNumBlocks - 1) * kBlockSize;
   }
 
   void VerifyRangeBeyondEOF() {
     // Just verify the first 1k
     VerifyRange();
   }
 
   void ReadRangeFullyBeyondEOF() {
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     reader_->SetReadRange((kNumBlocks * kBlockSize) + 1, kBlockSize);
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     expected_read_result_ = 0;
   }
 
   // IOChaining -------------------------------------------
   void IOChaining() {
     // 1. Write several blocks out initiating the subsequent write
     //    from within the completion callback of the previous write.
     // 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();
   }
 
   void WriteOutBlocksImmediately() {
     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();
   }
 
   void ReadInBlocksImmediately() {
     writer_.reset();
     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);
   }
 
   // DeleteWithinCallbacks -------------------------------------------
   void DeleteWithinCallbacks() {
     // 1. Write out a few blocks normally, and upon
     //    completion of the last write, delete the writer.
     // 2. Read in a few blocks normally, and upon completion
     //    of the last read, delete the reader.
 
     should_delete_reader_in_completion_callback_ = true;
     reader_deletion_count_down_ = kNumBlocks;
     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();
   }
 
   // DeleteWithIOPending -------------------------------------------
   void DeleteWithIOPending() {
     // 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();
   }
 
   void WriteThenDelete() {
     write_callback_was_called_ = false;
     WriteOneBlock(5);
     EXPECT_TRUE(writer_->IsWritePending());
     writer_.reset();
     ScheduleNextTask();
   }
 
   void ReadThenDelete() {
     read_callback_was_called_ = false;
     reader_.reset(service_->storage()->CreateResponseReader(
         GURL(), 0, written_response_id_));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     EXPECT_TRUE(reader_->IsReadPending());
     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);
   }
 
   void VerifyNoCallbacks() {
     EXPECT_TRUE(!write_callback_was_called_);
     EXPECT_TRUE(!read_callback_was_called_);
     TestFinished();
   }
 
   // Data members
 
   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_;
   scoped_refptr<IOBuffer> read_buffer_;
   int expected_read_result_;
   net::OldCompletionCallbackImpl<AppCacheResponseTest> read_callback_;
   net::OldCompletionCallbackImpl<AppCacheResponseTest> read_info_callback_;
   bool should_delete_reader_in_completion_callback_;
   int reader_deletion_count_down_;
   bool read_callback_was_called_;
@@ skipping 41 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&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);