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

webkit/appcache/mock_appcache_storage.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 "webkit/appcache/mock_appcache_storage.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_service.h"
 
 // This is a quick and easy 'mock' implementation of the storage interface
 // that doesn't put anything to disk.
 //
 // We simply add an extra reference to objects when they're put in storage,
 // and remove the extra reference when they are removed from storage.
 // Responses are never really removed from the in-memory disk cache.
 // Delegate callbacks are made asyncly to appropiately mimic what will
 // happen with a real disk-backed storage impl that involves IO on a
 // background thread.
 
 namespace appcache {
 
 MockAppCacheStorage::MockAppCacheStorage(AppCacheService* service)
     : AppCacheStorage(service),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       simulate_make_group_obsolete_failure_(false),
       simulate_store_group_and_newest_cache_failure_(false),
       simulate_find_main_resource_(false),
       simulate_find_sub_resource_(false),
       simulated_found_cache_id_(kNoCacheId),
       simulated_found_group_id_(0),
       simulated_found_network_namespace_(false) {
   last_cache_id_ = 0;
   last_group_id_ = 0;
   last_response_id_ = 0;
 }
 
 MockAppCacheStorage::~MockAppCacheStorage() {
-  STLDeleteElements(&pending_tasks_);
 }
 
 void MockAppCacheStorage::GetAllInfo(Delegate* delegate) {
-  ScheduleTask(method_factory_.NewRunnableMethod(
-      &MockAppCacheStorage::ProcessGetAllInfo,
-      make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+  ScheduleTask(
+      base::Bind(&MockAppCacheStorage::ProcessGetAllInfo,
+                 weak_factory_.GetWeakPtr(),
+                 make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
 void MockAppCacheStorage::LoadCache(int64 id, Delegate* delegate) {
   DCHECK(delegate);
   AppCache* cache = working_set_.GetCache(id);
   if (ShouldCacheLoadAppearAsync(cache)) {
-    ScheduleTask(method_factory_.NewRunnableMethod(
-        &MockAppCacheStorage::ProcessLoadCache,
-        id, make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+    ScheduleTask(
+        base::Bind(&MockAppCacheStorage::ProcessLoadCache,
+                   weak_factory_.GetWeakPtr(), id,
+                   make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadCache(id, GetOrCreateDelegateReference(delegate));
 }
 
 void MockAppCacheStorage::LoadOrCreateGroup(
     const GURL& manifest_url, Delegate* delegate) {
   DCHECK(delegate);
   AppCacheGroup* group = working_set_.GetGroup(manifest_url);
   if (ShouldGroupLoadAppearAsync(group)) {
-    ScheduleTask(method_factory_.NewRunnableMethod(
-        &MockAppCacheStorage::ProcessLoadOrCreateGroup,
-        manifest_url,
-        make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+    ScheduleTask(
+        base::Bind(&MockAppCacheStorage::ProcessLoadOrCreateGroup,
+                   weak_factory_.GetWeakPtr(), manifest_url,
+                   make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadOrCreateGroup(
       manifest_url, GetOrCreateDelegateReference(delegate));
 }
 
 void MockAppCacheStorage::StoreGroupAndNewestCache(
     AppCacheGroup* group, AppCache* newest_cache, Delegate* delegate) {
   DCHECK(group && delegate && newest_cache);
 
   // Always make this operation look async.
-  ScheduleTask(method_factory_.NewRunnableMethod(
-      &MockAppCacheStorage::ProcessStoreGroupAndNewestCache,
-      make_scoped_refptr(group),
-      make_scoped_refptr(newest_cache),
-      make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+  ScheduleTask(
+      base::Bind(&MockAppCacheStorage::ProcessStoreGroupAndNewestCache,
+                 weak_factory_.GetWeakPtr(), make_scoped_refptr(group),
+                 make_scoped_refptr(newest_cache),
+                 make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
 void MockAppCacheStorage::FindResponseForMainRequest(
     const GURL& url, const GURL& preferred_manifest_url, Delegate* delegate) {
   DCHECK(delegate);
 
   // Note: MockAppCacheStorage does not respect the preferred_manifest_url.
 
   // Always make this operation look async.
-  ScheduleTask(method_factory_.NewRunnableMethod(
-      &MockAppCacheStorage::ProcessFindResponseForMainRequest,
-      url,
-      make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+  ScheduleTask(
+      base::Bind(&MockAppCacheStorage::ProcessFindResponseForMainRequest,
+                 weak_factory_.GetWeakPtr(), url,
+                 make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
 void MockAppCacheStorage::FindResponseForSubRequest(
     AppCache* cache, const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
     bool* found_network_namespace) {
   DCHECK(cache && cache->is_complete());
 
   // This layer of indirection is here to facilitate testing.
   if (simulate_find_sub_resource_) {
@@ skipping 19 matching lines @@
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
 }
 
 void MockAppCacheStorage::MakeGroupObsolete(
     AppCacheGroup* group, Delegate* delegate) {
   DCHECK(group && delegate);
 
   // Always make this method look async.
-  ScheduleTask(method_factory_.NewRunnableMethod(
-      &MockAppCacheStorage::ProcessMakeGroupObsolete,
-      make_scoped_refptr(group),
-      make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+  ScheduleTask(
+      base::Bind(&MockAppCacheStorage::ProcessMakeGroupObsolete,
+                 weak_factory_.GetWeakPtr(), make_scoped_refptr(group),
+                 make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
 AppCacheResponseReader* MockAppCacheStorage::CreateResponseReader(
     const GURL& manifest_url, int64 group_id, int64 response_id) {
   if (simulated_reader_.get())
     return simulated_reader_.release();
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* MockAppCacheStorage::CreateResponseWriter(
@@ skipping 241 matching lines @@
 
   // Also remove from the working set, caches for an 'obsolete' group
   // may linger in use, but the group itself cannot be looked up by
   // 'manifest_url' in the working set any longer.
   working_set()->RemoveGroup(group);
 
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnGroupMadeObsolete(group, true);
 }
 
-void MockAppCacheStorage::ScheduleTask(Task* task) {
+void MockAppCacheStorage::ScheduleTask(const base::Closure& task) {
   pending_tasks_.push_back(task);
-  MessageLoop::current()->PostTask(FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &MockAppCacheStorage::RunOnePendingTask));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&MockAppCacheStorage::RunOnePendingTask,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void MockAppCacheStorage::RunOnePendingTask() {
   DCHECK(!pending_tasks_.empty());
-  Task* task = pending_tasks_.front();
+  base::Closure task = pending_tasks_.front();
   pending_tasks_.pop_front();
-  task->Run();
-  delete task;
+  task.Run();
 }
 
 void MockAppCacheStorage::AddStoredCache(AppCache* cache) {
   int64 cache_id = cache->cache_id();
   if (stored_caches_.find(cache_id) == stored_caches_.end()) {
     stored_caches_.insert(
         StoredCacheMap::value_type(cache_id, make_scoped_refptr(cache)));
   }
 }
 
@@ skipping 60 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache