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

net/http/partial_data.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/partial_data.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 97 matching lines @@
 }
 
 // -----------------------------------------------------------------------------
 
 PartialData::PartialData()
     : range_present_(false),
       final_range_(false),
       sparse_entry_(true),
       truncated_(false),
       initial_validation_(false),
-      core_(NULL),
-      callback_(NULL) {
+      core_(NULL) {
 }
 
 PartialData::~PartialData() {
   if (core_)
     core_->Cancel();
 }
 
 bool PartialData::Init(const HttpRequestHeaders& headers) {
   std::string range_header;
   if (!headers.GetHeader(HttpRequestHeaders::kRange, &range_header))
@@ skipping 25 matching lines @@
   DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange());
   int64 end = byte_range_.IsSuffixByteRange() ?
               byte_range_.suffix_length() : byte_range_.last_byte_position();
 
   headers->CopyFrom(extra_headers_);
   if (!truncated_ && byte_range_.IsValid())
     AddRangeHeader(current_range_start_, end, headers);
 }
 
 int PartialData::ShouldValidateCache(disk_cache::Entry* entry,
-                                     OldCompletionCallback* callback) {
+                                     const CompletionCallback& callback) {
   DCHECK_GE(current_range_start_, 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int len = GetNextRangeLen();
   if (!len)
     return 0;
 
   DVLOG(3) << "ShouldValidateCache len: " << len;
 
   if (sparse_entry_) {
-    DCHECK(!callback_);
+    DCHECK(callback_.is_null());
     Core* core = Core::CreateCore(this);
     cached_min_len_ = core->GetAvailableRange(entry, current_range_start_, len,
                                               &cached_start_);
 
     if (cached_min_len_ == ERR_IO_PENDING) {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
   } else if (!truncated_) {
     if (byte_range_.HasFirstBytePosition() &&
@@ skipping 287 matching lines @@
   int64 range_len =
       byte_range_.HasLastBytePosition() ?
       byte_range_.last_byte_position() - current_range_start_ + 1 :
       kint32max;
   if (range_len > kint32max)
     range_len = kint32max;
   return static_cast<int32>(range_len);
 }
 
 void PartialData::GetAvailableRangeCompleted(int result, int64 start) {
-  DCHECK(callback_);
+  DCHECK(!callback_.is_null());
   DCHECK_NE(ERR_IO_PENDING, result);
 
   cached_start_ = start;
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
-  OldCompletionCallback* cb = callback_;
-  callback_ = NULL;
-  cb->Run(result);
+  CompletionCallback cb = callback_;
+  callback_.Reset();
+  cb.Run(result);
 }
 
 }  // namespace net