Use base namespace for FilePath in content/browser

content/browser/in_process_webkit/indexed_db_context_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/in_process_webkit/indexed_db_context_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 #include "webkit/database/database_util.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using webkit_database::DatabaseUtil;
 using WebKit::WebIDBDatabase;
 using WebKit::WebIDBFactory;
 using WebKit::WebSecurityOrigin;
 
 namespace content {
-const FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
+const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
-const FilePath::CharType IndexedDBContextImpl::kIndexedDBExtension[] =
+const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
 
 namespace {
 
 void GetAllOriginsAndPaths(
-    const FilePath& indexeddb_path,
+    const base::FilePath& indexeddb_path,
     std::vector<GURL>* origins,
-    std::vector<FilePath>* file_paths) {
+    std::vector<base::FilePath>* file_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (indexeddb_path.empty())
     return;
   file_util::FileEnumerator file_enumerator(indexeddb_path,
       false, file_util::FileEnumerator::DIRECTORIES);
-  for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
+  for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
     if (file_path.Extension() == IndexedDBContextImpl::kIndexedDBExtension) {
       WebKit::WebString origin_id_webstring =
           webkit_base::FilePathToWebString(file_path.BaseName());
       origins->push_back(
           DatabaseUtil::GetOriginFromIdentifier(origin_id_webstring));
       if (file_paths)
         file_paths->push_back(file_path);
     }
   }
 }
 
 // Deletes session-only databases.
 void ClearSessionOnlyOrigins(
-    const FilePath& indexeddb_path,
+    const base::FilePath& indexeddb_path,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   std::vector<GURL> origins;
-  std::vector<FilePath> file_paths;
+  std::vector<base::FilePath> file_paths;
   GetAllOriginsAndPaths(indexeddb_path, &origins, &file_paths);
   DCHECK_EQ(origins.size(), file_paths.size());
-  std::vector<FilePath>::const_iterator file_path_iter = file_paths.begin();
+  std::vector<base::FilePath>::const_iterator file_path_iter =
+      file_paths.begin();
   for (std::vector<GURL>::const_iterator iter = origins.begin();
        iter != origins.end(); ++iter, ++file_path_iter) {
     if (!special_storage_policy->IsStorageSessionOnly(*iter))
       continue;
     if (special_storage_policy->IsStorageProtected(*iter))
       continue;
     file_util::Delete(*file_path_iter, true);
   }
 }
 
 }  // namespace
 
 IndexedDBContextImpl::IndexedDBContextImpl(
-    const FilePath& data_path,
+    const base::FilePath& data_path,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* webkit_thread_loop)
     : force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy) {
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess)) {
@@ skipping 28 matching lines @@
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
   EnsureDiskUsageCacheInitialized(origin_url);
   return origin_size_map_[origin_url];
 }
 
 base::Time IndexedDBContextImpl::GetOriginLastModified(const GURL& origin_url) {
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return base::Time();
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
-  FilePath idb_directory = GetIndexedDBFilePath(origin_id);
+  base::FilePath idb_directory = GetIndexedDBFilePath(origin_id);
   base::PlatformFileInfo file_info;
   if (!file_util::GetFileInfo(idb_directory, &file_info))
     return base::Time();
   return file_info.last_modified;
 }
 
 void IndexedDBContextImpl::DeleteForOrigin(const GURL& origin_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return;
 
   if (connections_.find(origin_url) != connections_.end()) {
     ConnectionSet& connections = connections_[origin_url];
     ConnectionSet::iterator it = connections.begin();
     while (it != connections.end()) {
       // Remove before closing so callbacks don't double-erase
       WebKit::WebIDBDatabase* db = *it;
       connections.erase(it++);
       db->forceClose();
     }
     DCHECK(connections_[origin_url].size() == 0);
     connections_.erase(origin_url);
   }
 
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
-  FilePath idb_directory = GetIndexedDBFilePath(origin_id);
+  base::FilePath idb_directory = GetIndexedDBFilePath(origin_id);
   EnsureDiskUsageCacheInitialized(origin_url);
   const bool recursive = true;
   bool deleted = file_util::Delete(idb_directory, recursive);
 
   QueryDiskAndUpdateQuotaUsage(origin_url);
   if (deleted) {
     RemoveFromOriginSet(origin_url);
     origin_size_map_.erase(origin_url);
     space_available_map_.erase(origin_url);
   }
 }
 
-FilePath IndexedDBContextImpl::GetFilePathForTesting(
+base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
   const string16& origin_id) const {
   return GetIndexedDBFilePath(origin_id);
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
                                             WebIDBDatabase* connection) {
   DCHECK(connections_[origin_url].count(connection) == 0);
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kIndexedDatabase, origin_url,
@@ skipping 77 matching lines @@
 
   // No WEBKIT thread here means we are running in a unit test where no clean
   // up is needed.
   BrowserThread::PostTask(
       BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&ClearSessionOnlyOrigins,
                  data_path_,
                  special_storage_policy_));
 }
 
-FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
+base::FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
     const string16& origin_id) const {
   DCHECK(!data_path_.empty());
-  FilePath::StringType id =
+  base::FilePath::StringType id =
       webkit_base::WebStringToFilePathString(origin_id).append(
           FILE_PATH_LITERAL(".indexeddb"));
   return data_path_.Append(id.append(kIndexedDBExtension));
 }
 
 int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
   string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url);
-  FilePath file_path = GetIndexedDBFilePath(origin_id);
+  base::FilePath file_path = GetIndexedDBFilePath(origin_id);
   return file_util::ComputeDirectorySize(file_path);
 }
 
 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
     const GURL& origin_url) {
   if (origin_size_map_.find(origin_url) == origin_size_map_.end())
     origin_size_map_[origin_url] = ReadUsageFromDisk(origin_url);
 }
 
 void IndexedDBContextImpl::QueryDiskAndUpdateQuotaUsage(
@@ skipping 67 matching lines @@
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 }  // namespace content