Cleanup FileSystemOperation for preparing for adding FSO-factory method

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 40 matching lines @@
 }
 
 FileSystemOperation::ScopedQuotaUtilHelper::~ScopedQuotaUtilHelper() {
   if (quota_util_) {
     DCHECK(quota_util_->proxy());
     quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
   }
 }
 
 FileSystemOperation::FileSystemOperation(
-    FileSystemCallbackDispatcher* dispatcher,
+    scoped_ptr<FileSystemCallbackDispatcher> dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context)
     : proxy_(proxy),
-      dispatcher_(dispatcher),
+      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(),
         base::FileUtilProxy::StatusCallback());
   }
 }
 
-void FileSystemOperation::OpenFileSystem(
-    const GURL& origin_url, fileapi::FileSystemType type, bool create) {
-#ifndef NDEBUG
-  DCHECK(kOperationNone == pending_operation_);
-  pending_operation_ = static_cast<FileSystemOperation::OperationType>(
-      kOperationOpenFileSystem);
-#endif
-
-  DCHECK(file_system_context());
-  operation_context_.set_src_origin_url(origin_url);
-  operation_context_.set_src_type(type);
-  // TODO(ericu): We don't really need to make this call if !create.
-  // Also, in the future we won't need it either way, as long as we do all
-  // permission+quota checks beforehand.  We only need it now because we have to
-  // create an unpredictable directory name.  Without that, we could lazily
-  // create the root later on the first filesystem write operation, and just
-  // return GetFileSystemRootURI() here.
-  FileSystemMountPointProvider* mount_point_provider =
-      file_system_context()->GetMountPointProvider(type);
-  if (!mount_point_provider) {
-    DidGetRootPath(false, FilePath(), std::string());
-    delete this;
-    return;
-  }
-  mount_point_provider->ValidateFileSystemRootAndGetURL(
-      origin_url, type, create,
-      base::Bind(&FileSystemOperation::DidGetRootPath,
-                 base::Owned(this)));
-}
-
 void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
@@ skipping 383 matching lines @@
       base::Bind(&FileSystemFileUtil::CreateOrOpen,
                  base::Unretained(operation_context_.src_file_util()),
                  &operation_context_,
                  src_virtual_path_, file_flags),
       base::Bind(&FileSystemFileUtil::Close,
                  base::Unretained(operation_context_.src_file_util()),
                  &operation_context_),
       base::Bind(&FileSystemOperation::DidOpenFile, base::Owned(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;
-}
-
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
-void FileSystemOperation::Cancel(FileSystemOperation* cancel_operation_ptr) {
-  scoped_ptr<FileSystemOperation> cancel_operation(cancel_operation_ptr);
+void FileSystemOperation::Cancel(
+    scoped_ptr<FileSystemCallbackDispatcher> cancel_dispatcher) {
   if (file_writer_delegate_.get()) {
 #ifndef NDEBUG
     DCHECK(kOperationWrite == pending_operation_);
 #endif
     // Writes are done without proxying through FileUtilProxy after the initial
     // opening of the PlatformFile.  All state changes are done on this thread,
     // so we're guaranteed to be able to shut down atomically.  We do need to
     // check that the file has been opened [which means the blob_request_ has
     // been created], so we know how much we need to do.
     if (blob_request_.get())
       // This halts any calls to file_writer_delegate_ from blob_request_.
       blob_request_->Cancel();
 
     if (dispatcher_.get())
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
-    cancel_operation->dispatcher_->DidSucceed();
+    cancel_dispatcher->DidSucceed();
     dispatcher_.reset();
   } else {
 #ifndef NDEBUG
     DCHECK(kOperationTruncate == pending_operation_);
 #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_operation so that when the truncate returns, it can see that it's
+    // 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_operation_.get());
-    cancel_operation_.swap(cancel_operation);
+    DCHECK(!cancel_dispatcher_.get());
+    cancel_dispatcher_ = cancel_dispatcher.Pass();
   }
 }
 
+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;
+}
+
 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.
     callback.Run(quota::kQuotaStatusOk, 0, kint64max);
     return;
   }
   DCHECK(quota_manager_proxy);
   DCHECK(quota_manager_proxy->quota_manager());
   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
       operation_context_.src_origin_url(),
       FileSystemTypeToQuotaStorageType(
           operation_context_.src_type()),
       callback);
 }
 
-void FileSystemOperation::DidGetRootPath(
-    bool success,
-    const FilePath& path, const std::string& name) {
-  if (!dispatcher_.get())
-    return;
-  DCHECK(success || path.empty());
-  GURL result;
-  if (!dispatcher_.get())
-    return;
-  // We ignore the path, and return a URL instead.  The point was just to verify
-  // that we could create/find the path.
-  if (success) {
-    result = GetFileSystemRootURI(
-        operation_context_.src_origin_url(),
-        operation_context_.src_type());
-    DCHECK(result.is_valid());
-    dispatcher_->DidOpenFileSystem(name, result);
-  } else {
-    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
-  }
-}
-
 void FileSystemOperation::DidEnsureFileExistsExclusive(
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
     if (dispatcher_.get())
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
   } else {
     DidFinishFileOperation(rv);
   }
 }
 
 void FileSystemOperation::DidEnsureFileExistsNonExclusive(
     base::PlatformFileError rv, bool /* created */) {
   DidFinishFileOperation(rv);
 }
 
 void FileSystemOperation::DidFinishFileOperation(
     base::PlatformFileError rv) {
-  if (cancel_operation_.get()) {
+  if (cancel_dispatcher_.get()) {
 #ifndef NDEBUG
     DCHECK(kOperationTruncate == pending_operation_);
 #endif
 
     if (dispatcher_.get())
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
-    cancel_operation_->dispatcher_->DidSucceed();
+    cancel_dispatcher_->DidSucceed();
   } else if (dispatcher_.get()) {
     if (rv == base::PLATFORM_FILE_OK)
       dispatcher_->DidSucceed();
     else
       dispatcher_->DidFail(rv);
   }
 }
 
 void FileSystemOperation::DidDirectoryExists(
     base::PlatformFileError rv,
@@ skipping 202 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