Use explicit WebString conversions in autofill

components/autofill/content/renderer/password_generation_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_generation_agent.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 62 matching lines @@
 // fill the generated password. It assumes that |field_signature| describes the
 // field where Chrome shows the password generation prompt. It returns no more
 // than 2 elements.
 std::vector<blink::WebInputElement> FindPasswordElementsForGeneration(
     const std::vector<blink::WebInputElement>& all_password_elements,
     const FieldSignature field_signature) {
   auto iter = std::find_if(
       all_password_elements.begin(), all_password_elements.end(),
       [&field_signature](const blink::WebInputElement& input) {
         FieldSignature signature = CalculateFieldSignatureByNameAndType(
-            input.nameForAutofill(), input.formControlType().utf8());
+            input.nameForAutofill().utf16(), input.formControlType().utf8());
         return signature == field_signature;
       });
   std::vector<blink::WebInputElement> passwords;
 
   // We copy not more than 2 fields because occasionally there are forms where
   // the security question answers are put in password fields and we don't want
   // to fill those.
   for (; iter != all_password_elements.end() && passwords.size() < 2; ++iter)
     passwords.push_back(*iter);
   return passwords;
@@ skipping 204 matching lines @@
   not_blacklisted_password_form_origins_.push_back(form.origin);
   DetermineGenerationElement();
 }
 
 void PasswordGenerationAgent::GeneratedPasswordAccepted(
     const base::string16& password) {
   password_is_generated_ = true;
   password_generation::LogPasswordGenerationEvent(
       password_generation::PASSWORD_ACCEPTED);
   for (auto& password_element : generation_form_data_->password_elements) {
-    password_element.setValue(password, true /* sendEvents */);
+    password_element.setValue(blink::WebString::fromUTF16(password),
+                              true /* sendEvents */);
     // setValue() above may have resulted in JavaScript closing the frame.
     if (!render_frame())
       return;
     password_element.setAutofilled(true);
     // Needed to notify password_autofill_agent that the content of the field
     // has changed. Without this we will overwrite the generated
     // password with an Autofilled password when saving.
     // https://crbug.com/493455
     password_agent_->UpdateStateForTextChange(password_element);
     // Advance focus to the next input field. We assume password fields in
@@ skipping 17 matching lines @@
     password_form = CreatePasswordFormFromWebForm(generation_element_.form(),
                                                   nullptr, nullptr);
   } else {
     password_form = CreatePasswordFormFromUnownedInputElements(
         *render_frame()->GetWebFrame(), nullptr, nullptr);
   }
   if (password_form) {
     // TODO(kolos): when we are good in username detection, save username
     // as well.
     password_form->username_value = base::string16();
-    password_form->password_value = generation_element_.value();
+    password_form->password_value = generation_element_.value().utf16();
   }
 
   return password_form;
 }
 
 void PasswordGenerationAgent::FoundFormsEligibleForGeneration(
     const std::vector<PasswordFormGenerationData>& forms) {
   generation_enabled_forms_.insert(generation_enabled_forms_.end(),
                                    forms.begin(), forms.end());
   DetermineGenerationElement();
@@ skipping 151 matching lines @@
 
   return true;
 }
 
 void PasswordGenerationAgent::ShowGenerationPopup() {
   if (!render_frame())
     return;
   GetPasswordManagerClient()->ShowPasswordGenerationPopup(
       render_frame()->GetRenderView()->ElementBoundsInWindow(
           generation_element_),
-      generation_element_.maxLength(), generation_element_.nameForAutofill(),
-      is_manually_triggered_, *generation_form_data_->form);
+      generation_element_.maxLength(),
+      generation_element_.nameForAutofill().utf16(), is_manually_triggered_,
+      *generation_form_data_->form);
   generation_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::ShowEditingPopup() {
   if (!render_frame())
     return;
   GetPasswordManagerClient()->ShowPasswordEditingPopup(
       render_frame()->GetRenderView()->ElementBoundsInWindow(
           generation_element_),
       *generation_form_data_->form);
@@ skipping 27 matching lines @@
 
   if (!password_form)
     return;
 
   generation_element_ = last_focused_password_element_;
   std::vector<blink::WebInputElement> password_elements;
   GetAccountCreationPasswordFields(control_elements, &password_elements);
   password_elements = FindPasswordElementsForGeneration(
       password_elements,
       CalculateFieldSignatureByNameAndType(
-          last_focused_password_element_.nameForAutofill(),
+          last_focused_password_element_.nameForAutofill().utf16(),
           last_focused_password_element_.formControlType().utf8()));
   generation_form_data_.reset(new AccountCreationFormData(
       make_linked_ptr(password_form.release()), password_elements));
   is_manually_triggered_ = true;
   ShowGenerationPopup();
 }
 
 const mojom::PasswordManagerDriverPtr&
 PasswordGenerationAgent::GetPasswordManagerDriver() {
   DCHECK(password_agent_);
   return password_agent_->GetPasswordManagerDriver();
 }
 
 const mojom::PasswordManagerClientAssociatedPtr&
 PasswordGenerationAgent::GetPasswordManagerClient() {
   if (!password_manager_client_) {
     render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
         &password_manager_client_);
   }
 
   return password_manager_client_;
 }
 
 }  // namespace autofill