Use explicit WebString conversions in autofill

components/autofill/content/renderer/form_cache.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/form_cache.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 23 matching lines @@
 using blink::WebSelectElement;
 using blink::WebString;
 using blink::WebVector;
 
 namespace autofill {
 
 namespace {
 
 void LogDeprecationMessages(const WebFormControlElement& element) {
   std::string autocomplete_attribute =
-      base::UTF16ToUTF8(base::StringPiece16(
-          element.getAttribute("autocomplete")));
+      element.getAttribute("autocomplete").utf8();
 
   static const char* const deprecated[] = { "region", "locality" };
   for (const char* str : deprecated) {
     if (autocomplete_attribute.find(str) == std::string::npos)
       continue;
     std::string msg = std::string("autocomplete='") + str +
         "' is deprecated and will soon be ignored. See http://goo.gl/YjeSsW";
     WebConsoleMessage console_message = WebConsoleMessage(
-        WebConsoleMessage::LevelWarning,
-        WebString(base::ASCIIToUTF16(msg)));
+        WebConsoleMessage::LevelWarning, WebString::fromASCII(msg));
     element.document().frame()->addMessageToConsole(console_message);
   }
 }
 
 // Determines whether the form is interesting enough to send to the browser
 // for further operations.
 bool IsFormInteresting(const FormData& form, size_t num_editable_elements) {
   if (form.fields.empty())
     return false;
 
@@ skipping 139 matching lines @@
 
     // Don't clear field that was not autofilled
     if (!control_element.isAutofilled())
       continue;
 
     control_element.setAutofilled(false);
 
     WebInputElement* input_element = toWebInputElement(&control_element);
     if (form_util::IsTextInput(input_element) ||
         form_util::IsMonthInput(input_element)) {
-      input_element->setValue(base::string16(), true);
+      input_element->setValue(blink::WebString(), true);
 
       // Clearing the value in the focused node (above) can cause selection
       // to be lost. We force selection range to restore the text cursor.
       if (element == *input_element) {
         int length = input_element->value().length();
         input_element->setSelectionRange(length, length);
       }
     } else if (form_util::IsTextAreaElement(control_element)) {
-      control_element.setValue(base::string16(), true);
+      control_element.setValue(blink::WebString(), true);
     } else if (form_util::IsSelectElement(control_element)) {
       WebSelectElement select_element = control_element.to<WebSelectElement>();
 
       std::map<const WebSelectElement, base::string16>::const_iterator
           initial_value_iter = initial_select_values_.find(select_element);
       if (initial_value_iter != initial_select_values_.end() &&
-          select_element.value() != initial_value_iter->second) {
-        select_element.setValue(initial_value_iter->second, true);
+          select_element.value().utf16() != initial_value_iter->second) {
+        select_element.setValue(
+            blink::WebString::fromUTF16(initial_value_iter->second), true);
       }
     } else {
       WebInputElement input_element = control_element.to<WebInputElement>();
       DCHECK(form_util::IsCheckableElement(&input_element));
       std::map<const WebInputElement, bool>::const_iterator it =
           initial_checked_state_.find(input_element);
       if (it != initial_checked_state_.end() &&
           input_element.isChecked() != it->second) {
         input_element.setChecked(it->second, true);
       }
@@ skipping 51 matching lines @@
   if (control_elements.size() != form.fields.size()) {
     // Keep things simple.  Don't show predictions for forms that were modified
     // between page load and the server's response to our query.
     return false;
   }
 
   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebFormControlElement& element = control_elements[i];
 
     const FormFieldData& field_data = form.data.fields[i];
-    if (base::string16(element.nameForAutofill()) != field_data.name) {
+    if (element.nameForAutofill().utf16() != field_data.name) {
       // Keep things simple.  Don't show predictions for elements whose names
       // were modified between page load and the server's response to our query.
       continue;
     }
 
     static const size_t kMaxLabelSize = 100;
     const base::string16 truncated_label = field_data.label.substr(
         0, std::min(field_data.label.length(), kMaxLabelSize));
 
     const FormFieldDataPredictions& field = form.fields[i];
     std::vector<base::string16> replacements;
 
     base::string16 overall_type = base::UTF8ToUTF16(field.overall_type);
 
     replacements.push_back(overall_type);
     replacements.push_back(base::UTF8ToUTF16(field.server_type));
     replacements.push_back(base::UTF8ToUTF16(field.heuristic_type));
     replacements.push_back(truncated_label);
     replacements.push_back(base::UTF8ToUTF16(field.parseable_name));
     replacements.push_back(base::UTF8ToUTF16(field.signature));
     replacements.push_back(base::UTF8ToUTF16(form.signature));
     const base::string16 title = l10n_util::GetStringFUTF16(
         IDS_AUTOFILL_SHOW_PREDICTIONS_TITLE, replacements, nullptr);
-    element.setAttribute("title", WebString(title));
+    element.setAttribute("title", WebString::fromUTF16(title));
 
-    element.setAttribute("autofill-prediction", WebString(overall_type));
+    element.setAttribute("autofill-prediction",
+                         WebString::fromUTF16(overall_type));
   }
 
   return true;
 }
 
 size_t FormCache::ScanFormControlElements(
     const std::vector<WebFormControlElement>& control_elements,
     bool log_deprecation_messages) {
   size_t num_editable_elements = 0;
   for (size_t i = 0; i < control_elements.size(); ++i) {
@@ skipping 16 matching lines @@
   return num_editable_elements;
 }
 
 void FormCache::SaveInitialValues(
     const std::vector<WebFormControlElement>& control_elements) {
   for (const WebFormControlElement& element : control_elements) {
     if (form_util::IsSelectElement(element)) {
       const WebSelectElement select_element =
           element.toConst<WebSelectElement>();
       initial_select_values_.insert(
-          std::make_pair(select_element, select_element.value()));
+          std::make_pair(select_element, select_element.value().utf16()));
     } else {
       const WebInputElement* input_element = toWebInputElement(&element);
       if (form_util::IsCheckableElement(input_element)) {
         initial_checked_state_.insert(
             std::make_pair(*input_element, input_element->isChecked()));
       }
     }
   }
 }
 
 }  // namespace autofill