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

webkit/appcache/appcache_request_handler_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 <vector>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/message_loop.h"
+#include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.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"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_backend_impl.h"
 #include "webkit/appcache/appcache_request_handler.h"
@@ skipping 177 matching lines @@
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
     host_ = NULL;
   }
 
   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, &AppCacheRequestHandlerTest::TestFinishedUnwound));
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&AppCacheRequestHandlerTest::TestFinishedUnwound,
+                   base::Unretained(this)));
   }
 
   void TestFinishedUnwound() {
     TearDownTest();
     test_finished_event_->Signal();
   }
 
-  void PushNextTask(Task* task) {
+  void PushNextTask(const base::Closure& task) {
     task_stack_.push(task);
   }
 
   void ScheduleNextTask() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     if (task_stack_.empty()) {
       TestFinished();
       return;
     }
     MessageLoop::current()->PostTask(FROM_HERE, task_stack_.top());
     task_stack_.pop();
   }
 
   // MainResource_Miss --------------------------------------------------
 
   void MainResource_Miss() {
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheRequestHandlerTest::Verify_MainResource_Miss));
+    PushNextTask(
+        base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss,
+                   base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/")));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
@@ skipping 20 matching lines @@
     EXPECT_FALSE(fallback_job);
 
     EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
 
     TestFinished();
   }
 
   // MainResource_Hit --------------------------------------------------
 
   void MainResource_Hit() {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheRequestHandlerTest::Verify_MainResource_Hit));
+    PushNextTask(
+        base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Hit,
+                   base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/")));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
@@ skipping 23 matching lines @@
 
     EXPECT_EQ(GURL("http://blah/manifest/"),
               host_->preferred_manifest_url());
 
     TestFinished();
   }
 
   // MainResource_Fallback --------------------------------------------------
 
   void MainResource_Fallback() {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheRequestHandlerTest::Verify_MainResource_Fallback));
+    PushNextTask(
+        base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Fallback,
+                   base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/")));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
@@ skipping 34 matching lines @@
 
     EXPECT_EQ(GURL("http://blah/manifest/"),
               host_->preferred_manifest_url());
 
     TestFinished();
   }
 
   // MainResource_FallbackOverride --------------------------------------------
 
   void MainResource_FallbackOverride() {
-    PushNextTask(NewRunnableMethod(
-       this,
-       &AppCacheRequestHandlerTest::Verify_MainResource_FallbackOverride));
+    PushNextTask(base::Bind(
+        &AppCacheRequestHandlerTest::Verify_MainResource_FallbackOverride,
+        base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/fallback-override")));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
@@ skipping 349 matching lines @@
     handler_.reset(worker_host->CreateRequestHandler(
         request_.get(), ResourceType::SHARED_WORKER));
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
   }
 
   // MainResource_Blocked --------------------------------------------------
 
   void MainResource_Blocked() {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheRequestHandlerTest::Verify_MainResource_Blocked));
+    PushNextTask(
+        base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Blocked,
+                   base::Unretained(this)));
 
     request_.reset(new MockURLRequest(GURL("http://blah/")));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_policy_->can_load_return_value_ = false;
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
@@ skipping 34 matching lines @@
     return cache;
   }
 
   MockAppCacheStorage* mock_storage() {
     return reinterpret_cast<MockAppCacheStorage*>(mock_service_->storage());
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
-  std::stack<Task*> task_stack_;
+  std::stack<base::Closure> task_stack_;
   scoped_ptr<MockAppCacheService> mock_service_;
   scoped_ptr<AppCacheBackendImpl> backend_impl_;
   scoped_ptr<MockFrontend> mock_frontend_;
   scoped_ptr<MockAppCachePolicy> mock_policy_;
   AppCacheHost* host_;
   scoped_ptr<MockURLRequest> request_;
   scoped_ptr<AppCacheRequestHandler> handler_;
   scoped_refptr<AppCacheURLRequestJob> job_;
   net::URLRequest::ProtocolFactory* orig_http_factory_;
 
@@ skipping 73 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace appcache
-
-// AppCacheRequestHandlerTest is expected to always live longer than the
-// runnable methods.  This lets us call NewRunnableMethod on its instances.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheRequestHandlerTest);