Use explicit WebString conversions in autofill

components/autofill/content/renderer/autofill_agent.cc

 // Copyright 2013 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/autofill/content/renderer/autofill_agent.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
@@ skipping 91 matching lines @@
 
   return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
 }
 
 // Gets all the data list values (with corresponding label) for the given
 // element.
 void GetDataListSuggestions(const WebInputElement& element,
                             std::vector<base::string16>* values,
                             std::vector<base::string16>* labels) {
   for (const auto& option : element.filteredDataListOptions()) {
-    values->push_back(option.value());
+    values->push_back(option.value().utf16());
     if (option.value() != option.label())
-      labels->push_back(option.label());
+      labels->push_back(option.label().utf16());
     else
       labels->push_back(base::string16());
   }
 }
 
 // Trim the vector before sending it to the browser process to ensure we
 // don't send too much data through the IPC.
 void TrimStringVectorForIPC(std::vector<base::string16>* strings) {
   // Limit the size of the vector.
   if (strings->size() > kMaxListSize)
@@ skipping 307 matching lines @@
 
 void AutofillAgent::DoAcceptDataListSuggestion(
     const base::string16& suggested_value) {
   WebInputElement* input_element = toWebInputElement(&element_);
   DCHECK(input_element);
   base::string16 new_value = suggested_value;
   // If this element takes multiple values then replace the last part with
   // the suggestion.
   if (input_element->isMultiple() && input_element->isEmailField()) {
     std::vector<base::string16> parts = base::SplitString(
-        base::StringPiece16(input_element->editingValue()),
-        base::ASCIIToUTF16(","), base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+        input_element->editingValue().utf16(), base::ASCIIToUTF16(","),
+        base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     if (parts.size() == 0)
       parts.push_back(base::string16());
 
     base::string16 last_part = parts.back();
     // We want to keep just the leading whitespace.
     for (size_t i = 0; i < last_part.size(); ++i) {
       if (!base::IsUnicodeWhitespace(last_part[i])) {
         last_part = last_part.substr(0, i);
         break;
       }
@@ skipping 81 matching lines @@
 
 void AutofillAgent::FillPasswordSuggestion(const base::string16& username,
                                            const base::string16& password) {
   bool handled =
       password_autofill_agent_->FillSuggestion(element_, username, password);
   DCHECK(handled);
 }
 
 void AutofillAgent::PreviewPasswordSuggestion(const base::string16& username,
                                               const base::string16& password) {
-  bool handled =
-      password_autofill_agent_->PreviewSuggestion(element_, username, password);
+  bool handled = password_autofill_agent_->PreviewSuggestion(
+      element_, blink::WebString::fromUTF16(username),
+      blink::WebString::fromUTF16(password));
   DCHECK(handled);
 }
 
 void AutofillAgent::ShowInitialPasswordAccountSuggestions(
     int32_t key,
     const PasswordFormFillData& form_data) {
   std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (password_autofill_agent_->logging_state_active()) {
     logger.reset(new RendererSavePasswordProgressLogger(
@@ skipping 165 matching lines @@
 
   GetAutofillDriver()->SetDataList(data_list_values, data_list_labels);
   GetAutofillDriver()->QueryFormFieldAutofill(
       autofill_query_id_, form, field,
       render_frame()->GetRenderView()->ElementBoundsInWindow(element_));
 }
 
 void AutofillAgent::DoFillFieldWithValue(const base::string16& value,
                                          WebInputElement* node) {
   base::AutoReset<bool> auto_reset(&ignore_text_changes_, true);
-  node->setEditingValue(value.substr(0, node->maxLength()));
+  node->setEditingValue(
+      blink::WebString::fromUTF16(value.substr(0, node->maxLength())));
 }
 
 void AutofillAgent::DoPreviewFieldWithValue(const base::string16& value,
                                             WebInputElement* node) {
   was_query_node_autofilled_ = element_.isAutofilled();
-  node->setSuggestedValue(value.substr(0, node->maxLength()));
+  node->setSuggestedValue(
+      blink::WebString::fromUTF16(value.substr(0, node->maxLength())));
   node->setAutofilled(true);
-  form_util::PreviewSuggestion(node->suggestedValue(), node->value(), node);
+  form_util::PreviewSuggestion(node->suggestedValue().utf16(),
+                               node->value().utf16(), node);
 }
 
 void AutofillAgent::ProcessForms() {
   // Record timestamp of when the forms are first seen. This is used to
   // measure the overhead of the Autofill feature.
   base::TimeTicks forms_seen_timestamp = base::TimeTicks::Now();
 
   WebLocalFrame* frame = render_frame()->GetWebFrame();
   std::vector<FormData> forms = form_cache_.ExtractNewForms();
 
@@ skipping 67 matching lines @@
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   if (agent_)
     agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill