Cleanup FileSystemOperation for preparing for adding FSO-factory method

webkit/fileapi/sandbox_mount_point_provider.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/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/metrics/histogram.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
+#include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
 
@@ skipping 234 matching lines @@
 const FilePath::CharType SandboxMountPointProvider::kOldFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
         FILE_PATH_LITERAL("FS.old");
 
-class SandboxMountPointProvider::GetFileSystemRootPathTask
-    : public base::RefCountedThreadSafe<
-        SandboxMountPointProvider::GetFileSystemRootPathTask> {
+class ValidateFileSystemRootHelper {
  public:
-  GetFileSystemRootPathTask(
-      scoped_refptr<base::MessageLoopProxy> file_message_loop,
-      const GURL& origin_url,
-      FileSystemType type,
-      ObfuscatedFileUtil* file_util,
-      const FilePath& old_base_path,
-      const FileSystemMountPointProvider::GetRootPathCallback& callback)
+  typedef FileSystemMountPointProvider::ValidateFileSystemCallback Callback;
+
+  ValidateFileSystemRootHelper(
+      base::MessageLoopProxy* file_message_loop,
+      ObfuscatedFileUtil* file_util)
       : file_message_loop_(file_message_loop),
-        origin_message_loop_proxy_(
-            base::MessageLoopProxy::current()),
-        origin_url_(origin_url),
-        type_(type),
         file_util_(file_util),
-        old_base_path_(old_base_path),
-        callback_(callback) {
+        error_(base::PLATFORM_FILE_OK) {
   }
 
-  virtual ~GetFileSystemRootPathTask() {
+  ~ValidateFileSystemRootHelper() {
     // Just in case we get deleted without running, make sure to clean up the
     // file_util_ on the right thread.
     if (file_util_.get() && !file_message_loop_->BelongsToCurrentThread())
       file_message_loop_->ReleaseSoon(FROM_HERE, file_util_.release());
   }
 
-  void Start(bool create) {
-    file_message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &GetFileSystemRootPathTask::GetFileSystemRootPathOnFileThread, this,
-            create));
-  }
-
- private:
-  void GetFileSystemRootPathOnFileThread(bool create) {
-    MigrateIfNeeded(file_util_, old_base_path_);
-    DispatchCallbackOnCallerThread(
-        file_util_->GetDirectoryForOriginAndType(origin_url_, type_, create));
+  void RunOnFileThread(const GURL& origin_url,
+                       FileSystemType type,
+                       const FilePath& old_base_path,
+                       bool create) {
+    MigrateIfNeeded(file_util_, old_base_path);
+    FilePath root_path =
+        file_util_->GetDirectoryForOriginAndType(origin_url, type, create);
+    if (root_path.empty()) {
+      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
+                                kCreateDirectoryError,
+                                kFileSystemErrorMax);
+      // TODO(kinuko): We should return appropriate error code.
+      error_ = base::PLATFORM_FILE_ERROR_FAILED;
+    } else {
+      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem, kOK, kFileSystemErrorMax);
+      error_ = base::PLATFORM_FILE_OK;
+    }
     // We must clear the reference on the file thread.
     file_util_ = NULL;
   }
 
-  void DispatchCallbackOnCallerThread(const FilePath& root_path) {
-    if (root_path.empty()) {
-      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
-                                kCreateDirectoryError,
-                                kFileSystemErrorMax);
-    }
-    origin_message_loop_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(&GetFileSystemRootPathTask::DispatchCallback, this,
-                   root_path));
+  void Reply(const Callback& callback) {
+    callback.Run(error_);
   }
 
-  void DispatchCallback(const FilePath& root_path) {
-    std::string origin_identifier = GetOriginIdentifierFromURL(origin_url_);
-    std::string type_string = GetFileSystemTypeString(type_);
-    DCHECK(!type_string.empty());
-    std::string name = origin_identifier + ":" + type_string;
-
-    if (!root_path.empty())
-      UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem, kOK, kFileSystemErrorMax);
-
-    callback_.Run(!root_path.empty(), root_path, name);
-    callback_.Reset();
-  }
-
+ private:
   scoped_refptr<base::MessageLoopProxy> file_message_loop_;
