Rename FileSystemMountPointProvider::ValidateFileSystemRoot to OpenFileSystem

webkit/browser/fileapi/sandbox_mount_point_provider.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/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 76 matching lines @@
   }
 
   virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
     return enum_->HasFileSystemType(type);
   }
 
  private:
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
-void DidValidateFileSystemRoot(
+void DidOpenFileSystem(
     base::WeakPtr<SandboxMountPointProvider> mount_point_provider,
-    const FileSystemMountPointProvider::ValidateFileSystemCallback& callback,
+    const FileSystemMountPointProvider::OpenFileSystemCallback& callback,
     base::PlatformFileError* error) {
   if (mount_point_provider)
     mount_point_provider.get()->CollectOpenFileSystemMetrics(*error);
   callback.Run(*error);
 }
 
-void ValidateRootOnFileThread(
+void OpenFileSystemOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
-    bool create,
+    OpenFileSystemMode mode,
     base::PlatformFileError* error_ptr) {
   DCHECK(error_ptr);
 
+  const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   base::FilePath root_path =
       file_util->GetDirectoryForOriginAndType(
           origin_url, type, create, error_ptr);
   if (*error_ptr != base::PLATFORM_FILE_OK) {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kCreateDirectoryError,
                               kFileSystemErrorMax);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel, kOK, kFileSystemErrorMax);
   }
@@ skipping 66 matching lines @@
       delete quota_observer;
     if (!file_task_runner_->DeleteSoon(FROM_HERE, file_system_usage_cache))
       delete file_system_usage_cache;
   }
 }
 
 bool SandboxMountPointProvider::CanHandleType(FileSystemType type) const {
   return IsSandboxType(type);
 }
 
-void SandboxMountPointProvider::ValidateFileSystemRoot(
-    const GURL& origin_url, fileapi::FileSystemType type, bool create,
-    const ValidateFileSystemCallback& callback) {
+void SandboxMountPointProvider::OpenFileSystem(
+    const GURL& origin_url, fileapi::FileSystemType type,
+    OpenFileSystemMode mode,
+    const OpenFileSystemCallback& callback) {
   if (file_system_options_.is_incognito() &&
       !(type == kFileSystemTypeTemporary &&
         enable_temporary_file_system_in_incognito_)) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kInvalidSchemeError,
                               kFileSystemErrorMax);
     return;
   }
 
   base::PlatformFileError* error_ptr = new base::PlatformFileError;
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&ValidateRootOnFileThread,
+      base::Bind(&OpenFileSystemOnFileThread,
                  sandbox_sync_file_util(),
-                 origin_url, type, create,
+                 origin_url, type, mode,
                  base::Unretained(error_ptr)),
-      base::Bind(&DidValidateFileSystemRoot,
+      base::Bind(&DidOpenFileSystem,
                  weak_factory_.GetWeakPtr(),
                  callback, base::Owned(error_ptr)));
 
   if (enable_usage_tracking_)
     return;
 
   // Schedule full usage recalculation on the next launch without
   // --disable-file-system-usage-tracking.
   file_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 434 matching lines @@
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
 
   return usage;
 }
 
 }  // namespace fileapi