Don't hardcode the "Local Storage" directory name in DomStorageContext.

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/location.h"
 #include "base/time.h"
 #include "webkit/dom_storage/dom_storage_area.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/quota/special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
+namespace {
+
+const char kLocalStorageDirectory[] = "Local Storage";
+
+}  // namespace
+
 namespace dom_storage {
 
 DomStorageContext::UsageInfo::UsageInfo() : data_size(0) {}
 DomStorageContext::UsageInfo::~UsageInfo() {}
 
 DomStorageContext::DomStorageContext(
     const FilePath& directory,
     quota::SpecialStoragePolicy* special_storage_policy,
     DomStorageTaskRunner* task_runner)
     : directory_(directory),
@@ skipping 11 matching lines @@
 DomStorageContext::~DomStorageContext() {
 }
 
 DomStorageNamespace* DomStorageContext::GetStorageNamespace(
     int64 namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
   if (found == namespaces_.end()) {
     if (namespace_id == kLocalStorageNamespaceId) {
-      if (!directory_.empty()) {
-        if (!file_util::CreateDirectory(directory_)) {
+      FilePath target_directory = GetLocalStorageDirectory();
+      if (!target_directory.empty()) {
+        if (!file_util::CreateDirectory(target_directory)) {
           LOG(ERROR) << "Failed to create 'Local Storage' directory,"
                         " falling back to in-memory only.";
-          directory_ = FilePath();
+          target_directory = FilePath();
         }
       }
       DomStorageNamespace* local =
-          new DomStorageNamespace(directory_, task_runner_);
+          new DomStorageNamespace(target_directory, task_runner_);
       namespaces_[kLocalStorageNamespaceId] = local;
       return local;
     }
     return NULL;
   }
   return found->second;
 }
 
+FilePath DomStorageContext::GetLocalStorageDirectory() {
+  if (directory_.empty())
+    return FilePath();
+  return directory_.AppendASCII(kLocalStorageDirectory);
+}
+
 void DomStorageContext::GetUsageInfo(std::vector<UsageInfo>* infos,
                                      bool include_file_info) {
   if (directory_.empty())
     return;
-  FileEnumerator enumerator(directory_, false, FileEnumerator::FILES);
+  FileEnumerator enumerator(GetLocalStorageDirectory(), false,
+                            FileEnumerator::FILES);
   for (FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
     if (path.MatchesExtension(DomStorageArea::kDatabaseFileExtension)) {
       UsageInfo 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 135 matching lines @@
   for (size_t i = 0; i < infos.size(); ++i) {
     const GURL& origin = infos[i].origin;
     if (special_storage_policy_ &&
         special_storage_policy_->IsStorageProtected(origin))
       continue;
     if (!clear_local_state_ &&
         !special_storage_policy_->IsStorageSessionOnly(origin))
       continue;
 
     const bool kNotRecursive = false;
-    FilePath database_file_path = directory_.Append(
+    FilePath database_file_path = GetLocalStorageDirectory().Append(
         DomStorageArea::DatabaseFileNameFromOrigin(origin));
     file_util::Delete(database_file_path, kNotRecursive);
     file_util::Delete(
         DomStorageDatabase::GetJournalFilePath(database_file_path),
         kNotRecursive);
   }
 }
 
 }  // namespace dom_storage