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

webkit/fileapi/file_system_url_request_job.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/fileapi/file_system_url_request_job.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/file_stream.h"
 #include "net/base/io_buffer.h"
@@ skipping 81 matching lines @@
   scoped_refptr<FileSystemURLRequestJob> job_;
   DISALLOW_COPY_AND_ASSIGN(CallbackDispatcher);
 };
 
 FileSystemURLRequestJob::FileSystemURLRequestJob(
     URLRequest* request, FileSystemContext* file_system_context,
     scoped_refptr<base::MessageLoopProxy> file_thread_proxy)
     : URLRequestJob(request),
       file_system_context_(file_system_context),
       file_thread_proxy_(file_thread_proxy),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &FileSystemURLRequestJob::DidRead)),
       stream_(NULL),
       is_directory_(false),
       remaining_bytes_(0) {
 }
 
 FileSystemURLRequestJob::~FileSystemURLRequestJob() {
   // Since we use the two-arg constructor of FileStream, we need to call Close()
   // manually: ~FileStream won't call it for us.
   if (stream_ != NULL)
     stream_->Close();
 }
 
 void FileSystemURLRequestJob::Start() {
-  MessageLoop::current()->PostTask(FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &FileSystemURLRequestJob::StartAsync));
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&FileSystemURLRequestJob::StartAsync,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void FileSystemURLRequestJob::Kill() {
   if (stream_ != NULL) {
     stream_->Close();
     stream_.reset(NULL);
   }
   URLRequestJob::Kill();
-  method_factory_.RevokeAll();
-  callback_factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 bool FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, int dest_size,
                                           int *bytes_read) {
   DCHECK_NE(dest_size, 0);
   DCHECK(bytes_read);
   DCHECK_GE(remaining_bytes_, 0);
 
   if (stream_ == NULL)
     return false;
@@ skipping 83 matching lines @@
   is_directory_ = file_info.is_directory;
 
   if (!byte_range_.ComputeBounds(file_info.size)) {
     NotifyFailed(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE);
     return;
   }
 
   if (!is_directory_) {
     base::FileUtilProxy::CreateOrOpen(
         file_thread_proxy_, platform_path, kFileFlags,
-        callback_factory_.NewCallback(&FileSystemURLRequestJob::DidOpen));
+        base::Bind(&FileSystemURLRequestJob::DidOpen,
+                   weak_factory_.GetWeakPtr()));
   } else {
     NotifyHeadersComplete();
   }
 }
 
 void FileSystemURLRequestJob::DidOpen(base::PlatformFileError error_code,
                                       base::PassPlatformFile file,
                                       bool created) {
   if (error_code != base::PLATFORM_FILE_OK) {
     NotifyFailed(error_code);
@@ skipping 54 matching lines @@
   }
 
   return false;
 }
 
 void FileSystemURLRequestJob::NotifyFailed(int rv) {
   NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 }  // namespace fileapi