[Password Manager] Use XHR completion as a possible signal for form submission

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 830 matching lines @@
       username_element->isNull() ? element : *username_element,
       show_all && !element.isPasswordField(), element.isPasswordField());
 }
 
 bool PasswordAutofillAgent::OriginCanAccessPasswordManager(
     const blink::WebSecurityOrigin& origin) {
   return origin.canAccessPasswordManager();
 }
 
 void PasswordAutofillAgent::OnDynamicFormsSeen() {
+  //LOG(INFO) << this << "DynamicFormsSeen";
   SendPasswordForms(false /* only_visible */);
 }
 
+void PasswordAutofillAgent::OnFormElementsRemoved(
+    const blink::WebVector<blink::WebNode>& nodes) {
+  //LOG(INFO) << nodes.size();
+  std::set<blink::WebFormElement> form_elements;
+  for (size_t i = 0; i < nodes.size(); ++i) {
+    if (!nodes[i].isElementNode()) {
+      //LOG(INFO) << "early exit";
+      continue;
+    }
+
+    blink::WebElement element = nodes[i].toConst<blink::WebElement>();
+    if (!element.hasHTMLTagName("input")) {
+      //LOG(INFO) << "later exit";
+      continue;
+    }
+
+    blink::WebInputElement input_element = element.to<blink::WebInputElement>();
+    //LOG(INFO) << input_element.getAttribute("id").utf8();
+    if (!input_element.form().isNull()) {
+      //LOG(INFO) << input_element.form().name().utf8();
+      form_elements.insert(input_element.form());
+    } else {
+      //LOG(INFO) << "no form";
+    }
+  }
+  //LOG(INFO) << form_elements.size();
+
+  if (!provisionally_saved_form_ ||
+      provisionally_saved_form_->username_value.empty() ||
+      (provisionally_saved_form_->password_value.empty() &&
+       provisionally_saved_form_->new_password_value.empty())) {
+    //LOG(INFO) << "no provisionally saved form";
+    return;
+  }
+
+  //LOG(INFO) << provisionally_saved_form_->action;
+  for (std::set<blink::WebFormElement>::iterator it = form_elements.begin();
+       it != form_elements.end(); ++it) {
+    GURL action(GetCanonicalActionURL(*it));
+    //LOG(INFO) << action.spec();
+    if (action == provisionally_saved_form_->action) {
+      Send(new AutofillHostMsg_PasswordFormSubmitted(
+          routing_id(), *provisionally_saved_form_));
+      provisionally_saved_form_.reset();
+      return;
+    }
+  }
+}
+
 void PasswordAutofillAgent::FirstUserGestureObserved() {
   gatekeeper_.OnUserGesture();
 }
 
 void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
   scoped_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_SEND_PASSWORD_FORMS_METHOD);
     logger->LogBoolean(Logger::STRING_ONLY_VISIBLE, only_visible);
@@ skipping 121 matching lines @@
                               usernames_usage_, OTHER_POSSIBLE_USERNAMES_MAX);
     usernames_usage_ = NOTHING_TO_AUTOFILL;
   }
 }
 
 void PasswordAutofillAgent::DidStopLoading() {
   did_stop_loading_ = true;
 }
 
 void PasswordAutofillAgent::FrameDetached() {
+  /*  LOG(INFO) << this << "closing";
+  if (!render_frame()->GetWebFrame()->parent())
+    LOG(INFO) << "MainFrame";
+  if (ProvisionallySavedPasswordIsValid())
+  LOG(INFO) << "Password Valid";*/
+  if (render_frame()->GetWebFrame()->parent() &&
+      ProvisionallySavedPasswordIsValid()) {
+    //LOG(INFO) << "SENDING";
+    Send(new AutofillHostMsg_PasswordFormSubmitted(
+        routing_id(), *provisionally_saved_form_));
+    provisionally_saved_form_.reset();
+  }
   FrameClosing();
 }
 
 void PasswordAutofillAgent::WillSendSubmitEvent(
     const blink::WebFormElement& form) {
+  LOG(INFO) << "Will send submit event";
   // Forms submitted via XHR are not seen by WillSubmitForm if the default
   // onsubmit handler is overridden. Such submission first gets detected in
   // DidStartProvisionalLoad, which no longer knows about the particular form,
   // and uses the candidate stored in |provisionally_saved_form_|.
   //
   // User-typed password will get stored to |provisionally_saved_form_| in
   // TextDidChangeInTextField. Autofilled or JavaScript-copied passwords need to
   // be saved here.
   //
   // Only non-empty passwords are saved here. Empty passwords were likely
@@ skipping 338 matching lines @@
   scoped_ptr<PasswordForm> password_form(
       CreatePasswordForm(form, &user_modified_elements_));
   if (!password_form || (restriction == RESTRICTION_NON_EMPTY_PASSWORD &&
                          password_form->password_value.empty() &&
                          password_form->new_password_value.empty())) {
     return;
   }
   provisionally_saved_form_ = password_form.Pass();
 }
 
+bool PasswordAutofillAgent::ProvisionallySavedPasswordIsValid() {
+  return provisionally_saved_form_ &&
+      !provisionally_saved_form_->username_value.empty() &&
+      (!provisionally_saved_form_->password_value.empty() ||
+       provisionally_saved_form_->new_password_value.empty());
+}
+
+void PasswordAutofillAgent::XHRSucceeded() {
+  blink::WebFrame* frame = render_frame()->GetWebFrame();
+  blink::WebVector<blink::WebFormElement> forms;
+  frame->document().forms(forms);
+
+  if (!provisionally_saved_form_ ||
+      provisionally_saved_form_->username_value.empty() ||
+      (provisionally_saved_form_->password_value.empty() &&
+       provisionally_saved_form_->new_password_value.empty()))
+    return;
+
+  bool matched = false;
+  std::vector<PasswordForm> password_forms;
+  for (size_t i = 0; i < forms.size(); ++i) {
+    const blink::WebFormElement& form = forms[i];
+    bool is_form_visible = IsWebNodeVisible(form);
+
+    // If requested, ignore non-rendered forms, e.g., those styled with
+    // display:none.
+    if (!is_form_visible) {
+      LOG(INFO) << "Form: " << form.action().utf8() << "is invisible";
+      continue;
+    }
+
+    scoped_ptr<PasswordForm> password_form(CreatePasswordForm(form, nullptr));
+    if (password_form.get()) {
+      password_forms.push_back(*password_form);
+      if (provisionally_saved_form_->username_element == password_form->username_element &&
+          (provisionally_saved_form_->password_element == password_form->password_element ||
+           provisionally_saved_form_->new_password_element == password_form->new_password_element)) {
+        matched = true;
+      }
+    }
+  }
+  LOG(INFO) << password_forms.size();
+  if (!matched)
+    LOG(INFO) << "Should Save";
+}
+
 // LegacyPasswordAutofillAgent -------------------------------------------------
 
 PasswordAutofillAgent::LegacyPasswordAutofillAgent::LegacyPasswordAutofillAgent(
     content::RenderView* render_view,
     PasswordAutofillAgent* agent)
     : content::RenderViewObserver(render_view), agent_(agent) {
 }
 
 PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     ~LegacyPasswordAutofillAgent() {
@@ skipping 10 matching lines @@
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::DidStopLoading() {
   agent_->DidStopLoading();
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 }  // namespace autofill