Test cleanup: Using MockSpecialStoragePolicy instead of local subclasses of SpecialStoragePolicy.

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/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/scoped_temp_dir.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/mock_special_storage_policy.h"
 #include "webkit/quota/quota_manager.h"
-#include "webkit/quota/special_storage_policy.h"
 
 namespace {
 
 const char kOrigin1Url[] = "http://origin1";
 const char kOrigin2Url[] = "http://protected_origin2";
 
-class TestSpecialStoragePolicy : public quota::SpecialStoragePolicy {
- public:
-  virtual bool IsStorageProtected(const GURL& origin) {
-    return origin == GURL(kOrigin2Url);
-  }
-
-  virtual bool IsStorageUnlimited(const GURL& origin) {
-    return false;
-  }
-
-  virtual bool IsFileHandler(const std::string& extension_id) {
-    return false;
-  }
-};
-
 class TestObserver : public webkit_database::DatabaseTracker::Observer {
  public:
   TestObserver() : new_notification_received_(false) {}
   virtual ~TestObserver() {}
   virtual void OnDatabaseSizeChanged(const string16& origin_identifier,
                                      const string16& database_name,
                                      int64 database_size) {
     new_notification_received_ = true;
     origin_identifier_ = origin_identifier;
     database_name_ = database_name;
@@ skipping 129 matching lines @@
 // 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, false,
-                            new TestSpecialStoragePolicy,
-                            NULL, NULL));
+                            GetSpecialStoragePolicy(), 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");
     const string16 kDB2 = ASCIIToUTF16("db2");
     const string16 kDB3 = ASCIIToUTF16("db3");
@@ skipping 81 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, false,
-                            new TestSpecialStoragePolicy,
-                            NULL, NULL));
+                            GetSpecialStoragePolicy(), NULL, NULL));
 
     // Add two observers.
     TestObserver observer1;
     TestObserver observer2;
     tracker->AddObserver(&observer1);
     tracker->AddObserver(&observer2);
 
     // Open three new databases.
     int64 database_size = 0;
     const string16 kOrigin1 =
@@ skipping 226 matching lines @@
     const string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     FilePath origin1_db_dir;
     {
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(
               temp_dir.path(), false, true,
-              new TestSpecialStoragePolicy,
-              NULL,
+              GetSpecialStoragePolicy(), NULL,
               base::MessageLoopProxy::CreateForCurrentThread()));
 
       // Open three new databases.
       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                               &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,
@@ skipping 38 matching lines @@
 
       tracker->Shutdown();
 
       base::ClosePlatformFile(file_handle);
       tracker->DatabaseClosed(kOrigin1, kDB3);
     }
 
     // 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));
+                            GetSpecialStoragePolicy(), 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_EQ(FilePath(), tracker->GetFullDBFilePath(kOrigin1, kDB1));
     EXPECT_TRUE(
         file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
     EXPECT_EQ(FilePath(), tracker->GetFullDBFilePath(kOrigin1, kDB3));
 
     // The origin directory should be gone as well.
     EXPECT_FALSE(file_util::PathExists(origin1_db_dir));
   }
+
+  static quota::SpecialStoragePolicy* GetSpecialStoragePolicy() {
+    if (!special_storage_policy_.get()) {
+      special_storage_policy_ = new quota::MockSpecialStoragePolicy;
+      special_storage_policy_->AddProtected(GURL(kOrigin2Url));
+    }
+    return special_storage_policy_.get();
+  }
+
+ private:
+  static scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy_;

[michaeln, 2011/08/12 18:53:52]

i would expect valgrind to complain about leaking this object. i think you can
remove the global and create a new one per test

[marja, 2011/08/16 10:54:25]

Hmm, why would valgrind complain: the dtor of the scoped_refptr is ran before
the program exits.

Anyway, probably it's more elegant to remove the global as you suggested, so I
did that.

 };
 
+scoped_refptr<quota::MockSpecialStoragePolicy>
+    DatabaseTracker_TestHelper_Test::special_storage_policy_;
+
 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