More Quota WebSQLDatabase 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 124 matching lines @@
     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);
+    quota_manager_proxy_->NotifyStorageAccessed(
+        quota::QuotaClient::kDatabase,
+        DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
+        quota::kStorageTypeTemporary);
+  }
 }
 
 void DatabaseTracker::DatabaseModified(const string16& origin_identifier,
                                        const string16& database_name) {
   if (!LazyInit())
     return;
 
-  int64 updated_db_size =
+  int64 new_size =
       UpdateCachedDatabaseFileSize(origin_identifier, database_name);
   int64 space_available = GetOriginSpaceAvailable(origin_identifier);
   FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged(
-      origin_identifier, database_name, updated_db_size, space_available));
+      origin_identifier, database_name, new_size, space_available));
 
   if (quota_manager_proxy_) {
-    // TODO(michaeln): notify the quota manager
-    // CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
-    // if (origin_info)
-    //   quota_manager_proxy_->NotifyStorageConsumed(
-    //       quota::QuotaClient::kDatabase,
-    //       DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
-    //       quota::kStorageTypeTemporary,
-    //       origin_info->TotalSize());
+    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);
+    }
   }
 }
 
 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))
     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);
+      }
+    }
+  }
+
   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,
                                              const string16& database_name) {
@@ skipping 143 matching lines @@
 
 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_ ?
+      GetDBFileSize(origin_identifier, database_name) : 0;
+
   // Try to delete the file on the hard drive.
-  // TODO(jochen): Delete journal files associated with this database.
   FilePath db_file = GetFullDBFilePath(origin_identifier, database_name);
   if (file_util::PathExists(db_file) && !file_util::Delete(db_file, false))
     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_ && db_file_size)
+    quota_manager_proxy_->NotifyStorageModified(
+        quota::QuotaClient::kDatabase,
+        DatabaseUtil::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_->GetAllDatabaseDetailsForOrigin(
           origin_identifier, &details) && details.empty()) {
     // Try to delete the origin in case this was the last database.
     DeleteOrigin(origin_identifier);
-  } else if (quota_manager_proxy_) {
-    // TODO(michaeln): notify the quota manager
-    // CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
-    // if (origin_info)
-    //  quota_manager_proxy_->NotifyStorageConsumed(
-    //      quota::QuotaClient::kDatabase,
-    //      DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
-    //      quota::kStorageTypeTemporary,
-    //      origin_info->TotalSize());
   }
   return true;
 }
 
 bool DatabaseTracker::DeleteOrigin(const string16& origin_identifier) {
   if (!LazyInit())
     return false;
 
   // Check if any database in this origin is opened by any renderer.
   if (database_connections_.IsOriginUsed(origin_identifier))
     return false;
 
+  int64 deleted_size = 0;
+  if (quota_manager_proxy_) {
+    CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier);
+    if (origin_info)
+      deleted_size = origin_info->TotalSize();
+  }
+
   // We need to invalidate the cached record whether file_util::Delete()
   // succeeds or not, because even if it fails, it might still delete some
   // DB files on the hard drive.
   origins_info_map_.erase(origin_identifier);
   FilePath origin_dir = db_dir_.Append(FilePath::FromWStringHack(
       UTF16ToWide(origin_identifier)));
   if (!file_util::Delete(origin_dir, true))
     return false;
 
   databases_table_->DeleteOrigin(origin_identifier);
 
-  if (quota_manager_proxy_) {
-    // TODO(michaeln): notify the quota manager
-    // quota_manager_proxy_->NotifyStorageConsumed(
-    //    quota::QuotaClient::kDatabase,
-    //    DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
-    //    quota::kStorageTypeTemporary,
-    //    0);
+  if (quota_manager_proxy_ && deleted_size) {
+    quota_manager_proxy_->NotifyStorageModified(
+        quota::QuotaClient::kDatabase,
+        DatabaseUtil::GetOriginFromIdentifier(origin_identifier),
+        quota::kStorageTypeTemporary,
+        -deleted_size);
   }
 
   return true;
 }
 
 bool DatabaseTracker::IsDatabaseScheduledForDeletion(
     const string16& origin_identifier,
     const string16& database_name) {
   DatabaseSet::iterator it = dbs_to_be_deleted_.find(origin_identifier);
   if (it == dbs_to_be_deleted_.end())
@@ skipping 369 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