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

content/browser/dom_storage/session_storage_database_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 "webkit/browser/dom_storage/session_storage_database.h"
+#include "content/browser/dom_storage/session_storage_database.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/common/dom_storage/dom_storage_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
 #include "url/gurl.h"
-#include "webkit/common/dom_storage/dom_storage_types.h"
 
-namespace dom_storage {
+namespace content {
 
 class SessionStorageDatabaseTest : public testing::Test {
  public:
   SessionStorageDatabaseTest();
   virtual ~SessionStorageDatabaseTest();
   virtual void SetUp() OVERRIDE;
 
  protected:
   typedef std::map<std::string, std::string> DataMap;
 
   // Helpers.
   static bool IsNamespaceKey(const std::string& key,
                              std::string* namespace_id);
   static bool IsNamespaceOriginKey(const std::string& key,
                                    std::string* namespace_id);
   static bool IsMapRefCountKey(const std::string& key,
                                int64* map_id);
   static bool IsMapValueKey(const std::string& key,
                             int64* map_id);
   void ResetDatabase();
   void ReadData(DataMap* data) const;
   void CheckDatabaseConsistency() const;
   void CheckEmptyDatabase() const;
   void DumpData() const;
   void CheckAreaData(const std::string& namespace_id,
                      const GURL& origin,
-                     const ValuesMap& reference) const;
-  void CompareValuesMaps(const ValuesMap& map1, const ValuesMap& map2) const;
+                     const DOMStorageValuesMap& reference) const;
+  void CompareValuesMaps(const DOMStorageValuesMap& map1,
+                         const DOMStorageValuesMap& map2) const;
   void CheckNamespaceIds(
       const std::set<std::string>& expected_namespace_ids) const;
   void CheckOrigins(
       const std::string& namespace_id,
       const std::set<GURL>& expected_origins) const;
   std::string GetMapForArea(const std::string& namespace_id,
                             const GURL& origin) const;
   int64 GetMapRefCount(const std::string& map_id) const;
 
   base::ScopedTempDir temp_dir_;
@@ skipping 246 matching lines @@
       LOG(WARNING) << it->key().ToString() << ": " << value;
     } else {
       LOG(WARNING) << it->key().ToString() << ": " << it->value().ToString();
     }
   }
   LOG(WARNING) << "----";
 }
 
 void SessionStorageDatabaseTest::CheckAreaData(
     const std::string& namespace_id, const GURL& origin,
-    const ValuesMap& reference) const {
-  ValuesMap values;
+    const DOMStorageValuesMap& reference) const {
+  DOMStorageValuesMap values;
   db_->ReadAreaValues(namespace_id, origin, &values);
   CompareValuesMaps(values, reference);
 }
 
 void SessionStorageDatabaseTest::CompareValuesMaps(
-    const ValuesMap& map1,
-    const ValuesMap& map2) const {
+    const DOMStorageValuesMap& map1,
+    const DOMStorageValuesMap& map2) const {
   ASSERT_EQ(map2.size(), map1.size());
-  for (ValuesMap::const_iterator it = map1.begin(); it != map1.end(); ++it) {
+  for (DOMStorageValuesMap::const_iterator it = map1.begin();
+       it != map1.end(); ++it) {
     base::string16 key = it->first;
     ASSERT_TRUE(map2.find(key) != map2.end());
     base::NullableString16 val1 = it->second;
     base::NullableString16 val2 = map2.find(key)->second;
     EXPECT_EQ(val2.is_null(), val1.is_null());
     EXPECT_EQ(val2.string(), val1.string());
   }
 }
 
 void SessionStorageDatabaseTest::CheckNamespaceIds(
@@ skipping 39 matching lines @@
   return ref_count;
 }
 
 TEST_F(SessionStorageDatabaseTest, EmptyDatabaseSanityCheck) {
   // An empty database should be valid.
   CheckDatabaseConsistency();
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteDataForOneOrigin) {
   // Keep track on what the values should look like.
-  ValuesMap reference;
+  DOMStorageValuesMap reference;
   // Write data.
   {
-    ValuesMap changes;
+    DOMStorageValuesMap changes;
     changes[kKey1] = kValue1;
     changes[kKey2] = kValue2;
     changes[kKey3] = kValue3;
     reference[kKey1] = kValue1;
     reference[kKey2] = kValue2;
     reference[kKey3] = kValue3;
     EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes));
   }
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, reference);
 
   // Overwrite and delete values.
   {
-    ValuesMap changes;
+    DOMStorageValuesMap changes;
     changes[kKey1] = kValue4;
     changes[kKey3] = kValueNull;
     reference[kKey1] = kValue4;
     reference.erase(kKey3);
     EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes));
   }
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, reference);
 
   // Clear data before writing.
   {
-    ValuesMap changes;
+    DOMStorageValuesMap changes;
     changes[kKey2] = kValue2;
     reference.erase(kKey1);
     reference[kKey2] = kValue2;
     EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, true, changes));
   }
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, reference);
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteDataForTwoOrigins) {
   // Write data.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
 
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue4;
   data2[kKey2] = kValue1;
   data2[kKey3] = kValue2;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, data1);
   CheckAreaData(kNamespace1, kOrigin2, data2);
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteDataForTwoNamespaces) {
   // Write data.
-  ValuesMap data11;
+  DOMStorageValuesMap data11;
   data11[kKey1] = kValue1;
   data11[kKey2] = kValue2;
   data11[kKey3] = kValue3;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data11));
