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

webkit/appcache/appcache_storage_impl_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 "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_service.h"
@@ skipping 114 matching lines @@
                      db_thread->message_loop_proxy(),
                      NULL),
         async_(false) {}
 
     virtual void GetUsageAndQuota(
         const GURL& origin, quota::StorageType type,
         const GetUsageAndQuotaCallback& callback) OVERRIDE {
       EXPECT_EQ(kOrigin, origin);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       if (async_) {
-        MessageLoop::current()->PostTask(FROM_HERE,
-            NewRunnableMethod(this, &MockQuotaManager::CallCallback,
-                              callback));
+        MessageLoop::current()->PostTask(
+            FROM_HERE, base::Bind(&MockQuotaManager::CallCallback,
+                                  base::Unretained(this), callback));
         return;
       }
       CallCallback(callback);
     }
 
     void CallCallback(const GetUsageAndQuotaCallback& callback) {
       callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
     }
 
     bool async_;
@@ skipping 53 matching lines @@
 
     virtual void Run() OVERRIDE {
       test_->SetUpTest();
 
       // Ensure InitTask execution prior to conducting a test.
       test_->FlushDbThreadTasks();
 
       // We also have to wait for InitTask completion call to be performed
       // on the IO thread prior to running the test. Its guaranteed to be
       // queued by this time.
-      MessageLoop::current()->PostTask(FROM_HERE,
-          NewRunnableFunction(&RunMethod, test_, method_));
+      MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(&RunMethod, test_, method_));
     }
 
     static void RunMethod(AppCacheStorageImplTest* test, Method method) {
       (test->*method)();
     }
 
    private:
     AppCacheStorageImplTest* test_;
     Method method_;
   };
@@ skipping 44 matching lines @@
     mock_quota_manager_proxy_ = NULL;
     delegate_.reset();
     service_.reset();
     FlushDbThreadTasks();
   }
 
   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, &AppCacheStorageImplTest::TestFinishedUnwound));
+    MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&AppCacheStorageImplTest::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()) {
       return;
     }
     MessageLoop::current()->PostTask(FROM_HERE, task_stack_.top());
     task_stack_.pop();
   }
 
   static void SignalEvent(base::WaitableEvent* event) {
     event->Signal();
   }
 
   void FlushDbThreadTasks() {
     // We pump a task thru the db thread to ensure any tasks previously
     // scheduled on that thread have been performed prior to return.
     base::WaitableEvent event(false, false);
-    db_thread->message_loop()->PostTask(FROM_HERE,
-        NewRunnableFunction(&AppCacheStorageImplTest::SignalEvent,
-                            &event));
+    db_thread->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&AppCacheStorageImplTest::SignalEvent, &event));
     event.Wait();
   }
 
   // LoadCache_Miss ----------------------------------------------------
 
   void LoadCache_Miss() {
     // Attempt to load a cache that doesn't exist. Should
-    // complete asyncly.
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheStorageImplTest::Verify_LoadCache_Miss));
+    // complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Miss,
+                            base::Unretained(this)));
 
     storage()->LoadCache(111, delegate());
     EXPECT_NE(111, delegate()->loaded_cache_id_);
   }
 
   void Verify_LoadCache_Miss() {
     EXPECT_EQ(111, delegate()->loaded_cache_id_);
     EXPECT_FALSE(delegate()->loaded_cache_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
@@ skipping 29 matching lines @@
 
     // Since the origin has no groups, the storage class will respond
     // syncly.
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
     Verify_CreateGroup();
   }
 
   void CreateGroupInPopulatedOrigin() {
     // Attempt to load a group that doesn't exist, one should
     // be created for us, but not stored.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_CreateGroup));
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_CreateGroup,
+                            base::Unretained(this)));
 
     // Since the origin has groups, storage class will have to
     // consult the database and completion will be async.
     storage()->usage_map_[kOrigin] = kDefaultEntrySize;
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
     EXPECT_FALSE(delegate()->loaded_group_.get());
   }
 
   void Verify_CreateGroup() {
@@ skipping 11 matching lines @@
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 
     TestFinished();
   }
 
   // LoadGroupAndCache_FarHit  --------------------------------------
 
   void LoadGroupAndCache_FarHit() {
     // Attempt to load a cache that is not currently in use
     // and does require loading from disk. This
-    // load should complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_LoadCache_Far_Hit));
+    // load should complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadCache_Far_Hit,
+                            base::Unretained(this)));
 
     // Setup some preconditions. Create a group and newest cache that
     // appear to be "stored" and "not currently in use".
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     group_ = NULL;
     cache_ = NULL;
 
     // Conduct the cache load test, completes async
     storage()->LoadCache(1, delegate());
   }
 
   void Verify_LoadCache_Far_Hit() {
     EXPECT_TRUE(delegate()->loaded_cache_);
     EXPECT_TRUE(delegate()->loaded_cache_->HasOneRef());
     EXPECT_EQ(1, delegate()->loaded_cache_id_);
 
     // The group should also have been loaded.
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group());
     EXPECT_TRUE(delegate()->loaded_cache_->owning_group()->HasOneRef());
     EXPECT_EQ(1, delegate()->loaded_cache_->owning_group()->group_id());
 
     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 
     // Drop things from the working set.
     delegate()->loaded_cache_ = NULL;
     EXPECT_FALSE(delegate()->loaded_group_);
 
