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

webkit/appcache/appcache_url_request_job_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 <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/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_error_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 187 matching lines @@
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     net::URLRequest::Deprecated::RegisterProtocolFactory(
         "http", orig_http_factory_);
     orig_http_factory_ = NULL;
     request_.reset();
     url_request_delegate_.reset();
     DCHECK(!mock_factory_job_);
 
-    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;
     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, &AppCacheURLRequestJobTest::TestFinishedUnwound));
+        base::Bind(&AppCacheURLRequestJobTest::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() {
     scoped_refptr<IOBuffer> body(new WrappedIOBuffer(kHttpBasicBody));
     std::string raw_headers(kHttpBasicHeaders, arraysize(kHttpBasicHeaders));
     WriteResponse(MakeHttpResponseInfo(raw_headers), body,
                   strlen(kHttpBasicBody));
   }
 
   void WriteResponse(net::HttpResponseInfo* head,
                      IOBuffer* body, int body_len) {
     DCHECK(body);
     scoped_refptr<IOBuffer> body_ref(body);
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheURLRequestJobTest::WriteResponseBody,
-        body_ref, body_len));
+    PushNextTask(base::Bind(&AppCacheURLRequestJobTest::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 157 matching lines @@
     EXPECT_EQ(kEntry.types(), job->entry().types());
     EXPECT_EQ(kEntry.response_id(), job->entry().response_id());
 
     TestFinished();
   }
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse));
+    PushNextTask(
+        base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse,
+                   base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
         new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverNetworkResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_network_response());
@@ skipping 10 matching lines @@
   void VerifyDeliverNetworkResponse() {
     EXPECT_EQ(request_->status().error(),
               net::ERR_INTERNET_DISCONNECTED);
     TestFinished();
   }
 
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyDeliverErrorResponse));
+    PushNextTask(
+        base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverErrorResponse,
+                   base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
         new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverErrorResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_error_response());
@@ skipping 15 matching lines @@
   // DeliverSmallAppCachedResponse --------------------------------------
   // "Small" being small enough to read completely in a single
   // request->Read call.
 
   void DeliverSmallAppCachedResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyDeliverSmallAppCachedResponse));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::RequestAppCachedResource, false));
+    PushNextTask(base::Bind(
+        &AppCacheURLRequestJobTest::VerifyDeliverSmallAppCachedResponse,
+        base::Unretained(this)));
+    PushNextTask(
+        base::Bind(&AppCacheURLRequestJobTest::RequestAppCachedResource,
+                   base::Unretained(this), false));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
@@ skipping 44 matching lines @@
 
   // DeliverLargeAppCachedResponse --------------------------------------
   // "Large" enough to require multiple calls to request->Read to complete.
 
   void DeliverLargeAppCachedResponse() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyDeliverLargeAppCachedResponse));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::VerifyDeliverLargeAppCachedResponse,
+       base::Unretained(this)));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::RequestAppCachedResource,
+       base::Unretained(this), true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
     // Continues async
   }
 
   void WriteLargeResponse() {
     // 3, 1k blocks
     static const char kHttpHeaders[] =
@@ skipping 18 matching lines @@
     TestFinished();
   }
 
   // DeliverPartialResponse --------------------------------------
 
   void DeliverPartialResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
     // 2. Use net::URLRequest to retrieve it a subset using a range request
     // 3. Verify we received what we expected to receive.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyDeliverPartialResponse));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::MakeRangeRequest));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::VerifyDeliverPartialResponse,
+       base::Unretained(this)));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::MakeRangeRequest, base::Unretained(this)));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
         new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
@@ skipping 41 matching lines @@
   }
 
   // CancelRequest --------------------------------------
 
   void CancelRequest() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyCancel));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::VerifyCancel, base::Unretained(this)));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::RequestAppCachedResource,
+       base::Unretained(this), true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = false;
     // Continues async
   }
 
   void VerifyCancel() {
     EXPECT_EQ(net::URLRequestStatus::CANCELED,
               request_->status().status());
     TestFinished();
   }
 
   // CancelRequestWithIOPending --------------------------------------
 
   void CancelRequestWithIOPending() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::VerifyCancel));
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::VerifyCancel, base::Unretained(this)));
+    PushNextTask(base::Bind(
+       &AppCacheURLRequestJobTest::RequestAppCachedResource,
+       base::Unretained(this), true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = true;
     // Continues async
   }
 
 
   // 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<AppCacheURLRequestJobTest> read_callback_;
   net::OldCompletionCallbackImpl<AppCacheURLRequestJobTest> read_info_callback_;
   bool should_delete_reader_in_completion_callback_;
   int reader_deletion_count_down_;
   bool read_callback_was_called_;
@@ skipping 51 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace appcache
-
-// AppCacheURLRequestJobTest is expected to always live longer than the
-// runnable methods.  This lets us call NewRunnableMethod on its instances.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheURLRequestJobTest);