More WebSQLDatabase and QuotaManager integration.

webkit/database/database_tracker.cc

 // Copyright (c) 2011 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/database/database_tracker.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/sql/connection.h"
@@ skipping 33 matching lines @@
     FILE_PATH_LITERAL("databases");
 const FilePath::CharType kIncognitoDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases-incognito");
 const FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kCurrentVersion = 2;
 static const int kCompatibleVersion = 1;
 static const char* kExtensionOriginIdentifierPrefix = "chrome-extension_";
 
 OriginInfo::OriginInfo()
-    : total_size_(0),
-      quota_(0) {}
+    : total_size_(0) {}
 
 OriginInfo::OriginInfo(const OriginInfo& origin_info)
     : origin_(origin_info.origin_),
       total_size_(origin_info.total_size_),
-      quota_(origin_info.quota_),
       database_info_(origin_info.database_info_) {}
 
 OriginInfo::~OriginInfo() {}
 
 void OriginInfo::GetAllDatabaseNames(std::vector<string16>* databases) const {
   for (DatabaseInfoMap::const_iterator it = database_info_.begin();
        it != database_info_.end(); it++) {
     databases->push_back(it->first);
   }
 }
 
 int64 OriginInfo::GetDatabaseSize(const string16& database_name) const {
   DatabaseInfoMap::const_iterator it = database_info_.find(database_name);
   if (it != database_info_.end())
     return it->second.first;
   return 0;
 }
 
 string16 OriginInfo::GetDatabaseDescription(
     const string16& database_name) const {
   DatabaseInfoMap::const_iterator it = database_info_.find(database_name);
   if (it != database_info_.end())
     return it->second.second;
   return string16();
 }
 
-OriginInfo::OriginInfo(const string16& origin, int64 total_size, int64 quota)
-    : origin_(origin), total_size_(total_size), quota_(quota) {}
+OriginInfo::OriginInfo(const string16& origin, int64 total_size)
+    : origin_(origin), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(
     const FilePath& profile_path,
     bool is_incognito,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     base::MessageLoopProxy* db_tracker_thread)
     : is_initialized_(false),
       is_incognito_(is_incognito),
       shutting_down_(false),
       profile_path_(profile_path),
       db_dir_(is_incognito_ ?
               profile_path_.Append(kIncognitoDatabaseDirectoryName) :
               profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Connection()),
       databases_table_(NULL),
       meta_table_(NULL),
-      default_quota_(5 * 1024 * 1024),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy),
       incognito_origin_directories_generator_(0) {
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(
         new DatabaseQuotaClient(db_tracker_thread, this));
   }
 }
 
 DatabaseTracker::~DatabaseTracker() {
   DCHECK(dbs_to_be_deleted_.empty());
   DCHECK(deletion_callbacks_.empty());
 }
 
-void DatabaseTracker::SetDefaultQuota(int64 quota) {
-  default_quota_ = quota;
-  ClearAllCachedOriginInfo();
-}
-
 void DatabaseTracker::DatabaseOpened(const string16& origin_identifier,
                                      const string16& database_name,
                                      const string16& database_description,
                                      int64 estimated_size,
                                      int64* database_size,
                                      int64* space_available) {
+  // TODO(michaeln): remove space_available from the interface
+  *space_available = 0;
+
   if (!LazyInit()) {
     *database_size = 0;
     *space_available = 0;
     return;
   }
 
-  InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
-                                database_description, estimated_size);
-  database_connections_.AddConnection(origin_identifier, database_name);
-
-  CachedOriginInfo* info = GetCachedOriginInfo(origin_identifier);
-  *database_size = (info ? info->GetDatabaseSize(database_name) : 0);
-  *space_available = GetOriginSpaceAvailable(origin_identifier);
-
-  if (quota_manager_proxy_) {
-    // So we can compute deltas as modifications are made.
-    database_connections_.SetOpenDatabaseSize(
-        origin_identifier, database_name, *database_size);
+  if (quota_manager_proxy_)
     quota_manager_proxy_->NotifyStorageAccessed(
         quota::QuotaClient::kDatabase,
         DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
         quota::kStorageTypeTemporary);
+
+  InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
+                                database_description, estimated_size);
+  if (database_connections_.AddConnection(origin_identifier, database_name)) {
+    *database_size = SeedOpenDatabaseSize(origin_identifier, database_name);
+    return;
   }