-    // Conduct the group load test, also complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit));
+    // Conduct the group load test, also complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_LoadGroup_Far_Hit,
+                            base::Unretained(this)));
 
     storage()->LoadOrCreateGroup(kManifestUrl, delegate());
   }
 
   void Verify_LoadGroup_Far_Hit() {
     EXPECT_TRUE(delegate()->loaded_group_);
     EXPECT_EQ(kManifestUrl, delegate()->loaded_manifest_url_);
     EXPECT_TRUE(delegate()->loaded_group_->newest_complete_cache());
     delegate()->loaded_groups_newest_cache_ = NULL;
     EXPECT_TRUE(delegate()->loaded_group_->HasOneRef());
     EXPECT_EQ(2, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
     TestFinished();
   }
 
   // StoreNewGroup  --------------------------------------
 
   void StoreNewGroup() {
-    // Store a group and its newest cache. Should complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_StoreNewGroup));
+    // Store a group and its newest cache. Should complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreNewGroup,
+                            base::Unretained(this)));
 
     // Setup some preconditions. Create a group and newest cache that
     // appear to be "unstored".
     group_ = new AppCacheGroup(
         service(), kManifestUrl, storage()->NewGroupId());
     cache_ = new AppCache(service(), storage()->NewCacheId());
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1,
                                               kDefaultEntrySize));
     // Hold a ref to the cache simulate the UpdateJob holding that ref,
     // and hold a ref to the group to simulate the CacheHost holding that ref.
 
-    // Have the quota manager retrun asyncly for this test.
+    // Have the quota manager retrun asynchronously for this test.
     mock_quota_manager_proxy_->mock_manager_->async_ = true;
 
     // Conduct the store test.
     storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreNewGroup() {
     EXPECT_TRUE(delegate()->stored_group_success_);
     EXPECT_EQ(group_.get(), delegate()->stored_group_.get());
@@ skipping 11 matching lines @@
     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
     EXPECT_EQ(kDefaultEntrySize, mock_quota_manager_proxy_->last_delta_);
 
     TestFinished();
   }
 
   // StoreExistingGroup  --------------------------------------
 
   void StoreExistingGroup() {
-    // Store a group and its newest cache. Should complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_StoreExistingGroup));
+    // Store a group and its newest cache. Should complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_StoreExistingGroup,
+                            base::Unretained(this)));
 
     // Setup some preconditions. Create a group and old complete cache
     // that appear to be "stored"
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // And a newest unstored complete cache.
     cache2_ = new AppCache(service(), 2);
     cache2_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1,
                                                kDefaultEntrySize + 100));
@@ skipping 37 matching lines @@
     // Setup some preconditions. Create a group and old complete cache
     // that appear to be "stored"
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // Change the cache.
     base::Time now = base::Time::Now();
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::MASTER, 1, 100));
     cache_->set_update_time(now);
 
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
-       now));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_StoreExistingGroupExistingCache,
+        base::Unretained(this), now));
 
     // Conduct the test.
     EXPECT_EQ(cache_, group_->newest_complete_cache());
     storage()->StoreGroupAndNewestCache(group_, cache_, delegate());
     EXPECT_FALSE(delegate()->stored_group_success_);
   }
 
   void Verify_StoreExistingGroupExistingCache(
       base::Time expected_update_time) {
     EXPECT_TRUE(delegate()->stored_group_success_);
@@ skipping 23 matching lines @@
     EXPECT_EQ(1, mock_quota_manager_proxy_->notify_storage_modified_count_);
     EXPECT_EQ(kOrigin, mock_quota_manager_proxy_->last_origin_);
     EXPECT_EQ(100, mock_quota_manager_proxy_->last_delta_);
 
     TestFinished();
   }
 
   // FailStoreGroup  --------------------------------------
 
   void FailStoreGroup() {
-    // Store a group and its newest cache. Should complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_FailStoreGroup));
+    // Store a group and its newest cache. Should complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FailStoreGroup,
+                            base::Unretained(this)));
 
     // Setup some preconditions. Create a group and newest cache that
     // appear to be "unstored" and big enough to exceed the 5M limit.
     const int64 kTooBig = 10 * 1024 * 1024;  // 10M
     group_ = new AppCacheGroup(
         service(), kManifestUrl, storage()->NewGroupId());
     cache_ = new AppCache(service(), storage()->NewCacheId());
     cache_->AddEntry(kManifestUrl,
                      AppCacheEntry(AppCacheEntry::MANIFEST, 1, kTooBig));
     // Hold a ref to the cache simulate the UpdateJob holding that ref,
@@ skipping 16 matching lines @@
 
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_accessed_count_);
     EXPECT_EQ(0, mock_quota_manager_proxy_->notify_storage_modified_count_);
 
     TestFinished();
   }
 
   // MakeGroupObsolete  -------------------------------
 
   void MakeGroupObsolete() {
-    // Make a group obsolete, should complete asyncly.
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_MakeGroupObsolete));
+    // Make a group obsolete, should complete asynchronously.
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_MakeGroupObsolete,
+                            base::Unretained(this)));
 
     // Setup some preconditions. Create a group and newest cache that
     // appears to be "stored" and "currently in use".
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     EXPECT_EQ(kDefaultEntrySize, storage()->usage_map_[kOrigin]);
 
     // Also insert some related records.
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.flags = AppCacheEntry::FALLBACK;
@@ skipping 67 matching lines @@
     EXPECT_FALSE(cache_->GetEntry(kEntryUrl)->IsForeign());
 
     // Conduct the test.
     storage()->MarkEntryAsForeign(kEntryUrl, 1);
 
     // The entry in the working set should have been updated syncly.
     EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsForeign());
     EXPECT_TRUE(cache_->GetEntry(kEntryUrl)->IsExplicit());
 
     // And the entry in storage should also be updated, but that
-    // happens asyncly on the db thread.
+    // happens asynchronously on the db thread.
     FlushDbThreadTasks();
     AppCacheDatabase::EntryRecord entry_record2;
     EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record2));
     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
               entry_record2.flags);
     TestFinished();
   }
 
   // MarkEntryAsForeignWithLoadInProgress  -------------------------------
 
   void MarkEntryAsForeignWithLoadInProgress() {
-    PushNextTask(NewRunnableMethod(this,
-       &AppCacheStorageImplTest::Verify_MarkEntryAsForeignWithLoadInProgress));
+    PushNextTask(base::Bind(
+       &AppCacheStorageImplTest::Verify_MarkEntryAsForeignWithLoadInProgress,
+       base::Unretained(this)));
 
     // Setup some preconditions. Create a cache with an entry
     // in storage, but not in the working set.
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT));
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.url = kEntryUrl;
     entry_record.flags = AppCacheEntry::EXPLICIT;
     entry_record.response_id = 0;
