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

webkit/media/buffered_data_source.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_data_source.h"
 
 #include "base/bind.h"
 #include "media/base/filter_host.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 207 matching lines @@
         stop_signal_received_) {
       return;
     }
   }
 
   if (url_.SchemeIs(kHttpScheme) || url_.SchemeIs(kHttpsScheme)) {
     // Do an unbounded range request starting at the beginning.  If the server
     // responds with 200 instead of 206 we'll fall back into a streaming mode.
     loader_ = CreateResourceLoader(0, kPositionNotSpecified);
     loader_->Start(
-        NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
+        base::Bind(&BufferedDataSource::HttpInitialStartCallback, this),
         base::Bind(&BufferedDataSource::NetworkEventCallback, this),
         frame_);
   } else {
     // For all other protocols, assume they support range request. We fetch
     // the full range of the resource to obtain the instance size because
     // we won't be served HTTP headers.
     loader_ = CreateResourceLoader(kPositionNotSpecified,
                                    kPositionNotSpecified);
     loader_->Start(
-        NewCallback(this, &BufferedDataSource::NonHttpInitialStartCallback),
+        base::Bind(&BufferedDataSource::NonHttpInitialStartCallback, this),
         base::Bind(&BufferedDataSource::NetworkEventCallback, this),
         frame_);
   }
 }
 
 void BufferedDataSource::ReadTask(
     int64 position,
     int read_size,
     uint8* buffer) {
   DCHECK(MessageLoop::current() == render_loop_);
@@ skipping 50 matching lines @@
 
   {
     // If there's no outstanding read then return early.
     base::AutoLock auto_lock(lock_);
     if (read_callback_.is_null())
       return;
   }
 
   loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified);
   loader_->Start(
-      NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
+      base::Bind(&BufferedDataSource::PartialReadStartCallback, this),
       base::Bind(&BufferedDataSource::NetworkEventCallback, this),
       frame_);
 }
 
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   playback_rate_ = playback_rate;
   loader_->SetPlaybackRate(playback_rate);
@@ skipping 47 matching lines @@
   DCHECK(loader_);
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (read_size_ > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[read_size_]);
   }
 
   // Perform the actual read with BufferedResourceLoader.
   loader_->Read(read_position_, read_size_, intermediate_read_buffer_.get(),
-                NewCallback(this, &BufferedDataSource::ReadCallback));
+                base::Bind(&BufferedDataSource::ReadCallback, this));
 }
 
 // Method to report the results of the current read request. Also reset all
 // the read parameters.
 void BufferedDataSource::DoneRead_Locked(int error) {
   VLOG(1) << "DoneRead: " << error << " bytes";
 
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!read_callback_.is_null());
   lock_.AssertAcquired();
@@ skipping 51 matching lines @@
     loader_->Stop();
   }
 
   if (error == net::ERR_INVALID_RESPONSE && using_range_request_) {
     // Assuming that the Range header was causing the problem. Retry without
     // the Range header.
     using_range_request_ = false;
     loader_ = CreateResourceLoader(kPositionNotSpecified,
                                    kPositionNotSpecified);
     loader_->Start(
-        NewCallback(this, &BufferedDataSource::HttpInitialStartCallback),
+        base::Bind(&BufferedDataSource::HttpInitialStartCallback, this),
         base::Bind(&BufferedDataSource::NetworkEventCallback, this),
         frame_);
     return;
   }
 
   // Reference to prevent destruction while inside the |initialize_cb_|
   // call. This is a temporary fix to prevent crashes caused by holding the
   // lock and running the destructor.
   // TODO: Review locking in this class and figure out a way to run the callback
   //       w/o the lock.
@@ skipping 201 matching lines @@
 
   if (streaming_)
     filter_host->SetStreaming(true);
 
   if (total_bytes_ != kPositionNotSpecified)
     filter_host->SetTotalBytes(total_bytes_);
   filter_host->SetBufferedBytes(buffered_bytes_);
 }
 
 }  // namespace webkit_media