base::Bind: Remove OldCompletionCallback.

webkit/appcache/appcache_disk_cache.h

 // 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.
 
 #ifndef WEBKIT_APPCACHE_APPCACHE_DISK_CACHE_H_
 #define WEBKIT_APPCACHE_APPCACHE_DISK_CACHE_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 27 matching lines @@
   bool is_disabled() const { return is_disabled_; }
 
   virtual int CreateEntry(int64 key, Entry** entry,
                           const net::CompletionCallback& callback) OVERRIDE;
   virtual int OpenEntry(int64 key, Entry** entry,
                         const net::CompletionCallback& callback) OVERRIDE;
   virtual int DoomEntry(int64 key,
                         const net::CompletionCallback& callback) OVERRIDE;
 
  private:
+  struct CreateBackendDataShim;
   class EntryImpl;
 
-  class CreateBackendCallback
-      : public net::CancelableOldCompletionCallback<AppCacheDiskCache> {
-   public:
-    typedef net::CancelableOldCompletionCallback<AppCacheDiskCache> BaseClass;
-    CreateBackendCallback(AppCacheDiskCache* object,
-                          void (AppCacheDiskCache::* method)(int))
-        : BaseClass(object, method), backend_ptr_(NULL) {}
-
-    disk_cache::Backend* backend_ptr_;  // Accessed directly.
-   private:
-    virtual ~CreateBackendCallback() {
-      delete backend_ptr_;
-    }
-  };
-
   // PendingCalls allow CreateEntry, OpenEntry, and DoomEntry to be called
   // immediately after construction, without waiting for the
   // underlying disk_cache::Backend to be fully constructed. Early
   // calls are queued up and serviced once the disk_cache::Backend is
   // really ready to go.
   enum PendingCallType {
     CREATE,
     OPEN,
     DOOM
   };
@@ skipping 18 matching lines @@
     }
 
     ~PendingCall();
   };
   typedef std::vector<PendingCall> PendingCalls;
 
   class ActiveCall;
   typedef std::set<ActiveCall*> ActiveCalls;
 
   bool is_initializing() const {
-    return create_backend_callback_.get() != NULL;
+    return !create_backend_callback_.IsCancelled();
   }
   disk_cache::Backend* disk_cache() { return disk_cache_.get(); }
   int Init(net::CacheType cache_type, const FilePath& directory,
            int cache_size, bool force, base::MessageLoopProxy* cache_thread,
            const net::CompletionCallback& callback);
-  void OnCreateBackendComplete(int rv);
+  // The |unused| parameter is a small hack so that we can have the

[groby-ooo-7-16, 2012/01/03 18:32:25]

Which one is |unused|. I assume you mean |backend|? 

[James Hawkins, 2012/01/03 18:39:21]

Done.

+  // CreateBackendDataShim object owned by the Callback that is created for
+  // this method.
+  void OnCreateBackendComplete(disk_cache::Backend** backend, int rv);
   void AddActiveCall(ActiveCall* call) { active_calls_.insert(call); }
   void RemoveActiveCall(ActiveCall* call) { active_calls_.erase(call); }
 
   bool is_disabled_;
   net::CompletionCallback init_callback_;
-  scoped_refptr<CreateBackendCallback> create_backend_callback_;
+  net::CancelableCompletionCallback create_backend_callback_;
   PendingCalls pending_calls_;
   ActiveCalls active_calls_;
   scoped_ptr<disk_cache::Backend> disk_cache_;
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_DISK_CACHE_H_