Use base namespace for string16 in chrome/renderer.

chrome/renderer/spellchecker/spellcheck_provider.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_provider.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/spellcheck_marker.h"
@@ skipping 33 matching lines @@
   if (render_view) {  // NULL in unit tests.
     render_view->GetWebView()->setSpellCheckClient(this);
     EnableSpellcheck(spellcheck_->is_spellcheck_enabled());
   }
 }
 
 SpellCheckProvider::~SpellCheckProvider() {
 }
 
 void SpellCheckProvider::RequestTextChecking(
-    const string16& text,
+    const base::string16& text,
     WebTextCheckingCompletion* completion,
     const std::vector<SpellCheckMarker>& markers) {
   // Ignore invalid requests.
   if (text.empty() || !HasWordCharacters(text, 0)) {
     completion->didCancelCheckingText();
     return;
   }
 
   // Try to satisfy check from cache.
   if (SatisfyRequestFromCache(text, completion))
@@ skipping 11 matching lines @@
   // available.
   Send(new SpellCheckHostMsg_RequestTextCheck(
       routing_id(),
       text_check_completions_.Add(completion),
       text,
       markers));
 #else
   Send(new SpellCheckHostMsg_CallSpellingService(
       routing_id(),
       text_check_completions_.Add(completion),
-      string16(text),
+      base::string16(text),
       markers));
 #endif  // !OS_MACOSX
 }
 
 bool SpellCheckProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheckProvider, message)
 #if !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RespondSpellingService,
                         OnRespondSpellingService)
@@ skipping 25 matching lines @@
 
   Send(new SpellCheckHostMsg_ToggleSpellCheck(routing_id(), enabled, checked));
 #endif  // OS_MACOSX
 }
 
 void SpellCheckProvider::spellCheck(
     const WebString& text,
     int& offset,
     int& length,
     WebVector<WebString>* optional_suggestions) {
-  string16 word(text);
-  std::vector<string16> suggestions;
+  base::string16 word(text);
+  std::vector<base::string16> suggestions;
   spellcheck_->SpellCheckWord(
       word.c_str(), word.size(), routing_id(),
       &offset, &length, optional_suggestions ? & suggestions : NULL);
   if (optional_suggestions) {
     *optional_suggestions = suggestions;
     UMA_HISTOGRAM_COUNTS("SpellCheck.api.check.suggestions", word.size());
   } else {
     UMA_HISTOGRAM_COUNTS("SpellCheck.api.check", word.size());
     // If optional_suggestions is not requested, the API is called
     // for marking.  So we use this for counting markable words.
@@ skipping 31 matching lines @@
   RequestTextChecking(text, completion, spellcheck_markers);
   UMA_HISTOGRAM_COUNTS("SpellCheck.api.async", text.length());
 }
 
 WebString SpellCheckProvider::autoCorrectWord(const WebString& word) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableSpellingAutoCorrect)) {
     UMA_HISTOGRAM_COUNTS("SpellCheck.api.autocorrect", word.length());
     return spellcheck_->GetAutoCorrectionWord(word, routing_id());
   }
-  return string16();
+  return base::string16();
 }
 
 void SpellCheckProvider::showSpellingUI(bool show) {
 #if defined(OS_MACOSX)
   UMA_HISTOGRAM_BOOLEAN("SpellCheck.api.showUI", show);
   Send(new SpellCheckHostMsg_ShowSpellingPanel(routing_id(), show));
 #endif
 }
 
 bool SpellCheckProvider::isShowingSpellingUI() {
   return spelling_panel_visible_;
 }
 
 void SpellCheckProvider::updateSpellingUIWithMisspelledWord(
     const WebString& word) {
 #if defined(OS_MACOSX)
   Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(routing_id(),
                                                                    word));
 #endif
 }
 
 #if !defined(OS_MACOSX)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     bool succeeded,
-    const string16& line,
+    const base::string16& line,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
 
   // If |succeeded| is false, we use local spellcheck as a fallback.
   if (!succeeded) {
     spellcheck_->RequestTextChecking(line, completion);
@@ skipping 10 matching lines @@
                                          &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 
   // Cache the request and the converted results.
   last_request_ = line;
   last_results_.swap(textcheck_results);
 }
 #endif
 
 bool SpellCheckProvider::HasWordCharacters(
-    const string16& text,
+    const base::string16& text,
     int index) const {
   const char16* data = text.data();
   int length = text.length();
   while (index < length) {
     uint32 code = 0;
     U16_NEXT(data, index, length, code);
     UErrorCode error = U_ZERO_ERROR;
     if (uscript_getScript(code, &error) != USCRIPT_COMMON)
       return true;
   }
@@ skipping 14 matching lines @@
   // TODO(groby): Unify with SpellCheckProvider::OnRespondSpellingService
   DCHECK(spellcheck_);
   WebTextCheckingCompletion* completion =
       text_check_completions_.Lookup(identifier);
   if (!completion)
     return;
   text_check_completions_.Remove(identifier);
   blink::WebVector<blink::WebTextCheckingResult> textcheck_results;
   spellcheck_->CreateTextCheckingResults(SpellCheck::DO_NOT_MODIFY,
                                          0,
-                                         string16(),
+                                         base::string16(),
                                          results,
                                          &textcheck_results);
   completion->didFinishCheckingText(textcheck_results);
 
   // TODO(groby): Add request caching once OSX reports back original request.
   // (cf. SpellCheckProvider::OnRespondSpellingService)
   // Cache the request and the converted results.
 }
 
 void SpellCheckProvider::OnToggleSpellPanel(bool is_currently_visible) {
@@ skipping 11 matching lines @@
   if (!render_view()->GetWebView())
     return;
 
   WebFrame* frame = render_view()->GetWebView()->focusedFrame();
   frame->enableContinuousSpellChecking(enable);
   if (!enable)
     frame->removeSpellingMarkers();
 }
 
 bool SpellCheckProvider::SatisfyRequestFromCache(
-    const string16& text,
+    const base::string16& text,
     WebTextCheckingCompletion* completion) {
   size_t last_length = last_request_.length();
 
   // Send back the |last_results_| if the |last_request_| is a substring of
   // |text| and |text| does not have more words to check. Provider cannot cancel
   // the spellcheck request here, because WebKit might have discarded the
   // previous spellcheck results and erased the spelling markers in response to
   // the user editing the text.
-  string16 request(text);
+  base::string16 request(text);
   size_t text_length = request.length();
   if (text_length >= last_length &&
       !request.compare(0, last_length, last_request_)) {
     if (text_length == last_length || !HasWordCharacters(text, last_length)) {
       completion->didFinishCheckingText(last_results_);
       return true;
     }
     int code = 0;
     int length = static_cast<int>(text_length);
     U16_PREV(text.data(), 0, length, code);
@@ skipping 22 matching lines @@
         results[i].length = last_results_[i].length;
         results[i].replacement = last_results_[i].replacement;
       }
       completion->didFinishCheckingText(results);
       return true;
     }
   }
 
   return false;
 }