Use explicit WebString conversions in autofill

components/autofill/content/renderer/password_form_conversion_utils.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_form_conversion_utils.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 128 matching lines @@
                                           web_control_elements.end());
   synthetic_form->action = web_form.action();
   synthetic_form->document = web_form.document();
 }
 
 // Helper function that removes |username_element.value()| from the vector
 // |other_possible_usernames|, if the value presents in the vector.
 void ExcludeUsernameFromOtherUsernamesList(
     const WebInputElement& username_element,
     std::vector<base::string16>* other_possible_usernames) {
-  other_possible_usernames->erase(
-      std::remove(other_possible_usernames->begin(),
-                  other_possible_usernames->end(),
-                  username_element.value()),
-      other_possible_usernames->end());
+  other_possible_usernames->erase(std::remove(other_possible_usernames->begin(),
+                                              other_possible_usernames->end(),
+                                              username_element.value().utf16()),
+                                  other_possible_usernames->end());
 }
 
 // Helper to determine which password is the main (current) one, and which is
 // the new password (e.g., on a sign-up or change password form), if any. If the
 // new password is found and there is another password field with the same user
 // input, the function also sets |confirmation_password| to this field.
 bool LocateSpecificPasswords(std::vector<WebInputElement> passwords,
                              WebInputElement* current_password,
                              WebInputElement* new_password,
                              WebInputElement* confirmation_password) {
@@ skipping 117 matching lines @@
     return;
 
   std::vector<blink::WebFormControlElement> autofillable_elements =
       form_util::ExtractAutofillableElementsFromSet(form.control_elements);
   const PasswordFormFieldPredictionMap& field_predictions =
       predictions_it->second;
   for (const auto& prediction : field_predictions) {
     const FormFieldData& target_field = prediction.first;
     const PasswordFormFieldPredictionType& type = prediction.second;
     for (const auto& control_element : autofillable_elements)  {
-      if (control_element.nameForAutofill() == target_field.name) {
+      if (control_element.nameForAutofill().utf16() == target_field.name) {
         const WebInputElement* input_element =
             toWebInputElement(&control_element);
 
         // TODO(sebsg): Investigate why this guard is necessary, see
         // https://crbug.com/517490 for more details.
         if (input_element) {
           (*predicted_elements)[*input_element] = type;
         }
         break;
       }
@@ skipping 12 matching lines @@
     return CreateMatcher(instance, kPasswordSiteUrlRegex);
   }
 };
 
 base::LazyInstance<re2::RE2, PasswordSiteUrlLazyInstanceTraits>
     g_password_site_matcher = LAZY_INSTANCE_INITIALIZER;
 
 // Returns the |input_field| name if its non-empty; otherwise a |dummy_name|.
 base::string16 FieldName(const WebInputElement& input_field,
                          const char dummy_name[]) {
-  base::string16 field_name = input_field.nameForAutofill();
+  base::string16 field_name = input_field.nameForAutofill().utf16();
   return field_name.empty() ? base::ASCIIToUTF16(dummy_name) : field_name;
 }
 
 bool FieldHasNonscriptModifiedValue(
     const FieldValueAndPropertiesMaskMap* field_map,
     const blink::WebFormControlElement& element) {
   if (!field_map)
     return false;
   FieldValueAndPropertiesMaskMap::const_iterator it = field_map->find(element);
   return it != field_map->end() && it->second.first.get();
@@ skipping 141 matching lines @@
         if (password_form->username_marked_by_site) {
           // A second or subsequent element marked with autocomplete='username'.
           // This makes us less confident that we have understood the form. We
           // will stick to our choice that the first such element was the real
           // username, but will start collecting other_possible_usernames from
           // the extra elements marked with autocomplete='username'. Note that
           // unlike username_element, other_possible_usernames is used only for
           // autofill, not for form identification, and blank autofill entries
           // are not useful, so we do not collect empty strings.
           if (!input_element->value().isEmpty())
-            other_possible_usernames.push_back(input_element->value());
+            other_possible_usernames.push_back(input_element->value().utf16());
         } else {
           // The first element marked with autocomplete='username'. Take the
           // hint and treat it as the username (overruling the tentative choice
           // we might have made before). Furthermore, drop all other possible
           // usernames we have accrued so far: they come from fields not marked
           // with the autocomplete attribute, making them unlikely alternatives.
           username_element = *input_element;
           password_form->username_marked_by_site = true;
           other_possible_usernames.clear();
         }
       } else {
         if (password_form->username_marked_by_site) {
           // Having seen elements with autocomplete='username', elements without
           // this attribute are no longer interesting. No-op.
         } else {
           // No elements marked with autocomplete='username' so far whatsoever.
           // If we have not yet selected a username element even provisionally,
           // then remember this element for the case when the next field turns
           // out to be a password. Save a non-empty username as a possible
           // alternative, at least for now.
           if (username_element.isNull())
             latest_input_element = *input_element;
           if (!input_element->value().isEmpty())
-            other_possible_usernames.push_back(input_element->value());
+            other_possible_usernames.push_back(input_element->value().utf16());
         }
       }
     }
   }
 
   WebInputElement password;
   WebInputElement new_password;
   WebInputElement confirmation_password;
   if (!LocateSpecificPasswords(passwords, &password, &new_password,
                                &confirmation_password))
@@ skipping 18 matching lines @@
 
   // Let server predictions override the selection of the username field. This
   // allows instant adjusting without changing Chromium code.
   auto username_element_iterator = predicted_elements.find(username_element);
   if (map_has_username_prediction &&
       (username_element_iterator == predicted_elements.end() ||
        username_element_iterator->second != PREDICTION_USERNAME)) {
     ExcludeUsernameFromOtherUsernamesList(predicted_username_element,
                                           &other_possible_usernames);
     if (!username_element.isNull()) {
-      other_possible_usernames.push_back(username_element.value());
+      other_possible_usernames.push_back(username_element.value().utf16());
     }
     username_element = predicted_username_element;
     password_form->was_parsed_using_autofill_predictions = true;
   }
 
   if (!username_element.isNull()) {
     password_form->username_element =
         FieldName(username_element, "anonymous_username");
-    base::string16 username_value = username_element.value();
+    base::string16 username_value = username_element.value().utf16();
     if (FieldHasNonscriptModifiedValue(field_value_and_properties_map,
                                        username_element)) {
       base::string16 typed_username_value =
           *field_value_and_properties_map->at(username_element).first;
       if (!base::StartsWith(base::i18n::ToLower(username_value),
                             base::i18n::ToLower(typed_username_value),
                             base::CompareCase::SENSITIVE)) {
         // We check that |username_value| was not obtained by autofilling
         // |typed_username_value|. In case when it was, |typed_username_value|
         // is incomplete, so we should leave autofilled value.
         username_value = typed_username_value;
       }
     }
     password_form->username_value = username_value;
   }
 
   password_form->origin =
       form_util::GetCanonicalOriginForDocument(form.document);
   GURL::Replacements rep;
   rep.SetPathStr("");
   password_form->signon_realm =
       password_form->origin.ReplaceComponents(rep).spec();
   password_form->other_possible_usernames.swap(other_possible_usernames);
 
   if (!password.isNull()) {
     password_form->password_element = FieldName(password, "anonymous_password");
     blink::WebString password_value = password.value();
     if (FieldHasNonscriptModifiedValue(field_value_and_properties_map,
                                        password))
-      password_value = *field_value_and_properties_map->at(password).first;
-    password_form->password_value = password_value;
+      password_value = blink::WebString::fromUTF16(
+          *field_value_and_properties_map->at(password).first);
+    password_form->password_value = password_value.utf16();
   }
   if (!new_password.isNull()) {
     password_form->new_password_element =
         FieldName(new_password, "anonymous_new_password");
-    password_form->new_password_value = new_password.value();
+    password_form->new_password_value = new_password.value().utf16();
     password_form->new_password_value_is_default =
         new_password.getAttribute("value") == new_password.value();
     if (HasAutocompleteAttributeValue(new_password, kAutocompleteNewPassword))
       password_form->new_password_marked_by_site = true;
     if (!confirmation_password.isNull()) {
       password_form->confirmation_password_element =
           FieldName(confirmation_password, "anonymous_confirmation_password");
     }
   }
 
@@ skipping 109 matching lines @@
     return std::unique_ptr<PasswordForm>();
 
   // No actual action on the form, so use the the origin as the action.
   password_form->action = password_form->origin;
 
   return password_form;
 }
 
 bool HasAutocompleteAttributeValue(const blink::WebInputElement& element,
                                    const char* value_in_lowercase) {
-  base::string16 autocomplete_attribute(element.getAttribute("autocomplete"));
+  base::string16 autocomplete_attribute(
+      element.getAttribute("autocomplete").utf16());
   std::vector<std::string> tokens = LowercaseAndTokenizeAttributeString(
       base::UTF16ToUTF8(autocomplete_attribute));
 
   return base::ContainsValue(tokens, value_in_lowercase);
 }
 
 }  // namespace autofill