Add FilePath to base namespace.

webkit/dom_storage/dom_storage_context.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/dom_storage/dom_storage_context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/time.h"
 #include "webkit/dom_storage/dom_storage_area.h"
 #include "webkit/dom_storage/dom_storage_database.h"
 #include "webkit/dom_storage/dom_storage_namespace.h"
 #include "webkit/dom_storage/dom_storage_task_runner.h"
 #include "webkit/dom_storage/dom_storage_types.h"
 #include "webkit/dom_storage/session_storage_database.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
 namespace dom_storage {
 
 static const int kSessionStoraceScavengingSeconds = 60;
 
 DomStorageContext::DomStorageContext(
-    const FilePath& localstorage_directory,
-    const FilePath& sessionstorage_directory,
+    const base::FilePath& localstorage_directory,
+    const base::FilePath& sessionstorage_directory,
     quota::SpecialStoragePolicy* special_storage_policy,
     DomStorageTaskRunner* task_runner)
     : localstorage_directory_(localstorage_directory),
       sessionstorage_directory_(sessionstorage_directory),
       task_runner_(task_runner),
       is_shutdown_(false),
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       scavenging_started_(false) {
   // AtomicSequenceNum starts at 0 but we want to start session
@@ skipping 22 matching lines @@
     int64 namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
   if (found == namespaces_.end()) {
     if (namespace_id == kLocalStorageNamespaceId) {
       if (!localstorage_directory_.empty()) {
         if (!file_util::CreateDirectory(localstorage_directory_)) {
           LOG(ERROR) << "Failed to create 'Local Storage' directory,"
                         " falling back to in-memory only.";
-          localstorage_directory_ = FilePath();
+          localstorage_directory_ = base::FilePath();
         }
       }
       DomStorageNamespace* local =
           new DomStorageNamespace(localstorage_directory_, task_runner_);
       namespaces_[kLocalStorageNamespaceId] = local;
       return local;
     }
     return NULL;
   }
   return found->second;
 }
 
 void DomStorageContext::GetLocalStorageUsage(
     std::vector<LocalStorageUsageInfo>* infos,
     bool include_file_info) {
   if (localstorage_directory_.empty())
     return;
   FileEnumerator enumerator(localstorage_directory_, false,
                             FileEnumerator::FILES);
-  for (FilePath path = enumerator.Next(); !path.empty();
+  for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     if (path.MatchesExtension(DomStorageArea::kDatabaseFileExtension)) {
       LocalStorageUsageInfo info;
       info.origin = DomStorageArea::OriginFromDatabaseFileName(path);
       if (include_file_info) {
         FileEnumerator::FindInfo find_info;
         enumerator.GetFindInfo(&find_info);
         info.data_size = FileEnumerator::GetFilesize(find_info);
         info.last_modified = FileEnumerator::GetLastModifiedTime(find_info);
       }
@@ skipping 203 matching lines @@
     const bool kDontIncludeFileInfo = false;
     GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
     for (size_t i = 0; i < infos.size(); ++i) {
       const GURL& origin = infos[i].origin;
       if (special_storage_policy_->IsStorageProtected(origin))
         continue;
       if (!special_storage_policy_->IsStorageSessionOnly(origin))
         continue;
 
       const bool kNotRecursive = false;
-      FilePath database_file_path = localstorage_directory_.Append(
+      base::FilePath database_file_path = localstorage_directory_.Append(
           DomStorageArea::DatabaseFileNameFromOrigin(origin));
       file_util::Delete(database_file_path, kNotRecursive);
       file_util::Delete(
           DomStorageDatabase::GetJournalFilePath(database_file_path),
           kNotRecursive);
     }
   }
   if (session_storage_database_.get()) {
     std::vector<SessionStorageUsageInfo> infos;
     GetSessionStorageUsage(&infos);
@@ skipping 88 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DomStorageContext::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace dom_storage