Use base namespace for FilePath in content/browser

content/browser/child_process_security_policy_impl.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 "content/browser/child_process_security_policy_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 62 matching lines @@
   void GrantScheme(const std::string& scheme) {
     scheme_policy_[scheme] = true;
   }
 
   // Revoke permission to request URLs with the specified scheme.
   void RevokeScheme(const std::string& scheme) {
     scheme_policy_[scheme] = false;
   }
 
   // Grant certain permissions to a file.
-  void GrantPermissionsForFile(const FilePath& file, int permissions) {
-    FilePath stripped = file.StripTrailingSeparators();
+  void GrantPermissionsForFile(const base::FilePath& file, int permissions) {
+    base::FilePath stripped = file.StripTrailingSeparators();
     file_permissions_[stripped] |= permissions;
     UMA_HISTOGRAM_COUNTS("ChildProcessSecurityPolicy.FilePermissionPathLength",
                          stripped.value().size());
   }
 
   // Grant navigation to a file but not the file:// scheme in general.
-  void GrantRequestOfSpecificFile(const FilePath &file) {
+  void GrantRequestOfSpecificFile(const base::FilePath &file) {
     request_file_set_.insert(file.StripTrailingSeparators());
   }
 
   // Revokes all permissions granted to a file.
-  void RevokeAllPermissionsForFile(const FilePath& file) {
-    FilePath stripped = file.StripTrailingSeparators();
+  void RevokeAllPermissionsForFile(const base::FilePath& file) {
+    base::FilePath stripped = file.StripTrailingSeparators();
     file_permissions_.erase(stripped);
     request_file_set_.erase(stripped);
   }
 
   // Grant certain permissions to a file.
   void GrantPermissionsForFileSystem(const std::string& filesystem_id,
                                      int permissions) {
     if (filesystem_permissions_.find(filesystem_id) ==
         filesystem_permissions_.end())
       fileapi::IsolatedContext::GetInstance()->AddReference(filesystem_id);
@@ skipping 24 matching lines @@
   // Determine whether permission has been granted to request |url|.
   bool CanRequestURL(const GURL& url) {
     // Having permission to a scheme implies permssion to all of its URLs.
     SchemeMap::const_iterator judgment(scheme_policy_.find(url.scheme()));
     if (judgment != scheme_policy_.end())
       return judgment->second;
 
     // file:// URLs are more granular.  The child may have been given
     // permission to a specific file but not the file:// scheme in general.
     if (url.SchemeIs(chrome::kFileScheme)) {
-      FilePath path;
+      base::FilePath path;
       if (net::FileURLToFilePath(url, &path))
         return request_file_set_.find(path) != request_file_set_.end();
     }
 
     return false;  // Unmentioned schemes are disallowed.
   }
 
   // Determine if the certain permissions have been granted to a file.
-  bool HasPermissionsForFile(const FilePath& file, int permissions) {
+  bool HasPermissionsForFile(const base::FilePath& file, int permissions) {
     if (!permissions || file.empty() || !file.IsAbsolute())
       return false;
-    FilePath current_path = file.StripTrailingSeparators();
-    FilePath last_path;
+    base::FilePath current_path = file.StripTrailingSeparators();
+    base::FilePath last_path;
     int skip = 0;
     while (current_path != last_path) {
-      FilePath base_name =  current_path.BaseName();
-      if (base_name.value() == FilePath::kParentDirectory) {
+      base::FilePath base_name =  current_path.BaseName();
+      if (base_name.value() == base::FilePath::kParentDirectory) {
         ++skip;
       } else if (skip > 0) {
-        if (base_name.value() != FilePath::kCurrentDirectory)
+        if (base_name.value() != base::FilePath::kCurrentDirectory)
           --skip;
       } else {
         if (file_permissions_.find(current_path) != file_permissions_.end())
           return (file_permissions_[current_path] & permissions) == permissions;
       }
       last_path = current_path;
       current_path = current_path.DirName();
     }
 
     return false;
@@ skipping 48 matching lines @@
   }
 
   bool can_read_raw_cookies() const {
     return can_read_raw_cookies_;
   }
 
  private:
   typedef std::map<std::string, bool> SchemeMap;
 
   typedef int FilePermissionFlags;  // bit-set of PlatformFileFlags
-  typedef std::map<FilePath, FilePermissionFlags> FileMap;
+  typedef std::map<base::FilePath, FilePermissionFlags> FileMap;
   typedef std::map<std::string, FilePermissionFlags> FileSystemMap;
-  typedef std::set<FilePath> FileSet;
+  typedef std::set<base::FilePath> FileSet;
 
   // Maps URL schemes to whether permission has been granted or revoked:
   //   |true| means the scheme has been granted.
   //   |false| means the scheme has been revoked.
   // If a scheme is not present in the map, then it has never been granted
   // or revoked.
   SchemeMap scheme_policy_;
 
   // The set of files the child process is permited to upload to the web.
   FileMap file_permissions_;
@@ skipping 155 matching lines @@
     return;
 
   {
     base::AutoLock lock(lock_);
     SecurityStateMap::iterator state = security_state_.find(child_id);
     if (state == security_state_.end())
       return;
 
     // When the child process has been commanded to request a file:// URL,
     // then we grant it the capability for that URL only.
-    FilePath path;
+    base::FilePath path;
     if (net::FileURLToFilePath(url, &path))
-        state->second->GrantRequestOfSpecificFile(path);
+      state->second->GrantRequestOfSpecificFile(path);
   }
 }
 
 void ChildProcessSecurityPolicyImpl::GrantReadFile(int child_id,
-                                                   const FilePath& file) {
+                                                   const base::FilePath& file) {
   GrantPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
 void ChildProcessSecurityPolicyImpl::GrantReadDirectory(
-    int child_id, const FilePath& directory) {
+    int child_id, const base::FilePath& directory) {
   GrantPermissionsForFile(child_id, directory, kEnumerateDirectoryPermissions);
 }
 
 void ChildProcessSecurityPolicyImpl::GrantPermissionsForFile(
-    int child_id, const FilePath& file, int permissions) {
+    int child_id, const base::FilePath& file, int permissions) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantPermissionsForFile(file, permissions);
 }
 
 void ChildProcessSecurityPolicyImpl::RevokeAllPermissionsForFile(
-    int child_id, const FilePath& file) {
+    int child_id, const base::FilePath& file) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->RevokeAllPermissionsForFile(file);
 }
 
 void ChildProcessSecurityPolicyImpl::GrantReadFileSystem(
@@ skipping 120 matching lines @@
     if (state == security_state_.end())
       return false;
 
     // Otherwise, we consult the child process's security state to see if it is
     // allowed to request the URL.
     return state->second->CanRequestURL(url);
   }
 }
 
 bool ChildProcessSecurityPolicyImpl::CanReadFile(int child_id,
-                                                 const FilePath& file) {
+                                                 const base::FilePath& file) {
   return HasPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanReadDirectory(
-    int child_id, const FilePath& directory) {
+    int child_id, const base::FilePath& directory) {
   return HasPermissionsForFile(child_id,
                                directory,
                                kEnumerateDirectoryPermissions);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanReadFileSystem(
     int child_id, const std::string& filesystem_id) {
   return HasPermissionsForFileSystem(child_id,
                                      filesystem_id,
                                      kReadFilePermissions);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanReadWriteFileSystem(
     int child_id, const std::string& filesystem_id) {
   return HasPermissionsForFileSystem(child_id,
                                      filesystem_id,
                                      kReadFilePermissions |
                                      kWriteFilePermissions);
 }
 
 bool ChildProcessSecurityPolicyImpl::HasPermissionsForFile(
-    int child_id, const FilePath& file, int permissions) {
+    int child_id, const base::FilePath& file, int permissions) {
   base::AutoLock lock(lock_);
   bool result = ChildProcessHasPermissionsForFile(child_id, file, permissions);
   if (!result) {
     // If this is a worker thread that has no access to a given file,
     // let's check that its renderer process has access to that file instead.
     WorkerToMainProcessMap::iterator iter = worker_map_.find(child_id);
     if (iter != worker_map_.end() && iter->second != 0) {
       result = ChildProcessHasPermissionsForFile(iter->second,
                                                  file,
                                                  permissions);
@@ skipping 25 matching lines @@
 void ChildProcessSecurityPolicyImpl::AddChild(int child_id) {
   if (security_state_.count(child_id) != 0) {
     NOTREACHED() << "Add child process at most once.";
     return;
   }
 
   security_state_[child_id] = new SecurityState();
 }
 
 bool ChildProcessSecurityPolicyImpl::ChildProcessHasPermissionsForFile(
-    int child_id, const FilePath& file, int permissions) {
+    int child_id, const base::FilePath& file, int permissions) {
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
   return state->second->HasPermissionsForFile(file, permissions);
 }
 
 bool ChildProcessSecurityPolicyImpl::CanAccessCookiesForOrigin(
     int child_id, const GURL& gurl) {
   base::AutoLock lock(lock_);
   SecurityStateMap::iterator state = security_state_.find(child_id);
@@ skipping 39 matching lines @@
     int permission) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
   return state->second->HasPermissionsForFileSystem(filesystem_id, permission);
 }
 
 }  // namespace content