-  scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
-  GURL origin_url_;
-  FileSystemType type_;
   scoped_refptr<ObfuscatedFileUtil> file_util_;
-  FilePath old_base_path_;
-  FileSystemMountPointProvider::GetRootPathCallback callback_;
+  base::PlatformFileError error_;
 };
 
 SandboxMountPointProvider::SandboxMountPointProvider(
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     const FilePath& profile_path,
     FileSystemOptions* file_system_options)
     : FileSystemQuotaUtil(file_message_loop),
       file_message_loop_(file_message_loop),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       sandbox_file_util_(
           new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
               QuotaFileUtil::CreateDefault())) {
   DCHECK(file_system_options);
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
   if (!file_message_loop_->BelongsToCurrentThread())
     file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util_.release());
 }
 
-bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
-                                                FileSystemType type,
-                                                const FilePath& unused) {
-  if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
-    return false;
-  // We essentially depend on quota to do our access controls, so here
-  // we only check if the requested scheme is allowed or not.
-  return IsAllowedScheme(origin_url);
-}
-
-void SandboxMountPointProvider::ValidateFileSystemRootAndGetURL(
+void SandboxMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
-    const FileSystemMountPointProvider::GetRootPathCallback& callback) {
-  FilePath origin_base_path;
-
+    const ValidateFileSystemCallback& callback) {
   if (file_system_options_->is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
-    callback.Run(false, FilePath(), std::string());
+    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
-    callback.Run(false, FilePath(), std::string());
+    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystem,
                               kInvalidScheme,
                               kFileSystemErrorMax);
     return;
   }
 
-  scoped_refptr<GetFileSystemRootPathTask> task(
-      new GetFileSystemRootPathTask(
-          file_message_loop_, origin_url, type, sandbox_file_util_.get(),
-          old_base_path(), callback));
-  task->Start(create);
+  ValidateFileSystemRootHelper* helper = new ValidateFileSystemRootHelper(
+      file_message_loop_, sandbox_file_util_);
+  file_message_loop_->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&ValidateFileSystemRootHelper::RunOnFileThread,
+                 base::Unretained(helper),
+                 origin_url, type, old_base_path(), create),

[tzik, 2011/12/22 06:49:20]

Could we add sandbox_file_util_ as parameter and omit it in
ValidateFileSystemRootHelper?

[kinuko, 2011/12/22 07:04:33]

Good point. Done.

+      base::Bind(&ValidateFileSystemRootHelper::Reply,
+                 base::Owned(helper),
+                 callback));
 };
 
 FilePath
-SandboxMountPointProvider::ValidateFileSystemRootAndGetPathOnFileThread(
+SandboxMountPointProvider::GetFileSystemRootPathOnFileThread(
     const GURL& origin_url, FileSystemType type, const FilePath& unused,
     bool create) {
   if (file_system_options_->is_incognito())
     // TODO(kinuko): return an isolated temporary directory.
     return FilePath();
 
   if (!IsAllowedScheme(origin_url))
     return FilePath();
 
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
   return sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create);
 }
 
+bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
+                                                FileSystemType type,
+                                                const FilePath& unused) {
+  if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
+    return false;
+  // We essentially depend on quota to do our access controls, so here
+  // we only check if the requested scheme is allowed or not.
+  return IsAllowedScheme(origin_url);
+}
+
 bool SandboxMountPointProvider::IsRestrictedFileName(const FilePath& filename)
     const {
   if (filename.value().empty())
     return false;
 
   for (size_t i = 0; i < arraysize(kRestrictedNames); ++i) {
     // Exact match.
     if (filename.value() == kRestrictedNames[i])
       return true;
   }
@@ skipping 238 matching lines @@
        i < file_system_options_->additional_allowed_schemes().size();
        ++i) {
     if (url.SchemeIs(
             file_system_options_->additional_allowed_schemes()[i].c_str()))
       return true;
   }
   return false;
 }
 
 }  // namespace fileapi