Modifying Autofill Agent to use synthetic form (i.e., formless elements) when no form is present on…

components/autofill/content/renderer/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/autofill_agent.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
@@ skipping 226 matching lines @@
   if (frame->parent())
     return;  // Not a top-level navigation.
 
   if (is_same_page_navigation) {
     OnSamePageNavigationCompleted();
   } else {
     // Navigation to a new page or a page refresh.
     form_cache_.Reset();
     submitted_forms_.clear();
     last_interacted_form_.reset();
+    formless_elements_user_edited_.clear();
   }
 }
 
 void AutofillAgent::DidFinishDocumentLoad() {
   ProcessForms();
 }
 
 void AutofillAgent::WillSendSubmitEvent(const WebFormElement& form) {
   FireHostSubmitEvents(form, /*form_submitted=*/false);
 }
@@ skipping 144 matching lines @@
 void AutofillAgent::TextFieldDidChangeImpl(
     const WebFormControlElement& element) {
   // If the element isn't focused then the changes don't matter. This check is
   // required to properly handle IME interactions.
   if (!element.focused())
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
   if (input_element) {
     // Remember the last form the user interacted with.
-    if (!element.form().isNull())
+    if (element.form().isNull()) {
+      formless_elements_user_edited_.insert(element);
+    } else {
       last_interacted_form_ = element.form();
+    }
 
     // |password_autofill_agent_| keeps track of all text changes even if
     // it isn't displaying UI.
     password_autofill_agent_->UpdateStateForTextChange(*input_element);
 
     if (password_generation_agent_ &&
         password_generation_agent_->TextDidChangeInTextField(*input_element)) {
       is_popup_possibly_visible_ = true;
       return;
     }
@@ skipping 194 matching lines @@
     return;
 
   ShowSuggestionsOptions options;
   options.autofill_on_empty_values = true;
   options.show_full_suggestion_list = true;
   for (auto element : elements)
     ShowSuggestions(element, options);
 }
 
 void AutofillAgent::OnSamePageNavigationCompleted() {
-  if (!last_interacted_form_.isNull()) {
-    // Assume form submission only if the form is now gone, either invisible or
-    // removed from the DOM.
+  if (last_interacted_form_.isNull()) {
+    // If no last interacted form is available (i.e., there is no form tag),
+    // we check if all the elements the user has interacted with are gone,
+    // and reconstruct the inputs for submission.
+    if (formless_elements_user_edited_.size() == 0 ||
+        form_util::IsSomeControlElementVisible(formless_elements_user_edited_))
+      return;
+
+    WebDocument document = render_frame()->GetWebFrame()->document();
+
+    // Build up the FormData from the unowned elements. This logic mostly
+    // mirrors the construction of the synthetic form in form_cache.cc, but
+    // happens at submit-time so we can capture the modifications the user
+    // has made, and doesn't depend on form_cache's internal state.
+    std::vector<WebElement> fieldsets;

[Mathieu, 2016/06/21 18:04:07]

Would be great to extract this in a function in this file, or reuse the logic in
form_cache by extracting it to form_autofill_util.

[tmartino, 2016/06/21 23:38:30]

Done. It's not quite doing the same thing as form_cache--there are some failure
conditions there that we don't want to transfer and I think it would be messier
to try and hack around them. But most of the meaty logic is already encapsulated
in the two calls from form_util anyway.

+    std::vector<WebFormControlElement> control_elements =
+        form_util::GetUnownedAutofillableFormFieldElements(document.all(),
+                                                           &fieldsets);
+
+    if (control_elements.size() > form_util::kMaxParseableFields)
+      return;
+
+    FormData constructed_form;
+    const form_util::ExtractMask extract_mask =
+        static_cast<form_util::ExtractMask>(form_util::EXTRACT_VALUE |
+                                            form_util::EXTRACT_OPTIONS);
+
+    if (!form_util::UnownedCheckoutFormElementsAndFieldSetsToFormData(
+            fieldsets, control_elements, nullptr, document, extract_mask,
+            &constructed_form, nullptr))
+      return;
+
+    FireHostSubmitEvents(constructed_form, /*form_submitted=*/true);
+  } else {
+    // Otherwise, assume form submission only if the form is now gone, either
+    // invisible or removed from the DOM.
     if (form_util::AreFormContentsVisible(last_interacted_form_))
       return;
 
     FireHostSubmitEvents(last_interacted_form_, /*form_submitted=*/true);
-    last_interacted_form_.reset();
   }
-  // TODO(tmartino): Else, try using Synthetic Form from form_cache.
+
+  last_interacted_form_.reset();
+  formless_elements_user_edited_.clear();
 }
 
 void AutofillAgent::ShowSuggestions(const WebFormControlElement& element,
                                     const ShowSuggestionsOptions& options) {
   if (!element.isEnabled() || element.isReadOnly())
     return;
   if (!element.suggestedValue().isEmpty())
     return;
 
   const WebInputElement* input_element = toWebInputElement(&element);
@@ skipping 178 matching lines @@
 void AutofillAgent::LegacyAutofillAgent::OnDestruct() {
   // No-op. Don't delete |this|.
 }
 
 void AutofillAgent::LegacyAutofillAgent::FocusChangeComplete() {
   if (agent_)
     agent_->FocusChangeComplete();
 }
 
 }  // namespace autofill