base::Bind: Remove OldCompletionCallback.

webkit/appcache/appcache_disk_cache.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_disk_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "net/base/net_errors.h"
 
 namespace appcache {
 
+// TODO(ajwong): Change disk_cache's API to return results via Callback.
+struct AppCacheDiskCache::CreateBackendDataShim {
+  CreateBackendDataShim() : backend(NULL) {}
+  disk_cache::Backend* backend;
+};
+
 // An implementation of AppCacheDiskCacheInterface::Entry that's a thin
 // wrapper around disk_cache::Entry.
 class AppCacheDiskCache::EntryImpl : public Entry {
  public:
   explicit EntryImpl(disk_cache::Entry* disk_cache_entry)
       : disk_cache_entry_(disk_cache_entry) {
     DCHECK(disk_cache_entry);
   }
 
   // Entry implementation.
@@ skipping 89 matching lines @@
   net::CompletionCallback callback_;
   AppCacheDiskCache* owner_;
   disk_cache::Entry* entry_ptr_;
 };
 
 AppCacheDiskCache::AppCacheDiskCache()
     : is_disabled_(false) {
 }
 
 AppCacheDiskCache::~AppCacheDiskCache() {
-  if (create_backend_callback_) {
-    create_backend_callback_->Cancel();
-    create_backend_callback_.release();
-    OnCreateBackendComplete(net::ERR_ABORTED);
+  if (!create_backend_callback_.IsCancelled()) {
+    create_backend_callback_.Cancel();
+    OnCreateBackendComplete(NULL, net::ERR_ABORTED);
   }
   disk_cache_.reset();
   STLDeleteElements(&active_calls_);
 }
 
 int AppCacheDiskCache::InitWithDiskBackend(
     const FilePath& disk_cache_directory, int disk_cache_size, bool force,
     base::MessageLoopProxy* cache_thread,
     const net::CompletionCallback& callback) {
   return Init(net::APP_CACHE, disk_cache_directory,
               disk_cache_size, force, cache_thread, callback);
 }
 
 int AppCacheDiskCache::InitWithMemBackend(
     int mem_cache_size, const net::CompletionCallback& callback) {
   return Init(net::MEMORY_CACHE, FilePath(), mem_cache_size, false, NULL,
               callback);
 }
 
 void AppCacheDiskCache::Disable() {
   if (is_disabled_)
     return;
 
   is_disabled_ = true;
 
-  if (create_backend_callback_) {
-    create_backend_callback_->Cancel();
-    create_backend_callback_.release();
-    OnCreateBackendComplete(net::ERR_ABORTED);
+  if (!create_backend_callback_.IsCancelled()) {
+    create_backend_callback_.Cancel();
+    OnCreateBackendComplete(NULL, net::ERR_ABORTED);
   }
 }
 
 int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry,
                                    const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
@@ skipping 45 matching lines @@
 
 AppCacheDiskCache::PendingCall::~PendingCall() {}
 
 int AppCacheDiskCache::Init(net::CacheType cache_type,
                             const FilePath& cache_directory,
                             int cache_size, bool force,
                             base::MessageLoopProxy* cache_thread,
                             const net::CompletionCallback& callback) {
   DCHECK(!is_initializing() && !disk_cache_.get());
   is_disabled_ = false;
-  create_backend_callback_ = new CreateBackendCallback(
-      this, &AppCacheDiskCache::OnCreateBackendComplete);
 
+  // TODO(ajwong): Change disk_cache's API to return results via Callback.
+  disk_cache::Backend** backend_ptr = new(disk_cache::Backend*);
+  create_backend_callback_.Reset(
+      base::Bind(&AppCacheDiskCache::OnCreateBackendComplete,
+                 base::Unretained(this), base::Owned(backend_ptr)));
   int rv = disk_cache::CreateCacheBackend(
       cache_type, cache_directory, cache_size, force, cache_thread, NULL,
-      &(create_backend_callback_->backend_ptr_),
-      base::Bind(&net::OldCompletionCallbackAdapter, create_backend_callback_));
+      backend_ptr, create_backend_callback_.callback());
   if (rv == net::ERR_IO_PENDING)
     init_callback_ = callback;
   else
-    OnCreateBackendComplete(rv);
+    OnCreateBackendComplete(backend_ptr, rv);
+
   return rv;
 }
 
-void AppCacheDiskCache::OnCreateBackendComplete(int rv) {
+void AppCacheDiskCache::OnCreateBackendComplete(
+    disk_cache::Backend** backend, int rv) {
   if (rv == net::OK) {
-    disk_cache_.reset(create_backend_callback_->backend_ptr_);
-    create_backend_callback_->backend_ptr_ = NULL;
+    DCHECK(backend);
+    disk_cache_.reset(*backend);
   }
-  create_backend_callback_ = NULL;
+
+  create_backend_callback_.Cancel();
 
   // Invoke our clients callback function.
   if (!init_callback_.is_null()) {
     init_callback_.Run(rv);
     init_callback_.Reset();
   }
 
   // Service pending calls that were queued up while we were initializing.
   for (PendingCalls::const_iterator iter = pending_calls_.begin();
        iter < pending_calls_.end(); ++iter) {
@@ skipping 13 matching lines @@
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }
 
 }  // namespace appcache