Change heuristic regex and order to match grabber-continental.

chrome/browser/autofill/form_field.h

 // 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.
 
 #ifndef CHROME_BROWSER_AUTOFILL_FORM_FIELD_H_
 #define CHROME_BROWSER_AUTOFILL_FORM_FIELD_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 61 matching lines @@
   // Associates the available AutofillTypes of a FormField into
   // |field_type_map|.
   virtual bool GetFieldInfo(FieldTypeMap* field_type_map) const = 0;
 
   // Returns true if |field| contains the regexp |pattern| in the name or label.
   // If |match_label_only| is true, then only the field's label is considered.
   static bool Match(const AutofillField* field,
                     const string16& pattern,
                     bool match_label_only);
 
+  struct Pattern {
+    string16 pattern;
+    bool select_one_is_ok;
+
+    Pattern(const string16& pattern)

[honten.org, 2011/05/12 05:36:33]

I know we need to add explicit.
But before adding explicit, I want to make sure the Pattern struct usage is
suitable or not.

[Ilya Sherman, 2011/05/13 00:54:53]

Let's instead create an enum along the lines of

enum MatchFormControlType {
  MATCH_ONLY_TEXT = 0,
  MATCH_TEXT_AND_SELECT
};

and pass a value of this type as an additional parameter to ParseText().

[honten.org, 2011/05/13 01:39:48]

After this change, we might need to implement more pattern parameter (e.g.
only_check_label or do_not_check_inferred_label) in the future, as I and David
discussed.

In that case, we need to add those parameters again and again every time. That's
the reason why I declared the sturct.

But, even if it is OK, I will change the parameters as an additional parameter.

What do you think?

On 2011/05/13 00:54:53, Ilya Sherman wrote:

[dhollowa, 2011/05/14 02:15:50]

I think this may be a good opportunity to use a bit-field.  Something like:

enum MatchType {
  MATCH_LABEL = 1 << 0,
  MATCH_NAME = 1 << 1,
  MATCH_REQUIRES_SELECT = 1 << 2
  MATCH_EMPTY = 1 << 3
};

Then we could try to consolidate FormField::ParseLabelAndName,
FormField::ParseLabelText, and all that mess.

On 2011/05/13 01:39:48, honten wrote:

+        : pattern(pattern),
+          select_one_is_ok(false) {
+    }
+    Pattern(const string16& pattern, bool select_one_is_ok)
+        : pattern(pattern),
+          select_one_is_ok(select_one_is_ok) {
+    }
+  };
+
   // Parses a field using the different field views we know about.  |is_ecml|
   // should be true when the field conforms to the ECML specification.
   static FormField* ParseFormField(AutofillScanner* scanner, bool is_ecml);
 
   // Attempts to parse a text field with the given pattern; returns true on
   // success, but doesn't return the actual text field itself.
-  static bool ParseText(AutofillScanner* scanner, const string16& pattern);
+  static bool ParseText(AutofillScanner* scanner, const Pattern& pattern);
 
   // Attempts to parse a text field with the given pattern.  Returns true on
   // success and fills |dest| with a pointer to the field.
   static bool ParseText(AutofillScanner* scanner,
-                        const string16& pattern,
+                        const Pattern& pattern,
                         const AutofillField** dest);
 
   // Attempts to parse a text field with an empty name or label.  Returns true
   // on success and fills |dest| with a pointer to the field.
   static bool ParseEmptyText(AutofillScanner* scanner,
                              const AutofillField** dest);
 
   // Attempts to parse a text field label with the given pattern.  Returns true
   // on success and fills |dest| with a pointer to the field.
   static bool ParseLabelText(AutofillScanner* scanner,
-                             const string16& pattern,
+                             const Pattern& pattern,
                              const AutofillField** dest);
 
   // Attempts to parse a control with an empty label.
   static bool ParseEmpty(AutofillScanner* scanner);
 
   // Adds an association between a field and a type to |field_type_map|.
   static bool Add(FieldTypeMap* field_type_map,
                   const AutofillField* field,
                   AutofillFieldType type);
 
  protected:
   // Only derived classes may instantiate.
   FormField() {}
 
   // Note: ECML compliance checking has been modified to accommodate Google
   // Checkout field name limitation. All ECML compliant web forms will be
   // recognized correctly as such however the restrictions on having exactly
   // ECML compliant names have been loosened to only require that field names
   // be prefixed with an ECML compliant name in order to accommodate checkout.
   // Additionally we allow the use of '.' as a word delimiter in addition to the
   // ECML standard '_' (see FormField::FormField for details).
   static string16 GetEcmlPattern(const char* ecml_name);
   static string16 GetEcmlPattern(const char* ecml_name1,
                                  const char* ecml_name2,
                                  char pattern_operator);
 
  private:
   static bool ParseText(AutofillScanner* scanner,
-                        const string16& pattern,
+                        const Pattern& pattern,
                         const AutofillField** dest,
                         bool match_label_only);
 
   // For empty strings we need to test that both label and name are empty.
   static bool ParseLabelAndName(AutofillScanner* scanner,
                                 const string16& pattern,
                                 const AutofillField** dest);
   static bool MatchName(const AutofillField* field, const string16& pattern);
   static bool MatchLabel(const AutofillField* field, const string16& pattern);
 
   DISALLOW_COPY_AND_ASSIGN(FormField);
 };
 
 #endif  // CHROME_BROWSER_AUTOFILL_FORM_FIELD_H_