Add FilePath to base namespace.

webkit/fileapi/file_system_directory_database.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/file_system_directory_database.h"
 
 #include <math.h>
 #include <algorithm>
 #include <set>
 #include <stack>
@@ skipping 15 matching lines @@
     const fileapi::FileSystemDirectoryDatabase::FileInfo& info,
     Pickle* pickle) {
   DCHECK(pickle);
   std::string data_path;
   // Round off here to match the behavior of the filesystem on real files.
   base::Time time =
       base::Time::FromDoubleT(floor(info.modification_time.ToDoubleT()));
   std::string name;
 
   data_path = fileapi::FilePathToString(info.data_path);
-  name = fileapi::FilePathToString(FilePath(info.name));
+  name = fileapi::FilePathToString(base::FilePath(info.name));
 
   if (pickle->WriteInt64(info.parent_id) &&
       pickle->WriteString(data_path) &&
       pickle->WriteString(name) &&
       pickle->WriteInt64(time.ToInternalValue()))
     return true;
 
   NOTREACHED();
   return false;
 }
@@ skipping 12 matching lines @@
       pickle.ReadInt64(&iter, &internal_time)) {
     info->data_path = fileapi::StringToFilePath(data_path);
     info->name = fileapi::StringToFilePath(name).value();
     info->modification_time = base::Time::FromInternalValue(internal_time);
     return true;
   }
   LOG(ERROR) << "Pickle could not be digested!";
   return false;
 }
 
-const FilePath::CharType kDirectoryDatabaseName[] = FILE_PATH_LITERAL("Paths");
+const base::FilePath::CharType kDirectoryDatabaseName[] = FILE_PATH_LITERAL("Paths");
 const char kChildLookupPrefix[] = "CHILD_OF:";
 const char kChildLookupSeparator[] = ":";
 const char kLastFileIdKey[] = "LAST_FILE_ID";
 const char kLastIntegerKey[] = "LAST_INTEGER";
 const int64 kMinimumReportIntervalHours = 1;
 const char kInitStatusHistogramLabel[] = "FileSystem.DirectoryDatabaseInit";
 
 enum InitStatus {
   INIT_STATUS_OK = 0,
   INIT_STATUS_CORRUPTION,
   INIT_STATUS_IO_ERROR,
   INIT_STATUS_UNKNOWN_ERROR,
   INIT_STATUS_MAX
 };
 
 std::string GetChildLookupKey(
     fileapi::FileSystemDirectoryDatabase::FileId parent_id,
-    const FilePath::StringType& child_name) {
+    const base::FilePath::StringType& child_name) {
   std::string name;
-  name = fileapi::FilePathToString(FilePath(child_name));
+  name = fileapi::FilePathToString(base::FilePath(child_name));
   return std::string(kChildLookupPrefix) + base::Int64ToString(parent_id) +
       std::string(kChildLookupSeparator) + name;
 }
 
 std::string GetChildListingKeyPrefix(
     fileapi::FileSystemDirectoryDatabase::FileId parent_id) {
   return std::string(kChildLookupPrefix) + base::Int64ToString(parent_id) +
       std::string(kChildLookupSeparator);
 }
 
@@ skipping 22 matching lines @@
 //  - Each file in the database has unique backing file.
 //  - Each file in |filesystem_data_directory_| has a database entry.
 //  - Directory structure is tree, i.e. connected and acyclic.
 class DatabaseCheckHelper {
  public:
   typedef fileapi::FileSystemDirectoryDatabase::FileId FileId;
   typedef fileapi::FileSystemDirectoryDatabase::FileInfo FileInfo;
 
   DatabaseCheckHelper(fileapi::FileSystemDirectoryDatabase* dir_db,
                       leveldb::DB* db,
-                      const FilePath& path);
+                      const base::FilePath& path);
 
   bool IsFileSystemConsistent() {
     return IsDatabaseEmpty() ||
         (ScanDatabase() && ScanDirectory() && ScanHierarchy());
   }
 
  private:
   bool IsDatabaseEmpty();
   // These 3 methods need to be called in the order.  Each method requires its
   // previous method finished successfully. They also require the database is
   // not empty.
   bool ScanDatabase();
   bool ScanDirectory();
   bool ScanHierarchy();
 
   fileapi::FileSystemDirectoryDatabase* dir_db_;
   leveldb::DB* db_;
-  FilePath path_;
+  base::FilePath path_;
 
