Use explicit WebString conversions in remaining content files

content/renderer/render_view_impl.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/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 
@@ skipping 366 matching lines @@
 
 namespace {
 
 typedef void (*SetFontFamilyWrapper)(blink::WebSettings*,
                                      const base::string16&,
                                      UScriptCode);
 
 void SetStandardFontFamilyWrapper(WebSettings* settings,
                                   const base::string16& font,
                                   UScriptCode script) {
-  settings->setStandardFontFamily(font, script);
+  settings->setStandardFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetFixedFontFamilyWrapper(WebSettings* settings,
                                const base::string16& font,
                                UScriptCode script) {
-  settings->setFixedFontFamily(font, script);
+  settings->setFixedFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetSerifFontFamilyWrapper(WebSettings* settings,
                                const base::string16& font,
                                UScriptCode script) {
-  settings->setSerifFontFamily(font, script);
+  settings->setSerifFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetSansSerifFontFamilyWrapper(WebSettings* settings,
                                    const base::string16& font,
                                    UScriptCode script) {
-  settings->setSansSerifFontFamily(font, script);
+  settings->setSansSerifFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetCursiveFontFamilyWrapper(WebSettings* settings,
                                  const base::string16& font,
                                  UScriptCode script) {
-  settings->setCursiveFontFamily(font, script);
+  settings->setCursiveFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetFantasyFontFamilyWrapper(WebSettings* settings,
                                  const base::string16& font,
                                  UScriptCode script) {
-  settings->setFantasyFontFamily(font, script);
+  settings->setFantasyFontFamily(WebString::fromUTF16(font), script);
 }
 
 void SetPictographFontFamilyWrapper(WebSettings* settings,
                                     const base::string16& font,
                                     UScriptCode script) {
-  settings->setPictographFontFamily(font, script);
+  settings->setPictographFontFamily(WebString::fromUTF16(font), script);
 }
 
 // If |scriptCode| is a member of a family of "similar" script codes, returns
 // the script code in that family that is used by WebKit for font selection
 // purposes.  For example, USCRIPT_KATAKANA_OR_HIRAGANA and USCRIPT_JAPANESE are
 // considered equivalent for the purposes of font selection.  WebKit uses the
 // script code USCRIPT_KATAKANA_OR_HIRAGANA.  So, if |scriptCode| is
 // USCRIPT_JAPANESE, the function returns USCRIPT_KATAKANA_OR_HIRAGANA.  WebKit
 // uses different scripts than the ones in Chrome pref names because the version
 // of ICU included on certain ports does not have some of the newer scripts.  If
@@ skipping 975 matching lines @@
                                     bool suppress_opener) {
   RenderFrameImpl* creator_frame = RenderFrameImpl::FromWebFrame(creator);
   mojom::CreateNewWindowParamsPtr params = mojom::CreateNewWindowParams::New();
   params->opener_render_frame_id = creator_frame->GetRoutingID();
   params->user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
   if (GetContentClient()->renderer()->AllowPopup())
     params->user_gesture = true;
   params->window_container_type = WindowFeaturesToContainerType(features);
   params->session_storage_namespace_id = session_storage_namespace_id_;
   if (frame_name != "_blank")
-    params->frame_name = base::UTF16ToUTF8(base::StringPiece16(frame_name));
+    params->frame_name = frame_name.utf8(
+        WebString::UTF8ConversionMode::kStrictReplacingErrorsWithFFFD);
   params->opener_url = creator->document().url();
 
   // The browser process uses the top frame's URL for a content settings check
   // to determine whether the popup is allowed.  If the top frame is remote,
   // its URL is not available, so use its replicated origin instead.
   //
   // TODO(alexmos): This works fine for regular origins but may break path
   // matching for file URLs with OOP subframes that open popups.  This should
   // be fixed by either moving this lookup to the browser process or removing
   // path-based matching for file URLs from content settings.  See
@@ skipping 187 matching lines @@
     }
   }
 }
 
 void RenderViewImpl::showValidationMessage(
     const blink::WebRect& anchor_in_viewport,
     const blink::WebString& main_text,
     blink::WebTextDirection main_text_hint,
     const blink::WebString& sub_text,
     blink::WebTextDirection sub_text_hint) {
-  base::string16 wrapped_main_text = main_text;
-  base::string16 wrapped_sub_text = sub_text;
+  base::string16 wrapped_main_text = main_text.utf16();
+  base::string16 wrapped_sub_text = sub_text.utf16();
 
   SetValidationMessageDirection(
       &wrapped_main_text, main_text_hint, &wrapped_sub_text, sub_text_hint);
 
   Send(new ViewHostMsg_ShowValidationMessage(
       GetRoutingID(), AdjustValidationMessageAnchor(anchor_in_viewport),
       wrapped_main_text, wrapped_sub_text));
 }
 
 void RenderViewImpl::hideValidationMessage() {
@@ skipping 453 matching lines @@
 }
 
 void RenderViewImpl::OnEnumerateDirectoryResponse(
     int id,
     const std::vector<base::FilePath>& paths) {
   if (!enumeration_completions_[id])
     return;
 
   WebVector<WebString> ws_file_names(paths.size());
   for (size_t i = 0; i < paths.size(); ++i)
-    ws_file_names[i] = paths[i].AsUTF16Unsafe();
+    ws_file_names[i] = blink::FilePathToWebString(paths[i]);
 
   enumeration_completions_[id]->didChooseFile(ws_file_names);
   enumeration_completions_.erase(id);
 }
 
 void RenderViewImpl::OnEnableAutoResize(const gfx::Size& min_size,
                                         const gfx::Size& max_size) {
   DCHECK(disable_scrollbars_size_limit_.IsEmpty());
   if (!webview())
     return;
@@ skipping 615 matching lines @@
                             INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   }
 
   std::unique_ptr<InputEventAck> ack(
       new InputEventAck(InputEventAckSource::MAIN_THREAD, input_event->type(),
                         INPUT_EVENT_ACK_STATE_NOT_CONSUMED));
   OnInputEventAck(std::move(ack));
 }
 
 }  // namespace content