Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

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.h"
 #include "base/files/file_enumerator.h"
 #include "base/message_loop/message_loop_proxy.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/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_proxy.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/database/database_identifier.h"
 
-namespace webkit_database {
+namespace storage {
 
 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;
 static const int kCompatibleVersion = 1;
 
@@ skipping 34 matching lines @@
     return it->second.second;
   return base::string16();
 }
 
 OriginInfo::OriginInfo(const std::string& origin_identifier, int64 total_size)
     : origin_identifier_(origin_identifier), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(
     const base::FilePath& profile_path,
     bool is_incognito,
-    quota::SpecialStoragePolicy* special_storage_policy,
-    quota::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy,
+    storage::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* db_tracker_thread)
     : is_initialized_(false),
       is_incognito_(is_incognito),
       force_keep_session_state_(false),
       shutting_down_(false),
       profile_path_(profile_path),
       db_dir_(is_incognito_
                   ? profile_path_.Append(kIncognitoDatabaseDirectoryName)
                   : profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Connection()),
@@ skipping 17 matching lines @@
                                      const base::string16& database_description,
                                      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_database::GetOriginFromIdentifier(origin_identifier),
-        quota::kStorageTypeTemporary);
+        storage::QuotaClient::kDatabase,
+        storage::GetOriginFromIdentifier(origin_identifier),
+        storage::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;
   }
   *database_size  = UpdateOpenDatabaseInfoAndNotify(origin_identifier,
@@ skipping 12 matching lines @@
                                      const base::string16& database_name) {
   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_database::GetOriginFromIdentifier(origin_identifier),
-        quota::kStorageTypeTemporary);
+        storage::QuotaClient::kDatabase,
+        storage::GetOriginFromIdentifier(origin_identifier),
+        storage::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,
     int error) {
@@ skipping 182 matching lines @@
                            ? GetDBFileSize(origin_identifier, database_name)
                            : 0;
 
   // Try to delete the file on the hard drive.
   base::FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
   if (!sql::Connection::Delete(db_file))
     return false;
 
   if (quota_manager_proxy_.get() && db_file_size)
     quota_manager_proxy_->NotifyStorageModified(
-        quota::QuotaClient::kDatabase,
-        webkit_database::GetOriginFromIdentifier(origin_identifier),
-        quota::kStorageTypeTemporary,
+        storage::QuotaClient::kDatabase,
+        storage::GetOriginFromIdentifier(origin_identifier),
+        storage::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()) {
     // Try to delete the origin in case this was the last database.
@@ skipping 37 matching lines @@
     base::FilePath new_file = new_origin_dir.Append(database.BaseName());
     base::Move(database, new_file);
   }
   base::DeleteFile(origin_dir, true);
   base::DeleteFile(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_database::GetOriginFromIdentifier(origin_identifier),
-        quota::kStorageTypeTemporary,
+        storage::QuotaClient::kDatabase,
+        storage::GetOriginFromIdentifier(origin_identifier),
+        storage::kStorageTypeTemporary,
         -deleted_size);
   }
 
   return true;
 }
 
 bool DatabaseTracker::IsDatabaseScheduledForDeletion(
     const std::string& origin_identifier,
     const base::string16& database_name) {
   DatabaseSet::iterator it = dbs_to_be_deleted_.find(origin_identifier);
@@ skipping 164 matching lines @@
   int64 old_size = database_connections_.GetOpenDatabaseSize(origin_id, name);
   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_database::GetOriginFromIdentifier(origin_id),
-          quota::kStorageTypeTemporary,
+          storage::QuotaClient::kDatabase,
+          storage::GetOriginFromIdentifier(origin_id),
+          storage::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,
     const base::string16& database_name) {
@@ skipping 49 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_database::GetOriginFromIdentifier(*ori))) {
+            storage::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 116 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_database::GetOriginFromIdentifier(*origin);
+    GURL origin_url = storage::GetOriginFromIdentifier(*origin);
     if (!special_storage_policy_->IsStorageSessionOnly(origin_url))
       continue;
     if (special_storage_policy_->IsStorageProtected(origin_url))
       continue;
-    webkit_database::OriginInfo origin_info;
+    storage::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();
          database != databases.end(); ++database) {
       base::File file(GetFullDBFilePath(*origin, *database),
                       base::File::FLAG_OPEN_ALWAYS |
                           base::File::FLAG_SHARE_DELETE |
                           base::File::FLAG_DELETE_ON_CLOSE |
@@ skipping 23 matching lines @@
   DCHECK(db_tracker_thread_.get());
   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
+}  // namespace storage