-  ValuesMap data12;
+  DOMStorageValuesMap data12;
   data12[kKey2] = kValue4;
   data12[kKey3] = kValue3;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data12));
-  ValuesMap data21;
+  DOMStorageValuesMap data21;
   data21[kKey1] = kValue2;
   data21[kKey2] = kValue4;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin1, false, data21));
-  ValuesMap data22;
+  DOMStorageValuesMap data22;
   data22[kKey2] = kValue1;
   data22[kKey3] = kValue2;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin2, false, data22));
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, data11);
   CheckAreaData(kNamespace1, kOrigin2, data12);
   CheckAreaData(kNamespace2, kOrigin1, data21);
   CheckAreaData(kNamespace2, kOrigin2, data22);
 }
 
 TEST_F(SessionStorageDatabaseTest, ShallowCopy) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   data2[kKey3] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
   // Make a shallow copy.
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   // Now both namespaces should have the same data.
   CheckDatabaseConsistency();
   CheckAreaData(kNamespace1, kOrigin1, data1);
   CheckAreaData(kNamespace1, kOrigin2, data2);
   CheckAreaData(kNamespaceClone, kOrigin1, data1);
   CheckAreaData(kNamespaceClone, kOrigin2, data2);
   // Both the namespaces refer to the same maps.
   EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin1),
             GetMapForArea(kNamespaceClone, kOrigin1));
   EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2),
             GetMapForArea(kNamespaceClone, kOrigin2));
   EXPECT_EQ(2, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1)));
   EXPECT_EQ(2, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin2)));
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteIntoShallowCopy) {
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
 
   // Write data into a shallow copy.
-  ValuesMap changes;
-  ValuesMap reference;
+  DOMStorageValuesMap changes;
+  DOMStorageValuesMap reference;
   changes[kKey1] = kValueNull;
   changes[kKey2] = kValue4;
   changes[kKey3] = kValue4;
   reference[kKey2] = kValue4;
   reference[kKey3] = kValue4;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespaceClone, kOrigin1, false,
                                      changes));
 
   // Values in the original namespace were not changed.
   CheckAreaData(kNamespace1, kOrigin1, data1);
   // But values in the copy were.
   CheckAreaData(kNamespaceClone, kOrigin1, reference);
 
   // The namespaces no longer refer to the same map.
   EXPECT_NE(GetMapForArea(kNamespace1, kOrigin1),
             GetMapForArea(kNamespaceClone, kOrigin1));
   EXPECT_EQ(1, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1)));
   EXPECT_EQ(1, GetMapRefCount(GetMapForArea(kNamespaceClone, kOrigin1)));
 }
 
 TEST_F(SessionStorageDatabaseTest, ManyShallowCopies) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   data2[kKey3] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   // Make a two shallow copies.
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   std::string another_clone("another_cloned");
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, another_clone));
 
   // Make a shallow copy of a shallow copy.
