Use chromium logic for database identifier<->origin conversions

webkit/browser/database/database_tracker.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/browser/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/transaction.h"
 #include "third_party/sqlite/sqlite3.h"
-#include "webkit/base/origin_url_conversions.h"
 #include "webkit/browser/database/database_quota_client.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/browser/database/databases_table.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
+#include "webkit/common/database/database_identifier.h"
 
 namespace webkit_database {
 
 const base::FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
 const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases-incognito");
 const base::FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kCurrentVersion = 2;
@@ skipping 76 matching lines @@
                                      int64 estimated_size,
                                      int64* database_size) {
   if (shutting_down_ || !LazyInit()) {
     *database_size = 0;
     return;
   }
 
   if (quota_manager_proxy_.get())
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kDatabase,
-        webkit_base::GetOriginURLFromIdentifier(origin_identifier),
+        webkit_database::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
 
   InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
                                 database_description, estimated_size);
   if (database_connections_.AddConnection(origin_identifier, database_name)) {
     *database_size = SeedOpenDatabaseInfo(origin_identifier,
                                           database_name,
                                           database_description);
     return;
   }
@@ skipping 14 matching lines @@
   if (database_connections_.IsEmpty()) {
     DCHECK(!is_initialized_);
     return;
   }
 
   // We call NotifiyStorageAccessed when a db is opened and also when
   // closed because we don't call it for read while open.
   if (quota_manager_proxy_.get())
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kDatabase,
-        webkit_base::GetOriginURLFromIdentifier(origin_identifier),
+        webkit_database::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
 
   UpdateOpenDatabaseSizeAndNotify(origin_identifier, database_name);
   if (database_connections_.RemoveConnection(origin_identifier, database_name))
     DeleteDatabaseIfNeeded(origin_identifier, database_name);
 }
 
 void DatabaseTracker::HandleSqliteError(
     const std::string& origin_identifier,
     const base::string16& database_name,
@@ skipping 191 matching lines @@
     return false;
 
   // Also delete any orphaned journal file.
   DCHECK(db_file.Extension().empty());
   file_util::Delete(db_file.InsertBeforeExtensionASCII(
       DatabaseUtil::kJournalFileSuffix), false);
 
   if (quota_manager_proxy_.get() && db_file_size)
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kDatabase,
-        webkit_base::GetOriginURLFromIdentifier(origin_identifier),
+        webkit_database::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary,
         -db_file_size);
 
   // Clean up the main database and invalidate the cached record.
   databases_table_->DeleteDatabaseDetails(origin_identifier, database_name);
   origins_info_map_.erase(origin_identifier);
 
   std::vector<DatabaseDetails> details;
   if (databases_table_->GetAllDatabaseDetailsForOriginIdentifier(
           origin_identifier, &details) && details.empty()) {
@@ skipping 39 matching lines @@
     file_util::Move(database, new_file);
   }
   file_util::Delete(origin_dir, true);
   file_util::Delete(new_origin_dir, true); // might fail on windows.
 
   databases_table_->DeleteOriginIdentifier(origin_identifier);
 
   if (quota_manager_proxy_.get() && deleted_size) {
     quota_manager_proxy_->NotifyStorageModified(
         quota::QuotaClient::kDatabase,
-        webkit_base::GetOriginURLFromIdentifier(origin_identifier),
+        webkit_database::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary,
         -deleted_size);
   }
 
   return true;
 }
 
 bool DatabaseTracker::IsDatabaseScheduledForDeletion(
     const std::string& origin_identifier,
     const base::string16& database_name) {
@@ skipping 166 matching lines @@
   CachedOriginInfo* info = MaybeGetCachedOriginInfo(origin_id, false);
   if (info && opt_description)
     info->SetDatabaseDescription(name, *opt_description);
   if (old_size != new_size) {
     database_connections_.SetOpenDatabaseSize(origin_id, name, new_size);
     if (info)
       info->SetDatabaseSize(name, new_size);
     if (quota_manager_proxy_.get())
       quota_manager_proxy_->NotifyStorageModified(
           quota::QuotaClient::kDatabase,
-          webkit_base::GetOriginURLFromIdentifier(origin_id),
+          webkit_database::GetOriginFromIdentifier(origin_id),
           quota::kStorageTypeTemporary,
           new_size - old_size);
     FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
         origin_id, name, new_size));
   }
   return new_size;
 }
 
 void DatabaseTracker::ScheduleDatabaseForDeletion(
     const std::string& origin_identifier,
@@ skipping 50 matching lines @@
 
   std::vector<std::string> origins_identifiers;
   if (!databases_table_->GetAllOriginIdentifiers(&origins_identifiers))
     return net::ERR_FAILED;
   int rv = net::OK;
   for (std::vector<std::string>::const_iterator ori =
            origins_identifiers.begin();
        ori != origins_identifiers.end(); ++ori) {
     if (special_storage_policy_.get() &&
         special_storage_policy_->IsStorageProtected(
-            webkit_base::GetOriginURLFromIdentifier(*ori))) {
+            webkit_database::GetOriginFromIdentifier(*ori))) {
       continue;
     }
 
     std::vector<DatabaseDetails> details;
     if (!databases_table_->
             GetAllDatabaseDetailsForOriginIdentifier(*ori, &details))
       rv = net::ERR_FAILED;
     for (std::vector<DatabaseDetails>::const_iterator db = details.begin();
          db != details.end(); ++db) {
       base::FilePath db_file = GetFullDBFilePath(*ori, db->database_name);
@@ skipping 118 matching lines @@
 
   if (!LazyInit())
     return;
 
   std::vector<std::string> origin_identifiers;
   GetAllOriginIdentifiers(&origin_identifiers);
 
   for (std::vector<std::string>::iterator origin =
            origin_identifiers.begin();
        origin != origin_identifiers.end(); ++origin) {
-    GURL origin_url = webkit_base::GetOriginURLFromIdentifier(*origin);
+    GURL origin_url = webkit_database::GetOriginFromIdentifier(*origin);
     if (!special_storage_policy_->IsStorageSessionOnly(origin_url))
       continue;
     if (special_storage_policy_->IsStorageProtected(origin_url))
       continue;
     webkit_database::OriginInfo origin_info;
     std::vector<base::string16> databases;
     GetOriginInfo(*origin, &origin_info);
     origin_info.GetAllDatabaseNames(&databases);
 
     for (std::vector<base::string16>::iterator database = databases.begin();
@@ skipping 30 matching lines @@
   if (!db_tracker_thread_->BelongsToCurrentThread()) {
     db_tracker_thread_->PostTask(
         FROM_HERE,
         base::Bind(&DatabaseTracker::SetForceKeepSessionState, this));
     return;
   }
   force_keep_session_state_ = true;
 }
 
 }  // namespace webkit_database