Add FilePath to base namespace.

webkit/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/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 45 matching lines @@
   kNotFound,
   kUnknownError,
   kFileSystemErrorMax,
 };
 
 const char kTemporaryOriginsCountLabel[] = "FileSystem.TemporaryOriginsCount";
 const char kPersistentOriginsCountLabel[] = "FileSystem.PersistentOriginsCount";
 
 // Restricted names.
 // http://dev.w3.org/2009/dap/file-system/file-dir-sys.html#naming-restrictions
-const FilePath::CharType* const kRestrictedNames[] = {
+const base::FilePath::CharType* const kRestrictedNames[] = {
   FILE_PATH_LITERAL("."), FILE_PATH_LITERAL(".."),
 };
 
 // Restricted chars.
-const FilePath::CharType kRestrictedChars[] = {
+const base::FilePath::CharType kRestrictedChars[] = {
   FILE_PATH_LITERAL('/'), FILE_PATH_LITERAL('\\'),
 };
 
 class ObfuscatedOriginEnumerator
     : public SandboxMountPointProvider::OriginEnumerator {
  public:
   explicit ObfuscatedOriginEnumerator(ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
   virtual ~ObfuscatedOriginEnumerator() {}
@@ skipping 20 matching lines @@
 }
 
 void ValidateRootOnFileThread(
     ObfuscatedFileUtil* file_util,
     const GURL& origin_url,
     FileSystemType type,
     bool create,
     base::PlatformFileError* error_ptr) {
   DCHECK(error_ptr);
 
-  FilePath root_path =
+  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);
   }
   // The reference of file_util will be derefed on the FILE thread
   // when the storage of this callback gets deleted regardless of whether
   // this method is called or not.
 }
 
 }  // anonymous namespace
 
-const FilePath::CharType SandboxMountPointProvider::kFileSystemDirectory[] =
+const base::FilePath::CharType SandboxMountPointProvider::kFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 // static
 bool SandboxMountPointProvider::CanHandleType(FileSystemType type) {
   return type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent ||
          type == kFileSystemTypeSyncable;
 }
 
 SandboxMountPointProvider::SandboxMountPointProvider(
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* file_task_runner,
-    const FilePath& profile_path,
+    const base::FilePath& profile_path,
     const FileSystemOptions& file_system_options)
     : file_task_runner_(file_task_runner),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       sandbox_file_util_(
           new AsyncFileUtilAdapter(
               new ObfuscatedFileUtil(
                   profile_path.Append(kFileSystemDirectory)))),
       quota_observer_(new SandboxQuotaObserver(
                       quota_manager_proxy,
@@ skipping 51 matching lines @@
       FROM_HERE,
       base::Bind(&ValidateRootOnFileThread,
                  sandbox_sync_file_util(),
                  origin_url, type, create,
                  base::Unretained(error_ptr)),
       base::Bind(&DidValidateFileSystemRoot,
                  weak_factory_.GetWeakPtr(),
                  callback, base::Owned(error_ptr)));
 };
 
-FilePath
+base::FilePath
 SandboxMountPointProvider::GetFileSystemRootPathOnFileThread(
     const FileSystemURL& url,
     bool create) {
   if (file_system_options_.is_incognito())
     // TODO(kinuko): return an isolated temporary directory.
-    return FilePath();
+    return base::FilePath();
 
   if (!IsAllowedScheme(url.origin()))
-    return FilePath();
+    return base::FilePath();
 
   return GetBaseDirectoryForOriginAndType(url.origin(), url.type(), create);
 }
 
 bool SandboxMountPointProvider::IsAccessAllowed(const FileSystemURL& url) {
   if (!CanHandleType(url.type()))
     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(url.origin());
 }
 
-bool SandboxMountPointProvider::IsRestrictedFileName(const FilePath& filename)
+bool SandboxMountPointProvider::IsRestrictedFileName(const base::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;
   }
 
   for (size_t i = 0; i < arraysize(kRestrictedChars); ++i) {
     if (filename.value().find(kRestrictedChars[i]) !=
-        FilePath::StringType::npos)
+        base::FilePath::StringType::npos)
       return true;
   }
 
   return false;
 }
 
 FileSystemFileUtil* SandboxMountPointProvider::GetFileUtil(
     FileSystemType type) {
   DCHECK(sandbox_file_util_.get());
   return sandbox_file_util_->sync_file_util();
@@ skipping 74 matching lines @@
                  origin_url,
                  type),
       callback);
 }
 
 SandboxMountPointProvider::OriginEnumerator*
 SandboxMountPointProvider::CreateOriginEnumerator() {
   return new ObfuscatedOriginEnumerator(sandbox_sync_file_util());
 }
 
