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

ui/gfx/text_elider_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.
 //
 // Unit tests for eliding and formatting utility functions.
 
 #include "ui/gfx/text_elider.h"
 
 #include "base/files/file_path.h"
 #include "base/i18n/rtl.h"
@@ skipping 361 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     base::string16 result = ElideText(UTF8ToUTF16(cases[i].input), font_list,
                                 cases[i].width, ELIDE_AT_END);
     EXPECT_EQ(cases[i].output, UTF16ToUTF8(result));
   }
 }
 
 // Checks that all occurrences of |first_char| are followed by |second_char| and
 // all occurrences of |second_char| are preceded by |first_char| in |text|.
 static void CheckSurrogatePairs(const base::string16& text,
-                                char16 first_char,
-                                char16 second_char) {
+                                base::char16 first_char,
+                                base::char16 second_char) {
   size_t index = text.find_first_of(first_char);
   while (index != base::string16::npos) {
     EXPECT_LT(index, text.length() - 1);
     EXPECT_EQ(second_char, text[index + 1]);
     index = text.find_first_of(first_char, index + 1);
   }
   index = text.find_first_of(second_char);
   while (index != base::string16::npos) {
     EXPECT_GT(index, 0U);
     EXPECT_EQ(first_char, text[index - 1]);
     index = text.find_first_of(second_char, index + 1);
   }
 }
 
 TEST(TextEliderTest, ElideTextSurrogatePairs) {
   const FontList font_list;
   // The below is 'MUSICAL SYMBOL G CLEF', which is represented in UTF-16 as
   // two characters forming a surrogate pair 0x0001D11E.
   const std::string kSurrogate = "\xF0\x9D\x84\x9E";
   const base::string16 kTestString =
       UTF8ToUTF16(kSurrogate + "ab" + kSurrogate + kSurrogate + "cd");
   const float kTestStringWidth = GetStringWidthF(kTestString, font_list);
-  const char16 kSurrogateFirstChar = kTestString[0];
-  const char16 kSurrogateSecondChar = kTestString[1];
+  const base::char16 kSurrogateFirstChar = kTestString[0];
+  const base::char16 kSurrogateSecondChar = kTestString[1];
   base::string16 result;
 
   // Elide |kTextString| to all possible widths and check that no instance of
   // |kSurrogate| was split in two.
   for (float width = 0; width <= kTestStringWidth; width++) {
     result = ElideText(kTestString, font_list, width, TRUNCATE_AT_END);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
 
     result = ElideText(kTestString, font_list, width, ELIDE_AT_END);
     CheckSurrogatePairs(result, kSurrogateFirstChar, kSurrogateSecondChar);
@@ skipping 544 matching lines @@
 
   // Test adds ... at right spot when there is not enough room to break at a
   // word boundary.
   EXPECT_EQ(L"foooooey\x2026", UTF16ToWide(TruncateString(string, 11)));
 
   // Test completely truncates string if break is on initial whitespace.
   EXPECT_EQ(L"\x2026", UTF16ToWide(TruncateString(ASCIIToUTF16("   "), 2)));
 }
 
 }  // namespace gfx