Use base namespace for FilePath in content/browser

content/browser/storage_partition_impl_map.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/storage_partition_impl_map.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 204 matching lines @@
 // further partitioned by extension id, followed by another level of directories
 // for the "default" extension storage partition and one directory for each
 // persistent partition used by a webview tag. Example:
 //
 //   Storage/ext/ABCDEF/def
 //   Storage/ext/ABCDEF/hash(partition name)
 //
 // The code in GetStoragePartitionPath() constructs these path names.
 //
 // TODO(nasko): Move extension related path code out of content.
-const FilePath::CharType kStoragePartitionDirname[] =
+const base::FilePath::CharType kStoragePartitionDirname[] =
     FILE_PATH_LITERAL("Storage");
-const FilePath::CharType kExtensionsDirname[] =
+const base::FilePath::CharType kExtensionsDirname[] =
     FILE_PATH_LITERAL("ext");
-const FilePath::CharType kDefaultPartitionDirname[] =
+const base::FilePath::CharType kDefaultPartitionDirname[] =
     FILE_PATH_LITERAL("def");
-const FilePath::CharType kTrashDirname[] =
+const base::FilePath::CharType kTrashDirname[] =
     FILE_PATH_LITERAL("trash");
 
 // Because partition names are user specified, they can be arbitrarily long
 // which makes them unsuitable for paths names. We use a truncation of a
 // SHA256 hash to perform a deterministic shortening of the string. The
 // kPartitionNameHashBytes constant controls the length of the truncation.
 // We use 6 bytes, which gives us 99.999% reliability against collisions over
 // 1 million partition domains.
 //
 // Analysis:
@@ skipping 22 matching lines @@
 // Needed for selecting all files in ObliterateOneDirectory() below.
 #if defined(OS_POSIX)
 const int kAllFileTypes = file_util::FileEnumerator::FILES |
                           file_util::FileEnumerator::DIRECTORIES |
                           file_util::FileEnumerator::SHOW_SYM_LINKS;
 #else
 const int kAllFileTypes = file_util::FileEnumerator::FILES |
                           file_util::FileEnumerator::DIRECTORIES;
 #endif
 
