Change heuristic regex and order to match grabber-continental.

chrome/browser/autofill/form_field.cc

 // Copyright (c) 2011 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 "chrome/browser/autofill/form_field.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 127 matching lines @@
                               ecml_fields[i].length_) == 0) {
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
+bool isTextInput(const string16& form_control_type) {
+  const char* text_types[] = {"text", "email", "search", "tel", "url",
+      "number", "date", "datetime", "datetime-local", "month", "week",
+      "time", "range"};
+  bool is_text_input = false;
+  for (size_t i = 0; i < sizeof(text_types)/sizeof(const char*); ++i)
+    is_text_input |= form_control_type == ASCIIToUTF16(text_types[i]);
+  return is_text_input;
+}
+
 }  // namespace
 
 // static
 void FormField::ParseFormFields(const std::vector<AutofillField*>& fields,
                                 FieldTypeMap* field_type_map) {
   // First, check if there is at least one form field with an ECML name.
   // If there is, then we will match an element only if it is in the standard.
   bool is_ecml = HasECMLField(fields);
 
   // Parse fields.
   AutofillScanner scanner(fields);
   while (!scanner.IsEnd()) {
     scoped_ptr<FormField> form_field(
         FormField::ParseFormField(&scanner, is_ecml));
     if (!form_field.get()) {
       scanner.Advance();
       continue;
     }
 
     bool ok = form_field->GetFieldInfo(field_type_map);
     DCHECK(ok);
   }
 }
 
 // static
+bool FormField::MatchWithType(const AutofillField* field,
+                              const string16& pattern,
+                              int match_type) {
+  if ((match_type & MATCH_LABEL) && MatchLabel(field, pattern))
+    return true;
+
+  // For now, we apply the same pattern to the field's label and the field's
+  // name.  Matching the name is a bit of a long shot for many patterns, but
+  // it generally doesn't hurt to try.
+  if ((match_type & MATCH_NAME) && MatchName(field, pattern))
+    return true;
+
+  return false;
+}
+
+// static
 bool FormField::Match(const AutofillField* field,
                       const string16& pattern,
                       bool match_label_only) {
-  if (MatchLabel(field, pattern))
-    return true;
-
-  // For now, we apply the same pattern to the field's label and the field's
-  // name.  Matching the name is a bit of a long shot for many patterns, but
-  // it generally doesn't hurt to try.
-  if (!match_label_only && MatchName(field, pattern))
-    return true;
-
-  return false;
+  return MatchWithType(field, pattern,
+                       MATCH_NAME | (match_label_only ? 0 : MATCH_LABEL));
 }
 
 // static
 bool FormField::MatchName(const AutofillField* field, const string16& pattern) {
   // TODO(jhawkins): Remove StringToLowerASCII.  WebRegularExpression needs to
   // be fixed to take WebTextCaseInsensitive into account.
   WebKit::WebRegularExpression re(WebKit::WebString(pattern),
                                   WebKit::WebTextCaseInsensitive);
   bool match = re.match(
       WebKit::WebString(StringToLowerASCII(field->name))) != -1;
@@ skipping 32 matching lines @@
   field = CreditCardField::Parse(scanner, is_ecml);
   if (field)
     return field;
 
   // We search for a |NameField| last since it matches the word "name", which is
   // relatively general.
   return NameField::Parse(scanner, is_ecml);
 }
 
 // static
-bool FormField::ParseText(AutofillScanner* scanner, const string16& pattern) {
-  const AutofillField* field;
-  return ParseText(scanner, pattern, &field);
-}
-
-// static
 bool FormField::ParseText(AutofillScanner* scanner,
                           const string16& pattern,
+                          int match_type) {
+  const AutofillField* field;
+  return ParseText(scanner, pattern, match_type, &field);
+}
+
+// static
+bool FormField::ParseText(AutofillScanner* scanner,
+                          const string16& pattern,
+                          int match_type,
                           const AutofillField** dest) {
-  return ParseText(scanner, pattern, dest, false);
+  return ParseText(scanner, pattern, dest, match_type);
 }
 
 // static
 bool FormField::ParseEmptyText(AutofillScanner* scanner,
                                const AutofillField** dest) {
-  return ParseLabelText(scanner, ASCIIToUTF16("^$"), dest);
-}
-
-// static
-bool FormField::ParseLabelText(AutofillScanner* scanner,
-                               const string16& pattern,
-                               const AutofillField** dest) {
-  return ParseText(scanner, pattern, dest, true);
+  return ParseText(scanner, ASCIIToUTF16("^$"),
+                   MATCH_LABEL | MATCH_TEXT | MATCH_SELECT, dest);
 }
 
 // static
 bool FormField::ParseText(AutofillScanner* scanner,
                           const string16& pattern,
                           const AutofillField** dest,
-                          bool match_label_only) {
+                          int match_type) {
   if (scanner->IsEnd())
     return false;
 
   const AutofillField* field = scanner->Cursor();
-  if (Match(field, pattern, match_label_only)) {
+
+//  if (!(match_type & MATCH_SELECT) &&
+//      field->form_control_type == ASCIIToUTF16("select-one"))
+//    return false;
+//
+//  if (!(match_type & MATCH_TEXT) &&
+//      isTextInput(field->form_control_type))
+//    return false;
+
+  if (MatchWithType(field, pattern, match_type)) {
     if (dest)
       *dest = field;
     scanner->Advance();
     return true;
   }
 
   return false;
 }
 
 // static
-bool FormField::ParseLabelAndName(AutofillScanner* scanner,
-                                  const string16& pattern,
-                                  const AutofillField** dest) {
+bool FormField::ParseEmpty(AutofillScanner* scanner) {
+  // TODO(jhawkins): Handle select fields.
+  const string16 pattern(ASCIIToUTF16("^$"));
   const AutofillField* field = scanner->Cursor();
   if (MatchLabel(field, pattern) && MatchName(field, pattern)) {
-    if (dest)
-      *dest = field;
     scanner->Advance();
     return true;
   }
 
   return false;
 }
 
 // static
-bool FormField::ParseEmpty(AutofillScanner* scanner) {
-  // TODO(jhawkins): Handle select fields.
-  return ParseLabelAndName(scanner, ASCIIToUTF16("^$"), NULL);
-}
-
-// static
 bool FormField::Add(FieldTypeMap* field_type_map,
                     const AutofillField* field,
                     AutofillFieldType type) {
   // Several fields are optional.
   if (!field)
     return true;
 
   // TODO(isherman): Is this the intent?
   return field_type_map->insert(make_pair(field->unique_name(), type)).second;
 }
 
 string16 FormField::GetEcmlPattern(const char* ecml_name) {
   return ASCIIToUTF16(std::string("^") + ecml_name);
 }
 
 string16 FormField::GetEcmlPattern(const char* ecml_name1,
                                    const char* ecml_name2,
                                    char pattern_operator) {
   return ASCIIToUTF16(StringPrintf("^%s%c^%s",
                                    ecml_name1, pattern_operator, ecml_name2));
 }