base::Bind: Convert disk_cache_based_ssl_host_info.

net/disk_cache/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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 #pragma once
@@ skipping 15 matching lines @@
 
 namespace net {
 class IOBuffer;
 class NetLog;
 }
 
 namespace disk_cache {
 
 class Entry;
 class Backend;
 typedef net::OldCompletionCallback OldCompletionCallback;

[csilv, 2011/12/06 00:56:08]

(comment-only)  I'm trying to decide if this is cool or lame.  I'm not sure. 
Leaning towards lame.

[James Hawkins, 2011/12/06 17:25:12]

It's lame, but removing it now would be a mess.

 
 // Returns an instance of a Backend of the given |type|. |path| points to a
 // folder where the cached data will be stored (if appropriate). This cache
 // instance must be the only object that will be reading or writing files to
 // that folder. The returned object should be deleted when not needed anymore.
 // If |force| is true, and there is a problem with the cache initialization, the
 // files will be deleted and a new set will be created. |max_bytes| is the
 // maximum size the cache can grow to. If zero is passed in as |max_bytes|, the
 // cache will determine the value to use. |thread| can be used to perform IO
 // operations if a dedicated thread is required; a valid value is expected for
@@ skipping 24 matching lines @@
   virtual int32 GetEntryCount() const = 0;
 
   // Opens an existing entry. Upon success, |entry| holds a pointer to an Entry
   // object representing the specified disk cache entry. When the entry pointer
   // is no longer needed, its Close method should be called. The return value is
   // a net error code. If this method returns ERR_IO_PENDING, the |callback|
   // will be invoked when the entry is available. The pointer to receive the
   // |entry| must remain valid until the operation completes.
   virtual int OpenEntry(const std::string& key, Entry** entry,
                         OldCompletionCallback* callback) = 0;
+  virtual int OpenEntry(const std::string& key, Entry** entry,
+                        const net::CompletionCallback& callback) = 0;
 
   // Creates a new entry. Upon success, the out param holds a pointer to an
   // Entry object representing the newly created disk cache entry. When the
   // entry pointer is no longer needed, its Close method should be called. The
   // return value is a net error code. If this method returns ERR_IO_PENDING,
   // the |callback| will be invoked when the entry is available. The pointer to
   // receive the |entry| must remain valid until the operation completes.
   virtual int CreateEntry(const std::string& key, Entry** entry,
                           OldCompletionCallback* callback) = 0;
+  virtual int CreateEntry(const std::string& key, Entry** entry,
+                          const net::CompletionCallback& callback) = 0;
 
   // Marks the entry, specified by the given key, for deletion. The return value
   // is a net error code. If this method returns ERR_IO_PENDING, the |callback|
   // will be invoked after the entry is doomed.
   virtual int DoomEntry(const std::string& key,
                         OldCompletionCallback* callback) = 0;
 
   // Marks all entries for deletion. The return value is a net error code. If
   // this method returns ERR_IO_PENDING, the |callback| will be invoked when the
   // operation completes.
@@ skipping 72 matching lines @@
   // called on the current thread once the read completes.  Returns the
   // number of bytes read or a network error code. If a completion callback is
   // provided then it will be called if this function returns ERR_IO_PENDING,
   // and a reference to |buf| will be retained until the callback is called.
   // Note that the callback will be invoked in any case, even after Close has
   // been called; in other words, the caller may close this entry without
   // having to wait for all the callbacks, and still rely on the cleanup
   // performed from the callback code.
   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
                        OldCompletionCallback* completion_callback) = 0;
+  virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
+                       const net::CompletionCallback& completion_callback) = 0;
 
   // Copies cache data from the given buffer of length |buf_len|.  If
   // completion_callback is null, then this call blocks until the write
   // operation is complete.  Otherwise, completion_callback will be
   // called on the current thread once the write completes.  Returns the
   // number of bytes written or a network error code. If a completion callback
   // is provided then it will be called if this function returns ERR_IO_PENDING,
   // and a reference to |buf| will be retained until the callback is called.
   // Note that the callback will be invoked in any case, even after Close has
   // been called; in other words, the caller may close this entry without
   // having to wait for all the callbacks, and still rely on the cleanup
   // performed from the callback code.
   // If truncate is true, this call will truncate the stored data at the end of
   // what we are writing here.
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         OldCompletionCallback* completion_callback,
                         bool truncate) = 0;
+  virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
+                        const net::CompletionCallback& completion_callback,
+                        bool truncate) = 0;
 
   // Sparse entries support:
   //
   // A Backend implementation can support sparse entries, so the cache keeps
   // track of which parts of the entry have been written before. The backend
   // will never return data that was not written previously, so reading from
   // such region will return 0 bytes read (or actually the number of bytes read
   // before reaching that region).
   //
   // There are only two streams for sparse entries: a regular control stream
@@ skipping 86 matching lines @@
   // Note: This method is deprecated.
   virtual int ReadyForSparseIO(OldCompletionCallback* completion_callback) = 0;
 
  protected:
   virtual ~Entry() {}
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_