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

chrome/renderer/spellchecker/spellcheck.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 "chrome/renderer/spellchecker/spellcheck.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
@@ skipping 157 matching lines @@
 // TODO(groby): Make sure we always have a spelling engine, even before Init()
 // is called.
 void SpellCheck::Init(base::PlatformFile file,
                       const std::set<std::string>& custom_words,
                       const std::string& language) {
   spellcheck_.Init(file, language);
   custom_dictionary_.Init(custom_words);
 }
 
 bool SpellCheck::SpellCheckWord(
-    const char16* in_word,
+    const base::char16* in_word,
     int in_word_len,
     int tag,
     int* misspelling_start,
     int* misspelling_len,
     std::vector<base::string16>* optional_suggestions) {
   DCHECK(in_word_len >= 0);
   DCHECK(misspelling_start && misspelling_len) << "Out vars must be given.";
 
   // Do nothing if we need to delay initialization. (Rather than blocking,
   // report the word as correctly spelled.)
@@ skipping 62 matching lines @@
     return autocorrect_word;  // Return the empty string.
 
   int word_length = static_cast<int>(word.size());
   if (word_length < 2 ||
       word_length > chrome::spellcheck_common::kMaxAutoCorrectWordSize)
     return autocorrect_word;
 
   if (InitializeIfNeeded())
     return autocorrect_word;
 
-  char16 misspelled_word[
+  base::char16 misspelled_word[
       chrome::spellcheck_common::kMaxAutoCorrectWordSize + 1];
-  const char16* word_char = word.c_str();
+  const base::char16* word_char = word.c_str();
   for (int i = 0; i <= chrome::spellcheck_common::kMaxAutoCorrectWordSize;
        ++i) {
     if (i >= word_length)
       misspelled_word[i] = 0;
     else
       misspelled_word[i] = word_char[i];
   }
 
   // Swap adjacent characters and spellcheck.
   int misspelling_start, misspelling_len;
@@ skipping 73 matching lines @@
 
 void SpellCheck::CreateTextCheckingResults(
     ResultFilter filter,
     int line_offset,
     const base::string16& line_text,
     const std::vector<SpellCheckResult>& spellcheck_results,
     WebVector<WebTextCheckingResult>* textcheck_results) {
   // Double-check misspelled words with our spellchecker and attach grammar
   // markers to them if our spellchecker tells they are correct words, i.e. they
   // are probably contextually-misspelled words.
-  const char16* text = line_text.c_str();
+  const base::char16* text = line_text.c_str();
   std::vector<WebTextCheckingResult> list;
   for (size_t i = 0; i < spellcheck_results.size(); ++i) {
     SpellCheckResult::Decoration decoration = spellcheck_results[i].decoration;
     int word_location = spellcheck_results[i].location;
     int word_length = spellcheck_results[i].length;
     int misspelling_start = 0;
     int misspelling_length = 0;
     if (decoration == SpellCheckResult::SPELLING &&
         filter == USE_NATIVE_CHECKER) {
       if (SpellCheckWord(text + word_location, word_length, 0,
                          &misspelling_start, &misspelling_length, NULL)) {
         decoration = SpellCheckResult::GRAMMAR;
       }
     }
     if (!custom_dictionary_.SpellCheckWord(
             line_text, word_location, word_length)) {
       list.push_back(WebTextCheckingResult(
           static_cast<WebTextDecorationType>(decoration),
           word_location + line_offset,
           word_length,
           spellcheck_results[i].replacement,
           spellcheck_results[i].hash));
     }
   }
   textcheck_results->assign(list);
 }