+  *database_size  = UpdateOpenDatabaseSizeAndNotify(origin_identifier,
+                                                    database_name);
 }
 
 void DatabaseTracker::DatabaseModified(const string16& origin_identifier,
                                        const string16& database_name) {
   if (!LazyInit())
     return;
-
-  int64 new_size =
-      UpdateCachedDatabaseFileSize(origin_identifier, database_name);
-  int64 space_available = GetOriginSpaceAvailable(origin_identifier);
-  FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
-      origin_identifier, database_name, new_size, space_available));
-
-  if (quota_manager_proxy_) {
-    int64 old_size = database_connections_.GetOpenDatabaseSize(
-        origin_identifier, database_name);
-    if (old_size != new_size) {
-      database_connections_.SetOpenDatabaseSize(
-          origin_identifier, database_name, new_size);
-      quota_manager_proxy_->NotifyStorageModified(
-          quota::QuotaClient::kDatabase,
-          DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
-          quota::kStorageTypeTemporary,
-          new_size - old_size);
-    }
-  }
+  UpdateOpenDatabaseSizeAndNotify(origin_identifier, database_name);
 }
 
 void DatabaseTracker::DatabaseClosed(const string16& origin_identifier,
                                      const string16& database_name) {
   if (database_connections_.IsEmpty()) {
     DCHECK(!is_initialized_);
     return;
   }
-  database_connections_.RemoveConnection(origin_identifier, database_name);
-  if (!database_connections_.IsDatabaseOpened(origin_identifier, database_name))
+
+  if (quota_manager_proxy_)
+    quota_manager_proxy_->NotifyStorageAccessed(
+        quota::QuotaClient::kDatabase,
+        DatabaseUtil::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::CloseDatabases(const DatabaseConnections& connections) {
   if (database_connections_.IsEmpty()) {
     DCHECK(!is_initialized_ || connections.IsEmpty());
     return;
   }
 
-  if (quota_manager_proxy_) {
-    // When being closed by this route, there's a chance that
-    // the tracker missed some DatabseModified calls. This method is used
-    // when a renderer crashes to cleanup it's open resources.
-    // We need to examine what we have in connections for the
-    // size of each open databases and notify any differences between the
-    // actual file sizes now.
-    std::vector<std::pair<string16, string16> > open_dbs;
-    connections.ListConnections(&open_dbs);
-    for (std::vector<std::pair<string16, string16> >::iterator it =
-             open_dbs.begin(); it != open_dbs.end(); ++it) {
-      int64 old_size = database_connections_.GetOpenDatabaseSize(
-          it->first, it->second);
-      int64 new_size = GetDBFileSize(it->first, it->second);
-      if (new_size != old_size) {
-        database_connections_.SetOpenDatabaseSize(
-            it->first, it->second, new_size);
-        quota_manager_proxy_->NotifyStorageModified(
-            quota::QuotaClient::kDatabase,
-            DatabaseUtil::GetOriginFromIdentifier(it->first),
-            quota::kStorageTypeTemporary,
-            new_size - old_size);
-      }
-    }
-  }
+  // When being closed by this route, there's a chance that
+  // the tracker missed some DatabseModified calls. This method is used
+  // when a renderer crashes to cleanup it's open resources.
+  // We need to examine what we have in connections for the
+  // size of each open databases and notify any differences between the
+  // actual file sizes now.
+  std::vector<std::pair<string16, string16> > open_dbs;
+  connections.ListConnections(&open_dbs);
+  for (std::vector<std::pair<string16, string16> >::iterator it =
+           open_dbs.begin(); it != open_dbs.end(); ++it)
+    UpdateOpenDatabaseSizeAndNotify(it->first, it->second);
 
   std::vector<std::pair<string16, string16> > closed_dbs;
   database_connections_.RemoveConnections(connections, &closed_dbs);
   for (std::vector<std::pair<string16, string16> >::iterator it =
            closed_dbs.begin(); it != closed_dbs.end(); ++it) {
     DeleteDatabaseIfNeeded(it->first, it->second);
   }
 }
 
 void DatabaseTracker::DeleteDatabaseIfNeeded(const string16& origin_identifier,
@@ skipping 41 matching lines @@
   observers_.RemoveObserver(observer);
   ClearAllCachedOriginInfo();
 }
 
 void DatabaseTracker::CloseTrackerDatabaseAndClearCaches() {
   ClearAllCachedOriginInfo();
 
   if (!is_incognito_) {
     meta_table_.reset(NULL);
     databases_table_.reset(NULL);
-    quota_table_.reset(NULL);
     db_->Close();
     is_initialized_ = false;
   }
 }
 
 string16 DatabaseTracker::GetOriginDirectory(
     const string16& origin_identifier) {
   if (!is_incognito_)
     return origin_identifier;
 
@@ skipping 61 matching lines @@
       // Restore 'origins_info' to its initial state.
       origins_info->clear();
       return false;
     }
     origins_info->push_back(OriginInfo(*origin_info));
   }
 
   return true;
 }
 
