Replace string16 with base::string16 in src/webkit

webkit/dom_storage/dom_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/dom_storage/dom_storage_database.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
@@ skipping 36 matching lines @@
   // as far as the DOM Storage db is concerned.
   ASSERT_TRUE(db->is_open());
   ASSERT_TRUE(db->Execute("DROP TABLE IF EXISTS ItemTable"));
   ASSERT_TRUE(db->Execute(
       "CREATE TABLE IF NOT EXISTS ItemTable ("
       "key TEXT UNIQUE ON CONFLICT REPLACE, "
       "value FLOAT NOT NULL ON CONFLICT FAIL)"));
 }
 
 void InsertDataV1(sql::Connection* db,
-                  const string16& key,
-                  const string16& value) {
+                  const base::string16& key,
+                  const base::string16& value) {
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE,
       "INSERT INTO ItemTable VALUES (?,?)"));
   statement.BindString16(0, key);
   statement.BindString16(1, value);
   ASSERT_TRUE(statement.is_valid());
   statement.Run();
 }
 
 void CheckValuesMatch(DomStorageDatabase* db,
                       const ValuesMap& expected) {
   ValuesMap values_read;
   db->ReadAllValues(&values_read);
   EXPECT_EQ(expected.size(), values_read.size());
 
   ValuesMap::const_iterator it = values_read.begin();
   for (; it != values_read.end(); ++it) {
-    string16 key = it->first;
+    base::string16 key = it->first;
     NullableString16 value = it->second;
     NullableString16 expected_value = expected.find(key)->second;
     EXPECT_EQ(expected_value.string(), value.string());
     EXPECT_EQ(expected_value.is_null(), value.is_null());
   }
 }
 
 void CreateMapWithValues(ValuesMap* values) {
-  string16 kCannedKeys[] = {
+  base::string16 kCannedKeys[] = {
       ASCIIToUTF16("test"),
       ASCIIToUTF16("company"),
       ASCIIToUTF16("date"),
       ASCIIToUTF16("empty")
   };
   NullableString16 kCannedValues[] = {
       NullableString16(ASCIIToUTF16("123"), false),
       NullableString16(ASCIIToUTF16("Google"), false),
       NullableString16(ASCIIToUTF16("18-01-2012"), false),
-      NullableString16(string16(), false)
+      NullableString16(base::string16(), false)
   };
   for (unsigned i = 0; i < sizeof(kCannedKeys) / sizeof(kCannedKeys[0]); i++)
     (*values)[kCannedKeys[i]] = kCannedValues[i];
 }
 
 TEST(DomStorageDatabaseTest, SimpleOpenAndClose) {
   DomStorageDatabase db;
   EXPECT_FALSE(db.IsOpen());
   ASSERT_TRUE(db.LazyOpen(true));
   EXPECT_TRUE(db.IsOpen());
@@ skipping 147 matching lines @@
   ASSERT_TRUE(db.CommitChanges(true, storage));
   CheckValuesMatch(&db, storage);
 
   // Now clear the values without inserting any new ones.
   storage.clear();
   ASSERT_TRUE(db.CommitChanges(true, storage));
   CheckValuesMatch(&db, storage);
 }
 
 TEST(DomStorageDatabaseTest, UpgradeFromV1ToV2WithData) {
-  const string16 kCannedKey = ASCIIToUTF16("foo");
+  const base::string16 kCannedKey = ASCIIToUTF16("foo");
   const NullableString16 kCannedValue(ASCIIToUTF16("bar"), false);
   ValuesMap expected;
   expected[kCannedKey] = kCannedValue;
 
   DomStorageDatabase db;
   db.db_.reset(new sql::Connection());
   ASSERT_TRUE(db.db_->OpenInMemory());
   CreateV1Table(db.db_.get());
   InsertDataV1(db.db_.get(), kCannedKey, kCannedValue.string());
 
   ASSERT_TRUE(db.UpgradeVersion1To2());
 
   EXPECT_EQ(DomStorageDatabase::V2, db.DetectSchemaVersion());
 
   CheckValuesMatch(&db, expected);
 }
 
 TEST(DomStorageDatabaseTest, TestSimpleRemoveOneValue) {
   DomStorageDatabase db;
 
   ASSERT_TRUE(db.LazyOpen(true));
-  const string16 kCannedKey = ASCIIToUTF16("test");
+  const base::string16 kCannedKey = ASCIIToUTF16("test");
   const NullableString16 kCannedValue(ASCIIToUTF16("data"), false);
   ValuesMap expected;
   expected[kCannedKey] = kCannedValue;
 
   // First write some data into the database.
   ASSERT_TRUE(db.CommitChanges(false, expected));
   CheckValuesMatch(&db, expected);
 
   ValuesMap values;
   // A null string in the map should mean that that key gets
@@ skipping 72 matching lines @@
 
     db.ReadAllValues(&values);
     EXPECT_EQ(0u, values.size());
     EXPECT_FALSE(db.IsOpen());
 
     EXPECT_TRUE(file_util::PathExists(temp_dir.path()));
   }
 }
 
 }  // namespace dom_storage