Move nullable_string16.h to the string subdirectory.

webkit/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 <algorithm>
 #include <map>
 #include <string>
@@ skipping 53 matching lines @@
 
   // Test data.
   const GURL kOrigin1;
   const GURL kOrigin2;
   const std::string kNamespace1;
   const std::string kNamespace2;
   const std::string kNamespaceClone;
   const base::string16 kKey1;
   const base::string16 kKey2;
   const base::string16 kKey3;
-  const NullableString16 kValue1;
-  const NullableString16 kValue2;
-  const NullableString16 kValue3;
-  const NullableString16 kValue4;
-  const NullableString16 kValueNull;
+  const base::NullableString16 kValue1;
+  const base::NullableString16 kValue2;
+  const base::NullableString16 kValue3;
+  const base::NullableString16 kValue4;
+  const base::NullableString16 kValueNull;
 
   DISALLOW_COPY_AND_ASSIGN(SessionStorageDatabaseTest);
 };
 
 SessionStorageDatabaseTest::SessionStorageDatabaseTest()
     : kOrigin1("http://www.origin1.com"),
       kOrigin2("http://www.origin2.com"),
       kNamespace1("namespace1"),
       kNamespace2("namespace2"),
       kNamespaceClone("wascloned"),
       kKey1(ASCIIToUTF16("key1")),
       kKey2(ASCIIToUTF16("key2")),
       kKey3(ASCIIToUTF16("key3")),
-      kValue1(NullableString16(ASCIIToUTF16("value1"), false)),
-      kValue2(NullableString16(ASCIIToUTF16("value2"), false)),
-      kValue3(NullableString16(ASCIIToUTF16("value3"), false)),
-      kValue4(NullableString16(ASCIIToUTF16("value4"), false)),
-      kValueNull(NullableString16(true)) { }
+      kValue1(base::NullableString16(ASCIIToUTF16("value1"), false)),
+      kValue2(base::NullableString16(ASCIIToUTF16("value2"), false)),
+      kValue3(base::NullableString16(ASCIIToUTF16("value3"), false)),
+      kValue4(base::NullableString16(ASCIIToUTF16("value4"), false)),
+      kValueNull(base::NullableString16(true)) { }
 
 SessionStorageDatabaseTest::~SessionStorageDatabaseTest() { }
 
 void SessionStorageDatabaseTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   ResetDatabase();
 }
 
 void SessionStorageDatabaseTest::ResetDatabase() {
   db_ = new SessionStorageDatabase(temp_dir_.path());
@@ skipping 216 matching lines @@
   CompareValuesMaps(values, reference);
 }
 
 void SessionStorageDatabaseTest::CompareValuesMaps(
     const ValuesMap& map1,
     const ValuesMap& map2) const {
   ASSERT_EQ(map2.size(), map1.size());
   for (ValuesMap::const_iterator it = map1.begin(); it != map1.end(); ++it) {
     base::string16 key = it->first;
     ASSERT_TRUE(map2.find(key) != map2.end());
-    NullableString16 val1 = it->second;
-    NullableString16 val2 = map2.find(key)->second;
+    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(
     const std::set<std::string>& expected_namespace_ids) const {
   std::map<std::string, std::vector<GURL> > namespaces_and_origins;
   EXPECT_TRUE(db_->ReadNamespacesAndOrigins(&namespaces_and_origins));
   EXPECT_EQ(expected_namespace_ids.size(), namespaces_and_origins.size());
@@ skipping 348 matching lines @@
   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;
   base::string16 string_with_raw_data;
   string_with_raw_data.assign(reinterpret_cast<char16*>(raw_data), 5);
-  changes[kKey1] = NullableString16(string_with_raw_data, false);
+  changes[kKey1] = base::NullableString16(string_with_raw_data, false);
   EXPECT_TRUE(db_->CommitAreaChanges(kNamespace1, kOrigin1, false, changes));
   CheckDatabaseConsistency();
   ValuesMap 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]);
 }
 
@@ skipping 75 matching lines @@
   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