Use base namespace for string16 in chrome/renderer.

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 53 matching lines @@
   for (size_t i = 0; i < markers.size(); ++i)
     markers_.push_back(markers[i]);
   // Visit all render views.
   return true;
 }
 
 }  // namespace
 
 class SpellCheck::SpellcheckRequest {
  public:
-  SpellcheckRequest(const string16& text,
+  SpellcheckRequest(const base::string16& text,
                     blink::WebTextCheckingCompletion* completion)
       : text_(text), completion_(completion) {
     DCHECK(completion);
   }
   ~SpellcheckRequest() {}
 
-  string16 text() { return text_; }
+  base::string16 text() { return text_; }
   blink::WebTextCheckingCompletion* completion() { return completion_; }
 
  private:
-  string16 text_;  // Text to be checked in this task.
+  base::string16 text_;  // Text to be checked in this task.
 
   // The interface to send the misspelled ranges to WebKit.
   blink::WebTextCheckingCompletion* completion_;
 
   DISALLOW_COPY_AND_ASSIGN(SpellcheckRequest);
 };
 
 
 // Initializes SpellCheck object.
 // spellcheck_enabled_ currently MUST be set to true, due to peculiarities of
@@ skipping 77 matching lines @@
   spellcheck_.Init(file, language);
   custom_dictionary_.Init(custom_words);
 }
 
 bool SpellCheck::SpellCheckWord(
     const char16* in_word,
     int in_word_len,
     int tag,
     int* misspelling_start,
     int* misspelling_len,
-    std::vector<string16>* optional_suggestions) {
+    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.)
   if (InitializeIfNeeded())
     return true;
 
   return spellcheck_.SpellCheckWord(in_word, in_word_len,
                                     tag,
                                     misspelling_start, misspelling_len,
                                     optional_suggestions);
 }
 
 bool SpellCheck::SpellCheckParagraph(
-    const string16& text,
+    const base::string16& text,
     WebVector<WebTextCheckingResult>* results) {
 #if !defined(OS_MACOSX)
   // Mac has its own spell checker, so this method will not be used.
   DCHECK(results);
   std::vector<WebTextCheckingResult> textcheck_results;
   size_t length = text.length();
   size_t offset = 0;
 
   // Spellcheck::SpellCheckWord() automatically breaks text into words and
   // checks the spellings of the extracted words. This function sets the
   // position and length of the first misspelled word and returns false when
   // the text includes misspelled words. Therefore, we just repeat calling the
   // function until it returns true to check the whole text.
   int misspelling_start = 0;
   int misspelling_length = 0;
   while (offset <= length) {
     if (SpellCheckWord(&text[offset],
                        length - offset,
                        0,
                        &misspelling_start,
                        &misspelling_length,
                        NULL)) {
       results->assign(textcheck_results);
       return true;
     }
 
     if (!custom_dictionary_.SpellCheckWord(
             text, misspelling_start + offset, misspelling_length)) {
-      string16 replacement;
+      base::string16 replacement;
       textcheck_results.push_back(WebTextCheckingResult(
           blink::WebTextDecorationTypeSpelling,
           misspelling_start + offset,
           misspelling_length,
           replacement));
     }
     offset += misspelling_start + misspelling_length;
   }
   results->assign(textcheck_results);
   return false;
 #else
   // This function is only invoked for spell checker functionality that runs
   // on the render thread. OSX builds don't have that.
   NOTREACHED();
   return true;
 #endif
 }
 
-string16 SpellCheck::GetAutoCorrectionWord(const string16& word, int tag) {
-  string16 autocorrect_word;
+base::string16 SpellCheck::GetAutoCorrectionWord(const base::string16& word,
+                                                 int tag) {
+  base::string16 autocorrect_word;
   if (!auto_spell_correct_turned_on_)
     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;
@@ skipping 32 matching lines @@
     }
 
     // Restore the swapped characters.
     std::swap(misspelled_word[i], misspelled_word[i + 1]);
   }
   return autocorrect_word;
 }
 
 #if !defined(OS_MACOSX)  // OSX uses its own spell checker
 void SpellCheck::RequestTextChecking(
-    const string16& text,
+    const base::string16& text,
     blink::WebTextCheckingCompletion* completion) {
   // Clean up the previous request before starting a new request.
   if (pending_request_param_.get())
     pending_request_param_->completion()->didCancelCheckingText();
 
   pending_request_param_.reset(new SpellcheckRequest(
       text, completion));
   // We will check this text after we finish loading the hunspell dictionary.
   if (InitializeIfNeeded())
     return;
@@ skipping 28 matching lines @@
     WebVector<blink::WebTextCheckingResult> results;
     SpellCheckParagraph(param->text(), &results);
     param->completion()->didFinishCheckingText(results);
   }
 }
 #endif
 
 void SpellCheck::CreateTextCheckingResults(
     ResultFilter filter,
     int line_offset,
-    const string16& line_text,
+    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();
   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;
@@ skipping 12 matching lines @@
       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);
 }