Move webkit/{browser,common}/dom_storage into content/

content/browser/dom_storage/dom_storage_database_unittest.cc

Index: content/browser/dom_storage/dom_storage_database_unittest.cc
diff --git a/webkit/browser/dom_storage/dom_storage_database_unittest.cc b/content/browser/dom_storage/dom_storage_database_unittest.cc
similarity index 79%
rename from webkit/browser/dom_storage/dom_storage_database_unittest.cc
rename to content/browser/dom_storage/dom_storage_database_unittest.cc
index d1be10b4f182fceae3963681932b1ee1a6b5483a..96a2e5d23cb2f544161ae32e33f14f7dd21a626b 100644
--- a/webkit/browser/dom_storage/dom_storage_database_unittest.cc
+++ b/content/browser/dom_storage/dom_storage_database_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/browser/dom_storage/dom_storage_database.h"
+#include "content/browser/dom_storage/dom_storage_database.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ -14,7 +14,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
-namespace dom_storage {
+namespace content {
 
 void CreateV1Table(sql::Connection* db) {
   ASSERT_TRUE(db->is_open());
@@ -66,13 +66,13 @@ void InsertDataV1(sql::Connection* db,
   statement.Run();
 }
 
-void CheckValuesMatch(DomStorageDatabase* db,
-                      const ValuesMap& expected) {
-  ValuesMap values_read;
+void CheckValuesMatch(DOMStorageDatabase* db,
+                      const DOMStorageValuesMap& expected) {
+  DOMStorageValuesMap values_read;
   db->ReadAllValues(&values_read);
   EXPECT_EQ(expected.size(), values_read.size());
 
-  ValuesMap::const_iterator it = values_read.begin();
+  DOMStorageValuesMap::const_iterator it = values_read.begin();
   for (; it != values_read.end(); ++it) {
     base::string16 key = it->first;
     base::NullableString16 value = it->second;
@@ -82,7 +82,7 @@ void CheckValuesMatch(DomStorageDatabase* db,
   }
 }
 
-void CreateMapWithValues(ValuesMap* values) {
+void CreateMapWithValues(DOMStorageValuesMap* values) {
   base::string16 kCannedKeys[] = {
       ASCIIToUTF16("test"),
       ASCIIToUTF16("company"),
@@ -99,28 +99,28 @@ void CreateMapWithValues(ValuesMap* values) {
     (*values)[kCannedKeys[i]] = kCannedValues[i];
 }
 
-TEST(DomStorageDatabaseTest, SimpleOpenAndClose) {
-  DomStorageDatabase db;
+TEST(DOMStorageDatabaseTest, SimpleOpenAndClose) {
+  DOMStorageDatabase db;
   EXPECT_FALSE(db.IsOpen());
   ASSERT_TRUE(db.LazyOpen(true));
   EXPECT_TRUE(db.IsOpen());
-  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::V2, db.DetectSchemaVersion());
   db.Close();
   EXPECT_FALSE(db.IsOpen());
 }
 
-TEST(DomStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
+TEST(DOMStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_name =
-      temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
-  ValuesMap storage;
+      temp_dir.path().AppendASCII("TestDOMStorageDatabase.db");
+  DOMStorageValuesMap storage;
   CreateMapWithValues(&storage);
 
   // First test the case that explicitly clearing the database will
   // trigger its deletion from disk.
   {
-    DomStorageDatabase db(file_name);
+    DOMStorageDatabase db(file_name);
     EXPECT_EQ(file_name, db.file_path());
     ASSERT_TRUE(db.CommitChanges(false, storage));
   }
@@ -129,8 +129,8 @@ TEST(DomStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
   {
     // Check that reading an existing db with data in it
     // keeps the DB on disk on close.
-    DomStorageDatabase db(file_name);
-    ValuesMap values;
+    DOMStorageDatabase db(file_name);
+    DOMStorageValuesMap values;
     db.ReadAllValues(&values);
     EXPECT_EQ(storage.size(), values.size());
   }
@@ -139,7 +139,7 @@ TEST(DomStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
   storage.clear();
 
   {
-    DomStorageDatabase db(file_name);
+    DOMStorageDatabase db(file_name);
     ASSERT_TRUE(db.CommitChanges(true, storage));
   }
   EXPECT_FALSE(base::PathExists(file_name));
@@ -148,16 +148,16 @@ TEST(DomStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
   // is an empty database also triggers deletion.
   CreateMapWithValues(&storage);
   {
-    DomStorageDatabase db(file_name);
+    DOMStorageDatabase db(file_name);
     ASSERT_TRUE(db.CommitChanges(false, storage));
   }
 
   EXPECT_TRUE(base::PathExists(file_name));
 
   {
-    DomStorageDatabase db(file_name);
+    DOMStorageDatabase db(file_name);
     ASSERT_TRUE(db.CommitChanges(false, storage));
-    ValuesMap::iterator it = storage.begin();
+    DOMStorageValuesMap::iterator it = storage.begin();
     for (; it != storage.end(); ++it)
       it->second = base::NullableString16();
     ASSERT_TRUE(db.CommitChanges(false, storage));
@@ -165,17 +165,17 @@ TEST(DomStorageDatabaseTest, CloseEmptyDatabaseDeletesFile) {
   EXPECT_FALSE(base::PathExists(file_name));
 }
 
-TEST(DomStorageDatabaseTest, TestLazyOpenIsLazy) {
+TEST(DOMStorageDatabaseTest, TestLazyOpenIsLazy) {
   // This test needs to operate with a file on disk to ensure that we will
   // open a file that already exists when only invoking ReadAllValues.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_name =
-      temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+      temp_dir.path().AppendASCII("TestDOMStorageDatabase.db");
 
-  DomStorageDatabase db(file_name);
+  DOMStorageDatabase db(file_name);
   EXPECT_FALSE(db.IsOpen());
-  ValuesMap values;
+  DOMStorageValuesMap values;
   db.ReadAllValues(&values);
   // Reading an empty db should not open the database.
   EXPECT_FALSE(db.IsOpen());
@@ -194,25 +194,25 @@ TEST(DomStorageDatabaseTest, TestLazyOpenIsLazy) {
   EXPECT_TRUE(db.IsOpen());
 }
 
-TEST(DomStorageDatabaseTest, TestDetectSchemaVersion) {
-  DomStorageDatabase db;
+TEST(DOMStorageDatabaseTest, TestDetectSchemaVersion) {
+  DOMStorageDatabase db;
   db.db_.reset(new sql::Connection());
   ASSERT_TRUE(db.db_->OpenInMemory());
 
   CreateInvalidValueColumnTable(db.db_.get());
-  EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::INVALID, db.DetectSchemaVersion());
 
   CreateInvalidKeyColumnTable(db.db_.get());
-  EXPECT_EQ(DomStorageDatabase::INVALID, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::INVALID, db.DetectSchemaVersion());
 
   CreateV1Table(db.db_.get());
-  EXPECT_EQ(DomStorageDatabase::V1, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::V1, db.DetectSchemaVersion());
 
   CreateV2Table(db.db_.get());
-  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::V2, db.DetectSchemaVersion());
 }
 
-TEST(DomStorageDatabaseTest, TestLazyOpenUpgradesDatabase) {
+TEST(DOMStorageDatabaseTest, TestLazyOpenUpgradesDatabase) {
   // This test needs to operate with a file on disk so that we
   // can create a table at version 1 and then close it again
   // so that LazyOpen sees there is work to do (LazyOpen will return
@@ -220,32 +220,32 @@ TEST(DomStorageDatabaseTest, TestLazyOpenUpgradesDatabase) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_name =
-      temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+      temp_dir.path().AppendASCII("TestDOMStorageDatabase.db");
 
-  DomStorageDatabase db(file_name);
+  DOMStorageDatabase db(file_name);
   db.db_.reset(new sql::Connection());
   ASSERT_TRUE(db.db_->Open(file_name));
   CreateV1Table(db.db_.get());
   db.Close();
 
   EXPECT_TRUE(db.LazyOpen(true));
-  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::V2, db.DetectSchemaVersion());
 }
 
-TEST(DomStorageDatabaseTest, SimpleWriteAndReadBack) {
-  DomStorageDatabase db;
+TEST(DOMStorageDatabaseTest, SimpleWriteAndReadBack) {
+  DOMStorageDatabase db;
 
-  ValuesMap storage;
+  DOMStorageValuesMap storage;
   CreateMapWithValues(&storage);
 
   EXPECT_TRUE(db.CommitChanges(false, storage));
   CheckValuesMatch(&db, storage);
 }
 
-TEST(DomStorageDatabaseTest, WriteWithClear) {
-  DomStorageDatabase db;
+TEST(DOMStorageDatabaseTest, WriteWithClear) {
+  DOMStorageDatabase db;
 
-  ValuesMap storage;
+  DOMStorageValuesMap storage;
   CreateMapWithValues(&storage);
 
   ASSERT_TRUE(db.CommitChanges(false, storage));
@@ -264,13 +264,13 @@ TEST(DomStorageDatabaseTest, WriteWithClear) {
   CheckValuesMatch(&db, storage);
 }
 
-TEST(DomStorageDatabaseTest, UpgradeFromV1ToV2WithData) {
+TEST(DOMStorageDatabaseTest, UpgradeFromV1ToV2WithData) {
   const base::string16 kCannedKey = ASCIIToUTF16("foo");
   const base::NullableString16 kCannedValue(ASCIIToUTF16("bar"), false);
-  ValuesMap expected;
+  DOMStorageValuesMap expected;
   expected[kCannedKey] = kCannedValue;
 
-  DomStorageDatabase db;
+  DOMStorageDatabase db;
   db.db_.reset(new sql::Connection());
   ASSERT_TRUE(db.db_->OpenInMemory());
   CreateV1Table(db.db_.get());
@@ -278,25 +278,25 @@ TEST(DomStorageDatabaseTest, UpgradeFromV1ToV2WithData) {
 
   ASSERT_TRUE(db.UpgradeVersion1To2());
 
-  EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
+  EXPECT_EQ(DOMStorageDatabase::V2, db.DetectSchemaVersion());
 
   CheckValuesMatch(&db, expected);
 }
 
-TEST(DomStorageDatabaseTest, TestSimpleRemoveOneValue) {
-  DomStorageDatabase db;
+TEST(DOMStorageDatabaseTest, TestSimpleRemoveOneValue) {
+  DOMStorageDatabase db;
 
   ASSERT_TRUE(db.LazyOpen(true));
   const base::string16 kCannedKey = ASCIIToUTF16("test");
   const base::NullableString16 kCannedValue(ASCIIToUTF16("data"), false);
-  ValuesMap expected;
+  DOMStorageValuesMap expected;
   expected[kCannedKey] = kCannedValue;
 
   // First write some data into the database.
   ASSERT_TRUE(db.CommitChanges(false, expected));
   CheckValuesMatch(&db, expected);
 
-  ValuesMap values;
+  DOMStorageValuesMap values;
   // A null string in the map should mean that that key gets
   // removed.
   values[kCannedKey] = base::NullableString16();
@@ -306,7 +306,7 @@ TEST(DomStorageDatabaseTest, TestSimpleRemoveOneValue) {
   CheckValuesMatch(&db, expected);
 }
 
-TEST(DomStorageDatabaseTest, TestCanOpenAndReadWebCoreDatabase) {
+TEST(DOMStorageDatabaseTest, TestCanOpenAndReadWebCoreDatabase) {
   base::FilePath webcore_database;
   PathService::Get(base::DIR_SOURCE_ROOT, &webcore_database);
   webcore_database = webcore_database.AppendASCII("webkit");
@@ -317,13 +317,13 @@ TEST(DomStorageDatabaseTest, TestCanOpenAndReadWebCoreDatabase) {
 
   ASSERT_TRUE(base::PathExists(webcore_database));
 
-  DomStorageDatabase db(webcore_database);
-  ValuesMap values;
+  DOMStorageDatabase db(webcore_database);
+  DOMStorageValuesMap values;
   db.ReadAllValues(&values);
   EXPECT_TRUE(db.IsOpen());
   EXPECT_EQ(2u, values.size());
 
-  ValuesMap::const_iterator it =
+  DOMStorageValuesMap::const_iterator it =
       values.find(ASCIIToUTF16("value"));
   EXPECT_TRUE(it != values.end());
   EXPECT_EQ(ASCIIToUTF16("I am in local storage!"), it->second.string());
@@ -336,12 +336,12 @@ TEST(DomStorageDatabaseTest, TestCanOpenAndReadWebCoreDatabase) {
   EXPECT_TRUE(it == values.end());
 }
 
-TEST(DomStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
+TEST(DOMStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
   // Write into the temporary file first.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath file_name =
-      temp_dir.path().AppendASCII("TestDomStorageDatabase.db");
+      temp_dir.path().AppendASCII("TestDOMStorageDatabase.db");
 
   const char kData[] = "I am not a database.";
   file_util::WriteFile(file_name, kData, strlen(kData));
@@ -353,8 +353,8 @@ TEST(DomStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
     // Try and open the file. As it's not a database, we should end up deleting
     // it and creating a new, valid file, so everything should actually
     // succeed.
-    DomStorageDatabase db(file_name);
-    ValuesMap values;
+    DOMStorageDatabase db(file_name);
+    DOMStorageValuesMap values;
     CreateMapWithValues(&values);
     EXPECT_TRUE(db.CommitChanges(true, values));
     EXPECT_TRUE(db.CommitChanges(false, values));
@@ -371,8 +371,8 @@ TEST(DomStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
 
     // Try to open a directory, we should fail gracefully and not attempt
     // to delete it.
-    DomStorageDatabase db(temp_dir.path());
-    ValuesMap values;
+    DOMStorageDatabase db(temp_dir.path());
+    DOMStorageValuesMap values;
     CreateMapWithValues(&values);
     EXPECT_FALSE(db.CommitChanges(true, values));
     EXPECT_FALSE(db.CommitChanges(false, values));
@@ -390,4 +390,4 @@ TEST(DomStorageDatabaseTest, TestCanOpenFileThatIsNotADatabase) {
   }
 }
 
-}  // namespace dom_storage
+}  // namespace content