[Password Generation] Process CONFIRMATION_PASSWORD votes on the client side

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 57 matching lines @@
   }
   return nullptr;
 }
 
 // This function returns a vector of password fields into which Chrome should
 // 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().utf16(), input.formControlType().utf8());
-        return signature == field_signature;
-      });
+    const PasswordFormGenerationData& generation_data) {
+  auto generation_field_iter = all_password_elements.end();
+  auto confirmation_field_iter = all_password_elements.end();
+  for (auto iter = all_password_elements.begin();
+       iter != all_password_elements.end(); ++iter) {
+    const blink::WebInputElement& input = *iter;
+    FieldSignature signature = CalculateFieldSignatureByNameAndType(
+        input.nameForAutofill().utf16(), input.formControlType().utf8());
+    if (signature == generation_data.field_signature)
+      generation_field_iter = iter;
+    else if (generation_data.confirmation_field_signature.has_value() &&

[dcheng, 2017/03/07 21:42:26]

Nit:

else if (generation_data.confirmation_field_signature &&
         signature == *generation_data.confirmation_field_signature)

[kolos1, 2017/03/08 07:43:50]

Done.

+             signature == generation_data.confirmation_field_signature.value())
+      confirmation_field_iter = iter;
+  }
+
   std::vector<blink::WebInputElement> passwords;
+  if (generation_field_iter != all_password_elements.end()) {
+    passwords.push_back(*generation_field_iter);
 
-  // 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);
+    if (confirmation_field_iter == all_password_elements.end())
+      confirmation_field_iter = generation_field_iter + 1;
+    if (confirmation_field_iter != all_password_elements.end())
+      passwords.push_back(*confirmation_field_iter);
+  }
   return passwords;
 }
 
 void CopyElementValueToOtherInputElements(
     const blink::WebInputElement* element,
     std::vector<blink::WebInputElement>* elements) {
   for (blink::WebInputElement& it : *elements) {
     if (*element != it) {
       it.setValue(element->value(), true /* sendEvents */);
     }
@@ skipping 294 matching lines @@
           VLOG(2)
               << "Have not received confirmation from Autofill that form is "
               << "used for account creation";
           continue;
         }
       }
     }
 
     VLOG(2) << "Password generation eligible form found";
     std::vector<blink::WebInputElement> password_elements =
-        generation_data ? FindPasswordElementsForGeneration(
-                              possible_form_data.password_elements,
-                              generation_data->field_signature)
-                        : possible_form_data.password_elements;
+        generation_data
+            ? FindPasswordElementsForGeneration(
+                  possible_form_data.password_elements, *generation_data)
+            : possible_form_data.password_elements;
     if (password_elements.empty()) {
       // It might be if JavaScript changes field names.
       VLOG(2) << "Fields for generation are not found";
       return;
     }
     generation_form_data_.reset(new AccountCreationFormData(
         possible_form_data.form, std::move(password_elements)));
     generation_element_ = generation_form_data_->password_elements[0];
     generation_element_.setAttribute("aria-autocomplete", "list");
     password_generation::LogPasswordGenerationEvent(
@@ skipping 137 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().utf16(),
-          last_focused_password_element_.formControlType().utf8()));
+      PasswordFormGenerationData(
+          0, /* form_signature */
+          CalculateFieldSignatureByNameAndType(
+              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