Finish the base::Bind migration for webkit/media.

webkit/media/buffered_resource_loader.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 "webkit/media/buffered_resource_loader.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "media/base/media_log.h"
@@ skipping 94 matching lines @@
     : deferred_(false),
       defer_strategy_(strategy),
       completed_(false),
       range_requested_(false),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
-      start_callback_(NULL),
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
-      read_callback_(NULL),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
       last_offset_(0),
       keep_test_loader_(false),
       bitrate_(bitrate),
       playback_rate_(playback_rate),
       media_log_(media_log) {
 
   size_t backward_capacity;
   size_t forward_capacity;
   ComputeTargetBufferWindow(
       playback_rate_, bitrate_, &backward_capacity, &forward_capacity);
   buffer_.reset(new media::SeekableBuffer(backward_capacity, forward_capacity));
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {
   if (!completed_ && url_loader_.get())
     url_loader_->cancel();
 }
 
-void BufferedResourceLoader::Start(net::OldCompletionCallback* start_callback,
-                                   const base::Closure& event_callback,
-                                   WebFrame* frame) {
+void BufferedResourceLoader::Start(
+    const net::CompletionCallback& start_callback,
+    const base::Closure& event_callback,
+    WebFrame* frame) {
   // Make sure we have not started.
-  DCHECK(!start_callback_.get());
+  DCHECK(start_callback_.is_null());
   DCHECK(event_callback_.is_null());
-  DCHECK(start_callback);
+  DCHECK(!start_callback.is_null());
   DCHECK(!event_callback.is_null());
   CHECK(frame);
 
-  start_callback_.reset(start_callback);
+  start_callback_ = start_callback;
   event_callback_ = event_callback;
 
   if (first_byte_position_ != kPositionNotSpecified) {
     // TODO(hclam): server may not support range request so |offset_| may not
     // equal to |first_byte_position_|.
     offset_ = first_byte_position_;
   }
 
   // Increment the reference count right before we start the request. This
   // reference will be release when this request has ended.
@@ skipping 25 matching lines @@
         WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
     url_loader_.reset(frame->createAssociatedURLLoader(options));
   }
 
   // Start the resource loading.
   url_loader_->loadAsynchronously(request, this);
 }
 
 void BufferedResourceLoader::Stop() {
   // Reset callbacks.
-  start_callback_.reset();
+  start_callback_.Reset();
   event_callback_.Reset();
-  read_callback_.reset();
+  read_callback_.Reset();
 
   // Use the internal buffer to signal that we have been stopped.
   // TODO(hclam): Not so pretty to do this.
   if (!buffer_.get())
     return;
 
   // Destroy internal buffer.
   buffer_.reset();
 
   if (url_loader_.get()) {
     if (deferred_)
       url_loader_->setDefersLoading(false);
     deferred_ = false;
 
     if (!completed_) {
       url_loader_->cancel();
       completed_ = true;
     }
   }
 }
 
-void BufferedResourceLoader::Read(int64 position,
-                                  int read_size,
-                                  uint8* buffer,
-                                  net::OldCompletionCallback* read_callback) {
-  DCHECK(!read_callback_.get());
+void BufferedResourceLoader::Read(
+    int64 position,
+    int read_size,
+    uint8* buffer,
+    const net::CompletionCallback& read_callback) {
+  DCHECK(read_callback_.is_null());
   DCHECK(buffer_.get());
-  DCHECK(read_callback);
+  DCHECK(!read_callback.is_null());
   DCHECK(buffer);
   DCHECK_GT(read_size, 0);
 
   // Save the parameter of reading.
-  read_callback_.reset(read_callback);
+  read_callback_ = read_callback;
   read_position_ = position;
   read_size_ = read_size;
   read_buffer_ = buffer;
 
   // If read position is beyond the instance size, we cannot read there.
   if (instance_size_ != kPositionNotSpecified &&
       instance_size_ <= read_position_) {
     DoneRead(0);
     return;
   }
@@ skipping 96 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // WebKit::WebURLLoaderClient implementation.
 void BufferedResourceLoader::willSendRequest(
     WebURLLoader* loader,
     WebURLRequest& newRequest,
     const WebURLResponse& redirectResponse) {
 
   // The load may have been stopped and |start_callback| is destroyed.
   // In this case we shouldn't do anything.
-  if (!start_callback_.get()) {
+  if (start_callback_.is_null()) {
     // Set the url in the request to an invalid value (empty url).
     newRequest.setURL(WebKit::WebURL());
     return;
   }
 
   // Only allow |single_origin_| if we haven't seen a different origin yet.
   if (single_origin_)
     single_origin_ = url_.GetOrigin() == GURL(newRequest.url()).GetOrigin();
 
   url_ = newRequest.url();
 }
 
 void BufferedResourceLoader::didSendData(
     WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
   NOTIMPLEMENTED();
 }
 
 void BufferedResourceLoader::didReceiveResponse(
     WebURLLoader* loader,
     const WebURLResponse& response) {
   VLOG(1) << "didReceiveResponse: " << response.httpStatusCode();
 
   // The loader may have been stopped and |start_callback| is destroyed.
   // In this case we shouldn't do anything.
-  if (!start_callback_.get())
+  if (start_callback_.is_null())
     return;
 
   bool partial_response = false;
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     int error = net::OK;
@@ skipping 99 matching lines @@
   VLOG(1) << "didFinishLoading";
 
   DCHECK(!completed_);
   completed_ = true;
 
   // If we didn't know the |instance_size_| we do now.
   if (instance_size_ == kPositionNotSpecified) {
     instance_size_ = offset_ + buffer_->forward_bytes();
   }
 
-  // If there is a start callback, calls it.
-  if (start_callback_.get()) {
+  // If there is a start callback, run it.
+  if (!start_callback_.is_null()) {
     DoneStart(net::OK);
   }
 
   // If there is a pending read but the request has ended, returns with what
   // we have.
   if (HasPendingRead()) {
     // Make sure we have a valid buffer before we satisfy a read request.
     DCHECK(buffer_.get());
 
     // Try to fulfill with what is in the buffer.
@@ skipping 14 matching lines @@
 }
 
 void BufferedResourceLoader::didFail(
     WebURLLoader* loader,
     const WebURLError& error) {
   VLOG(1) << "didFail: " << error.reason;
 
   DCHECK(!completed_);
   completed_ = true;
 
-  // If there is a start callback, calls it.
-  if (start_callback_.get()) {
+  // If there is a start callback, run it.
+  if (!start_callback_.is_null()) {
     DoneStart(error.reason);
   }
 
   // If there is a pending read but the request failed, return with the
   // reason for the error.
   if (HasPendingRead()) {
     DoneRead(error.reason);
   }
 
   // Notify that network response is completed.
@@ skipping 71 matching lines @@
   if (deferred_)
     return false;
 
   switch(defer_strategy_) {
     // Never defer at all, so never enable defer.
     case kNeverDefer:
       return false;
 
     // Defer if nothing is being requested.
     case kReadThenDefer:
-      return !read_callback_.get();
+      return read_callback_.is_null();
 
     // Defer if we've reached the max capacity of the threshold.
     case kThresholdDefer:
       return buffer_->forward_bytes() >= buffer_->forward_capacity();
   }
   // Otherwise don't enable defer.
   return false;
 }
 
 bool BufferedResourceLoader::ShouldDisableDefer() {
   // If we're not deferring, then disabling makes no sense.
   if (!deferred_)
     return false;
 
   switch(defer_strategy_) {
     // Always disable deferring.
     case kNeverDefer:
       return true;
 
     // We have an outstanding read request, and we have not buffered enough
     // yet to fulfill the request; disable defer to get more data.
     case kReadThenDefer:
-      return read_callback_.get() &&
+      return !read_callback_.is_null() &&
           last_offset_ > static_cast<int>(buffer_->forward_bytes());
 
     // We have less than half the capacity of our threshold, so
     // disable defer to get more data.
     case kThresholdDefer: {
       size_t amount_buffered = buffer_->forward_bytes();
       size_t half_capacity = buffer_->forward_capacity() / 2;
       return amount_buffered < half_capacity;
     }
   }
@@ skipping 97 matching lines @@
   } else if (first_byte_position > kPositionNotSpecified) {
     header = base::StringPrintf("bytes=%" PRId64 "-",
                                 first_byte_position);
   } else if (last_byte_position > kPositionNotSpecified) {
     NOTIMPLEMENTED() << "Suffix range not implemented";
   }
   return header;
 }
 
 void BufferedResourceLoader::DoneRead(int error) {
-  read_callback_->RunWithParams(Tuple1<int>(error));
-  read_callback_.reset();
+  read_callback_.Run(error);
+  read_callback_.Reset();
   if (buffer_.get() && saved_forward_capacity_) {
     buffer_->set_forward_capacity(saved_forward_capacity_);
     saved_forward_capacity_ = 0;
   }
   read_position_ = 0;
   read_size_ = 0;
   read_buffer_ = NULL;
   first_offset_ = 0;
   last_offset_ = 0;
   Log();
 }
 
 void BufferedResourceLoader::DoneStart(int error) {
-  start_callback_->RunWithParams(Tuple1<int>(error));
-  start_callback_.reset();
+  start_callback_.Run(error);
+  start_callback_.Reset();
 }
 
 void BufferedResourceLoader::NotifyNetworkEvent() {
   if (!event_callback_.is_null())
     event_callback_.Run();
 }
 
 bool BufferedResourceLoader::IsRangeRequest() const {
   return first_byte_position_ != kPositionNotSpecified;
 }
 
 void BufferedResourceLoader::Log() {
   if (buffer_.get()) {
     media_log_->AddEvent(
         media_log_->CreateBufferedExtentsChangedEvent(
             offset_ - buffer_->backward_bytes(),
             offset_,
             offset_ + buffer_->forward_bytes()));
   }
 }
 
 }  // namespace webkit_media