@@ skipping 24 matching lines @@
             GetMapForArea(clone_of_clone, kOrigin1));
   EXPECT_EQ(GetMapForArea(kNamespace1, kOrigin2),
             GetMapForArea(clone_of_clone, kOrigin2));
 
   // Check the ref counts.
   EXPECT_EQ(4, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin1)));
   EXPECT_EQ(4, GetMapRefCount(GetMapForArea(kNamespace1, kOrigin2)));
 }
 
 TEST_F(SessionStorageDatabaseTest, DisassociateShallowCopy) {
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
 
   // Disassoaciate the shallow copy.
   EXPECT_TRUE(db_->DeleteArea(kNamespaceClone, kOrigin1));
   CheckDatabaseConsistency();
 
   // Now new data can be written to that map.
-  ValuesMap reference;
-  ValuesMap changes;
+  DOMStorageValuesMap reference;
+  DOMStorageValuesMap changes;
   changes[kKey1] = kValueNull;
   changes[kKey2] = kValue4;
   changes[kKey3] = kValue4;
   reference[kKey2] = kValue4;
   reference[kKey3] = kValue4;
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespaceClone, kOrigin1, false,
                                      changes));
 
   // Values in the original map were not changed.
   CheckAreaData(kNamespace1, kOrigin1, data1);
 
   // But values in the disassociated map were.
   CheckAreaData(kNamespaceClone, kOrigin1, reference);
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteNamespace) {
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey2] = kValue4;
   data2[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
   EXPECT_TRUE(db_->DeleteNamespace(kNamespace1));
   CheckDatabaseConsistency();
   CheckEmptyDatabase();
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteNamespaceWithShallowCopy) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   data2[kKey3] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   // Make a shallow copy and delete the original namespace.
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   EXPECT_TRUE(db_->DeleteNamespace(kNamespace1));
 
   // The original namespace has no data.
   CheckDatabaseConsistency();
-  CheckAreaData(kNamespace1, kOrigin1, ValuesMap());
-  CheckAreaData(kNamespace1, kOrigin2, ValuesMap());
+  CheckAreaData(kNamespace1, kOrigin1, DOMStorageValuesMap());
+  CheckAreaData(kNamespace1, kOrigin2, DOMStorageValuesMap());
   // But the copy persists.
   CheckAreaData(kNamespaceClone, kOrigin1, data1);
   CheckAreaData(kNamespaceClone, kOrigin2, data2);
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteArea) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   data2[kKey3] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
   CheckDatabaseConsistency();
   // The data for the non-deleted origin persists.
   CheckAreaData(kNamespace1, kOrigin1, data1);
   // The data for the deleted origin is gone.
-  CheckAreaData(kNamespace1, kOrigin2, ValuesMap());
+  CheckAreaData(kNamespace1, kOrigin2, DOMStorageValuesMap());
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteAreaWithShallowCopy) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   data2[kKey3] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   // Make a shallow copy and delete an origin from the original namespace.
   EXPECT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1));
   CheckDatabaseConsistency();
 
   // The original namespace has data for only the non-deleted origin.