-void DatabaseTracker::SetOriginQuota(const string16& origin_identifier,
-                                     int64 new_quota) {
-  if (!LazyInit())
-    return;
-
-  if (quota_table_->SetOriginQuota(origin_identifier, new_quota) &&
-      (origins_info_map_.find(origin_identifier) != origins_info_map_.end())) {
-    origins_info_map_[origin_identifier].SetQuota(new_quota);
-  }
-}
-
-
 bool DatabaseTracker::DeleteClosedDatabase(const string16& origin_identifier,
                                            const string16& database_name) {
   if (!LazyInit())
     return false;
 
   // Check if the database is opened by any renderer.
   if (database_connections_.IsDatabaseOpened(origin_identifier, database_name))
     return false;
 
   int64 db_file_size = quota_manager_proxy_ ?
@@ skipping 74 matching lines @@
     return false;
 
   std::set<string16>& databases = it->second;
   return (databases.find(database_name) != databases.end());
 }
 
 bool DatabaseTracker::LazyInit() {
   if (!is_initialized_ && !shutting_down_) {
     DCHECK(!db_->is_open());
     DCHECK(!databases_table_.get());
-    DCHECK(!quota_table_.get());
     DCHECK(!meta_table_.get());
 
     // If the tracker database exists, but it's corrupt or doesn't
     // have a meta table, delete the database directory.
     const FilePath kTrackerDatabaseFullPath =
         db_dir_.Append(FilePath(kTrackerDatabaseFileName));
     if (file_util::DirectoryExists(db_dir_) &&
         file_util::PathExists(kTrackerDatabaseFullPath) &&
         (!db_->Open(kTrackerDatabaseFullPath) ||
          !sql::MetaTable::DoesTableExist(db_.get()))) {
       db_->Close();
       if (!file_util::Delete(db_dir_, true))
         return false;
     }
 
     db_->set_error_delegate(GetErrorHandlerForTrackerDb());
 
     databases_table_.reset(new DatabasesTable(db_.get()));
-    quota_table_.reset(new QuotaTable(db_.get()));
     meta_table_.reset(new sql::MetaTable());
 
     is_initialized_ =
         file_util::CreateDirectory(db_dir_) &&
         (db_->is_open() ||
          (is_incognito_ ? db_->OpenInMemory() :
           db_->Open(kTrackerDatabaseFullPath))) &&
         UpgradeToCurrentVersion();
     if (!is_initialized_) {
       databases_table_.reset(NULL);
-      quota_table_.reset(NULL);
       meta_table_.reset(NULL);
       db_->Close();
     }
   }
   return is_initialized_;
 }
 
 bool DatabaseTracker::UpgradeToCurrentVersion() {
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin() ||
       !meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion) ||
       (meta_table_->GetCompatibleVersionNumber() > kCurrentVersion) ||