-FilePath SandboxMountPointProvider::GetBaseDirectoryForOriginAndType(
+base::FilePath SandboxMountPointProvider::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) {
 
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
-  FilePath path = sandbox_sync_file_util()->GetDirectoryForOriginAndType(
+  base::FilePath path = sandbox_sync_file_util()->GetDirectoryForOriginAndType(
       origin_url, type, create, &error);
   if (error != base::PLATFORM_FILE_OK)
-    return FilePath();
+    return base::FilePath();
   return path;
 }
 
 base::PlatformFileError
 SandboxMountPointProvider::DeleteOriginDataOnFileThread(
     FileSystemContext* file_system_context,
     QuotaManagerProxy* proxy,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
 
@@ skipping 49 matching lines @@
         enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
 }
 
 int64 SandboxMountPointProvider::GetOriginUsageOnFileThread(
     FileSystemContext* file_system_context,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
   DCHECK(CanHandleType(type));
-  FilePath base_path =
+  base::FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false);
   if (base_path.empty() || !file_util::DirectoryExists(base_path)) return 0;
-  FilePath usage_file_path =
+  base::FilePath usage_file_path =
       base_path.Append(FileSystemUsageCache::kUsageFileName);
 
   bool is_valid = FileSystemUsageCache::IsValid(usage_file_path);
   int32 dirty_status = FileSystemUsageCache::GetDirty(usage_file_path);
   bool visited = (visited_origins_.find(origin_url) != visited_origins_.end());
   visited_origins_.insert(origin_url);
   if (is_valid && (dirty_status == 0 || (dirty_status > 0 && visited))) {
     // The usage cache is clean (dirty == 0) or the origin is already
     // initialized and running.  Read the cache file to get the usage.
     return FileSystemUsageCache::GetUsage(usage_file_path);
   }
   // The usage cache has not been initialized or the cache is dirty.
   // Get the directory size now and update the cache.
   FileSystemUsageCache::Delete(usage_file_path);
 
   FileSystemOperationContext context(file_system_context);
   FileSystemURL url = file_system_context->CreateCrackedFileSystemURL(
-      origin_url, type, FilePath());
+      origin_url, type, base::FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
       sandbox_sync_file_util()->CreateFileEnumerator(&context, url, true));
 
-  FilePath file_path_each;
+  base::FilePath file_path_each;
   int64 usage = 0;
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     usage += enumerator->Size();
     usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
   // This clears the dirty flag too.
   FileSystemUsageCache::UpdateUsage(usage_file_path, usage);
   return usage;
 }
 
 void SandboxMountPointProvider::InvalidateUsageCache(
     const GURL& origin_url, fileapi::FileSystemType type) {
   DCHECK(CanHandleType(type));
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
-  FilePath usage_file_path = GetUsageCachePathForOriginAndType(
+  base::FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       sandbox_sync_file_util(), origin_url, type, &error);
   if (error != base::PLATFORM_FILE_OK)
     return;
   FileSystemUsageCache::IncrementDirty(usage_file_path);
 }
 
 void SandboxMountPointProvider::CollectOpenFileSystemMetrics(
     base::PlatformFileError error_code) {
   base::Time now = base::Time::Now();
   bool throttled = now < next_release_time_for_open_filesystem_stat_;
@@ skipping 60 matching lines @@
 SandboxMountPointProvider::CreateFileSystemOperationForSync(
     FileSystemContext* file_system_context) {
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(file_system_context));
   operation_context->set_update_observers(update_observers_);
   operation_context->set_access_observers(access_observers_);
   return new LocalFileSystemOperation(file_system_context,
                                       operation_context.Pass());
 }
 
-FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
+base::FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
     const GURL& origin_url,
     FileSystemType type) {
   base::PlatformFileError error;
-  FilePath path = GetUsageCachePathForOriginAndType(
+  base::FilePath path = GetUsageCachePathForOriginAndType(
       sandbox_sync_file_util(), origin_url, type, &error);
   if (error != base::PLATFORM_FILE_OK)
-    return FilePath();
+    return base::FilePath();
   return path;
 }
 
 // static
-FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
+base::FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
     ObfuscatedFileUtil* sandbox_file_util,
     const GURL& origin_url,
     fileapi::FileSystemType type,
     base::PlatformFileError* error_out) {
   DCHECK(error_out);
   *error_out = base::PLATFORM_FILE_OK;
-  FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
+  base::FilePath base_path = sandbox_file_util->GetDirectoryForOriginAndType(
       origin_url, type, false /* create */, error_out);
   if (*error_out != base::PLATFORM_FILE_OK)
-    return FilePath();
+    return base::FilePath();
   return base_path.Append(FileSystemUsageCache::kUsageFileName);
 }
 
 bool SandboxMountPointProvider::IsAllowedScheme(const GURL& url) const {
   // Basically we only accept http or https. We allow file:// URLs
   // only if --allow-file-access-from-files flag is given.
   if (url.SchemeIs("http") || url.SchemeIs("https"))
     return true;
   if (url.SchemeIsFileSystem())
     return url.inner_url() && IsAllowedScheme(*url.inner_url());
 
   for (size_t i = 0;
        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;
 }
 
 ObfuscatedFileUtil* SandboxMountPointProvider::sandbox_sync_file_util() {
   DCHECK(sandbox_file_util_.get());
   return static_cast<ObfuscatedFileUtil*>(sandbox_file_util_->sync_file_util());
 }
 
 }  // namespace fileapi