Add CreateFileSystemOperation() method to FileSystemContext

webkit/fileapi/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/fileapi/file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
@@ skipping 39 matching lines @@
   }
 }
 
 FileSystemOperation::ScopedQuotaUtilHelper::~ScopedQuotaUtilHelper() {
   if (quota_util_) {
     DCHECK(quota_util_->proxy());
     quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
   }
 }
 
-FileSystemOperation::FileSystemOperation(
-    scoped_ptr<FileSystemCallbackDispatcher> dispatcher,
-    scoped_refptr<base::MessageLoopProxy> proxy,
-    FileSystemContext* file_system_context)
-    : proxy_(proxy),
-      dispatcher_(dispatcher.Pass()),
-      operation_context_(file_system_context, NULL),
-      peer_handle_(base::kNullProcessHandle) {
-#ifndef NDEBUG
-  pending_operation_ = kOperationNone;
-#endif
-}
-
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get()) {
     FileSystemOperationContext* c =
         new FileSystemOperationContext(operation_context_);
     base::FileUtilProxy::RelayClose(
         proxy_,
         base::Bind(&FileSystemFileUtil::Close,
                    base::Unretained(c->src_file_util()),
                    base::Owned(c)),
         file_writer_delegate_->file(),
@@ skipping 431 matching lines @@
 #endif
     // We're cancelling a truncate operation, but we can't actually stop it
     // since it's been proxied to another thread.  We need to save the
     // cancel_dispatcher so that when the truncate returns, it can see that it's
     // been cancelled, report it, and report that the cancel has succeeded.
     DCHECK(!cancel_dispatcher_.get());
     cancel_dispatcher_ = cancel_dispatcher.Pass();
   }
 }
 
+FileSystemOperation* FileSystemOperation::AsFileSystemOperation() {
+  return this;
+}
+
 void FileSystemOperation::SyncGetPlatformPath(const GURL& path,
                                               FilePath* platform_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetLocalPath;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   operation_context_.src_file_util()->GetLocalFilePath(
       &operation_context_, src_virtual_path_, platform_path);
 
   delete this;
 }
 
+FileSystemOperation::FileSystemOperation(
+    scoped_ptr<FileSystemCallbackDispatcher> dispatcher,
+    scoped_refptr<base::MessageLoopProxy> proxy,
+    FileSystemContext* file_system_context)
+    : proxy_(proxy),
+      dispatcher_(dispatcher.Pass()),
+      operation_context_(file_system_context, NULL),
+      peer_handle_(base::kNullProcessHandle) {
+#ifndef NDEBUG
+  pending_operation_ = kOperationNone;
+#endif
+}
+
 void FileSystemOperation::GetUsageAndQuotaThenCallback(
     const GURL& origin_url,
     const quota::QuotaManager::GetUsageAndQuotaCallback& callback) {
   quota::QuotaManagerProxy* quota_manager_proxy =
       file_system_context()->quota_manager_proxy();
   if (!quota_manager_proxy ||
       !file_system_context()->GetQuotaUtil(
           operation_context_.src_type())) {
     // If we don't have the quota manager or the requested filesystem type
     // does not support quota, we should be able to let it go.
@@ skipping 249 matching lines @@
   bool result = VerifyFileSystemPathForWrite(
       path, create, &origin_url, &type, &dest_virtual_path_, &file_util);
   operation_context_.set_dest_origin_url(origin_url);
   operation_context_.set_dest_type(type);
   if (!operation_context_.dest_file_util())
     operation_context_.set_dest_file_util(file_util);
   return result;
 }
 
 }  // namespace fileapi