base::Bind: Remove OldCompletionCallback.

webkit/appcache/appcache_response.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_RESPONSE_H_
 #define WEBKIT_APPCACHE_APPCACHE_RESPONSE_H_
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 82 matching lines @@
   virtual ~AppCacheDiskCacheInterface() {}
 };
 
 // Common base class for response reader and writer.
 class APPCACHE_EXPORT AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseIO();
   int64 response_id() const { return response_id_; }
 
  protected:
-  template <class T>
-  class EntryCallback : public net::CancelableOldCompletionCallback<T> {
-   public:
-    typedef net::CancelableOldCompletionCallback<T> BaseClass;
-    EntryCallback(T* object,  void (T::* method)(int))
-        : BaseClass(object, method), entry_ptr_(NULL) {}
-
-    AppCacheDiskCacheInterface::Entry* entry_ptr_;  // Accessed directly.
-   private:
-    ~EntryCallback() {
-      if (entry_ptr_)
-        entry_ptr_->Close();
-    }
-  };
-
   AppCacheResponseIO(int64 response_id,
                      int64 group_id,
                      AppCacheDiskCacheInterface* disk_cache);
 
   virtual void OnIOComplete(int result) = 0;
 
   bool IsIOPending() { return !callback_.is_null(); }
   void ScheduleIOCompletionCallback(int result);
   void InvokeUserCompletionCallback(int result);
   void ReadRaw(int index, int offset, net::IOBuffer* buf, int buf_len);
@@ skipping 59 matching lines @@
 
   // Should only be constructed by the storage class.
   AppCacheResponseReader(int64 response_id,
                          int64 group_id,
                          AppCacheDiskCacheInterface* disk_cache);
 
   virtual void OnIOComplete(int result) OVERRIDE;
   void ContinueReadInfo();
   void ContinueReadData();
   void OpenEntryIfNeededAndContinue();
-  void OnOpenEntryComplete(int rv);
+  void OnOpenEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv);
 
   int range_offset_;
   int range_length_;
   int read_position_;
-  scoped_refptr<EntryCallback<AppCacheResponseReader> > open_callback_;
+  net::CompletionCallback open_callback_;
+  base::WeakPtrFactory<AppCacheResponseReader> weak_factory_;
 };
 
 // Writes new response data to storage. If the object is deleted
 // and there is a write in progress, the implementation will return
 // immediately but will take care of any side effect of cancelling the
 // operation. In other words, instances are safe to delete at will.
 class APPCACHE_EXPORT AppCacheResponseWriter : public AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseWriter();
 
@@ skipping 37 matching lines @@
 
   // Should only be constructed by the storage class.
   AppCacheResponseWriter(int64 response_id,
                          int64 group_id,
                          AppCacheDiskCacheInterface* disk_cache);
 
   virtual void OnIOComplete(int result) OVERRIDE;
   void ContinueWriteInfo();
   void ContinueWriteData();
   void CreateEntryIfNeededAndContinue();
-  void OnCreateEntryComplete(int rv);
+  void OnCreateEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv);
 
   int info_size_;
   int write_position_;
   int write_amount_;
   CreationPhase creation_phase_;
-  scoped_refptr<EntryCallback<AppCacheResponseWriter> > create_callback_;
+  net::CompletionCallback create_callback_;
+  base::WeakPtrFactory<AppCacheResponseWriter> weak_factory_;
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_RESPONSE_H_