Remaining cleanup (base::Bind): Replacing FileUtilProxy calls with new callback

content/common/net/url_fetcher.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 "content/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 333 matching lines @@
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     FilePath file_path) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE,
-        NewRunnableMethod(core_, &Core::InformDelegateFetchIsComplete));
+        base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   temp_file_ = file_path;
   temp_file_handle_ = file_handle.ReleaseValue();
   total_bytes_written_ = 0;
 
   core_->io_message_loop_proxy_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(core_, &Core::StartURLRequestWhenAppropriate));
+      base::Bind(&Core::StartURLRequestWhenAppropriate, core_));
 }
 
 void URLFetcher::Core::TempFileWriter::WriteBuffer(int num_bytes) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Start writing to the temp file by setting the initial state
   // of |pending_bytes_| and |buffer_offset_| to indicate that the
   // entire buffer has not yet been written.
   pending_bytes_ = num_bytes;
   buffer_offset_ = 0;
   ContinueWrite(base::PLATFORM_FILE_OK, 0);
 }
 
 void URLFetcher::Core::TempFileWriter::ContinueWrite(
     base::PlatformFileError error_code,
     int bytes_written) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE,
-        NewRunnableMethod(core_, &Core::InformDelegateFetchIsComplete));
+        base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   total_bytes_written_ += bytes_written;
   buffer_offset_ += bytes_written;
   pending_bytes_ -= bytes_written;
 
   if (pending_bytes_ > 0) {
     base::FileUtilProxy::Write(
         file_message_loop_proxy_, temp_file_handle_,
@@ skipping 32 matching lines @@
 
 void URLFetcher::Core::TempFileWriter::DidCloseTempFile(
   base::PlatformFileError error_code) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE,
-        NewRunnableMethod(core_, &Core::InformDelegateFetchIsComplete));
+        base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   // If the file was successfully closed, then the URL request is complete.
   core_->RetryOrCompleteUrlFetch();
 }
 
 void URLFetcher::Core::TempFileWriter::RemoveTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
@@ skipping 104 matching lines @@
   if (io_message_loop_proxy_) {
     DCHECK_EQ(io_message_loop_proxy_,
               request_context_getter_->GetIOMessageLoopProxy());
   } else {
     io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   }
   CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &Core::StartOnIOThread));
+      base::Bind(&Core::StartOnIOThread, this));
 }
 
 void URLFetcher::Core::StartOnIOThread() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (response_destination_) {
     case STRING:
       StartURLRequestWhenAppropriate();
       break;
 
@@ skipping 13 matching lines @@
       NOTREACHED();
   }
 }
 
 void URLFetcher::Core::Stop() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &Core::CancelURLRequest));
+        FROM_HERE, base::Bind(&Core::CancelURLRequest, this));
   }
 }
 
 void URLFetcher::Core::ReceivedContentWasMalformed() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &Core::NotifyMalformedContent));
+        FROM_HERE, base::Bind(&Core::NotifyMalformedContent, this));
   }
 }
 
 void URLFetcher::Core::CancelAll() {
   g_registry.Get().CancelAll();
 }
 
 void URLFetcher::Core::OnResponseStarted(net::URLRequest* request) {
   DCHECK_EQ(request, request_.get());
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
@@ skipping 16 matching lines @@
                                 static_cast<int>(content.length()),
                                 is_last_chunk);
 }
 
 void URLFetcher::Core::AppendChunkToUpload(const std::string& content,
                                            bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
   CHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &Core::CompleteAddingUploadDataChunk, content,
-                        is_last_chunk));
+      base::Bind(&Core::CompleteAddingUploadDataChunk, this,
+                 content, is_last_chunk));
 }
 
 // Return true if the write was done and reading may continue.
 // Return false if the write is pending, and the next read will
 // be done later.
 bool URLFetcher::Core::WriteBuffer(int num_bytes) {
   bool write_complete = false;
   switch (response_destination_) {
     case STRING:
       data_.append(buffer_->data(), num_bytes);
@@ skipping 81 matching lines @@
         num_retries_ <= max_retries_) {
       StartOnIOThread();
       return;
     }
   } else {
     backoff_delay = base::TimeDelta();
   }
   request_context_getter_ = NULL;
   bool posted = delegate_loop_proxy_->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this,
-                        &Core::OnCompletedURLRequest,
-                        backoff_delay));
+      base::Bind(&Core::OnCompletedURLRequest, this,
+                 backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
 void URLFetcher::Core::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
@@ skipping 83 matching lines @@
             original_url_);
   }
 
   int64 delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
       GetBackoffReleaseTime());
   if (delay == 0) {
     StartURLRequest();
   } else {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        NewRunnableMethod(this, &Core::StartURLRequest),
+        base::Bind(&Core::StartURLRequest, this),
         delay);
   }
 }
 
 void URLFetcher::Core::CancelURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (request_.get()) {
     request_->Cancel();
     ReleaseRequest();
@@ skipping 246 matching lines @@
   DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
   if (core_->response_destination_ != TEMP_FILE ||
       !core_->temp_file_writer_.get())
     return false;
 
   *out_response_path = core_->temp_file_writer_->temp_file();
 
   if (take_ownership) {
     core_->io_message_loop_proxy_->PostTask(
         FROM_HERE,
-        NewRunnableMethod(core_.get(), &Core::DisownTempFile));
+        base::Bind(&Core::DisownTempFile, core_));
   }
   return true;
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }