Reduce use of DatabaseIdentifier in Indexed DB entry points.

content/browser/indexed_db/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/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 263 matching lines @@
     }
 
     list->Append(info.release());
   }
   return list.release();
 }
 
 int IndexedDBContextImpl::GetOriginBlobFileCount(const GURL& origin_url) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   int count = 0;
-  base::FileEnumerator file_enumerator(
-      GetBlobPath(storage::GetIdentifierFromOrigin(origin_url)), true,
-      base::FileEnumerator::FILES);
+  base::FileEnumerator file_enumerator(GetBlobStorePath(origin_url), true,
+                                       base::FileEnumerator::FILES);
   for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
     count++;
   }
   return count;
 }
 
 int64_t IndexedDBContextImpl::GetOriginDiskUsage(const GURL& origin_url) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (data_path_.empty() || !HasOrigin(origin_url))
@@ skipping 25 matching lines @@
   if (!s.ok()) {
     LOG(WARNING) << "Failed to delete LevelDB database: "
                  << idb_directory.AsUTF8Unsafe();
   } else {
     // LevelDB does not delete empty directories; work around this.
     // TODO(jsbell): Remove when upstream bug is fixed.
     // https://code.google.com/p/leveldb/issues/detail?id=209
     const bool kNonRecursive = false;
     base::DeleteFile(idb_directory, kNonRecursive);
   }
-  base::DeleteFile(GetBlobPath(storage::GetIdentifierFromOrigin(origin_url)),
-                   true /* recursive */);
+  base::DeleteFile(GetBlobStorePath(origin_url), true /* recursive */);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   if (s.ok()) {
     RemoveFromOriginSet(origin_url);
     origin_size_map_.erase(origin_url);
   }
 }
 
 void IndexedDBContextImpl::CopyOriginData(const GURL& origin_url,
                                           IndexedDBContext* dest_context) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
 
   if (data_path_.empty() || !HasOrigin(origin_url))
     return;
 
   IndexedDBContextImpl* dest_context_impl =
       static_cast<IndexedDBContextImpl*>(dest_context);
 
   ForceClose(origin_url, FORCE_CLOSE_COPY_ORIGIN);
-  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
 
   // Make sure we're not about to delete our own database.
   CHECK_NE(dest_context_impl->data_path().value(), data_path().value());
 
   // Delete any existing storage paths in the destination context.
   // A previously failed migration may have left behind partially copied
   // directories.
   for (const base::FilePath& dest_path :
        dest_context_impl->GetStoragePaths(origin_url))
     base::DeleteFile(dest_path, true);
@@ skipping 27 matching lines @@
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (data_path_.empty() || !HasOrigin(origin_url))
     return 0;
 
   if (!factory_.get())
     return 0;
 
   return factory_->GetConnectionCount(origin_url);
 }
 
-base::FilePath IndexedDBContextImpl::GetLevelDBPath(
-    const GURL& origin_url) const {
-  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
-  return GetLevelDBPath(origin_id);
-}
-
 std::vector<base::FilePath> IndexedDBContextImpl::GetStoragePaths(
     const GURL& origin_url) const {
-  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
   std::vector<base::FilePath> paths;
-  paths.push_back(GetLevelDBPath(origin_id));
-  paths.push_back(GetBlobPath(origin_id));
+  paths.push_back(GetLevelDBPath(origin_url));
+  paths.push_back(GetBlobStorePath(origin_url));
   return paths;
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
-    const std::string& origin_id) const {
-  return GetLevelDBPath(origin_id);
+    const GURL& origin_url) const {
+  return GetLevelDBPath(origin_url);
 }
 
 void IndexedDBContextImpl::SetTaskRunnerForTesting(
     base::SequencedTaskRunner* task_runner) {
   DCHECK(!task_runner_.get());
   task_runner_ = task_runner;
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
                                             IndexedDBConnection* connection) {
@@ skipping 49 matching lines @@
   // Clearing only session-only databases, and there are none.
   if (!has_session_only_databases)
     return;
 
   TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &ClearSessionOnlyOrigins, data_path_, special_storage_policy_));
 }
 
-base::FilePath IndexedDBContextImpl::GetBlobPath(
-    const std::string& origin_id) const {
-  DCHECK(!data_path_.empty());
-  return data_path_.AppendASCII(origin_id).AddExtension(kIndexedDBExtension)
+// static
+base::FilePath IndexedDBContextImpl::GetBlobStoreFileName(
+    const GURL& origin_url) {
+  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
+  return base::FilePath()
+      .AppendASCII(origin_id)
+      .AddExtension(kIndexedDBExtension)
       .AddExtension(kBlobExtension);
 }
 
-base::FilePath IndexedDBContextImpl::GetLevelDBPath(
-    const std::string& origin_id) const {
-  DCHECK(!data_path_.empty());
-  return data_path_.AppendASCII(origin_id).AddExtension(kIndexedDBExtension)
+// static
+base::FilePath IndexedDBContextImpl::GetLevelDBFileName(
+    const GURL& origin_url) {
+  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
+  return base::FilePath()
+      .AppendASCII(origin_id)
+      .AddExtension(kIndexedDBExtension)
       .AddExtension(kLevelDBExtension);
 }
 
+base::FilePath IndexedDBContextImpl::GetBlobStorePath(
+    const GURL& origin_url) const {
+  DCHECK(!data_path_.empty());
+  return data_path_.Append(GetBlobStoreFileName(origin_url));
+}
+
+base::FilePath IndexedDBContextImpl::GetLevelDBPath(
+    const GURL& origin_url) const {
+  DCHECK(!data_path_.empty());
+  return data_path_.Append(GetLevelDBFileName(origin_url));
+}
+
 int64_t IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
   int64_t total_size = 0;
   for (const base::FilePath& path : GetStoragePaths(origin_url))
     total_size += base::ComputeDirectorySize(path);
   return total_size;
 }
 
 void IndexedDBContextImpl::EnsureDiskUsageCacheInitialized(
@@ skipping 27 matching lines @@
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_.get();
 }
 
 }  // namespace content