Move code to clear web databases on shutdown to the database tracker

webkit/database/database_tracker_unittest.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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
+#include "base/test/thread_test_helper.h"
+#include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #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"
 
@@ skipping 158 matching lines @@
 // static methods of this class. Then we make our TEST() targets call these
 // static functions. This allows us to run each test in normal mode and
 // incognito mode without writing the same code twice.
 class DatabaseTracker_TestHelper_Test {
  public:
   static void TestDeleteOpenDatabase(bool incognito_mode) {
     // Initialize the tracker database.
     ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     scoped_refptr<DatabaseTracker> tracker(
-        new DatabaseTracker(temp_dir.path(), incognito_mode,
+        new DatabaseTracker(temp_dir.path(), incognito_mode, false,
                             new TestSpecialStoragePolicy,
                             NULL, NULL));
 
     // Create and open three databases.
     int64 database_size = 0;
     const string16 kOrigin1 =
         DatabaseUtil::GetOriginIdentifier(GURL(kOrigin1Url));
     const string16 kOrigin2 =
         DatabaseUtil::GetOriginIdentifier(GURL(kOrigin2Url));
     const string16 kDB1 = ASCIIToUTF16("db1");
@@ skipping 82 matching lines @@
 
     tracker->DatabaseClosed(kOrigin2, kDB3);
     tracker->RemoveObserver(&observer);
   }
 
   static void TestDatabaseTracker(bool incognito_mode) {
     // Initialize the tracker database.
     ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     scoped_refptr<DatabaseTracker> tracker(
-        new DatabaseTracker(temp_dir.path(), incognito_mode,
+        new DatabaseTracker(temp_dir.path(), incognito_mode, false,
                             new TestSpecialStoragePolicy,
                             NULL, NULL));
 
     // Add two observers.
     TestObserver observer1;
     TestObserver observer2;
     tracker->AddObserver(&observer1);
     tracker->AddObserver(&observer2);
 
     // Open three new databases.
@@ skipping 99 matching lines @@
     EXPECT_EQ(1, origins_info[0].TotalSize());
     EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
     EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
 
     EXPECT_EQ(kOrigin2, origins_info[1].GetOrigin());
     EXPECT_EQ(2, origins_info[1].TotalSize());
 
     // Trying to delete an origin with databases in use should fail
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
-    EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1));
+    EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
     EXPECT_TRUE(origin1_info);
     EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
     tracker->DatabaseClosed(kOrigin1, kDB1);
 
     // Delete an origin that doesn't have any database in use
-    EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1));
+    EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
     origins_info.clear();
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
     EXPECT_EQ(size_t(1), origins_info.size());
     EXPECT_EQ(kOrigin2, origins_info[0].GetOrigin());
 
     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
     EXPECT_TRUE(origin1_info);
     EXPECT_EQ(0, origin1_info->TotalSize());
   }
 
   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 */,
+        new DatabaseTracker(temp_dir.path(), false /* incognito */, false,
                             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;
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
@@ skipping 57 matching lines @@
     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();
   }
