Convert string16 to base::string16 in content.

content/browser/indexed_db/indexed_db_leveldb_coding_unittest.cc

 // Copyright (c) 2013 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 "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 286 matching lines @@
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeVarInt(&slice, &res));
     EXPECT_EQ(n, res);
     EXPECT_TRUE(slice.empty());
   }
 }
 
-static std::string WrappedEncodeString(string16 value) {
+static std::string WrappedEncodeString(base::string16 value) {
   std::string buffer;
   EncodeString(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeString) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   EXPECT_EQ(static_cast<size_t>(0),
             WrappedEncodeString(ASCIIToUTF16("")).size());
   EXPECT_EQ(static_cast<size_t>(2),
             WrappedEncodeString(ASCIIToUTF16("a")).size());
   EXPECT_EQ(static_cast<size_t>(6),
             WrappedEncodeString(ASCIIToUTF16("foo")).size());
   EXPECT_EQ(static_cast<size_t>(6),
-            WrappedEncodeString(string16(test_string_a)).size());
+            WrappedEncodeString(base::string16(test_string_a)).size());
   EXPECT_EQ(static_cast<size_t>(4),
-            WrappedEncodeString(string16(test_string_b)).size());
+            WrappedEncodeString(base::string16(test_string_b)).size());
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeString) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
-  std::vector<string16> test_cases;
-  test_cases.push_back(string16());
+  std::vector<base::string16> test_cases;
+  test_cases.push_back(base::string16());
   test_cases.push_back(ASCIIToUTF16("a"));
   test_cases.push_back(ASCIIToUTF16("foo"));
   test_cases.push_back(test_string_a);
   test_cases.push_back(test_string_b);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
-    const string16& test_case = test_cases[i];
+    const base::string16& test_case = test_cases[i];
     std::string v = WrappedEncodeString(test_case);
 
     StringPiece slice;
     if (v.size()) {
       slice = StringPiece(&*v.begin(), v.size());
     }
 
-    string16 result;
+    base::string16 result;
     EXPECT_TRUE(DecodeString(&slice, &result));
     EXPECT_EQ(test_case, result);
     EXPECT_TRUE(slice.empty());
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeString(&slice, &result));
     EXPECT_EQ(test_case, result);
     EXPECT_TRUE(slice.empty());
   }
 }
 
-static std::string WrappedEncodeStringWithLength(string16 value) {
+static std::string WrappedEncodeStringWithLength(base::string16 value) {
   std::string buffer;
   EncodeStringWithLength(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeStringWithLength) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   EXPECT_EQ(static_cast<size_t>(1),
-            WrappedEncodeStringWithLength(string16()).size());
+            WrappedEncodeStringWithLength(base::string16()).size());
   EXPECT_EQ(static_cast<size_t>(3),
             WrappedEncodeStringWithLength(ASCIIToUTF16("a")).size());
   EXPECT_EQ(static_cast<size_t>(7),
-            WrappedEncodeStringWithLength(string16(test_string_a)).size());
+            WrappedEncodeStringWithLength(
+                base::string16(test_string_a)).size());
   EXPECT_EQ(static_cast<size_t>(5),
-            WrappedEncodeStringWithLength(string16(test_string_b)).size());
+            WrappedEncodeStringWithLength(
+                base::string16(test_string_b)).size());
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeStringWithLength) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   const int kLongStringLen = 1234;
   char16 long_string[kLongStringLen + 1];
   for (int i = 0; i < kLongStringLen; ++i)
     long_string[i] = i;
   long_string[kLongStringLen] = 0;
 
-  std::vector<string16> test_cases;
+  std::vector<base::string16> test_cases;
   test_cases.push_back(ASCIIToUTF16(""));
   test_cases.push_back(ASCIIToUTF16("a"));
   test_cases.push_back(ASCIIToUTF16("foo"));
