Add FilePath to base namespace.

webkit/chromeos/fileapi/cros_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/chromeos/fileapi/cros_mount_point_provider.h"
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 54 matching lines @@
 void CrosMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url,
     fileapi::FileSystemType type,
     bool create,
     const ValidateFileSystemCallback& callback) {
   DCHECK(fileapi::IsolatedContext::IsIsolatedType(type));
   // Nothing to validate for external filesystem.
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
-FilePath CrosMountPointProvider::GetFileSystemRootPathOnFileThread(
+base::FilePath CrosMountPointProvider::GetFileSystemRootPathOnFileThread(
     const fileapi::FileSystemURL& url,
     bool create) {
   DCHECK(fileapi::IsolatedContext::IsIsolatedType(url.mount_type()));
   if (!url.is_valid())
-    return FilePath();
+    return base::FilePath();
 
-  FilePath root_path;
+  base::FilePath root_path;
   std::string mount_name = url.filesystem_id();
   if (!mount_points_->GetRegisteredPath(mount_name, &root_path) &&
       !system_mount_points_->GetRegisteredPath(mount_name, &root_path)) {
-    return FilePath();
+    return base::FilePath();
   }
 
   return root_path.DirName();
 }
 
 bool CrosMountPointProvider::IsAccessAllowed(
     const fileapi::FileSystemURL& url) {
   if (!url.is_valid())
     return false;
 
@@ skipping 12 matching lines @@
   std::string extension_id = origin_url.host();
   // Check first to make sure this extension has fileBrowserHander permissions.
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return false;
 
   return file_access_permissions_->HasAccessPermission(extension_id,
                                                        url.virtual_path());
 }
 
 // TODO(zelidrag): Share this code with SandboxMountPointProvider impl.
-bool CrosMountPointProvider::IsRestrictedFileName(const FilePath& path) const {
+bool CrosMountPointProvider::IsRestrictedFileName(
+    const base::FilePath& path) const {
   return false;
 }
 
 fileapi::FileSystemQuotaUtil* CrosMountPointProvider::GetQuotaUtil() {
   // No quota support.
   return NULL;
 }
 
 void CrosMountPointProvider::DeleteFileSystem(
     const GURL& origin_url,
@@ skipping 10 matching lines @@
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return;
 
   std::vector<fileapi::MountPoints::MountPointInfo> files;
   mount_points_->AddMountPointInfosTo(&files);
   system_mount_points_->AddMountPointInfosTo(&files);
 
   for (size_t i = 0; i < files.size(); ++i) {
     file_access_permissions_->GrantAccessPermission(
         extension_id,
-        FilePath::FromUTF8Unsafe(files[i].name));
+        base::FilePath::FromUTF8Unsafe(files[i].name));
   }
 }
 
 void CrosMountPointProvider::GrantFileAccessToExtension(
-    const std::string& extension_id, const FilePath& virtual_path) {
+    const std::string& extension_id, const base::FilePath& virtual_path) {
   // All we care about here is access from extensions for now.
   DCHECK(special_storage_policy_->IsFileHandler(extension_id));
   if (!special_storage_policy_->IsFileHandler(extension_id))
     return;
 
   std::string id;
   fileapi::FileSystemType type;
-  FilePath path;
+  base::FilePath path;
   if (!mount_points_->CrackVirtualPath(virtual_path, &id, &type, &path) &&
       !system_mount_points_->CrackVirtualPath(virtual_path,
                                               &id, &type, &path)) {
     return;
   }
 
   if (type == fileapi::kFileSystemTypeRestrictedNativeLocal) {
     LOG(ERROR) << "Can't grant access for restricted mount point";
     return;
   }
 
   file_access_permissions_->GrantAccessPermission(extension_id, virtual_path);
 }
 
 void CrosMountPointProvider::RevokeAccessForExtension(
       const std::string& extension_id) {
   file_access_permissions_->RevokePermissions(extension_id);
 }
 
-std::vector<FilePath> CrosMountPointProvider::GetRootDirectories() const {
+std::vector<base::FilePath> CrosMountPointProvider::GetRootDirectories() const {
   std::vector<fileapi::MountPoints::MountPointInfo> mount_points;
   mount_points_->AddMountPointInfosTo(&mount_points);
   system_mount_points_->AddMountPointInfosTo(&mount_points);
 
-  std::vector<FilePath> root_dirs;
+  std::vector<base::FilePath> root_dirs;
   for (size_t i = 0; i < mount_points.size(); ++i)
     root_dirs.push_back(mount_points[i].path);
   return root_dirs;
 }
 
 fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileUtil(
     fileapi::FileSystemType type) {
   DCHECK(type == fileapi::kFileSystemTypeNativeLocal ||
          type == fileapi::kFileSystemTypeRestrictedNativeLocal);
   return local_file_util_->sync_file_util();
@@ skipping 66 matching lines @@
     return new fileapi::RemoteFileStreamWriter(remote_proxy, url, offset);
   }
 
   if (url.type() == fileapi::kFileSystemTypeRestrictedNativeLocal)
     return NULL;
 
   DCHECK(url.type() == fileapi::kFileSystemTypeNativeLocal);
   return new fileapi::LocalFileStreamWriter(url.path(), offset);
 }
 
-bool CrosMountPointProvider::GetVirtualPath(const FilePath& filesystem_path,
-                                           FilePath* virtual_path) {
+bool CrosMountPointProvider::GetVirtualPath(const base::FilePath& filesystem_path,
+                                           base::FilePath* virtual_path) {
   return mount_points_->GetVirtualPath(filesystem_path, virtual_path) ||
          system_mount_points_->GetVirtualPath(filesystem_path, virtual_path);
 }
 
 fileapi::RemoteFileSystemProxyInterface* CrosMountPointProvider::GetRemoteProxy(
     const std::string& mount_name) const {
   fileapi::RemoteFileSystemProxyInterface* proxy =
       mount_points_->GetRemoteFileSystemProxy(mount_name);
   if (proxy)
     return proxy;
   return system_mount_points_->GetRemoteFileSystemProxy(mount_name);
 }
 
 }  // namespace chromeos