Update some uses of char16 to use the base:: namespace.

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 299 matching lines @@
   }
 }
 
 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'};
+  const base::char16 test_string_a[] = {'f', 'o', 'o', '\0'};
+  const base::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(base::string16(test_string_a)).size());
   EXPECT_EQ(static_cast<size_t>(4),
             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'};
+  const base::char16 test_string_a[] = {'f', 'o', 'o', '\0'};
+  const base::char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   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 base::string16& test_case = test_cases[i];
@@ skipping 18 matching lines @@
   }
 }
 
 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'};
+  const base::char16 test_string_a[] = {'f', 'o', 'o', '\0'};
+  const base::char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   EXPECT_EQ(static_cast<size_t>(1),
             WrappedEncodeStringWithLength(base::string16()).size());
   EXPECT_EQ(static_cast<size_t>(3),
             WrappedEncodeStringWithLength(ASCIIToUTF16("a")).size());
   EXPECT_EQ(static_cast<size_t>(7),
             WrappedEncodeStringWithLength(
                 base::string16(test_string_a)).size());
   EXPECT_EQ(static_cast<size_t>(5),
             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 base::char16 test_string_a[] = {'f', 'o', 'o', '\0'};
+  const base::char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   const int kLongStringLen = 1234;
-  char16 long_string[kLongStringLen + 1];
+  base::char16 long_string[kLongStringLen + 1];
   for (int i = 0; i < kLongStringLen; ++i)
     long_string[i] = i;
   long_string[kLongStringLen] = 0;
 
   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(base::string16(test_string_a));
   test_cases.push_back(base::string16(test_string_b));
@@ skipping 31 matching lines @@
   StringPiece slice_p(p);
   StringPiece slice_q(q);
   int result = CompareEncodedStringsWithLength(&slice_p, &slice_q, &ok);
   EXPECT_TRUE(ok);
   EXPECT_TRUE(slice_p.empty());
   EXPECT_TRUE(slice_q.empty());
   return result;
 }
 
 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'};
+  const base::char16 test_string_a[] = {0x1000, 0x1000, '\0'};
+  const base::char16 test_string_b[] = {0x1000, 0x1000, 0x1000, '\0'};
+  const base::char16 test_string_c[] = {0x1000, 0x1000, 0x1001, '\0'};
+  const base::char16 test_string_d[] = {0x1001, 0x1000, 0x1000, '\0'};
+  const base::char16 test_string_e[] = {0xd834, 0xdd1e, '\0'};
+  const base::char16 test_string_f[] = {0xfffd, '\0'};
 
   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(base::string16(test_string_a));
   test_cases.push_back(base::string16(test_string_b));
@@ skipping 455 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