-  test_cases.push_back(string16(test_string_a));
-  test_cases.push_back(string16(test_string_b));
-  test_cases.push_back(string16(long_string));
+  test_cases.push_back(base::string16(test_string_a));
+  test_cases.push_back(base::string16(test_string_b));
+  test_cases.push_back(base::string16(long_string));
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
-    string16 s = test_cases[i];
+    base::string16 s = test_cases[i];
     std::string v = WrappedEncodeStringWithLength(s);
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(v);
-    string16 res;
+    base::string16 res;
     EXPECT_TRUE(DecodeStringWithLength(&slice, &res));
     EXPECT_EQ(s, res);
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 
@@ skipping 20 matching lines @@
 }
 
 TEST(IndexedDBLevelDBCodingTest, CompareEncodedStringsWithLength) {
   const char16 test_string_a[] = {0x1000, 0x1000, '\0'};
   const char16 test_string_b[] = {0x1000, 0x1000, 0x1000, '\0'};
   const char16 test_string_c[] = {0x1000, 0x1000, 0x1001, '\0'};
   const char16 test_string_d[] = {0x1001, 0x1000, 0x1000, '\0'};
   const char16 test_string_e[] = {0xd834, 0xdd1e, '\0'};
   const char16 test_string_f[] = {0xfffd, '\0'};
 
-  std::vector<string16> test_cases;
+  std::vector<base::string16> test_cases;
   test_cases.push_back(ASCIIToUTF16(""));
   test_cases.push_back(ASCIIToUTF16("a"));
   test_cases.push_back(ASCIIToUTF16("b"));
   test_cases.push_back(ASCIIToUTF16("baaa"));
   test_cases.push_back(ASCIIToUTF16("baab"));
   test_cases.push_back(ASCIIToUTF16("c"));
-  test_cases.push_back(string16(test_string_a));
-  test_cases.push_back(string16(test_string_b));
-  test_cases.push_back(string16(test_string_c));
-  test_cases.push_back(string16(test_string_d));
-  test_cases.push_back(string16(test_string_e));
-  test_cases.push_back(string16(test_string_f));
+  test_cases.push_back(base::string16(test_string_a));
+  test_cases.push_back(base::string16(test_string_b));
+  test_cases.push_back(base::string16(test_string_c));
+  test_cases.push_back(base::string16(test_string_d));
+  test_cases.push_back(base::string16(test_string_e));
+  test_cases.push_back(base::string16(test_string_f));
 
   for (size_t i = 0; i < test_cases.size() - 1; ++i) {
-    string16 a = test_cases[i];
-    string16 b = test_cases[i + 1];
+    base::string16 a = test_cases[i];
+    base::string16 b = test_cases[i + 1];
 
     EXPECT_LT(a.compare(b), 0);
     EXPECT_GT(b.compare(a), 0);
     EXPECT_EQ(a.compare(a), 0);
     EXPECT_EQ(b.compare(b), 0);
 
     std::string encoded_a = WrappedEncodeStringWithLength(a);
     EXPECT_TRUE(encoded_a.size());
     std::string encoded_b = WrappedEncodeStringWithLength(b);
     EXPECT_TRUE(encoded_a.size());
@@ skipping 149 matching lines @@
   {
     key_paths.push_back(IndexedDBKeyPath());
     char expected[] = {0, 0,  // Header
                        0      // Type is null
     };
     encoded_paths.push_back(
         std::string(expected, expected + arraysize(expected)));
   }
 
   {
-    key_paths.push_back(IndexedDBKeyPath(string16()));
+    key_paths.push_back(IndexedDBKeyPath(base::string16()));
     char expected[] = {0, 0,  // Header
                        1,     // Type is string
                        0      // Length is 0
     };
     encoded_paths.push_back(
         std::string(expected, expected + arraysize(expected)));
   }
 
   {
     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo")));
@@ skipping 10 matching lines @@
     char expected[] = {0, 0,  // Header
                        1,     // Type is string
                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
                        'r'  // String length 7, UTF-16BE
     };
     encoded_paths.push_back(
         std::string(expected, expected + arraysize(expected)));
   }
 
   {
-    std::vector<string16> array;
-    array.push_back(string16());
+    std::vector<base::string16> array;
+    array.push_back(base::string16());
     array.push_back(ASCIIToUTF16("foo"));
     array.push_back(ASCIIToUTF16("foo.bar"));
 
     key_paths.push_back(IndexedDBKeyPath(array));
     char expected[] = {0, 0,                       // Header
                        2, 3,                       // Type is array, length is 3
                        0,                          // Member 1 (String length 0)
                        3, 0, 'f', 0, 'o', 0, 'o',  // Member 2 (String length 3)
                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
                        'r'  // Member 3 (String length 7)
@@ skipping 17 matching lines @@
     EXPECT_TRUE(slice.empty());
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeLegacyIDBKeyPath) {
   // Legacy encoding of string key paths.
   std::vector<IndexedDBKeyPath> key_paths;
   std::vector<std::string> encoded_paths;
 
   {
-    key_paths.push_back(IndexedDBKeyPath(string16()));
+    key_paths.push_back(IndexedDBKeyPath(base::string16()));
     encoded_paths.push_back(std::string());
   }
   {
     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo")));
     char expected[] = {0, 'f', 0, 'o', 0, 'o'};
     encoded_paths.push_back(std::string(expected, arraysize(expected)));
   }
   {
     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo.bar")));
     char expected[] = {0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0, 'r'};
@@ skipping 197 matching lines @@
     std::string vB = WrappedEncodeVarInt(static_cast<int64>(n));
 
     EXPECT_EQ(vA.size(), vB.size());
     EXPECT_EQ(*vA.begin(), *vB.begin());
   }
 }
 
 }  // namespace
 
 }  // namespace content