Add a flag to ignore autocomplete="off" for Autofill.

components/autofill/content/renderer/form_autofill_util.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/form_autofill_util.h"
 
 #include <map>
 
 #include "base/command_line.h"
+#include "base/command_line.h"

[Ilya Sherman, 2014/10/21 01:19:11]

nit: Duplicate #include.

[Evan Stade, 2014/10/21 19:12:47]

Done.

 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/autofill_data_validation.h"
 #include "components/autofill/core/common/autofill_switches.h"
+#include "components/autofill/core/common/autofill_switches.h"

[Ilya Sherman, 2014/10/21 01:19:11]

Here too.

[Evan Stade, 2014/10/21 19:12:47]

Done.

 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/web_element_descriptor.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebElementCollection.h"
 #include "third_party/WebKit/public/web/WebExceptionCode.h"
 #include "third_party/WebKit/public/web/WebFormControlElement.h"
@@ skipping 31 matching lines @@
 enum FieldFilterMask {
   FILTER_NONE                       = 0,
   FILTER_DISABLED_ELEMENTS          = 1 << 0,
   FILTER_READONLY_ELEMENTS          = 1 << 1,
   FILTER_NON_FOCUSABLE_ELEMENTS     = 1 << 2,
   FILTER_ALL_NON_EDITIABLE_ELEMENTS = FILTER_DISABLED_ELEMENTS |
                                       FILTER_READONLY_ELEMENTS |
                                       FILTER_NON_FOCUSABLE_ELEMENTS,
 };
 
+RequirementsMask ExtractionRequirements() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kIgnoreAutocompleteOffForAutofill)
+             ? REQUIRE_NONE
+             : REQUIRE_AUTOCOMPLETE;
+}
+
 bool IsOptionElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kOption, ("option"));
   return element.hasHTMLTagName(kOption);
 }
 
 bool IsScriptElement(const WebElement& element) {
   CR_DEFINE_STATIC_LOCAL(WebString, kScript, ("script"));
   return element.hasHTMLTagName(kScript);
 }
 
@@ skipping 395 matching lines @@
 
 // For each autofillable field in |data| that matches a field in the |form|,
 // the |callback| is invoked with the corresponding |form| field data.
 void ForEachMatchingFormField(const WebFormElement& form_element,
                               const WebElement& initiating_element,
                               const FormData& data,
                               FieldFilterMask filters,
                               bool force_override,
                               Callback callback) {
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);
 
   if (control_elements.size() != data.fields.size()) {

[Ilya Sherman, 2014/10/21 01:19:11]

Hmm, did you also change which fields are extracted when passing fields to the
browser?  If not, how has this check not been consistently failing for ages?

It seems safer to me to limit the smarts of the renderer somewhat: Always
extract all the fields, and just be judicious about which fields to fill when
getting back data from the browser.

[Evan Stade, 2014/10/21 19:12:47]

good question. I think if there was a mismatch, it only occurred on fields where
autocomplete was off.  See this code:
https://code.google.com/p/chromium/codesearch#chromium/src/components/autofil...

If autocomplete was off, there might have been a mismatch, but we didn't do any
filling anyway.

That said, I don't quite know why I don't have to change that line in some way
now, but leaving it alone, I still can't get Autofill not to work.
yea, that's the path I would take if I were going to remove this flag (make it
the default behavior). But since it's still just a flag, I wanted to leave the
current code as much alone as possible. I think the RequirementsMask will just
go away if we make this default behavior.

[Ilya Sherman, 2014/10/21 23:58:18]

Hmm, that's odd.  Could you please do a bit of debugging to convince yourself
that the code is working as you'd expect?  What is data.fields.size() if you try
to autofill from the top element in the following form?  With the flag enabled,
does Autofilling this form from the top field work, and fill the confirm email
field as well?

<form>
  <input name="full_name">
  <input name="email">
  <input name="confirm_email" autocomplete="off">
  <input name="phone">
</form>

     // This case should be reachable only for pathological websites and tests,
     // which add or remove form fields while the user is interacting with the
     // Autofill popup.
     return;
   }
 
   // It's possible that the site has injected fields into the form after the
   // page has loaded, so we can't assert that the size of the cached control
   // elements is equal to the size of the fields in |form|.  Fortunately, the
   // one case in the wild where this happens, paypal.com signup form, the fields
@@ skipping 550 matching lines @@
                            &PreviewFormField);
 }
 
 bool ClearPreviewedFormWithElement(const WebFormControlElement& element,
                                    bool was_autofilled) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);

[Ilya Sherman, 2014/10/21 01:19:11]

We could probably just always pass REQUIRE_NONE here, given that we skip any
non-autofilled fields.

[Evan Stade, 2014/10/21 19:12:47]

ditto

   for (size_t i = 0; i < control_elements.size(); ++i) {
     // There might be unrelated elements in this form which have already been
     // auto-filled.  For example, the user might have already filled the address
     // part of a form and now be dealing with the credit card section.  We only
     // want to reset the auto-filled status for fields that were previewed.
     WebFormControlElement control_element = control_elements[i];
 
     // Only text input, textarea and select elements can be previewed.
     WebInputElement* input_element = toWebInputElement(&control_element);
     if (!IsTextInput(input_element) &&
@@ skipping 38 matching lines @@
 
   return true;
 }
 
 bool FormWithElementIsAutofilled(const WebInputElement& element) {
   WebFormElement form_element = element.form();
   if (form_element.isNull())
     return false;
 
   std::vector<WebFormControlElement> control_elements;
-  ExtractAutofillableElements(form_element, REQUIRE_AUTOCOMPLETE,
-                              &control_elements);
+  ExtractAutofillableElements(
+      form_element, ExtractionRequirements(), &control_elements);

[Ilya Sherman, 2014/10/21 01:19:11]

We could probably just always pass REQUIRE_NONE here, too.

[Evan Stade, 2014/10/21 19:12:47]

ditto

   for (size_t i = 0; i < control_elements.size(); ++i) {
     WebInputElement* input_element = toWebInputElement(&control_elements[i]);
     if (!IsAutofillableInputElement(input_element))
       continue;
 
     if (input_element->isAutofilled())
       return true;
   }
 
   return false;
@@ skipping 52 matching lines @@
 
 gfx::RectF GetScaledBoundingBox(float scale, WebFormControlElement* element) {
   gfx::Rect bounding_box(element->boundsInViewportSpace());
   return gfx::RectF(bounding_box.x() * scale,
                     bounding_box.y() * scale,
                     bounding_box.width() * scale,
                     bounding_box.height() * scale);
 }
 
 }  // namespace autofill