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"
 #include "app/sql/diagnostic_error_delegate.h"
 #include "app/sql/meta_table.h"
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "webkit/database/database_quota_client.h"
 #include "webkit/database/database_util.h"
 #include "webkit/database/databases_table.h"
-#include "webkit/database/quota_table.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace {
 
 class HistogramUniquifier {
  public:
   static const char* name() { return "Sqlite.DatabaseTracker.Error"; }
 };
 
 sql::ErrorDelegate* GetErrorHandlerForTrackerDb() {
   return new sql::DiagnosticErrorDelegate<HistogramUniquifier>();
 }
 
 }  // anon namespace
 
 namespace webkit_database {
 
 const FilePath::CharType kDatabaseDirectoryName[] =
     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) {
+                                     int64* database_size) {
   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(

[kinuko, 2011/05/26 03:35:13]

Why are we notifying access on close?  Could we have a short comment about that?

[michaeln, 2011/05/26 03:57:32]

Will do...

We only call NotifiyStorageAccessed when a db is first opened. We call
NotifyStorageModified as writes occur, but we don't have any knowledge of reads
at this level. So on close, i'm bumping the last access date to make up for
that.

+        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);
+    FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
+        origin_id, name, new_size));
+  }
   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