Processing USERNAME reply from Autofill server in Password Manager

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 857 matching lines @@
   blink::WebFrame* frame = render_frame()->GetWebFrame();
   blink::WebVector<blink::WebFormElement> forms;
   frame->document().forms(forms);
 
   for (size_t i = 0; i < forms.size(); ++i) {
     const blink::WebFormElement& form = forms[i];
     if (!IsWebNodeVisible(form)) {
       continue;
     }
 
-    scoped_ptr<PasswordForm> password_form(
-        CreatePasswordForm(form, &nonscript_modified_values_));
+    scoped_ptr<PasswordForm> password_form(CreatePasswordForm(
+        form, &nonscript_modified_values_, &form_predictions_));
     if (password_form.get()) {
       if (provisionally_saved_form_->action == password_form->action) {
         // Form still exists, no save required.
         return;
       }
     }
   }
   Send(new AutofillHostMsg_InPageNavigation(routing_id(),
                                             *provisionally_saved_form_));
   provisionally_saved_form_.reset();
@@ skipping 47 matching lines @@
         LogHTMLForm(logger.get(), Logger::STRING_FORM_FOUND_ON_PAGE, form);
         logger->LogBoolean(Logger::STRING_FORM_IS_VISIBLE, is_form_visible);
       }
 
       // If requested, ignore non-rendered forms, e.g., those styled with
       // display:none.
       if (!is_form_visible)
         continue;
     }
 
-    scoped_ptr<PasswordForm> password_form(CreatePasswordForm(form, nullptr));
+    scoped_ptr<PasswordForm> password_form(
+        CreatePasswordForm(form, nullptr, &form_predictions_));
     if (password_form.get()) {
       if (logger) {
         logger->LogPasswordForm(Logger::STRING_FORM_IS_PASSWORD,
                                 *password_form);
       }
       password_forms.push_back(*password_form);
     }
   }
 
   if (password_forms.empty() && !only_visible) {
@@ skipping 10 matching lines @@
   } else {
     Send(new AutofillHostMsg_PasswordFormsParsed(routing_id(), password_forms));
   }
 }
 
 bool PasswordAutofillAgent::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PasswordAutofillAgent, message)
     IPC_MESSAGE_HANDLER(AutofillMsg_FillPasswordForm, OnFillPasswordForm)
     IPC_MESSAGE_HANDLER(AutofillMsg_SetLoggingState, OnSetLoggingState)
+    IPC_MESSAGE_HANDLER(AutofillMsg_AutofillUsernameDataReceived,
+                        OnAutofillUsernameDataReceived)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 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.
   SendPasswordForms(false);
@@ skipping 72 matching lines @@
 }
 
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
   scoped_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
 
-  scoped_ptr<PasswordForm> submitted_form = CreatePasswordForm(form, nullptr);
+  scoped_ptr<PasswordForm> submitted_form =
+      CreatePasswordForm(form, nullptr, &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);
@@ skipping 64 matching lines @@
       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];
         if (logger) {
           LogHTMLForm(logger.get(), Logger::STRING_FORM_FOUND_ON_PAGE,
                       form_element);
         }
-        scoped_ptr<PasswordForm> password_form(
-            CreatePasswordForm(form_element, &nonscript_modified_values_));
+        scoped_ptr<PasswordForm> password_form(CreatePasswordForm(
+            form_element, &nonscript_modified_values_, &form_predictions_));
         if (password_form.get() && !password_form->username_value.empty() &&
             FormContainsNonDefaultPasswordValue(*password_form, form_element)) {
           password_forms_found = true;
           if (logger) {
             logger->LogPasswordForm(Logger::STRING_PASSWORD_FORM_FOUND_ON_PAGE,
                                     *password_form);
           }
           Send(new AutofillHostMsg_PasswordFormSubmitted(routing_id(),
                                                          *password_form));
         }
@@ skipping 69 matching lines @@
     login_to_password_info_[username_element] = password_info;
     password_to_username_[password_element] = username_element;
     login_to_password_info_key_[username_element] = key;
   }
 }
 
 void PasswordAutofillAgent::OnSetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
+void PasswordAutofillAgent::OnAutofillUsernameDataReceived(
+    const std::map<autofill::FormData, autofill::FormFieldData>& predictions) {
+  form_predictions_ = predictions;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PasswordAutofillAgent, private:
 
 PasswordAutofillAgent::PasswordInfo::PasswordInfo()
     : backspace_pressed_last(false), password_was_edited_last(false) {
 }
 
 bool PasswordAutofillAgent::ShowSuggestionPopup(
     const PasswordFormFillData& fill_data,
     const blink::WebInputElement& user_input,
@@ skipping 130 matching lines @@
   }
   if (!password->suggestedValue().isEmpty()) {
       password->setSuggestedValue(blink::WebString());
       password->setAutofilled(was_password_autofilled_);
   }
 }
 
 void PasswordAutofillAgent::ProvisionallySavePassword(
     const blink::WebFormElement& form,
     ProvisionallySaveRestriction restriction) {
-  scoped_ptr<PasswordForm> password_form(
-      CreatePasswordForm(form, &nonscript_modified_values_));
+  scoped_ptr<PasswordForm> password_form(CreatePasswordForm(
+      form, &nonscript_modified_values_, &form_predictions_));
   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_ &&
@@ skipping 25 matching lines @@
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::DidStopLoading() {
   agent_->DidStopLoading();
 }
 
 void PasswordAutofillAgent::LegacyPasswordAutofillAgent::
     DidStartProvisionalLoad(blink::WebLocalFrame* navigated_frame) {
   agent_->LegacyDidStartProvisionalLoad(navigated_frame);
 }
 
 }  // namespace autofill