[Password Manager] Send a request to the password store if there is a password field on a page

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 581 matching lines @@
           continue;
         control_element.SetAttribute(
             blink::WebString::FromASCII(kDebugAttributeForFieldSignature),
             blink::WebString::FromUTF8(
                 base::Uint64ToString(CalculateFieldSignatureForField(field))));
       }
     }
   }
 }
 
+// Returns true iff there is a password field in |frame|.
+bool HasPasswordField(const blink::WebLocalFrame& frame) {
+  CR_DEFINE_STATIC_LOCAL(blink::WebString, kPassword, ("password"));
+
+  const blink::WebElementCollection elements = frame.GetDocument().All();
+  for (blink::WebElement element = elements.FirstItem(); !element.IsNull();
+       element = elements.NextItem()) {
+    if (element.IsFormControlElement()) {
+      const blink::WebFormControlElement& control =
+          element.To<blink::WebFormControlElement>();
+      if (control.FormControlType() == kPassword)
+        return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, public:
 
 PasswordAutofillAgent::PasswordAutofillAgent(content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       logging_state_active_(false),
       was_username_autofilled_(false),
       was_password_autofilled_(false),
+      sent_request_to_store_(false),
       binding_(this) {
   // PasswordAutofillAgent is guaranteed to outlive |render_frame|.
   render_frame->GetInterfaceRegistry()->AddInterface(
       base::Bind(&PasswordAutofillAgent::BindRequest, base::Unretained(this)));
 }
 
 PasswordAutofillAgent::~PasswordAutofillAgent() {
 }
 
 void PasswordAutofillAgent::BindRequest(
@@ skipping 489 matching lines @@
                                                    &form_predictions_));
     if (password_form) {
       if (logger) {
         logger->LogPasswordForm(Logger::STRING_FORM_IS_PASSWORD,
                                 *password_form);
       }
       password_forms.push_back(*password_form);
     }
   }
 
-  if (password_forms.empty() && !only_visible) {
-    // We need to send the PasswordFormsRendered message regardless of whether
-    // there are any forms visible, as this is also the code path that triggers
-    // showing the infobar.
-    return;
-  }
-
   if (only_visible) {
+    // Send the PasswordFormsRendered message regardless of whether
+    // |password_forms| is empty. The empty |password_forms| are a possible
+    // signal to the browser that a pending login attempt succeeded.
     blink::WebFrame* main_frame = render_frame()->GetWebFrame()->Top();
     bool did_stop_loading = !main_frame || !main_frame->IsLoading();
     GetPasswordManagerDriver()->PasswordFormsRendered(password_forms,
                                                       did_stop_loading);
   } else {
-    GetPasswordManagerDriver()->PasswordFormsParsed(password_forms);
+    // If there is a password field, but the list of password forms is empty for
+    // some reason, add a dummy form to the list. It will cause a request to the
+    // store. Therefore, saved passwords will be available for filling on click.
+    if (!sent_request_to_store_ && password_forms.empty() &&
+        HasPasswordField(*frame)) {
+      // Set everything that |FormDigest| needs.
+      password_forms.push_back(PasswordForm());
+      password_forms.back().scheme = PasswordForm::SCHEME_HTML;
+      password_forms.back().origin =
+          form_util::GetCanonicalOriginForDocument(frame->GetDocument());
+      GURL::Replacements rep;
+      rep.SetPathStr("");
+      password_forms.back().signon_realm =
+          password_forms.back().origin.ReplaceComponents(rep).spec();
+      sent_request_to_store_ = true;
+    }
+    if (!password_forms.empty())
+      GetPasswordManagerDriver()->PasswordFormsParsed(password_forms);
   }
 }
 
 void PasswordAutofillAgent::DidFinishDocumentLoad() {
   // The |frame| contents have been parsed, but not yet rendered.  Let the
   // PasswordManager know that forms are loaded, even though we can't yet tell
   // whether they're visible.
   form_util::ScopedLayoutPreventer layout_preventer;
   SendPasswordForms(false);
 }
@@ skipping 413 matching lines @@
   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();
   field_value_and_properties_map_.clear();
+  sent_request_to_store_ = false;
 }
 
 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());
@@ skipping 27 matching lines @@
 PasswordAutofillAgent::GetPasswordManagerDriver() {
   if (!password_manager_driver_) {
     render_frame()->GetRemoteInterfaces()->GetInterface(
         mojo::MakeRequest(&password_manager_driver_));
   }
 
   return password_manager_driver_;
 }
 
 }  // namespace autofill