-  std::set<FilePath> files_in_db_;
+  std::set<base::FilePath> files_in_db_;
 
   size_t num_directories_in_db_;
   size_t num_files_in_db_;
   size_t num_hierarchy_links_in_db_;
 
   FileId last_file_id_;
   FileId last_integer_;
 };
 
 DatabaseCheckHelper::DatabaseCheckHelper(
     fileapi::FileSystemDirectoryDatabase* dir_db,
     leveldb::DB* db,
-    const FilePath& path)
+    const base::FilePath& path)
     : dir_db_(dir_db), db_(db), path_(path),
       num_directories_in_db_(0),
       num_files_in_db_(0),
       num_hierarchy_links_in_db_(0),
       last_file_id_(-1), last_integer_(-1) {
   DCHECK(dir_db_);
   DCHECK(db_);
   DCHECK(!path_.empty() && file_util::DirectoryExists(path_));
 }
 
@@ skipping 77 matching lines @@
   }
 
   // TODO(tzik): Add constraint for |last_integer_| to avoid possible
   // data path confliction on ObfuscatedFileUtil.
   return max_file_id <= last_file_id_;
 }
 
 bool DatabaseCheckHelper::ScanDirectory() {
   // TODO(kinuko): Scans all local file system entries to verify each of them
   // has a database entry.
-  const FilePath kExcludes[] = {
-    FilePath(kDirectoryDatabaseName),
-    FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
+  const base::FilePath kExcludes[] = {
+    base::FilePath(kDirectoryDatabaseName),
+    base::FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
   };
 
   // Any path in |pending_directories| is relative to |path_|.
-  std::stack<FilePath> pending_directories;
-  pending_directories.push(FilePath());
+  std::stack<base::FilePath> pending_directories;
+  pending_directories.push(base::FilePath());
 
   while (!pending_directories.empty()) {
-    FilePath dir_path = pending_directories.top();
+    base::FilePath dir_path = pending_directories.top();
     pending_directories.pop();
 
     file_util::FileEnumerator file_enum(
         dir_path.empty() ? path_ : path_.Append(dir_path),
         false /* not recursive */,
         file_util::FileEnumerator::DIRECTORIES |
         file_util::FileEnumerator::FILES);
 
-    FilePath absolute_file_path;
+    base::FilePath absolute_file_path;
     while (!(absolute_file_path = file_enum.Next()).empty()) {
       file_util::FileEnumerator::FindInfo find_info;
       file_enum.GetFindInfo(&find_info);
 
-      FilePath relative_file_path;
+      base::FilePath relative_file_path;
       if (!path_.AppendRelativePath(absolute_file_path, &relative_file_path))
         return false;
 
       if (std::find(kExcludes, kExcludes + arraysize(kExcludes),
                     relative_file_path) != kExcludes + arraysize(kExcludes))
         continue;
 
       if (file_util::FileEnumerator::IsDirectory(find_info)) {
         pending_directories.push(relative_file_path);
         continue;
       }
 
       // Check if the file has a database entry.
-      std::set<FilePath>::iterator itr = files_in_db_.find(relative_file_path);
+      std::set<base::FilePath>::iterator itr = files_in_db_.find(relative_file_path);
       if (itr == files_in_db_.end()) {
         if (!file_util::Delete(absolute_file_path, false))
           return false;
       } else {
         files_in_db_.erase(itr);
       }
     }
   }
 
   return files_in_db_.empty();
@@ skipping 54 matching lines @@
   // Check if we've visited all database entries.
   return num_directories_in_db_ == visited_directories &&
       num_files_in_db_ == visited_files &&
       num_hierarchy_links_in_db_ == visited_links;
 }
 
 // Returns true if the given |data_path| contains no parent references ("..")
 // and does not refer to special system files.
 // This is called in GetFileInfo, AddFileInfo and UpdateFileInfo to
 // ensure we're only dealing with valid data paths.
-bool VerifyDataPath(const FilePath& data_path) {
+bool VerifyDataPath(const base::FilePath& data_path) {
   // |data_path| should not contain any ".." and should be a relative path
   // (to the filesystem_data_directory_).
   if (data_path.ReferencesParent() || data_path.IsAbsolute())
     return false;
   // See if it's not pointing to the special system paths.
-  const FilePath kExcludes[] = {
-    FilePath(kDirectoryDatabaseName),
-    FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
+  const base::FilePath kExcludes[] = {
+    base::FilePath(kDirectoryDatabaseName),
+    base::FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
   };
   for (size_t i = 0; i < arraysize(kExcludes); ++i) {
     if (data_path == kExcludes[i] || kExcludes[i].IsParent(data_path))
       return false;
   }
   return true;
 }
 
 }  // namespace
 
 namespace fileapi {
 
 FileSystemDirectoryDatabase::FileInfo::FileInfo() : parent_id(0) {
 }
 
 FileSystemDirectoryDatabase::FileInfo::~FileInfo() {
 }
 
 FileSystemDirectoryDatabase::FileSystemDirectoryDatabase(
-    const FilePath& filesystem_data_directory)
+    const base::FilePath& filesystem_data_directory)
     : filesystem_data_directory_(filesystem_data_directory) {
 }
 
 FileSystemDirectoryDatabase::~FileSystemDirectoryDatabase() {
 }
 
 bool FileSystemDirectoryDatabase::GetChildWithName(
-    FileId parent_id, const FilePath::StringType& name, FileId* child_id) {
+    FileId parent_id, const base::FilePath::StringType& name, FileId* child_id) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   DCHECK(child_id);
   std::string child_key = GetChildLookupKey(parent_id, name);
   std::string child_id_string;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), child_key, &child_id_string);
   if (status.IsNotFound())
     return false;
   if (status.ok()) {
     if (!base::StringToInt64(child_id_string, child_id)) {
       LOG(ERROR) << "Hit database corruption!";
       return false;
     }
     return true;
   }
   HandleError(FROM_HERE, status);
   return false;
 }
 
 bool FileSystemDirectoryDatabase::GetFileWithPath(
-    const FilePath& path, FileId* file_id) {
-  std::vector<FilePath::StringType> components;
+    const base::FilePath& path, FileId* file_id) {
+  std::vector<base::FilePath::StringType> components;
   VirtualPath::GetComponents(path, &components);
   FileId local_id = 0;
-  std::vector<FilePath::StringType>::iterator iter;
+  std::vector<base::FilePath::StringType>::iterator iter;
   for (iter = components.begin(); iter != components.end(); ++iter) {
-    FilePath::StringType name;
+    base::FilePath::StringType name;
     name = *iter;
     if (name == FILE_PATH_LITERAL("/"))
       continue;
     if (!GetChildWithName(local_id, name, &local_id))
       return false;
   }
   *file_id = local_id;
   return true;
 }
 
