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

components/autofill/core/browser/form_field.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/core/browser/form_field.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 22 matching lines @@
   // Ignore fields marked as presentational. See
   // http://www.w3.org/TR/wai-aria/roles#presentation
   return field->is_checkable ||
          field->role == FormFieldData::ROLE_ATTRIBUTE_PRESENTATION;
 }
 
 }  // namespace
 
 // static
 void FormField::ParseFormFields(const std::vector<AutofillField*>& fields,
+                                bool is_in_form_tag,
                                 ServerFieldTypeMap* map) {
   // Set up a working copy of the fields to be processed.
   std::vector<AutofillField*> remaining_fields(fields.size());
   std::copy(fields.begin(), fields.end(), remaining_fields.begin());
 
   remaining_fields.erase(
       std::remove_if(remaining_fields.begin(), remaining_fields.end(),
                      ShouldBeIgnored),
       remaining_fields.end());
 
+  ServerFieldTypeMap saved_map = *map;
+  size_t email_count = 0;
+  size_t count = 0;
+
   // Email pass.
-  ParseFormFieldsPass(EmailField::Parse, &remaining_fields, map);
+  email_count += ParseFormFieldsPass(EmailField::Parse, &remaining_fields, map);
+  count += email_count;
 
   // Phone pass.
-  ParseFormFieldsPass(PhoneField::Parse, &remaining_fields, map);
+  count += ParseFormFieldsPass(PhoneField::Parse, &remaining_fields, map);
 
   // Address pass.
-  ParseFormFieldsPass(AddressField::Parse, &remaining_fields, map);
+  count += ParseFormFieldsPass(AddressField::Parse, &remaining_fields, map);
 
   // Credit card pass.
-  ParseFormFieldsPass(CreditCardField::Parse, &remaining_fields, map);
+  count += ParseFormFieldsPass(CreditCardField::Parse, &remaining_fields, map);
 
   // Name pass.
-  ParseFormFieldsPass(NameField::Parse, &remaining_fields, map);
+  count += ParseFormFieldsPass(NameField::Parse, &remaining_fields, map);
+
+  // Do not autofill a form if there are less than 3 recognized fields.
+  // Otherwise it is very easy to have false positives. http://crbug.com/447332
+  // For <form> tags, make an exception for email fields, which are commonly the
+  // only recognized field on account registration sites.
+  size_t kThreshold = 3;
+  bool accept_parsing = (count >= kThreshold ||
+                         (is_in_form_tag && email_count > 0));
+  if (!accept_parsing)
+    *map = saved_map;
 }
 
 // static
 bool FormField::ParseField(AutofillScanner* scanner,
                            const base::string16& pattern,
                            AutofillField** match) {
   return ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT, match);
 }
 
 // static
@@ skipping 46 matching lines @@
   }
 
   return false;
 }
 
 // static
 bool FormField::Match(const AutofillField* field,
                       const base::string16& pattern,
                       int match_type) {
   if ((match_type & FormField::MATCH_LABEL) &&
-      autofill::MatchesPattern(field->label, pattern)) {
+      MatchesPattern(field->label, pattern)) {
     return true;
   }
 
   if ((match_type & FormField::MATCH_NAME) &&
-      autofill::MatchesPattern(field->name, pattern)) {
+      MatchesPattern(field->name, pattern)) {
     return true;
   }
 
   if ((match_type & FormField::MATCH_VALUE) &&
-      autofill::MatchesPattern(field->value, pattern)) {
+      MatchesPattern(field->value, pattern)) {
     return true;
   }
 
   return false;
 }
 
 // static
-void FormField::ParseFormFieldsPass(ParseFunction parse,
-                                    std::vector<AutofillField*>* fields,
-                                    ServerFieldTypeMap* map) {
+size_t FormField::ParseFormFieldsPass(ParseFunction parse,
+                                      std::vector<AutofillField*>* fields,
+                                      ServerFieldTypeMap* map) {
   // Store unmatched fields for further processing by the caller.
   std::vector<AutofillField*> remaining_fields;
 
+  size_t initial_field_count = map->size();
   AutofillScanner scanner(*fields);
   while (!scanner.IsEnd()) {
     scoped_ptr<FormField> form_field(parse(&scanner));
     if (!form_field) {
       remaining_fields.push_back(scanner.Cursor());
       scanner.Advance();
       continue;
     }
 
     // Add entries into the map for each field type found in |form_field|.
     bool ok = form_field->ClassifyField(map);
     DCHECK(ok);
   }
 
   std::swap(*fields, remaining_fields);
+
+  DCHECK_GE(map->size(), initial_field_count);
+  return map->size() - initial_field_count;

[Evan Stade, 2015/01/22 23:17:04]

this doesn't need to be part of ParseFormFieldsPass, as you can do it from
ParseFormFields

[Lei Zhang, 2015/01/22 23:32:04]

Done.

 }
 
 bool FormField::MatchesFormControlType(const std::string& type,
                                        int match_type) {
   if ((match_type & MATCH_TEXT) && type == "text")
     return true;
 
   if ((match_type & MATCH_EMAIL) && type == "email")
     return true;
 
   if ((match_type & MATCH_TELEPHONE) && type == "tel")
     return true;
 
   if ((match_type & MATCH_SELECT) && type == "select-one")
     return true;
 
   if ((match_type & MATCH_TEXT_AREA) && type == "textarea")
     return true;
 
   if ((match_type & MATCH_PASSWORD) && type == "password")
     return true;
 
   return false;
 }
 
 }  // namespace autofill