Move mock_special_storage_policy from webkit/ to content/public/test/

content/browser/database_tracker_unittest.cc

 // Copyright (c) 2012 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_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "content/public/test/mock_special_storage_policy.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "webkit/browser/database/database_tracker.h"
-#include "webkit/browser/quota/mock_special_storage_policy.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/common/database/database_identifier.h"
 
 using base::ASCIIToUTF16;
+using webkit_database::DatabaseConnections;
+using webkit_database::DatabaseTracker;
+using webkit_database::OriginInfo;
 
 namespace {
 
 const char kOrigin1Url[] = "http://origin1";
 const char kOrigin2Url[] = "http://protected_origin2";
 
 class TestObserver : public webkit_database::DatabaseTracker::Observer {
  public:
   TestObserver()
       : new_notification_received_(false),
@@ skipping 141 matching lines @@
 bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
   base::File file(file_path,
                   base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
   if (!file.IsValid())
     return false;
   return file.SetLength(length);
 }
 
 }  // namespace
 
-namespace webkit_database {
+namespace content {
 
 // We declare a helper class, and make it a friend of DatabaseTracker using
-// the FRIEND_TEST() macro, and we implement all tests we want to run as
+// the FORWARD_DECLARE_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.
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
-        new quota::MockSpecialStoragePolicy;
+    scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
+        new MockSpecialStoragePolicy;
     special_storage_policy->AddProtected(GURL(kOrigin2Url));
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(),
                             incognito_mode,
                             special_storage_policy.get(),
                             NULL,
                             NULL));
 
     // Create and open three databases.
     int64 database_size = 0;
@@ skipping 86 matching lines @@
         base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 
     tracker->DatabaseClosed(kOrigin2, kDB3);
     tracker->RemoveObserver(&observer);
   }
 
   static void TestDatabaseTracker(bool incognito_mode) {
     // Initialize the tracker database.
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
-    scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
-        new quota::MockSpecialStoragePolicy;
+    scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
+        new MockSpecialStoragePolicy;
     special_storage_policy->AddProtected(GURL(kOrigin2Url));
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(),
                             incognito_mode,
                             special_storage_policy.get(),
                             NULL,
                             NULL));
 
     // Add two observers.
     TestObserver observer1;
@@ skipping 237 matching lines @@
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     base::MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath origin1_db_dir;
     base::FilePath origin2_db_dir;
     {
-      scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
-          new quota::MockSpecialStoragePolicy;
+      scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
+          new MockSpecialStoragePolicy;
       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(temp_dir.path(),
                               false,
                               special_storage_policy.get(),
                               NULL,
                               base::MessageLoopProxy::current().get()));
 
       // Open two new databases.
       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
@@ skipping 58 matching lines @@
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     base::MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath origin1_db_dir;
     base::FilePath origin2_db_dir;
     {
-      scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
-          new quota::MockSpecialStoragePolicy;
+      scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
+          new MockSpecialStoragePolicy;
       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
       scoped_refptr<DatabaseTracker> tracker(
           new DatabaseTracker(temp_dir.path(),
                               false,
                               special_storage_policy.get(),
                               NULL,
                               base::MessageLoopProxy::current().get()));
       tracker->SetForceKeepSessionState();
 
       // Open two new databases.
@@ skipping 145 matching lines @@
     // Verify that once closed, the file is deleted and the record in the
     // tracker db is removed.
     tracker->DatabaseClosed(kOriginId, kName);
     EXPECT_FALSE(base::PathExists(spoof_db_file));
     EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 
     // --------------------------------------------------------
     // Create another record of a database in the tracker db and create
     // a spoof_db_file on disk in the expected location.
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
-                            &database_size);
-    base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId, kName);
+        &database_size);
+    base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId,
+        kName);
     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
     EXPECT_NE(spoof_db_file, spoof_db_file2);
     EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
 
     // Verify that with no connection open, the db is deleted immediately.
     tracker->DatabaseClosed(kOriginId, kName);
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_FALSE(observer.DidReceiveNewNotification());
@@ skipping 37 matching lines @@
 }
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
-}  // namespace webkit_database
+}  // namespace content