@@ skipping 39 matching lines @@
       LOG(ERROR) << "Resolved data path is invalid: "
                  << info->data_path.value();
       return false;
     }
     return true;
   }
   // Special-case the root, for databases that haven't been initialized yet.
   // Without this, a query for the root's file info, made before creating the
   // first file in the database, will fail and confuse callers.
   if (status.IsNotFound() && !file_id) {
-    info->name = FilePath::StringType();
-    info->data_path = FilePath();
+    info->name = base::FilePath::StringType();
+    info->data_path = base::FilePath();
     info->modification_time = base::Time::Now();
     info->parent_id = 0;
     return true;
   }
   HandleError(FROM_HERE, status);
   return false;
 }
 
 bool FileSystemDirectoryDatabase::AddFileInfo(
     const FileInfo& info, FileId* file_id) {
@@ skipping 167 matching lines @@
     return false;
   }
   // The database must not yet exist; initialize it.
   if (!StoreDefaultValues())
     return false;
 
   return GetNextInteger(next);
 }
 
 // static
-bool FileSystemDirectoryDatabase::DestroyDatabase(const FilePath& path) {
+bool FileSystemDirectoryDatabase::DestroyDatabase(const base::FilePath& path) {
   std::string name  = FilePathToString(path.Append(kDirectoryDatabaseName));
   leveldb::Status status = leveldb::DestroyDB(name, leveldb::Options());
   if (status.ok())
     return true;
   LOG(WARNING) << "Failed to destroy a database with status " <<
       status.ToString();
   return false;
 }
 
 bool FileSystemDirectoryDatabase::Init(RecoveryOption recovery_option) {
@@ skipping 197 matching lines @@
 
 void FileSystemDirectoryDatabase::HandleError(
     const tracked_objects::Location& from_here,
     const leveldb::Status& status) {
   LOG(ERROR) << "FileSystemDirectoryDatabase failed at: "
              << from_here.ToString() << " with error: " << status.ToString();
   db_.reset();
 }
 
 }  // namespace fileapi