Add FilePath to base namespace.

webkit/database/database_tracker.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/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/transaction.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "webkit/database/database_quota_client.h"
 #include "webkit/database/database_util.h"
 #include "webkit/database/databases_table.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace webkit_database {
 
-const FilePath::CharType kDatabaseDirectoryName[] =
+const base::FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
-const FilePath::CharType kIncognitoDatabaseDirectoryName[] =
+const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases-incognito");
-const FilePath::CharType kTrackerDatabaseFileName[] =
+const base::FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kCurrentVersion = 2;
 static const int kCompatibleVersion = 1;
 
-const FilePath::CharType kTemporaryDirectoryPrefix[] =
+const base::FilePath::CharType kTemporaryDirectoryPrefix[] =
     FILE_PATH_LITERAL("DeleteMe");
-const FilePath::CharType kTemporaryDirectoryPattern[] =
+const base::FilePath::CharType kTemporaryDirectoryPattern[] =
     FILE_PATH_LITERAL("DeleteMe*");
 
 OriginInfo::OriginInfo()
     : total_size_(0) {}
 
 OriginInfo::OriginInfo(const OriginInfo& origin_info)
     : origin_(origin_info.origin_),
       total_size_(origin_info.total_size_),
       database_info_(origin_info.database_info_) {}
 
@@ skipping 18 matching lines @@
   DatabaseInfoMap::const_iterator it = database_info_.find(database_name);
   if (it != database_info_.end())
     return it->second.second;
   return string16();
 }
 
 OriginInfo::OriginInfo(const string16& origin, int64 total_size)
     : origin_(origin), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(
-    const FilePath& profile_path,
+    const base::FilePath& profile_path,
     bool is_incognito,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* db_tracker_thread)
     : is_initialized_(false),
       is_incognito_(is_incognito),
       force_keep_session_state_(false),
       shutting_down_(false),
       profile_path_(profile_path),
       db_dir_(is_incognito_ ?
@@ skipping 182 matching lines @@
       incognito_origin_directories_.find(origin_identifier);
   if (it != incognito_origin_directories_.end())
     return it->second;
 
   string16 origin_directory =
       base::IntToString16(incognito_origin_directories_generator_++);
   incognito_origin_directories_[origin_identifier] = origin_directory;
   return origin_directory;
 }
 
