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 127 matching lines @@
 // the FRIEND_TEST() macro, and we implement all tests we want to run as
 // 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<quota::MockSpecialStoragePolicy> special_storage_policy =
+        new quota::MockSpecialStoragePolicy;
+    special_storage_policy->AddProtected(GURL(kOrigin2Url));
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), incognito_mode, false,
-                            new TestSpecialStoragePolicy,
-                            NULL, NULL));
+                            special_storage_policy, 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 79 matching lines @@
         file_util::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 
     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<quota::MockSpecialStoragePolicy> special_storage_policy =
+        new quota::MockSpecialStoragePolicy;
+    special_storage_policy->AddProtected(GURL(kOrigin2Url));
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), incognito_mode, false,
-                            new TestSpecialStoragePolicy,
-                            NULL, NULL));
+                            special_storage_policy, 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 223 matching lines @@
     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());
     FilePath origin1_db_dir;
     {
+      scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
+          new quota::MockSpecialStoragePolicy;
+      special_storage_policy->AddProtected(GURL(kOrigin2Url));
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(
               temp_dir.path(), false, true,
-              new TestSpecialStoragePolicy,
-              NULL,
+              special_storage_policy, NULL,
               base::MessageLoopProxy::current()));
 
       // 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 36 matching lines @@
           base::PLATFORM_FILE_SHARE_DELETE,
           NULL, NULL);
 
       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<quota::MockSpecialStoragePolicy> special_storage_policy =
+        new quota::MockSpecialStoragePolicy;
+    special_storage_policy->AddProtected(GURL(kOrigin2Url));
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), false, false,
-                            new TestSpecialStoragePolicy,
-                            NULL, NULL));
+                            special_storage_policy, 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));
@@ skipping 23 matching lines @@
   // 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