More Quota + WebSQLDatabase integration.

* Notify the QuotaManager of accesses and modifications to the amount of storage utlized.

* Still, the hard-coded 5MB limit is in place.

BUG=61676
TEST=database_tracker_unittest.cc, database_connections_unittest.cc
Review URL: http://codereview.chromium.org/7001014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@85400 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 366 insertions, 34 deletions

diff --git a/webkit/database/database_connections.cc b/webkit/database/database_connections.cc
index 612f73b4..35483de 100644
--- a/webkit/database/database_connections.cc
+++ b/webkit/database/database_connections.cc
@@ -40,7 +40,7 @@ bool DatabaseConnections::IsOriginUsed(
 
 void DatabaseConnections::AddConnection(const string16& origin_identifier,
                                         const string16& database_name) {
-  connections_[origin_identifier][database_name]++;
+  connections_[origin_identifier][database_name].first++;
 }
 
 void DatabaseConnections::RemoveConnection(const string16& origin_identifier,
@@ -62,13 +62,43 @@ void DatabaseConnections::RemoveConnections(
     const DBConnections& db_connections = origin_it->second;
     for (DBConnections::const_iterator db_it = db_connections.begin();
          db_it != db_connections.end(); db_it++) {
-      RemoveConnectionsHelper(origin_it->first, db_it->first, db_it->second);
+      RemoveConnectionsHelper(origin_it->first, db_it->first,
+                              db_it->second.first);
       if (!IsDatabaseOpened(origin_it->first, db_it->first))
         closed_dbs->push_back(std::make_pair(origin_it->first, db_it->first));
     }
   }
 }
 
+int64 DatabaseConnections::GetOpenDatabaseSize(
+    const string16& origin_identifier,
+    const string16& database_name) const {
+  DCHECK(IsDatabaseOpened(origin_identifier, database_name));
+  return connections_[origin_identifier][database_name].second;
+}
+
+void DatabaseConnections::SetOpenDatabaseSize(
+    const string16& origin_identifier,
+    const string16& database_name,
+    int64 size) {
+  DCHECK(IsDatabaseOpened(origin_identifier, database_name));
+  connections_[origin_identifier][database_name].second = size;
+}
+
+void DatabaseConnections::ListConnections(
+    std::vector<std::pair<string16, string16> > *list) const {
+  for (OriginConnections::const_iterator origin_it =
+           connections_.begin();
+       origin_it != connections_.end();
+       origin_it++) {
+    const DBConnections& db_connections = origin_it->second;
+    for (DBConnections::const_iterator db_it = db_connections.begin();
+         db_it != db_connections.end(); db_it++) {
+      list->push_back(std::make_pair(origin_it->first, db_it->first));
+    }
+  }
+}
+
 void DatabaseConnections::RemoveConnectionsHelper(
     const string16& origin_identifier,
     const string16& database_name,
@@ -77,7 +107,7 @@ void DatabaseConnections::RemoveConnectionsHelper(
       connections_.find(origin_identifier);
   DCHECK(origin_iterator != connections_.end());
   DBConnections& db_connections = origin_iterator->second;
-  int& count = db_connections[database_name];
+  int& count = db_connections[database_name].first;
   DCHECK(count >= num_connections);
   count -= num_connections;
   if (!count) {
diff --git a/webkit/database/database_connections.h b/webkit/database/database_connections.h
index 6a594b2..e358e43 100644
--- a/webkit/database/database_connections.h
+++ b/webkit/database/database_connections.h
@@ -36,10 +36,22 @@ class DatabaseConnections {
       const DatabaseConnections& connections,
       std::vector<std::pair<string16, string16> >* closed_dbs);
 
+  // Database sizes can be kept only if IsDatabaseOpened returns true.
+  int64 GetOpenDatabaseSize(const string16& origin_identifier,
+                            const string16& database_name) const;
+  void SetOpenDatabaseSize(const string16& origin_identifier,
+                           const string16& database_name,
+                           int64 size);
+
+  // Returns a list of the connections, <origin_id, name>.
+  void ListConnections(
+      std::vector<std::pair<string16, string16> > *list) const;
+
  private:
-  typedef std::map<string16, int> DBConnections;
+  // Mapping from name to <openCount, size>
+  typedef std::map<string16, std::pair<int, int64> > DBConnections;
   typedef std::map<string16, DBConnections> OriginConnections;
-  OriginConnections connections_;
+  mutable OriginConnections connections_;  // mutable for GetOpenDatabaseSize
 
   void RemoveConnectionsHelper(const string16& origin_identifier,
                                const string16& database_name,
diff --git a/webkit/database/database_connections_unittest.cc b/webkit/database/database_connections_unittest.cc
index 1b3ef34..b6081cc 100644
--- a/webkit/database/database_connections_unittest.cc
+++ b/webkit/database/database_connections_unittest.cc
@@ -33,9 +33,64 @@ void ScheduleRemoveConnectionTask(
 
 }  // anonymous namespace
 
+TEST(DatabaseConnectionsTest, DatabaseConnectionsTest) {
+  const string16 kOriginId(ASCIIToUTF16("origin_id"));
+  const string16 kName(ASCIIToUTF16("database_name"));
+  const string16 kName2(ASCIIToUTF16("database_name2"));
+  const int64 kSize = 1000;
+
+  DatabaseConnections connections;
+
+  EXPECT_TRUE(connections.IsEmpty());
+  EXPECT_FALSE(connections.IsDatabaseOpened(kOriginId, kName));
+  EXPECT_FALSE(connections.IsOriginUsed(kOriginId));
+
+  connections.AddConnection(kOriginId, kName);
+  EXPECT_FALSE(connections.IsEmpty());
+  EXPECT_TRUE(connections.IsDatabaseOpened(kOriginId, kName));
+  EXPECT_TRUE(connections.IsOriginUsed(kOriginId));
+  EXPECT_EQ(0, connections.GetOpenDatabaseSize(kOriginId, kName));
+  connections.SetOpenDatabaseSize(kOriginId, kName, kSize);
+  EXPECT_EQ(kSize, connections.GetOpenDatabaseSize(kOriginId, kName));
+
+  connections.RemoveConnection(kOriginId, kName);
+  EXPECT_TRUE(connections.IsEmpty());
+  EXPECT_FALSE(connections.IsDatabaseOpened(kOriginId, kName));
+  EXPECT_FALSE(connections.IsOriginUsed(kOriginId));
+
+  connections.AddConnection(kOriginId, kName);
+  connections.SetOpenDatabaseSize(kOriginId, kName, kSize);
+  EXPECT_EQ(kSize, connections.GetOpenDatabaseSize(kOriginId, kName));
+  connections.AddConnection(kOriginId, kName);
+  EXPECT_EQ(kSize, connections.GetOpenDatabaseSize(kOriginId, kName));
+  EXPECT_FALSE(connections.IsEmpty());
+  EXPECT_TRUE(connections.IsDatabaseOpened(kOriginId, kName));
+  EXPECT_TRUE(connections.IsOriginUsed(kOriginId));
+  connections.AddConnection(kOriginId, kName2);
+  EXPECT_TRUE(connections.IsDatabaseOpened(kOriginId, kName2));
+
+  DatabaseConnections another;
+  another.AddConnection(kOriginId, kName);
+  another.AddConnection(kOriginId, kName2);
+
+  std::vector<std::pair<string16, string16> > closed_dbs;
+  connections.RemoveConnections(another, &closed_dbs);
+  EXPECT_EQ(1u, closed_dbs.size());
+  EXPECT_EQ(kOriginId, closed_dbs[0].first);
+  EXPECT_EQ(kName2, closed_dbs[0].second);
+  EXPECT_FALSE(connections.IsDatabaseOpened(kOriginId, kName2));
+  EXPECT_TRUE(connections.IsDatabaseOpened(kOriginId, kName));
+  EXPECT_EQ(kSize, connections.GetOpenDatabaseSize(kOriginId, kName));
+
+  connections.RemoveAllConnections();
+  EXPECT_TRUE(connections.IsEmpty());
+
+  another.RemoveAllConnections();
+}
+
 TEST(DatabaseConnectionsTest, DatabaseConnectionsWrapperTest) {
-  string16 kOriginId(ASCIIToUTF16("origin_id"));
-  string16 kName(ASCIIToUTF16("database_name"));
+  const string16 kOriginId(ASCIIToUTF16("origin_id"));
+  const string16 kName(ASCIIToUTF16("database_name"));
 
   scoped_refptr<DatabaseConnectionsWrapper> obj(
       new DatabaseConnectionsWrapper);
diff --git a/webkit/database/database_tracker.cc b/webkit/database/database_tracker.cc
index 1dc29db..6c764f7 100644
--- a/webkit/database/database_tracker.cc
+++ b/webkit/database/database_tracker.cc
@@ -142,6 +142,16 @@ void DatabaseTracker::DatabaseOpened(const string16& origin_identifier,
   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,
@@ -149,21 +159,24 @@ void DatabaseTracker::DatabaseModified(const string16& origin_identifier,
   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);
+    }
   }
 }
 
@@ -183,6 +196,33 @@ void DatabaseTracker::CloseDatabases(const DatabaseConnections& connections) {
     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 =
@@ -346,12 +386,26 @@ bool DatabaseTracker::DeleteClosedDatabase(const string16& origin_identifier,
   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);
@@ -361,15 +415,6 @@ bool DatabaseTracker::DeleteClosedDatabase(const string16& origin_identifier,
           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;
 }
@@ -382,6 +427,13 @@ bool DatabaseTracker::DeleteOrigin(const string16& origin_identifier) {
   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.
@@ -393,13 +445,12 @@ bool DatabaseTracker::DeleteOrigin(const string16& origin_identifier) {
 
   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;
diff --git a/webkit/database/database_tracker_unittest.cc b/webkit/database/database_tracker_unittest.cc
index 66469bf..bb391b0 100644
--- a/webkit/database/database_tracker_unittest.cc
+++ b/webkit/database/database_tracker_unittest.cc
@@ -13,6 +13,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
+#include "webkit/quota/quota_manager.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace {
@@ -89,6 +90,91 @@ void CheckNotificationReceived(TestObserver* observer,
             observer->GetNotificationSpaceAvailable());
 }
 
+class TestQuotaManagerProxy : public quota::QuotaManagerProxy {
+ public:
+  TestQuotaManagerProxy()
+      : QuotaManagerProxy(NULL, NULL),
+        registered_client_(NULL) {
+  }
+
+  virtual ~TestQuotaManagerProxy() {
+    EXPECT_FALSE(registered_client_);
+  }
+
+  virtual void RegisterClient(quota::QuotaClient* client) {
+    EXPECT_FALSE(registered_client_);
+    registered_client_ = client;
+  }
+
+  virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
+                                     const GURL& origin,
+                                     quota::StorageType type) {
+    EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
+    EXPECT_EQ(quota::kStorageTypeTemporary, type);
+    accesses_[origin] += 1;
+  }
+
+  virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
+                                     const GURL& origin,
+                                     quota::StorageType type,
+                                     int64 delta) {
+    EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
+    EXPECT_EQ(quota::kStorageTypeTemporary, type);
+    modifications_[origin].first += 1;
+    modifications_[origin].second += delta;
+  }
+
+  // Not needed for our tests.
+  virtual void NotifyOriginInUse(const GURL& origin) {}
+  virtual void NotifyOriginNoLongerInUse(const GURL& origin) {}
+
+  void SimulateQuotaManagerDestroyed() {
+    if (registered_client_) {
+      registered_client_->OnQuotaManagerDestroyed();
+      registered_client_ = NULL;
+    }
+  }
+
+  bool WasAccessNotified(const GURL& origin) {
+    return accesses_[origin] != 0;
+  }
+
+  bool WasModificationNotified(const GURL& origin, int64 amount) {
+    return modifications_[origin].first != 0 &&
+           modifications_[origin].second == amount;
+  }
+
+  void reset() {
+    accesses_.clear();
+    modifications_.clear();
+  }
+
+  quota::QuotaClient* registered_client_;
+
+  // Map from origin to count of access notifications.
+  std::map<GURL, int> accesses_;
+
+  // Map from origin to <count, sum of deltas>
+  std::map<GURL, std::pair<int, int64> > modifications_;
+};
+
+
+bool EnsureFileOfSize(const FilePath& file_path, int64 length) {
+  base::PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED);
+  base::PlatformFile file =
+      base::CreatePlatformFile(
+          file_path,
+          base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE,
+          NULL,
+          &error_code);
+  if (error_code != base::PLATFORM_FILE_OK)
+    return false;
+  if (!base::TruncatePlatformFile(file, length))
+    error_code = base::PLATFORM_FILE_ERROR_FAILED;
+  base::ClosePlatformFile(file);
+  return error_code == base::PLATFORM_FILE_OK;
+}
+
 }  // namespace
 
 namespace webkit_database {
@@ -406,6 +492,95 @@ class DatabaseTracker_TestHelper_Test {
     EXPECT_EQ(0, origin1_info->TotalSize());
     EXPECT_EQ(origin1_quota, tracker->GetOriginSpaceAvailable(kOrigin1));
   }
+
+  static void DatabaseTrackerQuotaIntegration() {
+    const GURL kOrigin(kOrigin1Url);
+    const string16 kOriginId = DatabaseUtil::GetOriginIdentifier(kOrigin);
+    const string16 kName = ASCIIToUTF16("name");
+    const string16 kDescription = ASCIIToUTF16("description");
+
+    ScopedTempDir temp_dir;
+    ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+
+    // Initialize the tracker with a QuotaManagerProxy
+    scoped_refptr<TestQuotaManagerProxy> test_quota_proxy(
+        new TestQuotaManagerProxy);
+    scoped_refptr<DatabaseTracker> tracker(
+        new DatabaseTracker(temp_dir.path(), false /* incognito */,
+                            NULL, test_quota_proxy, NULL));
+    EXPECT_TRUE(test_quota_proxy->registered_client_);
+
+    // Create a database and modify it a couple of times, close it,
+    // then delete it. Observe the tracker notifies accordingly.
+
+    int64 database_size = 0;
+    int64 space_available = 0;
+    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                            &database_size, &space_available);
+    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+    test_quota_proxy->reset();
+
+    FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
+    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
+    tracker->DatabaseModified(kOriginId, kName);
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
+    test_quota_proxy->reset();
+
+    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+    tracker->DatabaseModified(kOriginId, kName);
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
+    test_quota_proxy->reset();
+
+    tracker->DatabaseClosed(kOriginId, kName);
+    EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kName, NULL));
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
+
+    // Create a database and modify it, try to delete it while open,
+    // then close it (at which time deletion will actually occur).
+    // Observe the tracker notifies accordingly.
+
+    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                            &database_size, &space_available);
+    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+    test_quota_proxy->reset();
+
+    db_file = tracker->GetFullDBFilePath(kOriginId, kName);
+    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+    tracker->DatabaseModified(kOriginId, kName);
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+    test_quota_proxy->reset();
+
+    EXPECT_EQ(net::ERR_IO_PENDING,
+              tracker->DeleteDatabase(kOriginId, kName, NULL));
+    EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
+
+    tracker->DatabaseClosed(kOriginId, kName);
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
+
+    // Create a database and up the file size without telling
+    // the tracker about the modification, than simulate a
+    // a renderer crash.
+    // Observe the tracker notifies accordingly.
+
+    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                            &database_size, &space_available);
+    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+    test_quota_proxy->reset();
+    db_file = tracker->GetFullDBFilePath(kOriginId, kName);
+    EXPECT_TRUE(file_util::CreateDirectory(db_file.DirName()));
+    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+    DatabaseConnections crashed_renderer_connections;
+    crashed_renderer_connections.AddConnection(kOriginId, kName);
+    EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+    tracker->CloseDatabases(crashed_renderer_connections);
+    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+
+    // Cleanup.
+    crashed_renderer_connections.RemoveAllConnections();
+    test_quota_proxy->SimulateQuotaManagerDestroyed();
+  }
 };
 
 TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
