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

net/http/http_cache.cc

 // 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.
 
 #include "net/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 145 matching lines @@
         callback_(cb),
         backend_(backend) {}
   ~WorkItem() {}
 
   // Calls back the transaction with the result of the operation.
   void NotifyTransaction(int result, ActiveEntry* entry) {
     DCHECK(!entry || entry->disk_entry);
     if (entry_)
       *entry_ = entry;
     if (trans_)
-      trans_->io_callback()->Run(result);
+      trans_->io_callback().Run(result);
   }
 
   // Notifies the caller about the operation completion. Returns true if the
   // callback was invoked.
   bool DoCallback(int result, disk_cache::Backend* backend) {
     if (backend_)
       *backend_ = backend;
     if (!callback_.is_null()) {
       callback_.Run(result);
       return true;
@@ skipping 47 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BackendCallback);
 };
 
 //-----------------------------------------------------------------------------
 
 // This class encapsulates a transaction whose only purpose is to write metadata
 // to a given entry.
 class HttpCache::MetadataWriter {
  public:
   explicit MetadataWriter(HttpCache::Transaction* trans)
-      : transaction_(trans),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &MetadataWriter::OnIOComplete)) {}
+      : transaction_(trans) {
+  }
+
   ~MetadataWriter() {}
 
-  // Implementes the bulk of HttpCache::WriteMetadata.
+  // Implements the bulk of HttpCache::WriteMetadata.
   void Write(const GURL& url, base::Time expected_response_time, IOBuffer* buf,
              int buf_len);
 
  private:
   void VerifyResponse(int result);
   void SelfDestroy();
   void OnIOComplete(int result);
 
   scoped_ptr<HttpCache::Transaction> transaction_;
   bool verified_;
   scoped_refptr<IOBuffer> buf_;
   int buf_len_;
   base::Time expected_response_time_;
-  OldCompletionCallbackImpl<MetadataWriter> callback_;
   HttpRequestInfo request_info_;
   DISALLOW_COPY_AND_ASSIGN(MetadataWriter);
 };
 
 void HttpCache::MetadataWriter::Write(const GURL& url,
                                       base::Time expected_response_time,
                                       IOBuffer* buf, int buf_len) {
   DCHECK_GT(buf_len, 0);
   DCHECK(buf);
   DCHECK(buf->data());
   request_info_.url = url;
   request_info_.method = "GET";
   request_info_.load_flags = LOAD_ONLY_FROM_CACHE;
 
   expected_response_time_ = expected_response_time;
   buf_ = buf;
   buf_len_ = buf_len;
   verified_ = false;
 
-  int rv = transaction_->Start(&request_info_, &callback_, BoundNetLog());
+  int rv = transaction_->Start(
+      &request_info_,
+      base::Bind(&MetadataWriter::OnIOComplete, base::Unretained(this)),
+      BoundNetLog());
   if (rv != ERR_IO_PENDING)
     VerifyResponse(rv);
 }
 
 void HttpCache::MetadataWriter::VerifyResponse(int result) {
   verified_ = true;
   if (result != OK)
     return SelfDestroy();
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
@@ skipping 616 matching lines @@
     TransactionList pending_queue;
     pending_queue.swap(entry->pending_queue);
 
     entry->disk_entry->Doom();
     DestroyEntry(entry);
 
     // We need to do something about these pending entries, which now need to
     // be added to a new entry.
     while (!pending_queue.empty()) {
       // ERR_CACHE_RACE causes the transaction to restart the whole process.
-      pending_queue.front()->io_callback()->Run(ERR_CACHE_RACE);
+      pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
       pending_queue.pop_front();
     }
   }
 }
 
 void HttpCache::DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans) {
   DCHECK(!entry->writer);
 
   TransactionList::iterator it =
       std::find(entry->readers.begin(), entry->readers.end(), trans);
@@ skipping 123 matching lines @@
 
   // Promote next transaction from the pending queue.
   Transaction* next = entry->pending_queue.front();
   if ((next->mode() & Transaction::WRITE) && !entry->readers.empty())
     return;  // Have to wait.
 
   entry->pending_queue.erase(entry->pending_queue.begin());
 
   int rv = AddTransactionToEntry(entry, next);
   if (rv != ERR_IO_PENDING) {
-    next->io_callback()->Run(rv);
+    next->io_callback().Run(rv);
   }
 }
 
 void HttpCache::OnIOComplete(int result, PendingOp* pending_op) {
   WorkItemOperation op = pending_op->writer->operation();
 
   // Completing the creation of the backend is simpler than the other cases.
   if (op == WI_CREATE_BACKEND)
     return OnBackendCreated(result, pending_op);
 
@@ skipping 114 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, backend))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net