Use explicit WebString conversions in spellcheck

content/child/browser_font_resource_trusted.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/child/browser_font_resource_trusted.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
@@ skipping 53 matching lines @@
       : bidi_(NULL),
         num_runs_(0) {
     StringVar* text_string = StringVar::FromPPVar(run.text);
     if (!text_string)
       return;  // Leave num_runs_ = 0 so we'll do nothing.
     text_ = base::UTF8ToUTF16(text_string->value());
 
     if (run.override_direction) {
       // Skip autodetection.
       num_runs_ = 1;
-      override_run_ = WebTextRun(text_, PP_ToBool(run.rtl), true);
+      override_run_ = WebTextRun(blink::WebString::fromUTF16(text_),
+                                 PP_ToBool(run.rtl), true);
     } else {
       bidi_ = ubidi_open();
       UErrorCode uerror = U_ZERO_ERROR;
       ubidi_setPara(bidi_, text_.data(), text_.size(), run.rtl, NULL, &uerror);
       if (U_SUCCESS(uerror))
         num_runs_ = ubidi_countRuns(bidi_, &uerror);
     }
   }
 
   ~TextRunCollection() {
     if (bidi_)
       ubidi_close(bidi_);
   }
 
   const base::string16& text() const { return text_; }
   int num_runs() const { return num_runs_; }
 
   // Returns a WebTextRun with the info for the run at the given index.
   // The range covered by the run is in the two output params.
   WebTextRun GetRunAt(int index, int32_t* run_start, int32_t* run_len) const {
     DCHECK(index < num_runs_);
     if (bidi_) {
       bool run_rtl = !!ubidi_getVisualRun(bidi_, index, run_start, run_len);
-      return WebTextRun(base::string16(&text_[*run_start], *run_len),
+      return WebTextRun(blink::WebString::fromUTF16(
+                            base::string16(&text_[*run_start], *run_len)),
                         run_rtl, true);
     }
 
     // Override run, return the single one.
     DCHECK_EQ(0, index);
     *run_start = 0;
     *run_len = static_cast<int32_t>(text_.size());
     return override_run_;
   }
 
@@ skipping 12 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TextRunCollection);
 };
 
 bool PPTextRunToWebTextRun(const PP_BrowserFont_Trusted_TextRun& text,
                            WebTextRun* run) {
   StringVar* text_string = StringVar::FromPPVar(text.text);
   if (!text_string)
     return false;
 
-  *run = WebTextRun(base::UTF8ToUTF16(text_string->value()),
-                    PP_ToBool(text.rtl),
-                    PP_ToBool(text.override_direction));
+  *run = WebTextRun(blink::WebString::fromUTF8(text_string->value()),
+                    PP_ToBool(text.rtl), PP_ToBool(text.override_direction));
   return true;
 }
 
 // The PP_* version lacks "None", so is just one value shifted from the
 // WebFontDescription version. These values are checked in
 // PPFontDescToWebFontDesc to make sure the conversion is correct. This is a
 // macro so it can also be used in the static_asserts.
 #define PP_FAMILY_TO_WEB_FAMILY(f) \
   static_cast<WebFontDescription::GenericFamily>(f + 1)
 
@@ skipping 47 matching lines @@
       case PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT:
       default:
         resolved_family = GetFontFromMap(prefs.standard_font_family_map,
                                          kCommonScript);
         break;
     }
   } else {
     // Use the exact font.
     resolved_family = base::UTF8ToUTF16(face_name->value());
   }
-  result.family = resolved_family;
+  result.family = blink::WebString::fromUTF16(resolved_family);
 
   result.genericFamily = PP_FAMILY_TO_WEB_FAMILY(font.family);
 
   if (font.size == 0) {
     // Resolve the default font size, using the resolved family to see if
     // we should use the fixed or regular font size. It's difficult at this
     // level to detect if the requested font is fixed width, so we only apply
     // the alternate font size to the default fixed font family.
     if (base::ToLowerASCII(resolved_family) ==
         base::ToLowerASCII(GetFontFromMap(prefs.fixed_font_family_map,
@@ skipping 59 matching lines @@
 
 PP_Bool BrowserFontResource_Trusted::Describe(
     PP_BrowserFont_Trusted_Description* description,
     PP_BrowserFont_Trusted_Metrics* metrics) {
   if (description->face.type != PP_VARTYPE_UNDEFINED)
     return PP_FALSE;
 
   // While converting the other way in PPFontDescToWebFontDesc we validated
   // that the enums can be casted.
   WebFontDescription web_desc = font_->getFontDescription();
-  description->face = StringVar::StringToPPVar(base::UTF16ToUTF8(
-      base::StringPiece16(web_desc.family)));
+  description->face = StringVar::StringToPPVar(web_desc.family.utf8());
   description->family =
       static_cast<PP_BrowserFont_Trusted_Family>(web_desc.genericFamily);
   description->size = static_cast<uint32_t>(web_desc.size);
   description->weight = static_cast<PP_BrowserFont_Trusted_Weight>(
       web_desc.weight);
   description->italic = web_desc.italic ? PP_TRUE : PP_FALSE;
   description->small_caps = web_desc.smallCaps ? PP_TRUE : PP_FALSE;
   description->letter_spacing = static_cast<int32_t>(web_desc.letterSpacing);
   description->word_spacing = static_cast<int32_t>(web_desc.wordSpacing);
 
@@ skipping 151 matching lines @@
 
     // Advance to the next run. Note that we avoid doing this for the last run
     // since it's unnecessary, measuring text is slow, and most of the time
     // there will be only one run anyway.
     if (i != runs.num_runs() - 1)
       web_position.x += font_->calculateWidth(run);
   }
 }
 
 }  // namespace content