Add password form search using blink::WebNode reference comparison.

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 <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 106 matching lines @@
 // to true returns a dummy name instead.
 base::string16 FieldName(const FormFieldData& field,
                          bool ambiguous_or_empty_names) {
   return ambiguous_or_empty_names
              ? IsPasswordField(field) ? base::ASCIIToUTF16(kDummyPasswordField)
                                       : base::ASCIIToUTF16(kDummyUsernameField)
              : field.name;
 }
 
 bool IsUnownedPasswordFormVisible(blink::WebFrame* frame,
+                                  const blink::WebInputElement& input_element,
                                   const GURL& action,
                                   const GURL& origin,
                                   const FormData& form_data,
                                   const FormsPredictionsMap& form_predictions) {
+  if (!input_element.isNull() && form_util::IsWebNodeVisible(input_element))
+    return true;
+
   std::unique_ptr<PasswordForm> unowned_password_form(
       CreatePasswordFormFromUnownedInputElements(*frame, nullptr,
                                                  &form_predictions));
   if (!unowned_password_form)
     return false;
   std::vector<blink::WebFormControlElement> control_elements =
       form_util::GetUnownedAutofillableFormFieldElements(
           frame->document().all(), nullptr);
   if (!form_util::IsSomeControlElementVisible(control_elements))
     return false;
@@ skipping 562 matching lines @@
   // To honor the user having explicitly cleared the password, even an empty
   // password will be saved here.
   std::unique_ptr<PasswordForm> password_form;
   if (element.form().isNull()) {
     password_form = CreatePasswordFormFromUnownedInputElements(
         *element_frame, &field_value_and_properties_map_, &form_predictions_);
   } else {
     password_form = CreatePasswordFormFromWebForm(
         element.form(), &field_value_and_properties_map_, &form_predictions_);
   }
-  ProvisionallySavePassword(std::move(password_form), RESTRICTION_NONE);
+  ProvisionallySavePassword(std::move(password_form), element.form(), element,
+                            RESTRICTION_NONE);
 
   if (element.isPasswordField()) {
     PasswordToLoginMap::iterator iter = password_to_username_.find(element);
     if (iter != password_to_username_.end()) {
       web_input_to_password_info_[iter->second].password_was_edited_last = true;
       // Note that the suggested value of |mutable_element| was reset when its
       // value changed.
       mutable_element.setAutofilled(false);
     }
   }
@@ skipping 261 matching lines @@
 
 void PasswordAutofillAgent::OnDynamicFormsSeen() {
   SendPasswordForms(false /* only_visible */);
 }
 
 void PasswordAutofillAgent::AJAXSucceeded() {
   OnSamePageNavigationCompleted();
 }
 
 void PasswordAutofillAgent::OnSamePageNavigationCompleted() {
-  if (!ProvisionallySavedPasswordIsValid())
+  if (!provisionally_saved_form_.IsPasswordValid())
     return;
 
   // Prompt to save only if the form is now gone, either invisible or
   // removed from the DOM.
   blink::WebFrame* frame = render_frame()->GetWebFrame();
-  if (form_util::IsFormVisible(frame, provisionally_saved_form_->action,
-                               provisionally_saved_form_->origin,
-                               provisionally_saved_form_->form_data) ||
-      IsUnownedPasswordFormVisible(frame, provisionally_saved_form_->action,
-                                   provisionally_saved_form_->origin,
-                                   provisionally_saved_form_->form_data,
-                                   form_predictions_)) {
+  const auto& password_form = provisionally_saved_form_.password_form();
+  if (form_util::IsFormVisible(frame, provisionally_saved_form_.form_element(),
+                               password_form.action, password_form.origin,
+                               password_form.form_data) ||
+      (provisionally_saved_form_.form_element().isNull() &&
+       IsUnownedPasswordFormVisible(
+           frame, provisionally_saved_form_.input_element(),
+           password_form.action, password_form.origin, password_form.form_data,
+           form_predictions_))) {
     return;
   }
 
-  GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
-  provisionally_saved_form_.reset();
+  GetPasswordManagerDriver()->InPageNavigation(password_form);
+  provisionally_saved_form_.Reset();
 }
 
 void PasswordAutofillAgent::FirstUserGestureObserved() {
   gatekeeper_.OnUserGesture();
 }
 
 void PasswordAutofillAgent::SendPasswordForms(bool only_visible) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(
@@ skipping 128 matching lines @@
   if (is_same_page_navigation) {
     OnSamePageNavigationCompleted();
   }
 }
 
 void PasswordAutofillAgent::FrameDetached() {
   // If a sub frame has been destroyed while the user was entering information
   // into a password form, try to save the data. See https://crbug.com/450806
   // for examples of sites that perform login using this technique.
   if (render_frame()->GetWebFrame()->parent() &&
-      ProvisionallySavedPasswordIsValid()) {
-    GetPasswordManagerDriver()->InPageNavigation(*provisionally_saved_form_);
+      provisionally_saved_form_.IsPasswordValid()) {
+    GetPasswordManagerDriver()->InPageNavigation(
+        provisionally_saved_form_.password_form());
   }
   FrameClosing();
 }
 
 void PasswordAutofillAgent::WillSendSubmitEvent(
     const blink::WebFormElement& form) {
   // 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
   // cleared by some scripts (http://crbug.com/28910, http://crbug.com/391693).
   // Had the user cleared the password, |provisionally_saved_form_| would
   // already have been updated in TextDidChangeInTextField.
   std::unique_ptr<PasswordForm> password_form = CreatePasswordFormFromWebForm(
       form, &field_value_and_properties_map_, &form_predictions_);
-  ProvisionallySavePassword(std::move(password_form),
+  ProvisionallySavePassword(std::move(password_form), form,
+                            blink::WebInputElement(),
                             RESTRICTION_NON_EMPTY_PASSWORD);
 }
 
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(
         GetPasswordManagerDriver().get()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
 
   std::unique_ptr<PasswordForm> submitted_form = CreatePasswordFormFromWebForm(
       form, &field_value_and_properties_map_, &form_predictions_);
 
   // If there is a provisionally saved password, copy over the previous
   // password value so we get the user's typed password, not the value that
   // may have been transformed for submit.
   // TODO(gcasto): Do we need to have this action equality check? Is it trying
   // to prevent accidentally copying over passwords from a different form?
   if (submitted_form) {
     if (logger) {
       logger->LogPasswordForm(Logger::STRING_CREATED_PASSWORD_FORM,
                               *submitted_form);
     }
-    if (provisionally_saved_form_ &&
-        submitted_form->action == provisionally_saved_form_->action) {
+    if (provisionally_saved_form_.IsSet() &&
+        submitted_form->action ==
+            provisionally_saved_form_.password_form().action) {
       if (logger)
         logger->LogMessage(Logger::STRING_SUBMITTED_PASSWORD_REPLACED);
-      submitted_form->password_value =
-          provisionally_saved_form_->password_value;
-      submitted_form->new_password_value =
-          provisionally_saved_form_->new_password_value;
-      submitted_form->username_value =
-          provisionally_saved_form_->username_value;
+      const auto& saved_form = provisionally_saved_form_.password_form();
+      submitted_form->password_value = saved_form.password_value;
+      submitted_form->new_password_value = saved_form.new_password_value;
+      submitted_form->username_value = saved_form.username_value;
     }
 
     // Some observers depend on sending this information now instead of when
     // the frame starts loading. If there are redirects that cause a new
     // RenderView to be instantiated (such as redirects to the WebStore)
     // we will never get to finish the load.
     GetPasswordManagerDriver()->PasswordFormSubmitted(*submitted_form);
-    provisionally_saved_form_.reset();
+    provisionally_saved_form_.Reset();
   } else if (logger) {
     logger->LogMessage(Logger::STRING_FORM_IS_NOT_PASSWORD);
   }
 }
 
 void PasswordAutofillAgent::OnDestruct() {
   binding_.Close();
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
@@ skipping 18 matching lines @@
   // history navigation). We don't want to trigger saving in these cases.
   content::DocumentState* document_state =
       content::DocumentState::FromDataSource(data_source);
   content::NavigationState* navigation_state =
       document_state->navigation_state();
   ui::PageTransition type = navigation_state->GetTransitionType();
   if (ui::PageTransitionIsWebTriggerable(type) &&
       ui::PageTransitionIsNewNavigation(type) &&
       !blink::WebUserGestureIndicator::isProcessingUserGesture()) {
     // If onsubmit has been called, try and save that form.
-    if (provisionally_saved_form_) {
+    if (provisionally_saved_form_.IsSet()) {
       if (logger) {
         logger->LogPasswordForm(
             Logger::STRING_PROVISIONALLY_SAVED_FORM_FOR_FRAME,
-            *provisionally_saved_form_);
+            provisionally_saved_form_.password_form());
       }
       GetPasswordManagerDriver()->PasswordFormSubmitted(
-          *provisionally_saved_form_);
-      provisionally_saved_form_.reset();
+          provisionally_saved_form_.password_form());
+      provisionally_saved_form_.Reset();
     } else {
       std::vector<std::unique_ptr<PasswordForm>> possible_submitted_forms;
       // Loop through the forms on the page looking for one that has been
       // filled out. If one exists, try and save the credentials.
       blink::WebVector<blink::WebFormElement> forms;
       render_frame()->GetWebFrame()->document().forms(forms);
 
       bool password_forms_found = false;
       for (size_t i = 0; i < forms.size(); ++i) {
         blink::WebFormElement form_element = forms[i];
@@ skipping 260 matching lines @@
       render_frame()->GetRenderView()->ElementBoundsInWindow(user_input));
   username_query_prefix_ = username_string;
   return CanShowSuggestion(password_info.fill_data, username_string, show_all);
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : web_input_to_password_info_) {
     password_to_username_.erase(iter.second.password_field);
   }
   web_input_to_password_info_.clear();
-  provisionally_saved_form_.reset();
+  provisionally_saved_form_.Reset();
   field_value_and_properties_map_.clear();
 }
 
 void PasswordAutofillAgent::ClearPreview(
     blink::WebInputElement* username,
     blink::WebInputElement* password) {
   if (!username->isNull() && !username->suggestedValue().isEmpty()) {
     username->setSuggestedValue(blink::WebString());
     username->setAutofilled(was_username_autofilled_);
     username->setSelectionRange(username_query_prefix_.length(),
                                 username->value().length());
   }
   if (!password->suggestedValue().isEmpty()) {
       password->setSuggestedValue(blink::WebString());
       password->setAutofilled(was_password_autofilled_);
   }
 }
 
 void PasswordAutofillAgent::ProvisionallySavePassword(
     std::unique_ptr<PasswordForm> password_form,
+    const blink::WebFormElement& form,
+    const blink::WebInputElement& input,
     ProvisionallySaveRestriction restriction) {
   if (!password_form || (restriction == RESTRICTION_NON_EMPTY_PASSWORD &&
                          password_form->password_value.empty() &&
                          password_form->new_password_value.empty())) {
     return;
   }
-  provisionally_saved_form_ = std::move(password_form);
-}
-
-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());
+  DCHECK(password_form && (!form.isNull() || !input.isNull()));
+  provisionally_saved_form_.Set(std::move(password_form), form, input);
 }
 
 const mojom::AutofillDriverPtr& PasswordAutofillAgent::GetAutofillDriver() {
   DCHECK(autofill_agent_);
   return autofill_agent_->GetAutofillDriver();
 }
 
 const mojom::PasswordManagerDriverPtr&
 PasswordAutofillAgent::GetPasswordManagerDriver() {
   if (!password_manager_driver_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&password_manager_driver_));
   }
 
   return password_manager_driver_;
 }
 
 }  // namespace autofill