base::Bind: Convert view_http_cache_job_factory.cc.

net/url_request/view_cache_helper.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/url_request/view_cache_helper.h"
 
 #include "base/stringprintf.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 27 matching lines @@
 
 }  // namespace.
 
 ViewCacheHelper::ViewCacheHelper()
     : disk_cache_(NULL),
       entry_(NULL),
       iter_(NULL),
       buf_len_(0),
       index_(0),
       data_(NULL),
-      callback_(NULL),
       next_state_(STATE_NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           cache_callback_(this, &ViewCacheHelper::OnIOComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           entry_callback_(new CancelableOldCompletionCallback<ViewCacheHelper>(
               this, &ViewCacheHelper::OnIOComplete))) {
 }
 
 ViewCacheHelper::~ViewCacheHelper() {
   if (entry_)
     entry_->Close();
 
   // Cancel any pending entry callback.
   entry_callback_->Cancel();
 }
 
 int ViewCacheHelper::GetEntryInfoHTML(const std::string& key,
                                       const URLRequestContext* context,
                                       std::string* out,
-                                      OldCompletionCallback* callback) {
+                                      const CompletionCallback& callback) {
   return GetInfoHTML(key, context, std::string(), out, callback);
 }
 
 int ViewCacheHelper::GetContentsHTML(const URLRequestContext* context,
                                      const std::string& url_prefix,
                                      std::string* out,
-                                     OldCompletionCallback* callback) {
+                                     const CompletionCallback& callback) {
   return GetInfoHTML(std::string(), context, url_prefix, out, callback);
 }
 
 // static
 void ViewCacheHelper::HexDump(const char *buf, size_t buf_len,
                               std::string* result) {
   const size_t kMaxRows = 16;
   int offset = 0;
 
   const unsigned char *p;
@@ skipping 28 matching lines @@
     buf_len -= row_max;
   }
 }
 
 //-----------------------------------------------------------------------------
 
 int ViewCacheHelper::GetInfoHTML(const std::string& key,
                                  const URLRequestContext* context,
                                  const std::string& url_prefix,
                                  std::string* out,
-                                 OldCompletionCallback* callback) {
-  DCHECK(!callback_);
+                                 const CompletionCallback& callback) {
+  DCHECK(callback_.is_null());
   DCHECK(context);
   key_ = key;
   context_ = context;
   url_prefix_ = url_prefix;
   data_ = out;
   next_state_ = STATE_GET_BACKEND;
   int rv = DoLoop(OK);
 
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 void ViewCacheHelper::DoCallback(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
-  DCHECK(callback_);
+  DCHECK(!callback_.is_null());
 
-  OldCompletionCallback* c = callback_;
-  callback_ = NULL;
-  c->Run(rv);
+  callback_.Run(rv);
+  callback_.Reset();
 }
 
 void ViewCacheHelper::HandleResult(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   DCHECK_NE(ERR_FAILED, rv);
   context_ = NULL;
-  if (callback_)
+  if (!callback_.is_null())
     DoCallback(rv);
 }
 
 int ViewCacheHelper::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
@@ skipping 186 matching lines @@
     entry_ = NULL;
   }
   return OK;
 }
 
 void ViewCacheHelper::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net.