base::Bind: Convert most of net/http.

net/http/http_cache_transaction.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.
 
 // This file declares HttpCache::Transaction, a private class of HttpCache so
 // it should only be included by http_cache.cc
 
 #ifndef NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #define NET_HTTP_HTTP_CACHE_TRANSACTION_H_
 #pragma once
@@ skipping 75 matching lines @@
   // We need to indicate that the response data was truncated.  Returns true on
   // success.
   bool AddTruncatedFlag();
 
   // Returns the LoadState of the writer transaction of a given ActiveEntry. In
   // other words, returns the LoadState of this transaction without asking the
   // http cache, because this transaction should be the one currently writing
   // to the cache entry.
   LoadState GetWriterLoadState() const;
 
-  OldCompletionCallback* io_callback() { return &io_callback_; }
+  const CompletionCallback& io_callback() { return io_callback_; }
 
   const BoundNetLog& net_log() const;
 
   // HttpTransaction methods:
-  virtual int Start(const HttpRequestInfo*, OldCompletionCallback*,
+  virtual int Start(const HttpRequestInfo*, const CompletionCallback&,
                     const BoundNetLog&) OVERRIDE;
   virtual int RestartIgnoringLastError(
-      OldCompletionCallback* callback) OVERRIDE;
-  virtual int RestartWithCertificate(X509Certificate* client_cert,
-                                     OldCompletionCallback* callback) OVERRIDE;
+      const CompletionCallback& callback) OVERRIDE;
+  virtual int RestartWithCertificate(
+      X509Certificate* client_cert,
+      const CompletionCallback& callback) OVERRIDE;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
-                              OldCompletionCallback* callback) OVERRIDE;
+                              const CompletionCallback& callback) OVERRIDE;
   virtual bool IsReadyToRestartForAuth() OVERRIDE;
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   OldCompletionCallback* callback) OVERRIDE;
+                   const CompletionCallback& callback) OVERRIDE;
   virtual void StopCaching() OVERRIDE;
   virtual void DoneReading() OVERRIDE;
   virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
   virtual LoadState GetLoadState() const OVERRIDE;
   virtual uint64 GetUploadProgress(void) const OVERRIDE;
 
  private:
   static const size_t kNumValidationHeaders = 2;
   // Helper struct to pair a header name with its value, for
   // headers used to validate cache entries.
@@ skipping 208 matching lines @@
   scoped_ptr<HttpRequestInfo> custom_request_;
   HttpRequestHeaders request_headers_copy_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
   // |external_validation_| contains the value of those headers.
   ValidationHeaders external_validation_;
   base::WeakPtr<HttpCache> cache_;
   HttpCache::ActiveEntry* entry_;
   base::TimeTicks entry_lock_waiting_since_;
   HttpCache::ActiveEntry* new_entry_;
   scoped_ptr<HttpTransaction> network_trans_;
-  OldCompletionCallback* callback_;  // Consumer's callback.
+  CompletionCallback callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   const HttpResponseInfo* new_response_;
   std::string cache_key_;
   Mode mode_;
   State target_state_;
   bool reading_;  // We are already reading.
   bool invalid_range_;  // We may bypass the cache for this request.
   bool truncated_;  // We don't have all the response data.
   bool is_sparse_;  // The data is stored in sparse byte ranges.
   bool range_requested_;  // The user requested a byte range.
   bool handling_206_;  // We must deal with this 206 response.
   bool cache_pending_;  // We are waiting for the HttpCache.
   bool done_reading_;
   scoped_refptr<IOBuffer> read_buf_;
   int io_buf_len_;
   int read_offset_;
   int effective_load_flags_;
   int write_len_;
   scoped_ptr<PartialData> partial_;  // We are dealing with range requests.
   uint64 final_upload_progress_;
-  OldCompletionCallbackImpl<Transaction> io_callback_;
+  CompletionCallback io_callback_;
   scoped_refptr<CancelableOldCompletionCallback<Transaction> > cache_callback_;
   scoped_refptr<CancelableOldCompletionCallback<Transaction> >
       write_headers_callback_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_TRANSACTION_H_