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

webkit/appcache/appcache_storage_impl.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/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 1190 matching lines @@
 }
 
 
 // AppCacheStorageImpl ---------------------------------------------------
 
 AppCacheStorageImpl::AppCacheStorageImpl(AppCacheService* service)
     : AppCacheStorage(service), is_incognito_(false),
       is_response_deletion_scheduled_(false),
       did_start_deleting_responses_(false),
       last_deletable_response_rowid_(0),
-      ALLOW_THIS_IN_INITIALIZER_LIST(doom_callback_(
-          this, &AppCacheStorageImpl::OnDeletedOneResponse)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(init_callback_(
-          this, &AppCacheStorageImpl::OnDiskCacheInitialized)),
       database_(NULL), is_disabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 AppCacheStorageImpl::~AppCacheStorageImpl() {
   std::for_each(pending_quota_queries_.begin(),
                 pending_quota_queries_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
   std::for_each(scheduled_database_tasks_.begin(),
                 scheduled_database_tasks_.end(),
@@ skipping 364 matching lines @@
   if (!disk_cache()) {
     DCHECK(is_disabled_);
     deletable_response_ids_.clear();
     deleted_response_ids_.clear();
     is_response_deletion_scheduled_ = false;
     return;
   }
 
   // TODO(michaeln): add group_id to DoomEntry args
   int64 id = deletable_response_ids_.front();
-  int rv = disk_cache_->DoomEntry(id, &doom_callback_);
+  int rv = disk_cache_->DoomEntry(
+      id, base::Bind(&AppCacheStorageImpl::OnDeletedOneResponse,
+                     base::Unretained(this)));
   if (rv != net::ERR_IO_PENDING)
     OnDeletedOneResponse(rv);
 }
 
 void AppCacheStorageImpl::OnDeletedOneResponse(int rv) {
   is_response_deletion_scheduled_ = false;
   if (is_disabled_)
     return;
 
   int64 id = deletable_response_ids_.front();
@@ skipping 65 matching lines @@
   DCHECK(IsInitTaskComplete());
 
   if (is_disabled_)
     return NULL;
 
   if (!disk_cache_.get()) {
     int rv = net::OK;
     disk_cache_.reset(new AppCacheDiskCache);
     if (is_incognito_) {
       rv = disk_cache_->InitWithMemBackend(
-          kMaxMemDiskCacheSize, &init_callback_);
+          kMaxMemDiskCacheSize,
+          base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
+                     base::Unretained(this)));
     } else {
       rv = disk_cache_->InitWithDiskBackend(
           cache_directory_.Append(kDiskCacheDirectoryName),
-          kMaxDiskCacheSize, false, cache_thread_, &init_callback_);
+          kMaxDiskCacheSize, false, cache_thread_,
+          base::Bind(&AppCacheStorageImpl::OnDiskCacheInitialized,
+                     base::Unretained(this)));
     }
 
     // We should not keep this reference around.
     cache_thread_ = NULL;
 
     if (rv != net::ERR_IO_PENDING)
       OnDiskCacheInitialized(rv);
   }
   return disk_cache_.get();
 }
@@ skipping 10 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(&DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache