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

webkit/appcache/appcache_response_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 <stack>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 64 matching lines @@
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheResponseTest Thread"));
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
   static void TearDownTestCase() {
     io_thread_.reset(NULL);
   }
 
-  AppCacheResponseTest()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
-            this, &AppCacheResponseTest::OnReadComplete)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_(
-            this, &AppCacheResponseTest::OnReadInfoComplete)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(write_callback_(
-            this, &AppCacheResponseTest::OnWriteComplete)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(write_info_callback_(
-            this, &AppCacheResponseTest::OnWriteInfoComplete)) {
-  }
+  AppCacheResponseTest() {}
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
@@ skipping 83 matching lines @@
     scoped_refptr<IOBuffer> body_ref(body);
     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_);
+    writer_->WriteInfo(
+        write_info_buffer_,
+        base::Bind(&AppCacheResponseTest::OnWriteInfoComplete,
+                   base::Unretained(this)));
   }
 
   void WriteResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(writer_->IsWritePending());
     write_buffer_ = io_buffer;
     expected_write_result_ = buf_len;
     writer_->WriteData(
-        write_buffer_, buf_len, &write_callback_);
+        write_buffer_, buf_len,
+        base::Bind(&AppCacheResponseTest::OnWriteComplete,
+                   base::Unretained(this)));
   }
 
   void ReadResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = io_buffer;
     expected_read_result_ = buf_len;
     reader_->ReadData(
-        read_buffer_, buf_len, &read_callback_);
+        read_buffer_, buf_len,
+        base::Bind(&AppCacheResponseTest::OnReadComplete,
+                   base::Unretained(this)));
   }
 
   // AppCacheResponseReader / Writer completion callbacks
 
   void OnWriteInfoComplete(int result) {
     EXPECT_FALSE(writer_->IsWritePending());
     EXPECT_EQ(expected_write_result_, result);
     ScheduleNextTask();
   }
 
@@ skipping 89 matching lines @@
     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_);
+    reader_->ReadInfo(
+        read_info_buffer_,
+        base::Bind(&AppCacheResponseTest::OnReadInfoComplete,
+                   base::Unretained(this)));
     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_);
+    reader_->ReadData(
+        read_buffer_, kBlockSize,
+        base::Bind(&AppCacheResponseTest::OnReadComplete,
+                   base::Unretained(this)));
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   // LoadResponseInfo_Miss ----------------------------------------------------
   void LoadResponseInfo_Miss() {
     PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Miss_Verify,
                             base::Unretained(this)));
     service_->storage()->LoadResponseInfo(GURL(), 0, kNoSuchResponseId,
                                           storage_delegate_.get());
@@ skipping 156 matching lines @@
     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_);
+        read_buffer_, kBlockSize,
+        base::Bind(&AppCacheResponseTest::OnReadComplete,
+                   base::Unretained(this)));
   }
 
   void ReadRange() {
     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);
   }
@@ skipping 141 matching lines @@
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   scoped_ptr<MockStorageDelegate> storage_delegate_;
   scoped_ptr<MockAppCacheService> service_;
   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_;
 
   int64 written_response_id_;
   scoped_ptr<AppCacheResponseWriter> writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
-  net::OldCompletionCallbackImpl<AppCacheResponseTest> write_callback_;
-  net::OldCompletionCallbackImpl<AppCacheResponseTest> write_info_callback_;
   bool should_delete_writer_in_completion_callback_;
   int writer_deletion_count_down_;
   bool write_callback_was_called_;
 
   static scoped_ptr<base::Thread> io_thread_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheResponseTest::io_thread_;
 
@@ skipping 23 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace appcache