Autofill: Set requirements for number of recognized fields in an autofillable form

components/autofill/content/renderer/form_cache.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_cache.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
@@ skipping 57 matching lines @@
 }
 
 }  // namespace
 
 FormCache::FormCache(const WebFrame& frame) : frame_(frame) {
 }
 
 FormCache::~FormCache() {
 }
 
-std::vector<FormData> FormCache::ExtractNewForms() {
+std::vector<FormData> FormCache::ExtractNewForms(size_t* unowned_form_index) {
+  DCHECK(unowned_form_index);
+
+  *unowned_form_index = 0;

[Evan Stade, 2015/01/22 23:43:44]

I think it's cleaner if fakeness is an attribute of FormData

[Lei Zhang, 2015/01/22 23:58:13]

FormData gets serialized as part of a PasswordForm. Touching that opens a big
can of worms.

[Evan Stade, 2015/01/23 02:21:46]

yea but this is not sustainable either. Next time we want to add some flag or
other to FormData, are we going to just keep plumbing extra parameters around
everywhere a FormData is passed?

I don't know if the serialization/deserialization code has to change. Maybe
serialization/deserialization doesn't care about synthetic form tags?

   std::vector<FormData> forms;
   WebDocument document = frame_.document();
   if (document.isNull())
     return forms;
 
   WebVector<WebFormElement> web_forms;
   document.forms(web_forms);
 
   // Log an error message for deprecated attributes, but only the first time
   // the form is parsed.
@@ skipping 19 matching lines @@
                                   REQUIRE_NONE, extract_mask, &form, nullptr)) {
       continue;
     }
 
     num_fields_seen += form.fields.size();
     if (num_fields_seen > kMaxParseableFields)
       return forms;
 
     if (form.fields.size() >= kRequiredAutofillFields &&
         !ContainsKey(parsed_forms_, form)) {
+      ++(*unowned_form_index);
       forms.push_back(form);
       parsed_forms_.insert(form);
     }
   }
 
   // Look for more parseable fields outside of forms.
   std::vector<WebElement> fieldsets;
   std::vector<WebFormControlElement> control_elements =
       GetUnownedAutofillableFormFieldElements(document.all(), &fieldsets);
 
@@ skipping 10 matching lines @@
                                                  &synthetic_form, nullptr)) {
     return forms;
   }
 
   num_fields_seen += synthetic_form.fields.size();
   if (num_fields_seen > kMaxParseableFields)
     return forms;
 
   if (synthetic_form.fields.size() >= kRequiredAutofillFields &&
       !parsed_forms_.count(synthetic_form)) {
+    // |*unowned_form_index| is already at the right index here.
     forms.push_back(synthetic_form);
     parsed_forms_.insert(synthetic_form);
     synthetic_form_ = synthetic_form;
   }
   return forms;
 }
 
 void FormCache::Reset() {
   synthetic_form_ = FormData();
   parsed_forms_.clear();
@@ skipping 160 matching lines @@
             std::make_pair(input_element, input_element.isChecked()));
       } else {
         ++num_editable_elements;
       }
     }
   }
   return num_editable_elements;
 }
 
 }  // namespace autofill