base::Bind: Convert SSLHostInfo::WaitForDataReady.

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 30 matching lines @@
     : SSLHostInfo(hostname, ssl_config, cert_verifier),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       callback_(new CallbackImpl(weak_ptr_factory_.GetWeakPtr(),
                                  &DiskCacheBasedSSLHostInfo::OnIOComplete)),
       state_(GET_BACKEND),
       ready_(false),
       found_entry_(false),
       hostname_(hostname),
       http_cache_(http_cache),
       backend_(NULL),
-      entry_(NULL),
-      user_callback_(NULL) {
+      entry_(NULL) {
 }
 
 void DiskCacheBasedSSLHostInfo::Start() {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(GET_BACKEND, state_);
   DoLoop(OK);
 }
 
-int DiskCacheBasedSSLHostInfo::WaitForDataReady(OldCompletionCallback* callback) {
+int DiskCacheBasedSSLHostInfo::WaitForDataReady(
+    const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(state_ != GET_BACKEND);
 
   if (ready_)
     return OK;
-  if (callback) {
-    DCHECK(!user_callback_);
+
+  if (!callback.is_null()) {
+    DCHECK(user_callback_.is_null());
     user_callback_ = callback;
   }
+
   return ERR_IO_PENDING;
 }
 
 void DiskCacheBasedSSLHostInfo::Persist() {
   DCHECK(CalledOnValidThread());
   DCHECK(state_ != GET_BACKEND);
 
   DCHECK(new_data_.empty());
   CHECK(ready_);
-  DCHECK(user_callback_ == NULL);
+  DCHECK(user_callback_.is_null());
   new_data_ = Serialize();
 
   if (!backend_)
     return;
 
   state_ = CREATE_OR_OPEN;
   DoLoop(OK);
 }
 
 DiskCacheBasedSSLHostInfo::~DiskCacheBasedSSLHostInfo() {
-  DCHECK(!user_callback_);
+  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) {
-    OldCompletionCallback* callback = user_callback_;
-    user_callback_ = NULL;
-    if (callback)
-      callback->Run(rv);
+  if (rv != ERR_IO_PENDING && !user_callback_.is_null()) {
+    CompletionCallback callback = user_callback_;
+    user_callback_.Reset();
+    callback.Run(rv);
   }
 }
 
 int DiskCacheBasedSSLHostInfo::DoLoop(int rv) {
   do {
     switch (state_) {
       case GET_BACKEND:
         rv = DoGetBackend();
         break;
       case GET_BACKEND_COMPLETE:
@@ skipping 152 matching lines @@
     case READ_COMPLETE:
     case CREATE_OR_OPEN_COMPLETE:
     case WRITE_COMPLETE:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace net