Move storage-related files from webkit/ to new top-level directory storage/

storage/browser/database/database_tracker.cc

Index: storage/browser/database/database_tracker.cc
diff --git a/webkit/browser/database/database_tracker.cc b/storage/browser/database/database_tracker.cc
similarity index 85%
rename from webkit/browser/database/database_tracker.cc
rename to storage/browser/database/database_tracker.cc
index ab1f6fd2806cd78607c89c435fac92cb26d56712..8d72e227d8c2efa053b760c5c06ba2a36b201e9f 100644
--- a/webkit/browser/database/database_tracker.cc
+++ b/storage/browser/database/database_tracker.cc
@@ -2,7 +2,7 @@
 // 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 "storage/browser/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
@@ -20,12 +20,12 @@
 #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"
+#include "storage/browser/database/database_quota_client.h"
+#include "storage/browser/database/database_util.h"
+#include "storage/browser/database/databases_table.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/browser/quota/special_storage_policy.h"
+#include "storage/common/database/database_identifier.h"
 
 namespace webkit_database {
 
@@ -43,20 +43,23 @@ const base::FilePath::CharType kTemporaryDirectoryPrefix[] =
 const base::FilePath::CharType kTemporaryDirectoryPattern[] =
     FILE_PATH_LITERAL("DeleteMe*");
 
-OriginInfo::OriginInfo()
-    : total_size_(0) {}
+OriginInfo::OriginInfo() : total_size_(0) {
+}
 
 OriginInfo::OriginInfo(const OriginInfo& origin_info)
     : origin_identifier_(origin_info.origin_identifier_),
       total_size_(origin_info.total_size_),
-      database_info_(origin_info.database_info_) {}
+      database_info_(origin_info.database_info_) {
+}
 
-OriginInfo::~OriginInfo() {}
+OriginInfo::~OriginInfo() {
+}
 
 void OriginInfo::GetAllDatabaseNames(
     std::vector<base::string16>* databases) const {
   for (DatabaseInfoMap::const_iterator it = database_info_.begin();
-       it != database_info_.end(); it++) {
+       it != database_info_.end();
+       it++) {
     databases->push_back(it->first);
   }
 }
@@ -77,7 +80,8 @@ base::string16 OriginInfo::GetDatabaseDescription(
 }
 
 OriginInfo::OriginInfo(const std::string& origin_identifier, int64 total_size)
-    : origin_identifier_(origin_identifier), total_size_(total_size) {}
+    : origin_identifier_(origin_identifier), total_size_(total_size) {
+}
 
 DatabaseTracker::DatabaseTracker(
     const base::FilePath& profile_path,
@@ -125,17 +129,15 @@ void DatabaseTracker::DatabaseOpened(const std::string& origin_identifier,
         webkit_database::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
 
-  InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
-                                database_description, estimated_size);
+  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);
+    *database_size = SeedOpenDatabaseInfo(
+        origin_identifier, database_name, database_description);
     return;
   }
-  *database_size  = UpdateOpenDatabaseInfoAndNotify(origin_identifier,
-                                                    database_name,
-                                                    &database_description);
+  *database_size = UpdateOpenDatabaseInfoAndNotify(
+      origin_identifier, database_name, &database_description);
 }
 
 void DatabaseTracker::DatabaseModified(const std::string& origin_identifier,
@@ -165,10 +167,9 @@ void DatabaseTracker::DatabaseClosed(const std::string& origin_identifier,
     DeleteDatabaseIfNeeded(origin_identifier, database_name);
 }
 
-void DatabaseTracker::HandleSqliteError(
-    const std::string& origin_identifier,
-    const base::string16& database_name,
-    int error) {
+void DatabaseTracker::HandleSqliteError(const std::string& origin_identifier,
+                                        const base::string16& database_name,
+                                        int error) {
   // We only handle errors that indicate corruption and we
   // do so with a heavy hand, we delete it. Any renderers/workers
   // with this database open will receive a message to close it
@@ -178,8 +179,7 @@ void DatabaseTracker::HandleSqliteError(
   // Note: the client-side filters out all but these two errors as
   // a small optimization, see WebDatabaseObserverImpl::HandleSqliteError.
   if (error == SQLITE_CORRUPT || error == SQLITE_NOTADB) {
-    DeleteDatabase(origin_identifier, database_name,
-                   net::CompletionCallback());
+    DeleteDatabase(origin_identifier, database_name, net::CompletionCallback());
   }
 }
 
@@ -198,13 +198,17 @@ void DatabaseTracker::CloseDatabases(const DatabaseConnections& connections) {
   std::vector<std::pair<std::string, base::string16> > open_dbs;
   connections.ListConnections(&open_dbs);
   for (std::vector<std::pair<std::string, base::string16> >::iterator it =
-           open_dbs.begin(); it != open_dbs.end(); ++it)
+           open_dbs.begin();
+       it != open_dbs.end();
+       ++it)
     UpdateOpenDatabaseSizeAndNotify(it->first, it->second);
 
   std::vector<std::pair<std::string, base::string16> > closed_dbs;
   database_connections_.RemoveConnections(connections, &closed_dbs);
   for (std::vector<std::pair<std::string, base::string16> >::iterator it =
-           closed_dbs.begin(); it != closed_dbs.end(); ++it) {
+           closed_dbs.begin();
+       it != closed_dbs.end();
+       ++it) {
     DeleteDatabaseIfNeeded(it->first, it->second);
   }
 }
@@ -294,8 +298,8 @@ base::FilePath DatabaseTracker::GetFullDBFilePath(
     return base::FilePath();
 
   return db_dir_.Append(base::FilePath::FromUTF16Unsafe(
-      GetOriginDirectory(origin_identifier))).AppendASCII(
-          base::Int64ToString(id));
+                            GetOriginDirectory(origin_identifier)))
+      .AppendASCII(base::Int64ToString(id));
 }
 
 bool DatabaseTracker::GetOriginInfo(const std::string& origin_identifier,
@@ -317,8 +321,7 @@ bool DatabaseTracker::GetAllOriginIdentifiers(
   return databases_table_->GetAllOriginIdentifiers(origin_identifiers);
 }
 
-bool DatabaseTracker::GetAllOriginsInfo(
-    std::vector<OriginInfo>* origins_info) {
+bool DatabaseTracker::GetAllOriginsInfo(std::vector<OriginInfo>* origins_info) {
   DCHECK(origins_info);
   DCHECK(origins_info->empty());
 
@@ -327,7 +330,8 @@ bool DatabaseTracker::GetAllOriginsInfo(
     return false;
 
   for (std::vector<std::string>::const_iterator it = origins.begin();
-       it != origins.end(); it++) {
+       it != origins.end();
+       it++) {
     CachedOriginInfo* origin_info = GetCachedOriginInfo(*it);
     if (!origin_info) {
       // Restore 'origins_info' to its initial state.
@@ -372,7 +376,8 @@ bool DatabaseTracker::DeleteClosedDatabase(
 
   std::vector<DatabaseDetails> details;
   if (databases_table_->GetAllDatabaseDetailsForOriginIdentifier(
-          origin_identifier, &details) && details.empty()) {
+          origin_identifier, &details) &&
+      details.empty()) {
     // Try to delete the origin in case this was the last database.
     DeleteOrigin(origin_identifier, false);
   }
@@ -402,20 +407,17 @@ bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier,
   // as we can't delete the origin directory on windows if it contains opened
   // files.
   base::FilePath new_origin_dir;
-  base::CreateTemporaryDirInDir(db_dir_,
-                                kTemporaryDirectoryPrefix,
-                                &new_origin_dir);
+  base::CreateTemporaryDirInDir(
+      db_dir_, kTemporaryDirectoryPrefix, &new_origin_dir);
   base::FileEnumerator databases(
-      origin_dir,
-      false,
-      base::FileEnumerator::FILES);
+      origin_dir, false, base::FileEnumerator::FILES);
   for (base::FilePath database = databases.Next(); !database.empty();
        database = databases.Next()) {
     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.
+  base::DeleteFile(new_origin_dir, true);  // might fail on windows.
 
   databases_table_->DeleteOriginIdentifier(origin_identifier);
 
@@ -450,11 +452,10 @@ bool DatabaseTracker::LazyInit() {
     // If there are left-over directories from failed deletion attempts, clean
     // them up.
     if (base::DirectoryExists(db_dir_)) {
-      base::FileEnumerator directories(
-          db_dir_,
-          false,
-          base::FileEnumerator::DIRECTORIES,
-          kTemporaryDirectoryPattern);
+      base::FileEnumerator directories(db_dir_,
+                                       false,
+                                       base::FileEnumerator::DIRECTORIES,
+                                       kTemporaryDirectoryPattern);
       for (base::FilePath directory = directories.Next(); !directory.empty();
            directory = directories.Next()) {
         base::DeleteFile(directory, true);
@@ -479,12 +480,11 @@ bool DatabaseTracker::LazyInit() {
     databases_table_.reset(new DatabasesTable(db_.get()));
     meta_table_.reset(new sql::MetaTable());
 
-    is_initialized_ =
-        base::CreateDirectory(db_dir_) &&
-        (db_->is_open() ||
-         (is_incognito_ ? db_->OpenInMemory() :
-          db_->Open(kTrackerDatabaseFullPath))) &&
-        UpgradeToCurrentVersion();
+    is_initialized_ = base::CreateDirectory(db_dir_) &&
+                      (db_->is_open() ||
+                       (is_incognito_ ? db_->OpenInMemory()
+                                      : db_->Open(kTrackerDatabaseFullPath))) &&
+                      UpgradeToCurrentVersion();
     if (!is_initialized_) {
       databases_table_.reset(NULL);
       meta_table_.reset(NULL);
@@ -534,7 +534,8 @@ void DatabaseTracker::ClearAllCachedOriginInfo() {
 }
 
 DatabaseTracker::CachedOriginInfo* DatabaseTracker::MaybeGetCachedOriginInfo(
-    const std::string& origin_identifier, bool create_if_needed) {
+    const std::string& origin_identifier,
+    bool create_if_needed) {
   if (!LazyInit())
     return NULL;
 
@@ -552,10 +553,11 @@ DatabaseTracker::CachedOriginInfo* DatabaseTracker::MaybeGetCachedOriginInfo(
     CachedOriginInfo& origin_info = origins_info_map_[origin_identifier];
     origin_info.SetOriginIdentifier(origin_identifier);
     for (std::vector<DatabaseDetails>::const_iterator it = details.begin();
-         it != details.end(); it++) {
+         it != details.end();
+         it++) {
       int64 db_file_size;
-      if (database_connections_.IsDatabaseOpened(
-              origin_identifier, it->database_name)) {
+      if (database_connections_.IsDatabaseOpened(origin_identifier,
+                                                 it->database_name)) {
         db_file_size = database_connections_.GetOpenDatabaseSize(
             origin_identifier, it->database_name);
       } else {
@@ -571,20 +573,20 @@ DatabaseTracker::CachedOriginInfo* DatabaseTracker::MaybeGetCachedOriginInfo(
 
 int64 DatabaseTracker::GetDBFileSize(const std::string& origin_identifier,
                                      const base::string16& database_name) {
-  base::FilePath db_file_name = GetFullDBFilePath(origin_identifier,
-                                                  database_name);
+  base::FilePath db_file_name =
+      GetFullDBFilePath(origin_identifier, database_name);
   int64 db_file_size = 0;
   if (!base::GetFileSize(db_file_name, &db_file_size))
     db_file_size = 0;
   return db_file_size;
 }
 
-int64 DatabaseTracker::SeedOpenDatabaseInfo(
-    const std::string& origin_id, const base::string16& name,
-    const base::string16& description) {
+int64 DatabaseTracker::SeedOpenDatabaseInfo(const std::string& origin_id,
+                                            const base::string16& name,
+                                            const base::string16& description) {
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
   int64 size = GetDBFileSize(origin_id, name);
-  database_connections_.SetOpenDatabaseSize(origin_id, name,  size);
+  database_connections_.SetOpenDatabaseSize(origin_id, name, size);
   CachedOriginInfo* info = MaybeGetCachedOriginInfo(origin_id, false);
   if (info) {
     info->SetDatabaseSize(name, size);
@@ -594,7 +596,8 @@ int64 DatabaseTracker::SeedOpenDatabaseInfo(
 }
 
 int64 DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
-    const std::string& origin_id, const base::string16& name,
+    const std::string& origin_id,
+    const base::string16& name,
     const base::string16* opt_description) {
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
   int64 new_size = GetDBFileSize(origin_id, name);
@@ -612,8 +615,8 @@ int64 DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
           webkit_database::GetOriginFromIdentifier(origin_id),
           quota::kStorageTypeTemporary,
           new_size - old_size);
-    FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
-        origin_id, name, new_size));
+    FOR_EACH_OBSERVER(
+        Observer, observers_, OnDatabaseSizeChanged(origin_id, name, new_size));
   }
   return new_size;
 }
@@ -621,11 +624,13 @@ int64 DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
 void DatabaseTracker::ScheduleDatabaseForDeletion(
     const std::string& origin_identifier,
     const base::string16& database_name) {
-  DCHECK(database_connections_.IsDatabaseOpened(origin_identifier,
-                                                database_name));
+  DCHECK(
+      database_connections_.IsDatabaseOpened(origin_identifier, database_name));
   dbs_to_be_deleted_[origin_identifier].insert(database_name);
-  FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseScheduledForDeletion(
-      origin_identifier, database_name));
+  FOR_EACH_OBSERVER(
+      Observer,
+      observers_,
+      OnDatabaseScheduledForDeletion(origin_identifier, database_name));
 }
 
 void DatabaseTracker::ScheduleDatabasesForDeletion(
@@ -636,9 +641,11 @@ void DatabaseTracker::ScheduleDatabasesForDeletion(
   if (!callback.is_null())
     deletion_callbacks_.push_back(std::make_pair(callback, databases));
   for (DatabaseSet::const_iterator ori = databases.begin();
-       ori != databases.end(); ++ori) {
+       ori != databases.end();
+       ++ori) {
     for (std::set<base::string16>::const_iterator db = ori->second.begin();
-         db != ori->second.end(); ++db)
+         db != ori->second.end();
+         ++db)
       ScheduleDatabaseForDeletion(ori->first, *db);
   }
 }
@@ -677,7 +684,8 @@ int DatabaseTracker::DeleteDataModifiedSince(
   int rv = net::OK;
   for (std::vector<std::string>::const_iterator ori =
            origins_identifiers.begin();
-       ori != origins_identifiers.end(); ++ori) {
+       ori != origins_identifiers.end();
+       ++ori) {
     if (special_storage_policy_.get() &&
         special_storage_policy_->IsStorageProtected(
             webkit_database::GetOriginFromIdentifier(*ori))) {
@@ -685,11 +693,12 @@ int DatabaseTracker::DeleteDataModifiedSince(
     }
 
     std::vector<DatabaseDetails> details;
-    if (!databases_table_->
-            GetAllDatabaseDetailsForOriginIdentifier(*ori, &details))
+    if (!databases_table_->GetAllDatabaseDetailsForOriginIdentifier(*ori,
+                                                                    &details))
       rv = net::ERR_FAILED;
     for (std::vector<DatabaseDetails>::const_iterator db = details.begin();
-         db != details.end(); ++db) {
+         db != details.end();
+         ++db) {
       base::FilePath db_file = GetFullDBFilePath(*ori, db->database_name);
       base::File::Info file_info;
       base::GetFileInfo(db_file, &file_info);
@@ -715,18 +724,20 @@ int DatabaseTracker::DeleteDataModifiedSince(
 }
 
 int DatabaseTracker::DeleteDataForOrigin(
-    const std::string& origin, const net::CompletionCallback& callback) {
+    const std::string& origin,
+    const net::CompletionCallback& callback) {
   if (!LazyInit())
     return net::ERR_FAILED;
 
   DatabaseSet to_be_deleted;
 
   std::vector<DatabaseDetails> details;
-  if (!databases_table_->
-          GetAllDatabaseDetailsForOriginIdentifier(origin, &details))
+  if (!databases_table_->GetAllDatabaseDetailsForOriginIdentifier(origin,
+                                                                  &details))
     return net::ERR_FAILED;
   for (std::vector<DatabaseDetails>::const_iterator db = details.begin();
-       db != details.end(); ++db) {
+       db != details.end();
+       ++db) {
     // Check if the database is opened by any renderer.
     if (database_connections_.IsDatabaseOpened(origin, db->database_name))
       to_be_deleted[origin].insert(db->database_name);
@@ -789,7 +800,8 @@ void DatabaseTracker::DeleteIncognitoDBDirectory() {
   is_initialized_ = false;
 
   for (FileHandlesMap::iterator it = incognito_file_handles_.begin();
-       it != incognito_file_handles_.end(); it++) {
+       it != incognito_file_handles_.end();
+       it++) {
     delete it->second;
   }
 
@@ -814,9 +826,9 @@ void DatabaseTracker::ClearSessionOnlyOrigins() {
   std::vector<std::string> origin_identifiers;
   GetAllOriginIdentifiers(&origin_identifiers);
 
-  for (std::vector<std::string>::iterator origin =
-           origin_identifiers.begin();
-       origin != origin_identifiers.end(); ++origin) {
+  for (std::vector<std::string>::iterator origin = origin_identifiers.begin();
+       origin != origin_identifiers.end();
+       ++origin) {
     GURL origin_url = webkit_database::GetOriginFromIdentifier(*origin);
     if (!special_storage_policy_->IsStorageSessionOnly(origin_url))
       continue;
@@ -828,18 +840,17 @@ void DatabaseTracker::ClearSessionOnlyOrigins() {
     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 |
-                          base::File::FLAG_READ);
+         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 | base::File::FLAG_READ);
     }
     DeleteOrigin(*origin, true);
   }
 }
 
-
 void DatabaseTracker::Shutdown() {
   DCHECK(db_tracker_thread_.get());
   DCHECK(db_tracker_thread_->BelongsToCurrentThread());