@@ -424,4 +599,9 @@ TEST(DatabaseTrackerTest, DatabaseTrackerIncognitoMode) {
   DatabaseTracker_TestHelper_Test::TestDatabaseTracker(true);
 }
 
+TEST(DatabaseTrackerTest, DatabaseTrackerQuotaIntegration) {
+  // There is no difference in behavior between incognito and not.
+  DatabaseTracker_TestHelper_Test::DatabaseTrackerQuotaIntegration();
+}
+
 }  // namespace webkit_database
diff --git a/webkit/database/database_util.cc b/webkit/database/database_util.cc
index 85a1143..d86a8c2 100644
--- a/webkit/database/database_util.cc
+++ b/webkit/database/database_util.cc
@@ -12,6 +12,8 @@
 
 namespace webkit_database {
 
+const char DatabaseUtil::kJournalFileSuffix[] = "-journal";
+
 bool DatabaseUtil::CrackVfsFileName(const string16& vfs_file_name,
                                     string16* origin_identifier,
                                     string16* database_name,
diff --git a/webkit/database/database_util.h b/webkit/database/database_util.h
index 20410dc..cbc13da 100644
--- a/webkit/database/database_util.h
+++ b/webkit/database/database_util.h
@@ -16,6 +16,8 @@ class DatabaseTracker;
 
 class DatabaseUtil {
  public:
+  static const char kJournalFileSuffix[];
+
   // Extract various information from a database vfs_file_name.  All return
   // parameters are optional.
   static bool CrackVfsFileName(const string16& vfs_file_name,