Use explicit WebString conversions in spellcheck

components/spellcheck/renderer/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 "components/spellcheck/renderer/spellcheck_provider.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/spellcheck/common/spellcheck_marker.h"
 #include "components/spellcheck/common/spellcheck_messages.h"
@@ skipping 109 matching lines @@
 
   Send(new SpellCheckHostMsg_ToggleSpellCheck(routing_id(), enabled, checked));
 #endif  // USE_BROWSER_SPELLCHECKER
 }
 
 void SpellCheckProvider::checkSpelling(
     const WebString& text,
     int& offset,
     int& length,
     WebVector<WebString>* optional_suggestions) {
-  base::string16 word(text);
+  base::string16 word = text.utf16();
   std::vector<base::string16> suggestions;
   const int kWordStart = 0;
   spellcheck_->SpellCheckWord(
       word.c_str(), kWordStart, word.size(), routing_id(),
       &offset, &length, optional_suggestions ? & suggestions : NULL);
   if (optional_suggestions) {
-    *optional_suggestions = suggestions;
+    WebVector<WebString> web_suggestions(suggestions.size());
+    std::transform(
+        suggestions.begin(), suggestions.end(), web_suggestions.begin(),
+        [](const base::string16& s) { return WebString::fromUTF16(s); });
+    *optional_suggestions = web_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.
     Send(new SpellCheckHostMsg_NotifyChecked(routing_id(), word, 0 < length));
   }
 }
 
 void SpellCheckProvider::requestCheckingOfText(
     const WebString& text,
     const WebVector<uint32_t>& markers,
     const WebVector<unsigned>& marker_offsets,
     WebTextCheckingCompletion* completion) {
   std::vector<SpellCheckMarker> spellcheck_markers;
   for (size_t i = 0; i < markers.size(); ++i) {
     spellcheck_markers.push_back(
         SpellCheckMarker(markers[i], marker_offsets[i]));
   }
-  RequestTextChecking(text, completion, spellcheck_markers);
+  RequestTextChecking(text.utf16(), completion, spellcheck_markers);
   UMA_HISTOGRAM_COUNTS("SpellCheck.api.async", text.length());
 }
 
 void SpellCheckProvider::cancelAllPendingRequests() {
   for (WebTextCheckCompletions::iterator iter(&text_check_completions_);
        !iter.IsAtEnd(); iter.Advance()) {
     iter.GetCurrentValue()->didCancelCheckingText();
   }
   text_check_completions_.Clear();
 }
 
 void SpellCheckProvider::showSpellingUI(bool show) {
 #if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
   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 BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(routing_id(),
-                                                                   word));
+  Send(new SpellCheckHostMsg_UpdateSpellingPanelWithMisspelledWord(
+      routing_id(), word.utf16()));
 #endif
 }
 
 #if !BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 void SpellCheckProvider::OnRespondSpellingService(
     int identifier,
     bool succeeded,
     const base::string16& line,
     const std::vector<SpellCheckResult>& results) {
   WebTextCheckingCompletion* completion =
@@ skipping 140 matching lines @@
     completion->didFinishCheckingText(results);
     return true;
   }
 
   return false;
 }
 
 void SpellCheckProvider::OnDestruct() {
   delete this;
 }