-  CheckAreaData(kNamespace1, kOrigin1, ValuesMap());
+  CheckAreaData(kNamespace1, kOrigin1, DOMStorageValuesMap());
   CheckAreaData(kNamespace1, kOrigin2, data2);
   // But the copy persists.
   CheckAreaData(kNamespaceClone, kOrigin1, data1);
   CheckAreaData(kNamespaceClone, kOrigin2, data2);
 }
 
 TEST_F(SessionStorageDatabaseTest, WriteRawBytes) {
   // Write data which is not valid utf8 and contains null bytes.
   unsigned char raw_data[10] = {255, 0, 0, 0, 1, 2, 3, 4, 5, 0};
-  ValuesMap changes;
+  DOMStorageValuesMap changes;
   base::string16 string_with_raw_data;
   string_with_raw_data.assign(reinterpret_cast<char16*>(raw_data), 5);
   changes[kKey1] = base::NullableString16(string_with_raw_data, false);
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes));
   CheckDatabaseConsistency();
-  ValuesMap values;
+  DOMStorageValuesMap values;
   db_->ReadAreaValues(kNamespace1, kOrigin1, &values);
   const unsigned char* data =
       reinterpret_cast<const unsigned char*>(values[kKey1].string().data());
   for (int i = 0; i < 10; ++i)
     EXPECT_EQ(raw_data[i], data[i]);
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteNamespaceConfusion) {
   // Regression test for a bug where a namespace with id 10 prevented deleting
   // the namespace with id 1.
 
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges("foobar", kOrigin1, false, data1));
   ASSERT_TRUE(db_->CommitAreaChanges("foobarbaz", kOrigin1, false, data1));
 
   // Delete the namespace with ID 1.
   EXPECT_TRUE(db_->DeleteNamespace("foobar"));
 }
 
 TEST_F(SessionStorageDatabaseTest, ReadNamespaceIds) {
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
   std::set<std::string> expected_namespace_ids;
 
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
   expected_namespace_ids.insert(kNamespace1);
   CheckNamespaceIds(expected_namespace_ids);
 
   ASSERT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   expected_namespace_ids.insert(kNamespaceClone);
   CheckNamespaceIds(expected_namespace_ids);
 
   ASSERT_TRUE(db_->DeleteNamespace(kNamespace1));
   expected_namespace_ids.erase(kNamespace1);
   CheckNamespaceIds(expected_namespace_ids);
 
   CheckDatabaseConsistency();
 }
 
 TEST_F(SessionStorageDatabaseTest, ReadNamespaceIdsInEmptyDatabase) {
   std::set<std::string> expected_namespace_ids;
   CheckNamespaceIds(expected_namespace_ids);
 }
 
 TEST_F(SessionStorageDatabaseTest, ReadOriginsInNamespace) {
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   data1[kKey2] = kValue2;
   data1[kKey3] = kValue3;
 
   std::set<GURL> expected_origins1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data1));
   expected_origins1.insert(kOrigin1);
   expected_origins1.insert(kOrigin2);
   CheckOrigins(kNamespace1, expected_origins1);
 
   std::set<GURL> expected_origins2;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace2, kOrigin2, false, data1));
   expected_origins2.insert(kOrigin2);
   CheckOrigins(kNamespace2, expected_origins2);
 
   ASSERT_TRUE(db_->CloneNamespace(kNamespace1, kNamespaceClone));
   CheckOrigins(kNamespaceClone, expected_origins1);
 
   ASSERT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
   expected_origins1.erase(kOrigin2);
   CheckOrigins(kNamespace1, expected_origins1);
 
   CheckDatabaseConsistency();
 }
 
 TEST_F(SessionStorageDatabaseTest, DeleteAllOrigins) {
   // Write data for a namespace, for 2 origins.
-  ValuesMap data1;
+  DOMStorageValuesMap data1;
   data1[kKey1] = kValue1;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, data1));
-  ValuesMap data2;
+  DOMStorageValuesMap data2;
   data2[kKey1] = kValue2;
   ASSERT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin2, false, data2));
 
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin1));
   EXPECT_TRUE(db_->DeleteArea(kNamespace1, kOrigin2));
   // Check that also the namespace start key was deleted.
   CheckDatabaseConsistency();
 }
 
 
-}  // namespace dom_storage
+}  // namespace content