+
+  static void DatabaseTrackerClearLocalStateOnExit() {

[michaeln, 2011/07/01 03:02:34]

Can you alter the test such that a file is held open when Shutdown() is called,
and then closed after Shutdown() has returned.

[jochen (gone - plz use gerrit), 2011/07/06 09:24:53]

Done.

+    int64 database_size = 0;
+    const string16 kOrigin1 =
+        DatabaseUtil::GetOriginIdentifier(GURL(kOrigin1Url));
+    const string16 kOrigin2 =
+        DatabaseUtil::GetOriginIdentifier(GURL(kOrigin2Url));
+    const string16 kDB1 = ASCIIToUTF16("db1");
+    const string16 kDB2 = ASCIIToUTF16("db2");
+    const string16 kDB3 = ASCIIToUTF16("db3");
+    const string16 kDescription = ASCIIToUTF16("database_description");
+
+    // Initialize the tracker database.
+    ScopedTempDir temp_dir;
+    ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+    base::Thread thread("Database tracker thread");
+    ASSERT_TRUE(thread.Start());
+    {
+      scoped_refptr<DatabaseTracker> tracker(
+          new DatabaseTracker(temp_dir.path(), false, true,
+                              new TestSpecialStoragePolicy,
+                              NULL, thread.message_loop_proxy()));
+
+      // Open three new databases.
+      tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,

[michaeln, 2011/07/01 03:02:34]

Having these methods be called on something other than the 'tracker thread' will
prevent adding DCHECKs in the tracker class that things are being called on that
thread. I don't think you actually need a new thread to conduct this test. Can
we use a 'proxy' for the current thread's message loop instead and call
RunAllPending() as needed.

[jochen (gone - plz use gerrit), 2011/07/06 09:24:53]

Done.

+                              &database_size);
+      EXPECT_EQ(0, database_size);
+      tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+                              &database_size);
+      EXPECT_EQ(0, database_size);
+      tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
+                              &database_size);
+      EXPECT_EQ(0, database_size);
+
+      // Write some data to each file.
+      EXPECT_TRUE(
+          file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
+              FilePath::FromWStringHack(UTF16ToWide(

[michaeln, 2011/07/01 03:02:34]

Let's avoid adding more usages of FromWStringHack.

 db_file = tracker->GetFullDBFilePath(kOriginId, kName);
 EXPECT_TRUE(CreateDirectory(db_file.DirName()));
 EXPECT_TRUE(EnsureFileOfSize(db_file, 1));

[jochen (gone - plz use gerrit), 2011/07/06 09:24:53]

Done.

+                  tracker->GetOriginDirectory(kOrigin1))))));
+      EXPECT_TRUE(
+          file_util::CreateDirectory(tracker->DatabaseDirectory().Append(
+              FilePath::FromWStringHack(UTF16ToWide(
+                  tracker->GetOriginDirectory(kOrigin2))))));
+      EXPECT_EQ(1, file_util::WriteFile(
+          tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
+      EXPECT_EQ(2, file_util::WriteFile(
+          tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
+      EXPECT_EQ(4, file_util::WriteFile(
+          tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4));
+      tracker->DatabaseModified(kOrigin1, kDB1);
+      tracker->DatabaseModified(kOrigin2, kDB2);
+      tracker->DatabaseModified(kOrigin1, kDB3);
+
+      // Close all databases.
+      tracker->DatabaseClosed(kOrigin1, kDB1);
+      tracker->DatabaseClosed(kOrigin2, kDB2);
+      tracker->DatabaseClosed(kOrigin1, kDB3);
+
+      tracker->Shutdown();
+
+      // Synchronize with the database tracker thread to ensure that the
+      // shutdown tasks have completed.
+      scoped_refptr<base::ThreadTestHelper> sync =
+          new base::ThreadTestHelper(thread.message_loop_proxy());
+      ASSERT_TRUE(sync->Run());
+    }
+
+    // At this point, the database tracker should be gone. Create a new one.
+    scoped_refptr<DatabaseTracker> tracker(
+        new DatabaseTracker(temp_dir.path(), false, false,
+                            new TestSpecialStoragePolicy,
+                            NULL, NULL));
+
+    // Get all data for all origins.
+    std::vector<OriginInfo> origins_info;
+    EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
+    EXPECT_EQ(size_t(1), origins_info.size());
+    EXPECT_EQ(kOrigin2, origins_info[0].GetOrigin());
+    EXPECT_FALSE(
+        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
+    EXPECT_TRUE(
+        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
+    EXPECT_FALSE(
+        file_util::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB3)));
+  }
 };
 
 TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
   DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false);
 }
 
 TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) {
   DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(true);
 }
 
 TEST(DatabaseTrackerTest, DatabaseTracker) {
   DatabaseTracker_TestHelper_Test::TestDatabaseTracker(false);
 }
 
 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();
 }
 
+TEST(DatabaseTrackerTest, DatabaseTrackerClearLocalStateOnExit) {
+  // Only works for regular mode.
+  DatabaseTracker_TestHelper_Test::DatabaseTrackerClearLocalStateOnExit();
+}
+
 }  // namespace webkit_database