@@ skipping 22 matching lines @@
     AppCacheDatabase::EntryRecord entry_record;
     EXPECT_TRUE(database()->FindEntry(1, kEntryUrl, &entry_record));
     EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
               entry_record.flags);
     TestFinished();
   }
 
   // FindNoMainResponse  -------------------------------
 
   void FindNoMainResponse() {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_FindNoMainResponse));
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_FindNoMainResponse,
+                            base::Unretained(this)));
 
     // Conduct the test.
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindNoMainResponse() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
     TestFinished();
   }
 
   // BasicFindMainResponse  -------------------------------
 
   void BasicFindMainResponseInDatabase() {
     BasicFindMainResponse(true);
   }
 
   void BasicFindMainResponseInWorkingSet() {
     BasicFindMainResponse(false);
   }
 
   void BasicFindMainResponse(bool drop_from_working_set) {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_BasicFindMainResponse));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_BasicFindMainResponse,
+        base::Unretained(this)));
 
     // Setup some preconditions. Create a complete cache with an entry
     // in storage.
     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1));
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.url = kEntryUrl;
     entry_record.flags = AppCacheEntry::EXPLICIT;
     entry_record.response_id = 1;
@@ skipping 27 matching lines @@
 
   void BasicFindMainFallbackResponseInDatabase() {
     BasicFindMainFallbackResponse(true);
   }
 
   void BasicFindMainFallbackResponseInWorkingSet() {
     BasicFindMainFallbackResponse(false);
   }
 
   void BasicFindMainFallbackResponse(bool drop_from_working_set) {
-    PushNextTask(NewRunnableMethod(
-       this, &AppCacheStorageImplTest::Verify_BasicFindMainFallbackResponse));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_BasicFindMainFallbackResponse,
+        base::Unretained(this)));
 
     // Setup some preconditions. Create a complete cache with a
     // fallback namespace and entry.
     MakeCacheAndGroup(kManifestUrl, 2, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::FALLBACK, 1));
     cache_->AddEntry(kEntryUrl2, AppCacheEntry(AppCacheEntry::FALLBACK, 2));
     cache_->fallback_namespaces_.push_back(
         FallbackNamespace(kFallbackNamespace2, kEntryUrl2));
     cache_->fallback_namespaces_.push_back(
         FallbackNamespace(kFallbackNamespace, kEntryUrl));
