Use chromium logic for database identifier<->origin conversions

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 <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_quota_client.h"
 #include "content/browser/indexed_db/webidbdatabase_impl.h"
 #include "content/browser/indexed_db/webidbfactory_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/indexed_db_info.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "webkit/base/file_path_string_conversions.h"
-#include "webkit/base/origin_url_conversions.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
+#include "webkit/common/database/database_identifier.h"
 
 using webkit_database::DatabaseUtil;
 
 namespace content {
 const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
-const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBExtension[] =
+static const base::FilePath::CharType kIndexedDBExtension[] =
+    FILE_PATH_LITERAL(".indexeddb");
+
+static const base::FilePath::CharType kLevelDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
 
 namespace {
 
 void GetAllOriginsAndPaths(const base::FilePath& indexeddb_path,
                            std::vector<GURL>* origins,
                            std::vector<base::FilePath>* file_paths) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (indexeddb_path.empty())
     return;
   base::FileEnumerator file_enumerator(
       indexeddb_path, false, base::FileEnumerator::DIRECTORIES);
   for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
-    if (file_path.Extension() == IndexedDBContextImpl::kIndexedDBExtension) {
-      std::string origin_id = file_path.BaseName().MaybeAsASCII();
-      origins->push_back(webkit_base::GetOriginURLFromIdentifier(origin_id));
+    if (file_path.Extension() == kLevelDBExtension &&
+        file_path.RemoveExtension().Extension() == kIndexedDBExtension) {
+      std::string origin_id = file_path.BaseName().RemoveExtension()
+          .RemoveExtension().MaybeAsASCII();
+      origins->push_back(webkit_database::GetOriginFromIdentifier(origin_id));
       if (file_paths)
         file_paths->push_back(file_path);
     }
   }
 }
 
 // Deletes session-only databases.
 void ClearSessionOnlyOrigins(
     const base::FilePath& indexeddb_path,
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
@@ skipping 124 matching lines @@
       connections.erase(it++);
       db->forceClose();
     }
     DCHECK_EQ(connections_[origin_url].size(), 0UL);
     connections_.erase(origin_url);
   }
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) {
   std::string origin_id =
-      webkit_base::GetOriginIdentifierFromURL(origin_url);
+      webkit_database::GetIdentifierFromOrigin(origin_url);
   return GetIndexedDBFilePath(origin_id);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
     const std::string& origin_id) const {
   return GetIndexedDBFilePath(origin_id);
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
                                             WebIDBDatabaseImpl* connection) {
@@ skipping 87 matching lines @@
       BrowserThread::WEBKIT_DEPRECATED,
       FROM_HERE,
       base::Bind(
           &ClearSessionOnlyOrigins, data_path_, special_storage_policy_));
 }
 
 base::FilePath IndexedDBContextImpl::GetIndexedDBFilePath(
     const std::string& origin_id) const {
   DCHECK(!data_path_.empty());
   return data_path_.AppendASCII(origin_id).
-      AddExtension(FILE_PATH_LITERAL(".indexeddb")).
-      AddExtension(kIndexedDBExtension);
+      AddExtension(kIndexedDBExtension).
+      AddExtension(kLevelDBExtension);
 }
 
 int64 IndexedDBContextImpl::ReadUsageFromDisk(const GURL& origin_url) const {
   if (data_path_.empty())
     return 0;
   std::string origin_id =
-      webkit_base::GetOriginIdentifierFromURL(origin_url);
+      webkit_database::GetIdentifierFromOrigin(origin_url);
   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);
 }
 
@@ skipping 77 matching lines @@
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 }  // namespace content