Make FileSystemOperation::Write take closure-friendly parameters

webkit/browser/fileapi/local_file_system_operation.cc

 // Copyright (c) 2012 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/browser/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
 #include "net/base/escape.h"
-#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 #include "webkit/browser/fileapi/copy_or_move_operation_delegate.h"
 #include "webkit/browser/fileapi/file_observers.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_mount_point_provider.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/file_writer_delegate.h"
@@ skipping 126 matching lines @@
           file_system_context(), url,
           base::Bind(&LocalFileSystemOperation::DidFinishOperation,
                      AsWeakPtr(), callback)));
   if (recursive)
     recursive_operation_delegate_->RunRecursively();
   else
     recursive_operation_delegate_->Run();
 }
 
 void LocalFileSystemOperation::Write(
-    const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
-    const GURL& blob_url,
-    int64 offset,
+    scoped_ptr<FileWriterDelegate> writer_delegate,
+    scoped_ptr<net::URLRequest> blob_request,
     const WriteCallback& callback) {
-  GetWriteClosure(url_request_context, url, blob_url, offset, callback).Run();
+  DCHECK(SetPendingOperationType(kOperationWrite));
+  file_writer_delegate_ = writer_delegate.Pass();
+  file_writer_delegate_->Start(
+      blob_request.Pass(),
+      base::Bind(&LocalFileSystemOperation::DidWrite, AsWeakPtr(),
+                 url, callback));
 }
 
 void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoTruncate,
                  AsWeakPtr(), url, callback, length),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
@@ skipping 169 matching lines @@
   if (status != quota::kQuotaStatusOk) {
     LOG(WARNING) << "Got unexpected quota error : " << status;
     error_callback.Run();
     return;
   }
 
   operation_context_->set_allowed_bytes_growth(quota - usage);
   task.Run();
 }
 
-base::Closure LocalFileSystemOperation::GetWriteClosure(
-    const net::URLRequestContext* url_request_context,
-    const FileSystemURL& url,
-    const GURL& blob_url,
-    int64 offset,
-    const WriteCallback& callback) {
-  DCHECK(SetPendingOperationType(kOperationWrite));
-  scoped_ptr<FileStreamWriter> writer(
-      file_system_context()->CreateFileStreamWriter(url, offset));
-
-  if (!writer) {
-    // Write is not supported.
-    return base::Bind(&LocalFileSystemOperation::DidFailWrite,
-                      AsWeakPtr(), callback,
-                      base::PLATFORM_FILE_ERROR_SECURITY);
-  }
-
-  DCHECK(blob_url.is_valid());
-  file_writer_delegate_.reset(new FileWriterDelegate(
-      base::Bind(&LocalFileSystemOperation::DidWrite, AsWeakPtr(),
-                 url, callback),
-      writer.Pass()));
-
-  scoped_ptr<net::URLRequest> blob_request(url_request_context->CreateRequest(
-      blob_url, file_writer_delegate_.get()));
-
-  return base::Bind(&FileWriterDelegate::Start,
-                    base::Unretained(file_writer_delegate_.get()),
-                    base::Passed(&blob_request));
-}
-
-void LocalFileSystemOperation::DidFailWrite(
-    const WriteCallback& callback,
-    base::PlatformFileError result) {
-  callback.Run(result, 0, false);
-}
-
 void LocalFileSystemOperation::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive) {
   async_file_util_->EnsureFileExists(
       operation_context_.Pass(), url,
       base::Bind(
           exclusive ?
               &LocalFileSystemOperation::DidEnsureFileExistsExclusive :
               &LocalFileSystemOperation::DidEnsureFileExistsNonExclusive,
@@ skipping 143 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi