[Password Generation] Enable generation for dynamically created forms.

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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/autofill/content/common/autofill_messages.h"
@@ skipping 105 matching lines @@
   // document load finishes, so we need to clear previous states here before we
   // hear back from the browser. We only clear this state on main frame load
   // as we don't want subframe loads to clear state that we have received from
   // the main frame. Note that we assume there is only one account creation
   // form, but there could be multiple password forms in each frame.
   if (!frame->parent()) {
     not_blacklisted_password_form_origins_.clear();
     generation_enabled_forms_.clear();
     generation_element_.reset();
     possible_account_creation_form_.reset(new PasswordForm());
+    if (password_elements_.empty()) {

[vabr (Chromium), 2014/10/16 07:46:15]

If I understand correctly, this logs the event from the previous load, to avoid
logging both NO_SIGN_UP_DETECTED and SIGN_UP_DETECTED on pages with only
dynamically generated sign-up forms.
If that's the case, a code comment would be helpful to understand this. Also,
are we concerned about situations where the user does not navigate further
(e.g., closes the browser), and thus nothing is logged?

[Garrett Casto, 2014/10/16 19:14:06]

I think that happens rarely enough not to worry about. Plus we already have this
issue for the other stats, so at least in this case they shouldn't be skewed
with respect to each other.

+      password_generation::LogPasswordGenerationEvent(
+          password_generation::NO_SIGN_UP_DETECTED);
+    } else {
+      password_generation::LogPasswordGenerationEvent(
+          password_generation::SIGN_UP_DETECTED);
+    }
     password_elements_.clear();
     password_is_generated_ = false;
     if (password_edited_) {
       password_generation::LogPasswordGenerationEvent(
           password_generation::PASSWORD_EDITED);
     }
     password_edited_ = false;
 
     if (generation_popup_shown_) {
       password_generation::LogPasswordGenerationEvent(
           password_generation::GENERATION_POPUP_SHOWN);
     }
     generation_popup_shown_ = false;
 
     if (editing_popup_shown_) {
       password_generation::LogPasswordGenerationEvent(
           password_generation::EDITING_POPUP_SHOWN);
     }
     editing_popup_shown_ = false;
   }
 }
 
+void PasswordGenerationAgent::OnDynamicFormsSeen(blink::WebLocalFrame* frame) {
+  FindPossibleGenerationForm(frame);
+}
+
 void PasswordGenerationAgent::DidFinishLoad(blink::WebLocalFrame* frame) {
+  FindPossibleGenerationForm(frame);
+}
+
+void PasswordGenerationAgent::FindPossibleGenerationForm(
+    blink::WebLocalFrame* frame) {
   if (!enabled_)
     return;
 
   // We don't want to generate passwords if the browser won't store or sync
   // them.
   if (!ShouldAnalyzeDocument(frame->document()))
     return;
 
+  // If we have already found a signup form for this page, no need to continue.
+  if (!password_elements_.empty())
+    return;
+
   blink::WebVector<blink::WebFormElement> forms;
   frame->document().forms(forms);
   for (size_t i = 0; i < forms.size(); ++i) {
     if (forms[i].isNull())
       continue;
 
     // If we can't get a valid PasswordForm, we skip this form because the
     // the password won't get saved even if we generate it.
     scoped_ptr<PasswordForm> password_form(
         CreatePasswordForm(forms[i]));
     if (!password_form.get()) {
       DVLOG(2) << "Skipping form as it would not be saved";
       continue;
     }
 
     // Do not generate password for GAIA since it is used to retrieve the
     // generated paswords.
     GURL realm(password_form->signon_realm);
     if (realm == GaiaUrls::GetInstance()->gaia_login_form_realm())
       continue;
 
     std::vector<blink::WebInputElement> passwords;
     if (GetAccountCreationPasswordFields(forms[i], &passwords)) {
       DVLOG(2) << "Account creation form detected";
-      password_generation::LogPasswordGenerationEvent(
-          password_generation::SIGN_UP_DETECTED);
       password_elements_ = passwords;
       possible_account_creation_form_.swap(password_form);
       DetermineGenerationElement();
       // We assume that there is only one account creation field per URL.
       return;
     }
   }
-  password_generation::LogPasswordGenerationEvent(
-      password_generation::NO_SIGN_UP_DETECTED);
 }
 
 bool PasswordGenerationAgent::ShouldAnalyzeDocument(
     const blink::WebDocument& document) const {
   // Make sure that this security origin is allowed to use password manager.
   // Generating a password that can't be saved is a bad idea.
   blink::WebSecurityOrigin origin = document.securityOrigin();
   if (!origin.canAccessPasswordManager()) {
     DVLOG(1) << "No PasswordManager access";
     return false;
@@ skipping 178 matching lines @@
       *possible_account_creation_form_));
 
   editing_popup_shown_ = true;
 }
 
 void PasswordGenerationAgent::HidePopup() {
   Send(new AutofillHostMsg_HidePasswordGenerationPopup(routing_id()));
 }
 
 }  // namespace autofill