-      !databases_table_->Init() ||
-      !quota_table_->Init())
+      !databases_table_->Init())
     return false;
 
   if (meta_table_->GetVersionNumber() < kCurrentVersion)
     meta_table_->SetVersionNumber(kCurrentVersion);
 
   return transaction.Commit();
 }
 
 void DatabaseTracker::InsertOrUpdateDatabaseDetails(
     const string16& origin_identifier,
@@ skipping 30 matching lines @@
     std::vector<DatabaseDetails> details;
     if (!databases_table_->GetAllDatabaseDetailsForOrigin(
             origin_identifier, &details)) {
       return NULL;
     }
 
     CachedOriginInfo& origin_info = origins_info_map_[origin_identifier];
     origin_info.SetOrigin(origin_identifier);
     for (std::vector<DatabaseDetails>::const_iterator it = details.begin();
          it != details.end(); it++) {
-      int64 db_file_size =
-          GetDBFileSize(origin_identifier, it->database_name);
+      int64 db_file_size;
+      if (database_connections_.IsDatabaseOpened(
+              origin_identifier, it->database_name)) {
+        db_file_size = database_connections_.GetOpenDatabaseSize(
+            origin_identifier, it->database_name);
+      } else {
+        db_file_size = GetDBFileSize(origin_identifier, it->database_name);
+      }
       origin_info.SetDatabaseSize(it->database_name, db_file_size);
       origin_info.SetDatabaseDescription(it->database_name, it->description);
     }
-
-    if (special_storage_policy_.get() &&
-        special_storage_policy_->IsStorageUnlimited(
-            DatabaseUtil::GetOriginFromIdentifier(origin_identifier))) {
-      // TODO(michaeln): handle the case where it changes status sometime after
-      // the cached origin_info has been established
-      origin_info.SetQuota(kint64max);
-    } else {
-      int64 origin_quota = quota_table_->GetOriginQuota(origin_identifier);
-      if (origin_quota > 0)
-        origin_info.SetQuota(origin_quota);
-      else
-        origin_info.SetQuota(default_quota_);
-    }
   }
 
   return &origins_info_map_[origin_identifier];
 }
 
 int64 DatabaseTracker::GetDBFileSize(const string16& origin_identifier,
                                      const string16& database_name) {
   FilePath db_file_name = GetFullDBFilePath(origin_identifier, database_name);
   int64 db_file_size = 0;
   if (!file_util::GetFileSize(db_file_name, &db_file_size))
     db_file_size = 0;
   return db_file_size;
 }
 
-int64 DatabaseTracker::GetOriginSpaceAvailable(
-    const string16& origin_identifier) {
-  // TODO(michaeln): Come up with a value according to the the QuotaMgr.
-  CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
-  if (!origin_info)
-    return 0;
-  int64 space_available = origin_info->Quota() - origin_info->TotalSize();
-  return (space_available < 0 ? 0 : space_available);
+int64 DatabaseTracker::SeedOpenDatabaseSize(
+    const string16& origin_id, const string16& name) {
+  DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
+  int64 size = GetDBFileSize(origin_id, name);
+  database_connections_.SetOpenDatabaseSize(origin_id, name,  size);
+  if (origins_info_map_.find(origin_id) != origins_info_map_.end())
+    origins_info_map_[origin_id].SetDatabaseSize(name, size);
+  return size;
 }
 
-int64 DatabaseTracker::UpdateCachedDatabaseFileSize(
-    const string16& origin_identifier,
-    const string16& database_name) {
-  int64 new_size = GetDBFileSize(origin_identifier, database_name);
-  CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
-  if (origin_info)
-    origin_info->SetDatabaseSize(database_name, new_size);
+int64 DatabaseTracker::UpdateOpenDatabaseSizeAndNotify(
+    const string16& origin_id, const string16& name) {
+  DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
+  int64 new_size = GetDBFileSize(origin_id, name);
+  int64 old_size = database_connections_.GetOpenDatabaseSize(origin_id, name);
+  if (old_size != new_size) {
+    database_connections_.SetOpenDatabaseSize(origin_id, name, new_size);
+    if (origins_info_map_.find(origin_id) != origins_info_map_.end())
+      origins_info_map_[origin_id].SetDatabaseSize(name, new_size);
+    if (quota_manager_proxy_)
+      quota_manager_proxy_->NotifyStorageModified(
+          quota::QuotaClient::kDatabase,
+          DatabaseUtil::GetOriginFromIdentifier(origin_id),
+          quota::kStorageTypeTemporary,
+          new_size - old_size);
+    const int64 kNotUsed = 0;
+    FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
+        origin_id, name, new_size, kNotUsed));
+  }
   return new_size;
 }
 
 void DatabaseTracker::ScheduleDatabaseForDeletion(
     const string16& origin_identifier,
     const string16& 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(
@@ skipping 204 matching lines @@
       std::string basename = file_path.BaseName().MaybeAsASCII();
       if (!basename.empty() &&
           !StartsWithASCII(basename, kExtensionOriginIdentifierPrefix, true)) {
         file_util::Delete(file_path, true);
       }
     }
   }
 }
 
 }  // namespace webkit_database