Heuristics for grabber-continental.com.out (select-one)

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 63 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);
 }
 
+bool IsTextField(const string16& type) {
+  return type == ASCIIToUTF16("text");
+}
+
+bool IsEmailField(const string16& type) {
+  return type == ASCIIToUTF16("email");
+}
+
+bool IsMonthField(const string16& type) {
+  return type == ASCIIToUTF16("month");
+}
+
+bool IsTelephoneField(const string16& type) {
+  return type == ASCIIToUTF16("tel");
+}
+
+bool IsSelectField(const string16& type) {
+  return type == ASCIIToUTF16("select-one");
+}
+
 }  // namespace
 
 // static
 void FormField::ParseFormFields(const std::vector<AutofillField*>& fields,
                                 FieldTypeMap* 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(ParseFormField(&scanner, is_ecml));
     if (!form_field.get()) {
       scanner.Advance();
       continue;
     }
 
     // Add entries into the map for each field type found in |form_field|.
     bool ok = form_field->ClassifyField(map);
     DCHECK(ok);
   }
 }
 
 // static
 bool FormField::ParseField(AutofillScanner* scanner,
                            const string16& pattern,
                            const AutofillField** match) {
-  return ParseFieldSpecifics(scanner, pattern, MATCH_ALL, match);
+  return ParseFieldSpecifics(scanner, pattern, MATCH_DEFAULT, match);
 }
 
 // static
 bool FormField::ParseFieldSpecifics(AutofillScanner* scanner,
                                     const string16& pattern,
                                     int match_type,
                                     const AutofillField** match) {
   if (scanner->IsEnd())
     return false;
 
   const AutofillField* field = scanner->Cursor();
-  if (Match(field, pattern, match_type)) {
-    if (match)
-      *match = field;
-    scanner->Advance();
-    return true;
+
+  if ((match_type & MATCH_TEXT) && IsTextField(field->form_control_type))
+    return MatchAndAdvance(scanner, pattern, match_type, match);
+
+  if ((match_type & MATCH_EMAIL) && IsEmailField(field->form_control_type))
+    return MatchAndAdvance(scanner, pattern, match_type, match);
+
+  if ((match_type & MATCH_MONTH) && IsMonthField(field->form_control_type))
+    return MatchAndAdvance(scanner, pattern, match_type, match);

[Ilya Sherman, 2011/05/25 03:52:02]

There don't seem to be any clients who ever call into this method with
MATCH_MONTH.  Presumably the credit card code should do that somewhere...

[dhollowa, 2011/05/25 15:29:47]

The credit card code currently explicitly looks for "month" type and matches
based on that context.  It is a bit of a special case.  I'll remove this for
now, but I'm expecting we'll want to bring it back when we rework that code.

On 2011/05/25 03:52:02, Ilya Sherman wrote:

+
+  if ((match_type & MATCH_TELEPHONE)
+      && IsTelephoneField(field->form_control_type)) {
+    return MatchAndAdvance(scanner, pattern, match_type, match);
   }
 
+  if ((match_type & MATCH_SELECT) && IsSelectField(field->form_control_type))
+    return MatchAndAdvance(scanner, pattern, match_type, match);
+
   return false;
 }
 
 // static
 bool FormField::ParseEmptyLabel(AutofillScanner* scanner,
                                 const AutofillField** match) {
-  return ParseFieldSpecifics(scanner, ASCIIToUTF16("^$"), MATCH_LABEL, match);
+  return ParseFieldSpecifics(scanner,
+                             ASCIIToUTF16("^$"),
+                             MATCH_LABEL | MATCH_ALL_INPUTS,
+                             match);
 }
 
 // static
 bool FormField::AddClassification(const AutofillField* field,
                                   AutofillFieldType type,
                                   FieldTypeMap* map) {
   // Several fields are optional.
   if (!field)
     return true;
 
   return map->insert(make_pair(field->unique_name(), type)).second;
 }
 
+// static.
+bool FormField::MatchAndAdvance(AutofillScanner* scanner,
+                                const string16& pattern,
+                                int match_type,
+                                const AutofillField** match) {
+  const AutofillField* field = scanner->Cursor();
+  if (FormField::Match(field, pattern, match_type)) {
+    if (match)
+      *match = field;
+    scanner->Advance();
+    return true;
+  }
+
+  return false;
+}
+
 // static
 bool FormField::Match(const AutofillField* field,
                       const string16& pattern,
                       int match_type) {
   if ((match_type & FormField::MATCH_LABEL) && MatchLabel(field, pattern))
       return true;
 
   if ((match_type & FormField::MATCH_NAME) && MatchName(field, pattern))
       return true;
 
   return false;
 }