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

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 49 matching lines @@
   int response_data_size;
 
   HttpResponseInfoIOBuffer();
   explicit HttpResponseInfoIOBuffer(net::HttpResponseInfo* info);
 
  private:
   friend class base::RefCountedThreadSafe<HttpResponseInfoIOBuffer>;
   virtual ~HttpResponseInfoIOBuffer();
 };
 
-// Low level storage api used by the response reader and writer.
+// Low level storage API used by the response reader and writer.
 class APPCACHE_EXPORT AppCacheDiskCacheInterface {
  public:
   class Entry {
    public:
     virtual int Read(int index, int64 offset, net::IOBuffer* buf, int buf_len,
                      const net::CompletionCallback& callback) = 0;
     virtual int Write(int index, int64 offset, net::IOBuffer* buf, int buf_len,
                       const net::CompletionCallback& callback) = 0;
     virtual int64 GetSize(int index) = 0;
     virtual void Close() = 0;
    protected:
     virtual ~Entry() {}
   };
 
   virtual int CreateEntry(int64 key, Entry** entry,
-                          net::OldCompletionCallback* callback) = 0;
+                          const net::CompletionCallback& callback) = 0;
   virtual int OpenEntry(int64 key, Entry** entry,
-                        net::OldCompletionCallback* callback) = 0;
-  virtual int DoomEntry(int64 key, net::OldCompletionCallback* callback) = 0;
+                        const net::CompletionCallback& callback) = 0;
+  virtual int DoomEntry(int64 key, const net::CompletionCallback& callback) = 0;
 
  protected:
   friend class base::RefCounted<AppCacheDiskCacheInterface>;
   virtual ~AppCacheDiskCacheInterface() {}
 };
 
 // Common base class for response reader and writer.
 class APPCACHE_EXPORT AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseIO();
@@ skipping 14 matching lines @@
         entry_ptr_->Close();
     }
   };
 
   AppCacheResponseIO(int64 response_id,
                      int64 group_id,
                      AppCacheDiskCacheInterface* disk_cache);
 
   virtual void OnIOComplete(int result) = 0;
 
-  bool IsIOPending() { return user_callback_ ? true : false; }
+  bool IsIOPending() { return callback_.is_null() ? false : true; }

[awong, 2011/12/20 23:51:47]

"!callback_.is_null()"?

[James Hawkins, 2011/12/21 00:43:08]

Haha, done.

   void ScheduleIOOldCompletionCallback(int result);
   void InvokeUserOldCompletionCallback(int result);
   void ReadRaw(int index, int offset, net::IOBuffer* buf, int buf_len);
   void WriteRaw(int index, int offset, net::IOBuffer* buf, int buf_len);
 
   const int64 response_id_;
   const int64 group_id_;
   AppCacheDiskCacheInterface* disk_cache_;
   AppCacheDiskCacheInterface::Entry* entry_;
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
   scoped_refptr<net::IOBuffer> buffer_;
   int buffer_len_;
-  net::OldCompletionCallback* user_callback_;
+  net::CompletionCallback callback_;
   base::WeakPtrFactory<AppCacheResponseIO> weak_factory_;
 
  private:
   void OnRawIOComplete(int result);
 };
 
 // Reads existing response data from storage. If the object is deleted
 // and there is a read 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 AppCacheResponseReader : public AppCacheResponseIO {
  public:
   virtual ~AppCacheResponseReader();
 
   // Reads http info from storage. Always returns the result of the read
   // asynchronously through the 'callback'. Returns the number of bytes read
   // or a net:: error code. Guaranteed to not perform partial reads of
   // the info data. The reader acquires a reference to the 'info_buf' until
   // completion at which time the callback is invoked with either a negative
   // error code or the number of bytes read. The 'info_buf' argument should
   // contain a NULL http_info when ReadInfo is called. The 'callback' is a
   // required parameter.
   // Should only be called where there is no Read operation in progress.
   // (virtual for testing)
   virtual void ReadInfo(HttpResponseInfoIOBuffer* info_buf,
-                        net::OldCompletionCallback* callback);
+                        const net::CompletionCallback& callback);
 
   // Reads data from storage. Always returns the result of the read
   // asynchronously through the 'callback'. Returns the number of bytes read
   // or a net:: error code. EOF is indicated with a return value of zero.
   // The reader acquires a reference to the provided 'buf' until completion
   // at which time the callback is invoked with either a negative error code
   // or the number of bytes read. The 'callback' is a required parameter.
   // Should only be called where there is no Read operation in progress.
   // (virtual for testing)
   virtual void ReadData(net::IOBuffer* buf, int buf_len,
-                        net::OldCompletionCallback* callback);
+                        const net::CompletionCallback& callback);
 
   // Returns true if there is a read operation, for data or info, pending.
   bool IsReadPending() { return IsIOPending(); }
 
   // Used to support range requests. If not called, the reader will
   // read the entire response body. If called, this must be called prior
   // to the first call to the ReadData method.
   void SetReadRange(int offset, int length);
 
  protected:
@@ skipping 26 matching lines @@
   virtual ~AppCacheResponseWriter();
 
   // Writes the http info to storage. Always returns the result of the write
   // asynchronously through the 'callback'. Returns the number of bytes written
   // or a net:: error code. The writer acquires a reference to the 'info_buf'
   // until completion at which time the callback is invoked with either a
   // negative error code or the number of bytes written. The 'callback' is a
   // required parameter. The contents of 'info_buf' are not modified.
   // Should only be called where there is no Write operation in progress.
   void WriteInfo(HttpResponseInfoIOBuffer* info_buf,
-                 net::OldCompletionCallback* callback);
+                 const net::CompletionCallback& callback);
 
   // Writes data to storage. Always returns the result of the write
   // asynchronously through the 'callback'. Returns the number of bytes written
   // or a net:: error code. Guaranteed to not perform partial writes.
   // The writer acquires a reference to the provided 'buf' until completion at
   // which time the callback is invoked with either a negative error code or
   // the number of bytes written. The 'callback' is a required parameter.
   // The contents of 'buf' are not modified.
   // Should only be called where there is no Write operation in progress.
   void WriteData(net::IOBuffer* buf, int buf_len,
-                 net::OldCompletionCallback* callback);
+                 const net::CompletionCallback& callback);
 
   // Returns true if there is a write pending.
   bool IsWritePending() { return IsIOPending(); }
 
   // Returns the amount written, info and data.
   int64 amount_written() { return info_size_ + write_position_; }
 
  private:
   friend class AppCacheStorageImpl;
   friend class MockAppCacheStorage;
@@ skipping 20 matching lines @@
   int write_position_;
   int write_amount_;
   CreationPhase creation_phase_;
   scoped_refptr<EntryCallback<AppCacheResponseWriter> > create_callback_;
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_RESPONSE_H_