-FilePath DatabaseTracker::GetFullDBFilePath(
+base::FilePath DatabaseTracker::GetFullDBFilePath(
     const string16& origin_identifier,
     const string16& database_name) {
   DCHECK(!origin_identifier.empty());
   if (!LazyInit())
-    return FilePath();
+    return base::FilePath();
 
   int64 id = databases_table_->GetDatabaseID(
       origin_identifier, database_name);
   if (id < 0)
-    return FilePath();
+    return base::FilePath();
 
-  FilePath file_name = FilePath::FromWStringHack(
+  base::FilePath file_name = base::FilePath::FromWStringHack(
       UTF8ToWide(base::Int64ToString(id)));
-  return db_dir_.Append(FilePath::FromWStringHack(
+  return db_dir_.Append(base::FilePath::FromWStringHack(
       UTF16ToWide(GetOriginDirectory(origin_identifier)))).Append(file_name);
 }
 
 bool DatabaseTracker::GetOriginInfo(const string16& origin_identifier,
                                     OriginInfo* info) {
   DCHECK(info);
   CachedOriginInfo* cached_info = GetCachedOriginInfo(origin_identifier);
   if (!cached_info)
     return false;
   *info = OriginInfo(*cached_info);
@@ skipping 37 matching lines @@
     return false;
 
   // Check if the database is opened by any renderer.
   if (database_connections_.IsDatabaseOpened(origin_identifier, database_name))
     return false;
 
   int64 db_file_size = quota_manager_proxy_ ?
       GetDBFileSize(origin_identifier, database_name) : 0;
 
   // Try to delete the file on the hard drive.
-  FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
+  base::FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
   if (file_util::PathExists(db_file) && !file_util::Delete(db_file, false))
     return false;
 
   // Also delete any orphaned journal file.
   DCHECK(db_file.Extension().empty());
   file_util::Delete(db_file.InsertBeforeExtensionASCII(
       DatabaseUtil::kJournalFileSuffix), false);
 
   if (quota_manager_proxy_ && db_file_size)
     quota_manager_proxy_->NotifyStorageModified(
@@ skipping 25 matching lines @@
     return false;
 
   int64 deleted_size = 0;
   if (quota_manager_proxy_) {
     CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
     if (origin_info)
       deleted_size = origin_info->TotalSize();
   }
 
   origins_info_map_.erase(origin_identifier);
-  FilePath origin_dir = db_dir_.Append(FilePath::FromWStringHack(
+  base::FilePath origin_dir = db_dir_.Append(base::FilePath::FromWStringHack(
       UTF16ToWide(origin_identifier)));
 
   // Create a temporary directory to move possibly still existing databases to,
   // as we can't delete the origin directory on windows if it contains opened
   // files.
-  FilePath new_origin_dir;
+  base::FilePath new_origin_dir;
   file_util::CreateTemporaryDirInDir(db_dir_,
                                      kTemporaryDirectoryPrefix,
                                      &new_origin_dir);
   file_util::FileEnumerator databases(
       origin_dir,
       false,
       file_util::FileEnumerator::FILES);
-  for (FilePath database = databases.Next(); !database.empty();
+  for (base::FilePath database = databases.Next(); !database.empty();
        database = databases.Next()) {
-    FilePath new_file = new_origin_dir.Append(database.BaseName());
+    base::FilePath new_file = new_origin_dir.Append(database.BaseName());
     file_util::Move(database, new_file);
   }
   file_util::Delete(origin_dir, true);
   file_util::Delete(new_origin_dir, true); // might fail on windows.
 
   databases_table_->DeleteOrigin(origin_identifier);
 
   if (quota_manager_proxy_ && deleted_size) {
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kDatabase,
@@ skipping 23 matching lines @@
     DCHECK(!meta_table_.get());
 
     // If there are left-over directories from failed deletion attempts, clean
     // them up.
     if (file_util::DirectoryExists(db_dir_)) {
       file_util::FileEnumerator directories(
           db_dir_,
           false,
           file_util::FileEnumerator::DIRECTORIES,
           kTemporaryDirectoryPattern);
-      for (FilePath directory = directories.Next(); !directory.empty();
+      for (base::FilePath directory = directories.Next(); !directory.empty();
            directory = directories.Next()) {
         file_util::Delete(directory, true);
       }
     }
 
     // If the tracker database exists, but it's corrupt or doesn't
     // have a meta table, delete the database directory.
-    const FilePath kTrackerDatabaseFullPath =
-        db_dir_.Append(FilePath(kTrackerDatabaseFileName));
+    const base::FilePath kTrackerDatabaseFullPath =
+        db_dir_.Append(base::FilePath(kTrackerDatabaseFileName));
     if (file_util::DirectoryExists(db_dir_) &&
         file_util::PathExists(kTrackerDatabaseFullPath) &&
         (!db_->Open(kTrackerDatabaseFullPath) ||
          !sql::MetaTable::DoesTableExist(db_.get()))) {
       db_->Close();
       if (!file_util::Delete(db_dir_, true))
         return false;
     }
 
     db_->set_error_histogram_name("Sqlite.DatabaseTracker.Error");
@@ skipping 86 matching lines @@
       origin_info.SetDatabaseSize(it->database_name, db_file_size);
       origin_info.SetDatabaseDescription(it->database_name, it->description);
     }
   }
 
   return &origins_info_map_[origin_identifier];
 }
 
 int64 DatabaseTracker::GetDBFileSize(const string16& origin_identifier,
                                      const string16& database_name) {
-  FilePath db_file_name = GetFullDBFilePath(origin_identifier, database_name);
+  base::FilePath db_file_name = GetFullDBFilePath(origin_identifier,
+                                                  database_name);
   int64 db_file_size = 0;
   if (!file_util::GetFileSize(db_file_name, &db_file_size))
     db_file_size = 0;
   return db_file_size;
 }
 
 int64 DatabaseTracker::SeedOpenDatabaseInfo(
     const string16& origin_id, const string16& name,
     const string16& description) {
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
@@ skipping 95 matching lines @@
         special_storage_policy_->IsStorageProtected(
             DatabaseUtil::GetOriginFromIdentifier(*ori))) {
       continue;
     }
 
     std::vector<DatabaseDetails> details;
     if (!databases_table_->GetAllDatabaseDetailsForOrigin(*ori, &details))
       rv = net::ERR_FAILED;
     for (std::vector<DatabaseDetails>::const_iterator db = details.begin();
          db != details.end(); ++db) {
-      FilePath db_file = GetFullDBFilePath(*ori, db->database_name);
+      base::FilePath db_file = GetFullDBFilePath(*ori, db->database_name);
       base::PlatformFileInfo file_info;
       file_util::GetFileInfo(db_file, &file_info);
       if (file_info.last_modified < cutoff)
         continue;
 
       // Check if the database is opened by any renderer.
       if (database_connections_.IsDatabaseOpened(*ori, db->database_name))
         to_be_deleted[*ori].insert(db->database_name);
       else
         DeleteClosedDatabase(*ori, db->database_name);
@@ skipping 78 matching lines @@
 }
 
 void DatabaseTracker::DeleteIncognitoDBDirectory() {
   shutting_down_ = true;
   is_initialized_ = false;
 
   for (FileHandlesMap::iterator it = incognito_file_handles_.begin();
        it != incognito_file_handles_.end(); it++)
     base::ClosePlatformFile(it->second);
 
-  FilePath incognito_db_dir =
+  base::FilePath incognito_db_dir =
       profile_path_.Append(kIncognitoDatabaseDirectoryName);
   if (file_util::DirectoryExists(incognito_db_dir))
     file_util::Delete(incognito_db_dir, true);
 }
 
 void DatabaseTracker::ClearSessionOnlyOrigins() {
   shutting_down_ = true;
 
   bool has_session_only_databases =
       special_storage_policy_.get() &&
@@ skipping 56 matching lines @@
   if (!db_tracker_thread_->BelongsToCurrentThread()) {
     db_tracker_thread_->PostTask(
         FROM_HERE,
         base::Bind(&DatabaseTracker::SetForceKeepSessionState, this));
     return;
   }
   force_keep_session_state_ = true;
 }
 
 }  // namespace webkit_database