base::Bind: Convert disk_cache_based_ssl_host_info.

net/http/disk_cache_based_ssl_host_info.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/disk_cache_based_ssl_host_info.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 22 matching lines @@
   }
 }
 
 DiskCacheBasedSSLHostInfo::DiskCacheBasedSSLHostInfo(
     const std::string& hostname,
     const SSLConfig& ssl_config,
     CertVerifier* cert_verifier,
     HttpCache* http_cache)
     : SSLHostInfo(hostname, ssl_config, cert_verifier),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      callback_(new CallbackImpl(weak_ptr_factory_.GetWeakPtr(),
-                                 &DiskCacheBasedSSLHostInfo::OnIOComplete)),
+      callback_(base::Bind(&DiskCacheBasedSSLHostInfo::OnIOComplete,
+                           weak_ptr_factory_.GetWeakPtr())),
       state_(GET_BACKEND),
       ready_(false),
       found_entry_(false),
       hostname_(hostname),
       http_cache_(http_cache),
       backend_(NULL),
       entry_(NULL) {
 }
 
 void DiskCacheBasedSSLHostInfo::Start() {
@@ skipping 31 matching lines @@
     return;
 
   state_ = CREATE_OR_OPEN;
   DoLoop(OK);
 }
 
 DiskCacheBasedSSLHostInfo::~DiskCacheBasedSSLHostInfo() {
   DCHECK(user_callback_.is_null());
   if (entry_)
     entry_->Close();
-  if (!IsCallbackPending())
-    delete callback_;
 }
 
 std::string DiskCacheBasedSSLHostInfo::key() const {
   return "sslhostinfo:" + hostname_;
 }
 
 void DiskCacheBasedSSLHostInfo::OnIOComplete(int rv) {
   rv = DoLoop(rv);
   if (rv != ERR_IO_PENDING && !user_callback_.is_null()) {
     CompletionCallback callback = user_callback_;
@@ skipping 45 matching lines @@
         rv = OK;
         NOTREACHED();
     }
   } while (rv != ERR_IO_PENDING && state_ != NONE);
 
   return rv;
 }
 
 int DiskCacheBasedSSLHostInfo::DoGetBackendComplete(int rv) {
   if (rv == OK) {
-    backend_ = callback_->backend();
     state_ = OPEN;
   } else {
     state_ = WAIT_FOR_DATA_READY_DONE;
   }
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoOpenComplete(int rv) {
   if (rv == OK) {
-    entry_ = callback_->entry();
     state_ = READ;
     found_entry_ = true;
   } else {
     state_ = WAIT_FOR_DATA_READY_DONE;
   }
 
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoReadComplete(int rv) {
   if (rv > 0)
     data_.assign(read_buffer_->data(), rv);
 
   state_ = WAIT_FOR_DATA_READY_DONE;
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoWriteComplete(int rv) {
   state_ = SET_DONE;
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoCreateOrOpenComplete(int rv) {
-  if (rv != OK) {
+  if (rv != OK)
     state_ = SET_DONE;
-  } else {
-    entry_ = callback_->entry();
+  else
     state_ = WRITE;
-  }
+
   return OK;
 }
 
 int DiskCacheBasedSSLHostInfo::DoGetBackend() {
   state_ = GET_BACKEND_COMPLETE;
-  return http_cache_->GetBackend(callback_->backend_pointer(), callback_);
+  return http_cache_->GetBackend(&backend_, callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoOpen() {
   state_ = OPEN_COMPLETE;
-  return backend_->OpenEntry(key(), callback_->entry_pointer(), callback_);
+  return backend_->OpenEntry(key(), &entry_, callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoRead() {
   const int32 size = entry_->GetDataSize(0 /* index */);
   if (!size) {
     state_ = WAIT_FOR_DATA_READY_DONE;
     return OK;
   }
 
   read_buffer_ = new IOBuffer(size);
   state_ = READ_COMPLETE;
   return entry_->ReadData(0 /* index */, 0 /* offset */, read_buffer_,
                           size, callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoWrite() {
   write_buffer_ = new IOBuffer(new_data_.size());
   memcpy(write_buffer_->data(), new_data_.data(), new_data_.size());
   state_ = WRITE_COMPLETE;
 
   return entry_->WriteData(0 /* index */, 0 /* offset */, write_buffer_,
-                           new_data_.size(), callback_, true /* truncate */);
+                           new_data_.size(), callback_,
+                           true /* truncate */);
 }
 
 int DiskCacheBasedSSLHostInfo::DoCreateOrOpen() {
   DCHECK(entry_ == NULL);
   state_ = CREATE_OR_OPEN_COMPLETE;
   if (found_entry_)
-    return backend_->OpenEntry(key(), callback_->entry_pointer(), callback_);
+    return backend_->OpenEntry(key(), &entry_, callback_);
 
-  return backend_->CreateEntry(key(), callback_->entry_pointer(), callback_);
+  return backend_->CreateEntry(key(), &entry_, callback_);
 }
 
 int DiskCacheBasedSSLHostInfo::DoWaitForDataReadyDone() {
   DCHECK(!ready_);
   state_ = NONE;
   ready_ = true;
   // We close the entry because, if we shutdown before ::Persist is called,
   // then we might leak a cache reference, which causes a DCHECK on shutdown.
   if (entry_)
     entry_->Close();
@@ skipping 17 matching lines @@
     case READ_COMPLETE:
     case CREATE_OR_OPEN_COMPLETE:
     case WRITE_COMPLETE:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace net