Use explicit WebString conversions in autofill

components/autofill/content/renderer/password_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/password_autofill_agent.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 149 matching lines @@
   bool found_input = false;
   bool is_password_field = IsPasswordField(field);
   bool does_password_field_has_ambigous_or_empty_name =
       ambiguous_or_empty_names && is_password_field;
   bool ambiguous_and_multiple_password_fields_with_autocomplete =
       does_password_field_has_ambigous_or_empty_name &&
       HasPasswordWithAutocompleteAttribute(control_elements);
   base::string16 field_name = FieldName(field, ambiguous_or_empty_names);
   for (const blink::WebFormControlElement& control_element : control_elements) {
     if (!ambiguous_or_empty_names &&
-        control_element.nameForAutofill() != field_name) {
+        control_element.nameForAutofill().utf16() != field_name) {
       continue;
     }
 
     if (!control_element.hasHTMLTagName("input"))
       continue;
 
     // Only fill saved passwords into password fields and usernames into text
     // fields.
     const blink::WebInputElement input_element =
         control_element.toConst<blink::WebInputElement>();
@@ skipping 211 matching lines @@
     RendererSavePasswordProgressLogger* logger) {
   if (logger)
     logger->LogMessage(Logger::STRING_FILL_USERNAME_AND_PASSWORD_METHOD);
 
   // Don't fill username if password can't be set.
   if (!IsElementAutocompletable(*password_element))
     return false;
 
   base::string16 current_username;
   if (!username_element->isNull()) {
-    current_username = username_element->value();
+    current_username = username_element->value().utf16();
   }
 
   // username and password will contain the match found if any.
   base::string16 username;
   base::string16 password;
 
   // Look for any suitable matches to current field text.
   if (DoUsernamesMatch(fill_data.username_field.value, current_username,
                        exact_username_match)) {
     username = fill_data.username_field.value;
@@ skipping 33 matching lines @@
   if (password.empty())
     return false;
 
   // TODO(tkent): Check maxlength and pattern for both username and password
   // fields.
 
   // Input matches the username, fill in required values.
   if (!username_element->isNull() &&
       IsElementAutocompletable(*username_element)) {
     // TODO(crbug.com/507714): Why not setSuggestedValue?
-    username_element->setValue(username, true);
+    username_element->setValue(blink::WebString::fromUTF16(username), true);
     UpdateFieldValueAndPropertiesMaskMap(*username_element, &username,
                                          FieldPropertiesFlags::AUTOFILLED,
                                          field_value_and_properties_map);
     username_element->setAutofilled(true);
     if (logger)
       logger->LogElementName(Logger::STRING_USERNAME_FILLED, *username_element);
     if (set_selection) {
       form_util::PreviewSuggestion(username, current_username,
                                    username_element);
     }
   } else if (current_username != username) {
     // If the username can't be filled and it doesn't match a saved password
     // as is, don't autofill a password.
     return false;
   }
 
   // Wait to fill in the password until a user gesture occurs. This is to make
   // sure that we do not fill in the DOM with a password until we believe the
   // user is intentionally interacting with the page.
-  password_element->setSuggestedValue(password);
+  password_element->setSuggestedValue(blink::WebString::fromUTF16(password));
   UpdateFieldValueAndPropertiesMaskMap(*password_element, &password,
                                        FieldPropertiesFlags::AUTOFILLED,
                                        field_value_and_properties_map);
   registration_callback.Run(password_element);
 
   password_element->setAutofilled(true);
   if (logger)
     logger->LogElementName(Logger::STRING_PASSWORD_FILLED, *password_element);
   return true;
 }
@@ skipping 54 matching lines @@
   // select to fill the password element, so the password element must be marked
   // as autofilled and the fill step should also be skipped if the user is not
   // in the "no highlighting" group.
   //
   // In all other cases, do nothing.
   bool form_has_fillable_username = !username_field_name.empty() &&
                                     IsElementAutocompletable(username_element);
 
   if (form_has_fillable_username && username_element.value().isEmpty()) {
     // TODO(tkent): Check maxlength and pattern.
-    username_element.setValue(fill_data.username_field.value, true);
+    username_element.setValue(
+        blink::WebString::fromUTF16(fill_data.username_field.value), true);
   }
 
   // Fill if we have an exact match for the username. Note that this sets
   // username to autofilled.
   return FillUserNameAndPassword(
       &username_element, &password_element, fill_data,
       true /* exact_username_match */, false /* set_selection */,
       field_value_and_properties_map, registration_callback, logger);
 }
 
@@ skipping 76 matching lines @@
   // Show the popup with the list of available usernames.
   return ShowSuggestions(element, false, false);
 }
 
 void PasswordAutofillAgent::UpdateStateForTextChange(
     const blink::WebInputElement& element) {
   // TODO(vabr): Get a mutable argument instead. http://crbug.com/397083
   blink::WebInputElement mutable_element = element;  // We need a non-const.
 
   if (element.isTextField()) {
-    const base::string16 element_value = element.value();
+    const base::string16 element_value = element.value().utf16();
     UpdateFieldValueAndPropertiesMaskMap(element, &element_value,
                                          FieldPropertiesFlags::USER_TYPED,
                                          &field_value_and_properties_map_);
   }
 
   blink::WebFrame* const element_frame = element.document().frame();
   // The element's frame might have been detached in the meantime (see
   // http://crbug.com/585363, comments 5 and 6), in which case frame() will
   // return null. This was hardly caused by form submission (unless the user
   // is supernaturally quick), so it is OK to drop the ball here.
@@ skipping 46 matching lines @@
       !IsElementAutocompletable(password_element)) {
     return false;
   }
 
   password_info->password_was_edited_last = false;
   if (element->isPasswordField()) {
     password_info->password_field_suggestion_was_accepted = true;
     password_info->password_field = password_element;
   } else if (!username_element.isNull() &&
              IsElementAutocompletable(username_element)) {
-    username_element.setValue(blink::WebString(username), true);
+    username_element.setValue(blink::WebString::fromUTF16(username), true);
     username_element.setAutofilled(true);
     UpdateFieldValueAndPropertiesMaskMap(username_element, &username,
                                          FieldPropertiesFlags::AUTOFILLED,
                                          &field_value_and_properties_map_);
   }
 
-  password_element.setValue(blink::WebString(password), true);
+  password_element.setValue(blink::WebString::fromUTF16(password), true);
   password_element.setAutofilled(true);
   UpdateFieldValueAndPropertiesMaskMap(password_element, &password,
                                        FieldPropertiesFlags::AUTOFILLED,
                                        &field_value_and_properties_map_);
 
   blink::WebInputElement mutable_filled_element = *element;
   mutable_filled_element.setSelectionRange(element->value().length(),
                                            element->value().length());
 
   return true;
@@ skipping 14 matching lines @@
 
   if (!FindPasswordInfoForElement(*element, &username_element,
                                   &password_element, &password_info) ||
       !IsElementAutocompletable(password_element)) {
     return false;
   }
 
   if (!element->isPasswordField() && !username_element.isNull() &&
       IsElementAutocompletable(username_element)) {
     if (username_query_prefix_.empty())
-      username_query_prefix_ = username_element.value();
+      username_query_prefix_ = username_element.value().utf16();
 
     was_username_autofilled_ = username_element.isAutofilled();
     username_element.setSuggestedValue(username);
     username_element.setAutofilled(true);
-    form_util::PreviewSuggestion(username_element.suggestedValue(),
+    form_util::PreviewSuggestion(username_element.suggestedValue().utf16(),
                                  username_query_prefix_, &username_element);
   }
   was_password_autofilled_ = password_element.isAutofilled();
   password_element.setSuggestedValue(password);
   password_element.setAutofilled(true);
 
   return true;
 }
 
 bool PasswordAutofillAgent::DidClearAutofillSelection(
@@ skipping 613 matching lines @@
     if (input.isPasswordField() && !input.form().isNull()) {
       if (!input.form().isNull()) {
         password_form = CreatePasswordFormFromWebForm(
             input.form(), &field_value_and_properties_map_, &form_predictions_);
       } else {
         password_form = CreatePasswordFormFromUnownedInputElements(
             *render_frame()->GetWebFrame(), &field_value_and_properties_map_,
             &form_predictions_);
         // Only try to use this form if |input| is one of the password elements
         // for |password_form|.
-        if (password_form->password_element != input.nameForAutofill() &&
-            password_form->new_password_element != input.nameForAutofill())
+        if (password_form->password_element !=
+                input.nameForAutofill().utf16() &&
+            password_form->new_password_element !=
+                input.nameForAutofill().utf16())
           password_form.reset();
       }
     }
   }
 
   if (!password_form)
     password_form.reset(new PasswordForm());
 
   callback.Run(*password_form);
 }
@@ skipping 24 matching lines @@
   FormData form;
   FormFieldData field;
   form_util::FindFormAndFieldForFormControlElement(user_input, &form, &field);
 
   int options = 0;
   if (show_all)
     options |= SHOW_ALL;
   if (show_on_password_field)
     options |= IS_PASSWORD_FIELD;
 
-  base::string16 username_string(
-      user_input.isPasswordField()
-          ? base::string16()
-          : static_cast<base::string16>(user_input.value()));
+  base::string16 username_string(user_input.isPasswordField()
+                                     ? base::string16()
+                                     : user_input.value().utf16());
 
   GetPasswordManagerDriver()->ShowPasswordSuggestions(
       password_info.key, field.text_direction, username_string, options,
       render_frame()->GetRenderView()->ElementBoundsInWindow(user_input));
   username_query_prefix_ = username_string;
   return CanShowSuggestion(password_info.fill_data, username_string, show_all);
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : web_input_to_password_info_) {
@@ skipping 46 matching lines @@
 PasswordAutofillAgent::GetPasswordManagerDriver() {
   if (!password_manager_driver_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&password_manager_driver_));
   }
 
   return password_manager_driver_;
 }
 
 }  // namespace autofill