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

content/common/android/address_parser_internal.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 "content/common/android/address_parser_internal.h"
 
 #include <bitset>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 
 namespace {
 
 // Number of digits for a valid zip code.
 const size_t kZipDigits = 5;
 
 // Number of digits for a valid zip code in the Zip Plus 4 format.
 const size_t kZipPlus4Digits = 9;
 
 // Maximum number of digits of a house number, including possible hyphens.
 const size_t kMaxHouseDigits = 5;
 
-char16 SafePreviousChar(const base::string16::const_iterator& it,
+base::char16 SafePreviousChar(const base::string16::const_iterator& it,
     const base::string16::const_iterator& begin) {
   if (it == begin)
     return ' ';
   return *(it - 1);
 }
 
-char16 SafeNextChar(const base::string16::const_iterator& it,
+base::char16 SafeNextChar(const base::string16::const_iterator& it,
     const base::string16::const_iterator& end) {
   if (it == end)
     return ' ';
   return *(it + 1);
 }
 
 bool WordLowerCaseEqualsASCII(base::string16::const_iterator word_begin,
     base::string16::const_iterator word_end, const char* ascii_to_match) {
   for (base::string16::const_iterator it = word_begin; it != word_end;
       ++it, ++ascii_to_match) {
@@ skipping 25 matching lines @@
 
 namespace internal {
 
 Word::Word(const base::string16::const_iterator& begin,
            const base::string16::const_iterator& end)
     : begin(begin),
       end(end) {
   DCHECK(begin <= end);
 }
 
-bool HouseNumberParser::IsPreDelimiter(char16 character) {
+bool HouseNumberParser::IsPreDelimiter(base::char16 character) {
   return character == ':' || IsPostDelimiter(character);
 }
 
-bool HouseNumberParser::IsPostDelimiter(char16 character) {
+bool HouseNumberParser::IsPostDelimiter(base::char16 character) {
   return IsWhitespace(character) || strchr(",\"'", character);
 }
 
 void HouseNumberParser::RestartOnNextDelimiter() {
   ResetState();
   for (; it_ != end_ && !IsPreDelimiter(*it_); ++it_) {}
 }
 
 void HouseNumberParser::AcceptChars(size_t num_chars) {
   size_t offset = std::min(static_cast<size_t>(std::distance(it_, end_)),
@@ skipping 63 matching lines @@
         if (it_ + 3 <= end_ && LowerCaseEqualsASCII(it_, it_ + 3, "one"))
           AcceptChars(3);
         else
           RestartOnNextDelimiter();
         continue;
       }
 
       // There should be more than 1 character because of result_chars.
       DCHECK_GT(result_chars_, 0U);
       DCHECK(it_ != begin_);
-      char16 previous = SafePreviousChar(it_, begin_);
+      base::char16 previous = SafePreviousChar(it_, begin_);
       if (IsAsciiDigit(previous)) {
         // Check cases like '12A'.
-        char16 next = SafeNextChar(it_, end_);
+        base::char16 next = SafeNextChar(it_, end_);
         if (IsPostDelimiter(next)) {
           AcceptChars(1);
           continue;
         }
 
         // Handle cases like 12a, 1st, 2nd, 3rd, 7th.
         if (IsAsciiAlpha(next)) {
-          char16 last_digit = previous;
-          char16 first_letter = base::ToLowerASCII(*it_);
-          char16 second_letter = base::ToLowerASCII(next);
+          base::char16 last_digit = previous;
+          base::char16 first_letter = base::ToLowerASCII(*it_);
+          base::char16 second_letter = base::ToLowerASCII(next);
           bool is_teen = SafePreviousChar(it_ - 1, begin_) == '1' &&
               num_digits_ == 2;
 
           switch (last_digit - '0') {
           case 1:
             if ((first_letter == 's' && second_letter == 't') ||
                 (first_letter == 't' && second_letter == 'h' && is_teen)) {
               AcceptChars(2);
               continue;
             }
@@ skipping 153 matching lines @@
 
   DCHECK_EQ(state_names_accumulative[arraysize(state_names_accumulative) - 1],
       static_cast<int>(ARRAYSIZE_UNSAFE(state_names)));
 
   const Word& first_word = words->at(state_first_word);
   int length = first_word.end - first_word.begin;
   if (length < 2 || !IsAsciiAlpha(*first_word.begin))
     return false;
 
   // No state names start with x, y, z.
-  char16 first_letter = base::ToLowerASCII(*first_word.begin);
+  base::char16 first_letter = base::ToLowerASCII(*first_word.begin);
   if (first_letter > 'w')
     return false;
 
   DCHECK(first_letter >= 'a');
   int first_index = first_letter - 'a';
 
   // Look for two-letter state names.
   if (length == 2 && IsAsciiAlpha(*(first_word.begin + 1))) {
-    char16 second_letter = base::ToLowerASCII(*(first_word.begin + 1));
+    base::char16 second_letter = base::ToLowerASCII(*(first_word.begin + 1));
     DCHECK(second_letter >= 'a');
 
     int second_index = second_letter - 'a';
     if (!(state_two_letter_suffix[first_index] & (1 << second_index)))
       return false;
 
     std::bitset<32> previous_suffixes = state_two_letter_suffix[first_index] &
         ((1 << second_index) - 1);
     *state_last_word = state_first_word;
     *state_index = state_two_letter_accumulative[first_index] +
@@ skipping 218 matching lines @@
   };
 
   DCHECK_EQ(
       location_names_accumulative[arraysize(location_names_accumulative) - 1],
       static_cast<int>(ARRAYSIZE_UNSAFE(location_names)));
 
   if (!IsAsciiAlpha(*word.begin))
     return false;
 
   // No location names start with y, z.
-  char16 first_letter = base::ToLowerASCII(*word.begin);
+  base::char16 first_letter = base::ToLowerASCII(*word.begin);
   if (first_letter > 'x')
     return false;
 
   DCHECK(first_letter >= 'a');
   int index = first_letter - 'a';
   int length = std::distance(word.begin, word.end);
   for (int i = location_names_accumulative[index];
       i < location_names_accumulative[index + 1]; ++i) {
     if (location_names[i].length != length &&
         (location_names[i].allow_plural &&
          location_names[i].length + 1 != length)) {
       continue;
     }
 
     if (LowerCaseEqualsASCIIWithPlural(word.begin, word.end,
                                        location_names[i].string,
                                        location_names[i].allow_plural)) {
       return true;
     }
   }
 
   return false;
 }
 
 } // namespace internal
 
 } // namespace address_parser
 
 }  // namespace content