@@ skipping 36 matching lines @@
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(2, delegate()->found_fallback_entry_.response_id());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     TestFinished();
   }
 
   // FindMainResponseWithMultipleHits  -------------------------------
 
   void FindMainResponseWithMultipleHits() {
-    PushNextTask(NewRunnableMethod(this,
-        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits,
+        base::Unretained(this)));
 
     // Setup some preconditions, create a few caches with an identical set
     // of entries and fallback namespaces. Only the last one remains in
     // the working set to simulate appearing as "in use".
     MakeMultipleHitCacheAndGroup(kManifestUrl, 1);
     MakeMultipleHitCacheAndGroup(kManifestUrl2, 2);
     MakeMultipleHitCacheAndGroup(kManifestUrl3, 3);
 
     // Conduct the test, we should find the response from the last cache
     // since it's "in use".
@@ skipping 49 matching lines @@
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
     EXPECT_EQ(3, delegate()->found_cache_id_);
     EXPECT_EQ(3, delegate()->found_group_id_);
     EXPECT_EQ(3, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct another test perferring kManifestUrl
     delegate_.reset(new MockStorageDelegate(this));
-    PushNextTask(NewRunnableMethod(this,
-        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2,
+        base::Unretained(this)));
     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl, delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits2() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
     EXPECT_EQ(1, delegate()->found_cache_id_);
     EXPECT_EQ(1, delegate()->found_group_id_);
     EXPECT_EQ(1, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct the another test perferring kManifestUrl2
     delegate_.reset(new MockStorageDelegate(this));
-    PushNextTask(NewRunnableMethod(this,
-        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3,
+        base::Unretained(this)));
     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl2, delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits3() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_group_id_);
     EXPECT_EQ(2, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct another test with no preferred manifest that hits the fallback.
     delegate_.reset(new MockStorageDelegate(this));
-    PushNextTask(NewRunnableMethod(this,
-        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4,
+        base::Unretained(this)));
     storage()->FindResponseForMainRequest(
         kFallbackTestUrl, GURL(), delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits4() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
     EXPECT_EQ(3, delegate()->found_cache_id_);
     EXPECT_EQ(3, delegate()->found_group_id_);
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(3 + kFallbackEntryIdOffset,
               delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
 
     // Conduct another test preferring kManifestUrl2 that hits the fallback.
     delegate_.reset(new MockStorageDelegate(this));
-    PushNextTask(NewRunnableMethod(this,
-        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5));
+    PushNextTask(base::Bind(
+        &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5,
+        base::Unretained(this)));
     storage()->FindResponseForMainRequest(
         kFallbackTestUrl, kManifestUrl2, delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits5() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_group_id_);
@@ skipping 50 matching lines @@
         database()->InsertFallbackNameSpace(&fallback_namespace_record));
     whitelist_record.cache_id = 1;
     whitelist_record.namespace_url = kOnlineNamespaceWithinFallback;
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&whitelist_record));
     if (drop_from_working_set) {
       cache_ = NULL;
       group_ = NULL;
     }
 
     // We should not find anything for the foreign entry.
-    PushNextTask(NewRunnableMethod(
-        this, &AppCacheStorageImplTest::Verify_ExclusionNotFound,
-        kEntryUrl, 1));
+    PushNextTask(base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
+                            base::Unretained(this), kEntryUrl, 1));
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
   }
 
   void Verify_ExclusionNotFound(GURL expected_url, int phase) {
     EXPECT_EQ(expected_url, delegate()->found_url_);
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(0, delegate()->found_group_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
 
     if (phase == 1) {
       // We should not find anything for the online namespace.
-      PushNextTask(NewRunnableMethod(this,
-          &AppCacheStorageImplTest::Verify_ExclusionNotFound,
-          kOnlineNamespace, 2));
+      PushNextTask(
+          base::Bind(&AppCacheStorageImplTest::Verify_ExclusionNotFound,
+                     base::Unretained(this), kOnlineNamespace, 2));
       storage()->FindResponseForMainRequest(
           kOnlineNamespace, GURL(), delegate());
       return;
     }
     if (phase == 2) {
       // We should not find anything for the online namespace nested within
       // the fallback namespace.
-      PushNextTask(NewRunnableMethod(this,
+      PushNextTask(base::Bind(
           &AppCacheStorageImplTest::Verify_ExclusionNotFound,
-          kOnlineNamespaceWithinFallback, 3));
+          base::Unretained(this), kOnlineNamespaceWithinFallback, 3));
       storage()->FindResponseForMainRequest(
           kOnlineNamespaceWithinFallback, GURL(), delegate());
       return;
     }
 
     TestFinished();
   }
 
   // Test case helpers --------------------------------------------------
 
@@ skipping 46 matching lines @@
       EXPECT_TRUE(database()->InsertEntry(&entry_record));
 
       storage()->usage_map_[manifest_url.GetOrigin()] =
           default_entry.response_size();
     }
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
-  std::stack<Task*> task_stack_;
+  std::stack<base::Closure> task_stack_;
   scoped_ptr<AppCacheService> service_;
   scoped_ptr<MockStorageDelegate> delegate_;
   scoped_refptr<MockQuotaManagerProxy> mock_quota_manager_proxy_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   scoped_refptr<AppCache> cache2_;
 };
 
 
 TEST_F(AppCacheStorageImplTest, LoadCache_Miss) {
@@ skipping 80 matching lines @@
 }
 
 TEST_F(AppCacheStorageImplTest, FindMainResponseExclusionsInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
-
-// AppCacheStorageImplTest is expected to always live longer than the
-// runnable methods.  This lets us call NewRunnableMethod on its instances.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);