-FilePath GetStoragePartitionDomainPath(
+base::FilePath GetStoragePartitionDomainPath(
     const std::string& partition_domain) {
   CHECK(IsStringUTF8(partition_domain));
 
-  return FilePath(kStoragePartitionDirname).Append(kExtensionsDirname)
-      .Append(FilePath::FromUTF8Unsafe(partition_domain));
+  return base::FilePath(kStoragePartitionDirname).Append(kExtensionsDirname)
+      .Append(base::FilePath::FromUTF8Unsafe(partition_domain));
 }
 
 // Helper function for doing a depth-first deletion of the data on disk.
 // Examines paths directly in |current_dir| (no recursion) and tries to
 // delete from disk anything that is in, or isn't a parent of something in
 // |paths_to_keep|. Paths that need further expansion are added to
 // |paths_to_consider|.
-void ObliterateOneDirectory(const FilePath& current_dir,
-                            const std::vector<FilePath>& paths_to_keep,
-                            std::vector<FilePath>* paths_to_consider) {
+void ObliterateOneDirectory(const base::FilePath& current_dir,
+                            const std::vector<base::FilePath>& paths_to_keep,
+                            std::vector<base::FilePath>* paths_to_consider) {
   CHECK(current_dir.IsAbsolute());
 
   file_util::FileEnumerator enumerator(current_dir, false, kAllFileTypes);
-  for (FilePath to_delete = enumerator.Next(); !to_delete.empty();
+  for (base::FilePath to_delete = enumerator.Next(); !to_delete.empty();
        to_delete = enumerator.Next()) {
     // Enum tracking which of the 3 possible actions to take for |to_delete|.
     enum { kSkip, kEnqueue, kDelete } action = kDelete;
 
-    for (std::vector<FilePath>::const_iterator to_keep = paths_to_keep.begin();
+    for (std::vector<base::FilePath>::const_iterator to_keep =
+             paths_to_keep.begin();
          to_keep != paths_to_keep.end();
          ++to_keep) {
       if (to_delete == *to_keep) {
         action = kSkip;
         break;
       } else if (to_delete.IsParent(*to_keep)) {
         // |to_delete| contains a path to keep. Add to stack for further
         // processing.
         action = kEnqueue;
         break;
@@ skipping 13 matching lines @@
         break;
     }
   }
 }
 
 // Synchronously attempts to delete |unnormalized_root|, preserving only
 // entries in |paths_to_keep|. If there are no entries in |paths_to_keep| on
 // disk, then it completely removes |unnormalized_root|. All paths must be
 // absolute paths.
 void BlockingObliteratePath(
-    const FilePath& unnormalized_browser_context_root,
-    const FilePath& unnormalized_root,
-    const std::vector<FilePath>& paths_to_keep,
+    const base::FilePath& unnormalized_browser_context_root,
+    const base::FilePath& unnormalized_root,
+    const std::vector<base::FilePath>& paths_to_keep,
     const scoped_refptr<base::TaskRunner>& closure_runner,
     const base::Closure& on_gc_required) {
   // Early exit required because file_util::AbsolutePath() will fail on POSIX
   // if |unnormalized_root| does not exist. This is safe because there is
   // nothing to do in this situation anwyays.
   if (!file_util::PathExists(unnormalized_root)) {
     return;
   }
 
   // Never try to obliterate things outside of the browser context root or the
   // browser context root itself. Die hard.
-  FilePath root = unnormalized_root;
-  FilePath browser_context_root = unnormalized_browser_context_root;
+  base::FilePath root = unnormalized_root;
+  base::FilePath browser_context_root = unnormalized_browser_context_root;
   CHECK(file_util::AbsolutePath(&root));
   CHECK(file_util::AbsolutePath(&browser_context_root));
   CHECK(file_util::ContainsPath(browser_context_root, root) &&
         browser_context_root != root);
 
   // Reduce |paths_to_keep| set to those under the root and actually on disk.
-  std::vector<FilePath> valid_paths_to_keep;
-  for (std::vector<FilePath>::const_iterator it = paths_to_keep.begin();
+  std::vector<base::FilePath> valid_paths_to_keep;
+  for (std::vector<base::FilePath>::const_iterator it = paths_to_keep.begin();
        it != paths_to_keep.end();
        ++it) {
     if (root.IsParent(*it) && file_util::PathExists(*it))
       valid_paths_to_keep.push_back(*it);
   }
 
   // If none of the |paths_to_keep| are valid anymore then we just whack the
   // root and be done with it.  Otherwise, signal garbage collection and do
   // a best-effort delete of the on-disk structures.
   if (valid_paths_to_keep.empty()) {
     file_util::Delete(root, true);
     return;
   }
   closure_runner->PostTask(FROM_HERE, on_gc_required);
 
   // Otherwise, start at the root and delete everything that is not in
   // |valid_paths_to_keep|.
-  std::vector<FilePath> paths_to_consider;
+  std::vector<base::FilePath> paths_to_consider;
   paths_to_consider.push_back(root);
   while(!paths_to_consider.empty()) {
-    FilePath path = paths_to_consider.back();
+    base::FilePath path = paths_to_consider.back();
     paths_to_consider.pop_back();
     ObliterateOneDirectory(path, valid_paths_to_keep, &paths_to_consider);
   }
 }
 
 // Deletes all entries inside the |storage_root| that are not in the
 // |active_paths|.  Deletion is done in 2 steps:
 //
 //   (1) Moving all garbage collected paths into a trash directory.
 //   (2) Asynchronously deleting the trash directory.
 //
 // The deletion is asynchronous because after (1) completes, calling code can
 // safely continue to use the paths that had just been garbage collected
 // without fear of race conditions.
 //
 // This code also ignores failed moves rather than attempting a smarter retry.
 // Moves shouldn't fail here unless there is some out-of-band error (eg.,
 // FS corruption). Retry logic is dangerous in the general case because
 // there is not necessarily a guaranteed case where the logic may succeed.
 //
 // This function is still named BlockingGarbageCollect() because it does
 // execute a few filesystem operations synchronously.
 void BlockingGarbageCollect(
-    const FilePath& storage_root,
+    const base::FilePath& storage_root,
     const scoped_refptr<base::TaskRunner>& file_access_runner,
-    scoped_ptr<base::hash_set<FilePath> > active_paths) {
+    scoped_ptr<base::hash_set<base::FilePath> > active_paths) {
   CHECK(storage_root.IsAbsolute());
 
   file_util::FileEnumerator enumerator(storage_root, false, kAllFileTypes);
-  FilePath trash_directory;
+  base::FilePath trash_directory;
   if (!file_util::CreateTemporaryDirInDir(storage_root, kTrashDirname,
                                           &trash_directory)) {
     // Unable to continue without creating the trash directory so give up.
     return;
   }
-  for (FilePath path = enumerator.Next(); !path.empty();
+  for (base::FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     if (active_paths->find(path) == active_paths->end() &&
         path != trash_directory) {
       // Since |trash_directory| is unique for each run of this function there
       // can be no colllisions on the move.
       file_util::Move(path, trash_directory.Append(path.BaseName()));
     }
   }
 
   file_access_runner->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&file_util::Delete), trash_directory,
                  true));
 }
 
 }  // namespace
 
 // static
-FilePath StoragePartitionImplMap::GetStoragePartitionPath(
+base::FilePath StoragePartitionImplMap::GetStoragePartitionPath(
     const std::string& partition_domain,
     const std::string& partition_name) {
   if (partition_domain.empty())
-    return FilePath();
+    return base::FilePath();
 
-  FilePath path = GetStoragePartitionDomainPath(partition_domain);
+  base::FilePath path = GetStoragePartitionDomainPath(partition_domain);
 
   // TODO(ajwong): Mangle in-memory into this somehow, either by putting
   // it into the partition_name, or by manually adding another path component
   // here.  Otherwise, it's possible to have an in-memory StoragePartition and
   // a persistent one that return the same FilePath for GetPath().
   if (!partition_name.empty()) {
     // For analysis of why we can ignore collisions, see the comment above
     // kPartitionNameHashBytes.
     char buffer[kPartitionNameHashBytes];
     crypto::SHA256HashString(partition_name, &buffer[0],
@@ skipping 24 matching lines @@
     const std::string& partition_name,
     bool in_memory) {
   // Find the previously created partition if it's available.
   StoragePartitionConfig partition_config(
       partition_domain, partition_name, in_memory);
 
   PartitionMap::const_iterator it = partitions_.find(partition_config);
   if (it != partitions_.end())
     return it->second;
 
-  FilePath partition_path =
+  base::FilePath partition_path =
       browser_context_->GetPath().Append(
           GetStoragePartitionPath(partition_domain, partition_name));
   StoragePartitionImpl* partition =
       StoragePartitionImpl::Create(browser_context_, in_memory,
                                    partition_path);
   partitions_[partition_config] = partition;
 
   // These calls must happen after StoragePartitionImpl::Create().
   partition->SetURLRequestContext(
       partition_domain.empty() ?
@@ skipping 24 matching lines @@
       browser_context_, site, false, &partition_domain,
       &partition_name, &in_memory);
 
   // Find the active partitions for the domain. Because these partitions are
   // active, it is not possible to just delete the directories that contain
   // the backing data structures without causing the browser to crash. Instead,
   // of deleteing the directory, we tell each storage context later to
   // remove any data they have saved. This will leave the directory structure
   // intact but it will only contain empty databases.
   std::vector<StoragePartitionImpl*> active_partitions;
-  std::vector<FilePath> paths_to_keep;
+  std::vector<base::FilePath> paths_to_keep;
   for (PartitionMap::const_iterator it = partitions_.begin();
        it != partitions_.end();
        ++it) {
     const StoragePartitionConfig& config = it->first;
     if (config.partition_domain == partition_domain) {
       it->second->AsyncClearAllData();
       if (!config.in_memory) {
         paths_to_keep.push_back(it->second->GetPath());
       }
     }
   }
 
   // Start a best-effort delete of the on-disk storage excluding paths that are
   // known to still be in use. This is to delete any previously created
   // StoragePartition state that just happens to not have been used during this
   // run of the browser.
-  FilePath domain_root = browser_context_->GetPath().Append(
+  base::FilePath domain_root = browser_context_->GetPath().Append(
       GetStoragePartitionDomainPath(partition_domain));
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&BlockingObliteratePath, browser_context_->GetPath(),
                  domain_root, paths_to_keep,
                  base::MessageLoopProxy::current(), on_gc_required));
 }
 
 void StoragePartitionImplMap::GarbageCollect(
-    scoped_ptr<base::hash_set<FilePath> > active_paths,
+    scoped_ptr<base::hash_set<base::FilePath> > active_paths,
     const base::Closure& done) {
   // Include all paths for current StoragePartitions in the active_paths since
   // they cannot be deleted safely.
   for (PartitionMap::const_iterator it = partitions_.begin();
        it != partitions_.end();
        ++it) {
     const StoragePartitionConfig& config = it->first;
     if (!config.in_memory)
       active_paths->insert(it->second->GetPath());
   }
 
   // Find the directory holding the StoragePartitions and delete everything in
   // there that isn't considered active.
-  FilePath storage_root = browser_context_->GetPath().Append(
+  base::FilePath storage_root = browser_context_->GetPath().Append(
       GetStoragePartitionDomainPath(std::string()));
   file_access_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&BlockingGarbageCollect, storage_root,
                  file_access_runner_,
                  base::Passed(&active_paths)),
       done);
 }
 
 void StoragePartitionImplMap::ForEach(
@@ skipping 17 matching lines @@
     resource_context_initialized_ = true;
     InitializeResourceContext(browser_context_);
   }
 
   // Check first to avoid memory leak in unittests.
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ChromeAppCacheService::InitializeOnIOThread,
                    partition->GetAppCacheService(),
-                   in_memory ? FilePath() :
+                   in_memory ? base::FilePath() :
                        partition->GetPath().Append(kAppCacheDirname),
                    browser_context_->GetResourceContext(),
                    make_scoped_refptr(partition->GetURLRequestContext()),
                    make_scoped_refptr(
                        browser_context_->GetSpecialStoragePolicy())));
 
     // Add content's URLRequestContext's hooks.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
             &InitializeURLRequestContext,
             make_scoped_refptr(partition->GetURLRequestContext()),
             make_scoped_refptr(partition->GetAppCacheService()),
             make_scoped_refptr(partition->GetFileSystemContext()),
             make_scoped_refptr(
                 ChromeBlobStorageContext::GetFor(browser_context_)),
             browser_context_->GetResourceContext(),
             browser_context_->IsOffTheRecord()));
 
     // We do not call InitializeURLRequestContext() for media contexts because,
     // other than the HTTP cache, the media contexts share the same backing
     // objects as their associated "normal" request context.  Thus, the previous
     // call serves to initialize the media request context for this storage
     // partition as well.
   }
 }
 
 }  // namespace content