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/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/lazy_instance.h"
-#include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 static const int kBufferSize = 4096;
 const int URLFetcher::kInvalidHttpResponseCode = -1;
 
+using base::FileUtilProxy;
+using base::PlatformFileError;
+
 class URLFetcher::Core
     : public base::RefCountedThreadSafe<URLFetcher::Core>,
       public net::URLRequest::Delegate {
  public:
   // For POST requests, set |content_type| to the MIME type of the content
   // and set |content| to the data to upload.  |flags| are flags to apply to
   // the load operation--these should be one or more of the LOAD_* flags
   // defined in net/base/load_flags.h.
   Core(URLFetcher* fetcher,
        const GURL& original_url,
@@ skipping 94 matching lines @@
     // Callback which gets the result of closing the temp file.
     void DidCloseTempFile(base::PlatformFileError error);
 
     // The URLFetcher::Core which instantiated this class.
     URLFetcher::Core* core_;
 
     // The last error encountered on a file operation.  base::PLATFORM_FILE_OK
     // if no error occurred.
     base::PlatformFileError error_code_;
 
-    // Callbacks are created for use with base::FileUtilProxy.
-    base::ScopedCallbackFactory<URLFetcher::Core::TempFileWriter>
-        callback_factory_;
+    // For file_util calls on the FileThread.
+    base::WeakPtrFactory<URLFetcher::Core::TempFileWriter>
+        weak_factory_;
 
     // Message loop on which file opperations should happen.
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
 
     // Path to the temporary file.  This path is empty when there
     // is no temp file.
     FilePath temp_file_;
 
     // Handle to the temp file.
     base::PlatformFile temp_file_handle_;
 
+    // Bytes written by the last ContinueWrite.
+    int bytes_written_;
+
     // We always append to the file.  Track the total number of bytes
     // written, so that writes know the offset to give.
     int64 total_bytes_written_;
 
     // How many bytes did the last Write() try to write?  Needed so
     // that if not all the bytes get written on a Write(), we can
     // call Write() again with the rest.
     int pending_bytes_;
 
     // When writing, how many bytes from the buffer have been successfully
@@ skipping 139 matching lines @@
 
 // static
 base::LazyInstance<URLFetcher::Core::Registry>
     URLFetcher::Core::g_registry(base::LINKER_INITIALIZED);
 
 URLFetcher::Core::TempFileWriter::TempFileWriter(
     URLFetcher::Core* core,
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy)
     : core_(core),
       error_code_(base::PLATFORM_FILE_OK),
-      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       file_message_loop_proxy_(file_message_loop_proxy),
       temp_file_handle_(base::kInvalidPlatformFileValue) {
 }
 
 URLFetcher::Core::TempFileWriter::~TempFileWriter() {
   RemoveTempFile();
 }
 
 void URLFetcher::Core::TempFileWriter::CreateTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
   CHECK(file_message_loop_proxy_.get());
-  base::FileUtilProxy::CreateTemporary(
+  FileUtilProxy::CreateTemporary(
       file_message_loop_proxy_,
       0,  // No additional file flags.
-      callback_factory_.NewCallback(
-          &URLFetcher::Core::TempFileWriter::DidCreateTempFile));
+      base::Bind(&URLFetcher::Core::TempFileWriter::DidCreateTempFile,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void URLFetcher::Core::TempFileWriter::DidCreateTempFile(
     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(
+    FileUtilProxy::Write(
         file_message_loop_proxy_,
         temp_file_handle_,
         total_bytes_written_,  // Append to the end
         (core_->buffer_->data() + buffer_offset_),
         pending_bytes_,
-        callback_factory_.NewCallback(
-            &URLFetcher::Core::TempFileWriter::ContinueWrite));
+        base::Bind(&URLFetcher::Core::TempFileWriter::ContinueWrite,
+                   weak_factory_.GetWeakPtr()));
   } else {
     // Finished writing core_->buffer_ to the file. Read some more.
     core_->ReadResponse();
   }
 }
 
 void URLFetcher::Core::TempFileWriter::DisownTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Disowning is done by the delegate's OnURLFetchComplete method.
   // The temp file should be closed by the time that method is called.
   DCHECK(temp_file_handle_ == base::kInvalidPlatformFileValue);
 
   // Forget about any temp file by reseting the path.
   temp_file_ = FilePath();
 }
 
 void URLFetcher::Core::TempFileWriter::CloseTempFileAndCompleteRequest() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
-    base::FileUtilProxy::Close(
+    FileUtilProxy::PostFileTaskAndReplyStatus<bool, PlatformFileError>(
         file_message_loop_proxy_,
-        temp_file_handle_,
-        callback_factory_.NewCallback(
-            &URLFetcher::Core::TempFileWriter::DidCloseTempFile));
+        FROM_HERE,
+        base::Bind(&base::ClosePlatformFile, temp_file_handle_),
+        base::Bind(&URLFetcher::Core::TempFileWriter::DidCloseTempFile,
+                   weak_factory_.GetWeakPtr()));
     temp_file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
 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());
 
   // Close the temp file if it is open.
   if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
-    base::FileUtilProxy::Close(
-        file_message_loop_proxy_,
-        temp_file_handle_,
-        NULL);  // No callback: Ignore errors.
+    file_message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::IgnoreReturn(base::Callback<bool(void)>(
+            base::Bind(&base::ClosePlatformFile, temp_file_handle_))));
     temp_file_handle_ = base::kInvalidPlatformFileValue;
   }
 
   if (!temp_file_.empty()) {
-    base::FileUtilProxy::Delete(
-        file_message_loop_proxy_,
-        temp_file_,
-        false,  // No need to recurse, as the path is to a file.
-        NULL);  // No callback: Ignore errors.
+    file_message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::IgnoreReturn(base::Callback<bool(void)>(
+            base::Bind(&file_util::Delete, temp_file_,
+                       false /* recursive */))));
     DisownTempFile();
   }
 }
 
 // static
 URLFetcher::Factory* URLFetcher::factory_ = NULL;
 
 void URLFetcher::Delegate::OnURLFetchComplete(
     const URLFetcher* source,
     const GURL& url,
@@ skipping 81 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 543 matching lines @@
 }
 
 // static
 int URLFetcher::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }