Change heuristic regex and order to match grabber-continental.

chrome/browser/autofill/address_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/address_field.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 67 matching lines @@
 
   // Allow address fields to appear in any order.
   while (!scanner->IsEnd()) {
     if (ParseCompany(scanner, is_ecml, address_field.get()) ||
         ParseAddressLines(scanner, is_ecml, address_field.get()) ||
         ParseCity(scanner, is_ecml, address_field.get()) ||
         ParseState(scanner, is_ecml, address_field.get()) ||
         ParseZipCode(scanner, is_ecml, address_field.get()) ||
         ParseCountry(scanner, is_ecml, address_field.get())) {
       continue;
-    } else if (ParseText(scanner, attention_ignored) ||
-               ParseText(scanner, region_ignored)) {
+    } else if (ParseText(scanner, attention_ignored,
+                         MATCH_NAME | MATCH_LABEL | MATCH_TEXT) ||
+               ParseText(scanner, region_ignored,
+                         MATCH_NAME | MATCH_LABEL | MATCH_TEXT)) {
       // We ignore the following:
       // * Attention.
       // * Province/Region/Other.
       continue;
     } else if (scanner->Cursor() != initial_field && ParseEmpty(scanner)) {
       // Ignore non-labeled fields within an address; the page
       // MapQuest Driving Directions North America.html contains such a field.
       // We only ignore such fields after we've parsed at least one other field;
       // otherwise we'd effectively parse address fields before other field
       // types after any non-labeled fields, and we want email address fields to
@@ skipping 59 matching lines @@
     return false;
 
   string16 pattern;
   if (is_ecml) {
     pattern = GetEcmlPattern(kEcmlShipToCompanyName,
                              kEcmlBillToCompanyName, '|');
   } else {
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_COMPANY_RE);
   }
 
-  return ParseText(scanner, pattern, &address_field->company_);
+  return ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                   &address_field->company_);
 }
 
 // static
 bool AddressField::ParseAddressLines(AutofillScanner* scanner,
                                      bool is_ecml,
                                      AddressField* address_field) {
   // We only match the string "address" in page text, not in element names,
   // because sometimes every element in a group of address fields will have
   // a name containing the string "address"; for example, on the page
   // Kohl's - Register Billing Address.html the text element labeled "city"
   // has the name "BILL_TO_ADDRESS<>city".  We do match address labels
   // such as "address1", which appear as element names on various pages (eg
   // AmericanGirl-Registration.html, BloomingdalesBilling.html,
   // EBay Registration Enter Information.html).
   if (address_field->address1_)
     return false;
 
   string16 pattern;
   if (is_ecml) {
     pattern = GetEcmlPattern(kEcmlShipToAddress1, kEcmlBillToAddress1, '|');
-    if (!ParseText(scanner, pattern, &address_field->address1_))
+    if (!ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                   &address_field->address1_))
       return false;
   } else {
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_LINE_1_RE);
     string16 label_pattern =
         l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_LINE_1_LABEL_RE);
 
-    if (!ParseText(scanner, pattern, &address_field->address1_) &&
-        !ParseLabelText(scanner, label_pattern, &address_field->address1_))
+    if (!ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                   &address_field->address1_) &&
+        !ParseText(scanner, label_pattern, MATCH_LABEL | MATCH_TEXT,
+                   &address_field->address1_))
       return false;
   }
 
   // Optionally parse more address lines, which may have empty labels.
   // Some pages have 3 address lines (eg SharperImageModifyAccount.html)
   // Some pages even have 4 address lines (e.g. uk/ShoesDirect2.html)!
   if (is_ecml) {
     pattern = GetEcmlPattern(kEcmlShipToAddress2, kEcmlBillToAddress2, '|');
     if (!ParseEmptyText(scanner, &address_field->address2_))
-      ParseText(scanner, pattern, &address_field->address2_);
+      ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                &address_field->address2_);
   } else {
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_LINE_2_RE);
     string16 label_pattern =
         l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_LINE_1_LABEL_RE);
     if (!ParseEmptyText(scanner, &address_field->address2_) &&
-        !ParseText(scanner, pattern, &address_field->address2_))
-      ParseLabelText(scanner, label_pattern, &address_field->address2_);
+        !ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                   &address_field->address2_))
+      ParseText(scanner, label_pattern, MATCH_LABEL | MATCH_TEXT,
+                &address_field->address2_);
   }
 
   // Try for a third line, which we will promptly discard.
   if (address_field->address2_ != NULL) {
     if (is_ecml) {
       pattern = GetEcmlPattern(kEcmlShipToAddress3, kEcmlBillToAddress3, '|');
-      ParseText(scanner, pattern);
+      ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT);
     } else {
       pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_LINE_3_RE);
       if (!ParseEmptyText(scanner, NULL))
-        ParseText(scanner, pattern, NULL);
+        ParseText(scanner, pattern,
+                  MATCH_NAME | MATCH_LABEL | MATCH_TEXT, NULL);
     }
   }
 
   return true;
 }
 
 // static
 bool AddressField::ParseCountry(AutofillScanner* scanner,
                                 bool is_ecml,
                                 AddressField* address_field) {
   // Parse a country.  The occasional page (e.g.
   // Travelocity_New Member Information1.html) calls this a "location".
   // Note: ECML standard uses 2 letter country code (ISO 3166)
   if (address_field->country_ && !address_field->country_->IsEmpty())
     return false;
 
   string16 pattern;
   if (is_ecml)
     pattern = GetEcmlPattern(kEcmlShipToCountry, kEcmlBillToCountry, '|');
   else
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_COUNTRY_RE);
 
-  return ParseText(scanner, pattern, &address_field->country_);
+  return ParseText(scanner, pattern,
+                   MATCH_NAME | MATCH_LABEL | MATCH_TEXT | MATCH_SELECT,
+                   &address_field->country_);
 }
 
 // static
 bool AddressField::ParseZipCode(AutofillScanner* scanner,
                                 bool is_ecml,
                                 AddressField* address_field) {
   // Parse a zip code.  On some UK pages (e.g. The China Shop2.html) this
   // is called a "post code".
   //
   // HACK: Just for the MapQuest driving directions page we match the
@@ skipping 18 matching lines @@
   // more detail.
   string16 bill_to_postal_code_field(ASCIIToUTF16(kEcmlBillToPostalCode));
   if (StartsWith(name, bill_to_postal_code_field, false)) {
     tempType = kBillingAddress;
   } else if (StartsWith(name, bill_to_postal_code_field, false)) {
     tempType = kShippingAddress;
   } else {
     tempType = kGenericAddress;
   }
 
-  if (!ParseText(scanner, pattern, &address_field->zip_))
+  if (!ParseText(scanner, pattern, MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
+                 &address_field->zip_))
     return false;
 
   address_field->type_ = tempType;
   if (!is_ecml) {
     // Look for a zip+4, whose field name will also often contain
     // the substring "zip".
     ParseText(scanner,
               l10n_util::GetStringUTF16(IDS_AUTOFILL_ZIP_4_RE),
+              MATCH_NAME | MATCH_LABEL | MATCH_TEXT,
               &address_field->zip4_);
   }
 
   return true;
 }
 
 // static
 bool AddressField::ParseCity(AutofillScanner* scanner,
                              bool is_ecml,
                              AddressField* address_field) {
   // Parse a city name.  Some UK pages (e.g. The China Shop2.html) use
   // the term "town".
   if (address_field->city_)
     return false;
 
   string16 pattern;
   if (is_ecml)
     pattern = GetEcmlPattern(kEcmlShipToCity, kEcmlBillToCity, '|');
   else
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_CITY_RE);
 
-  return ParseText(scanner, pattern, &address_field->city_);
+  return ParseText(scanner, pattern,
+                   MATCH_NAME | MATCH_LABEL | MATCH_TEXT | MATCH_SELECT,
+                   &address_field->city_);
 }
 
 // static
 bool AddressField::ParseState(AutofillScanner* scanner,
                               bool is_ecml,
                               AddressField* address_field) {
   if (address_field->state_)
     return false;
 
   string16 pattern;
   if (is_ecml)
     pattern = GetEcmlPattern(kEcmlShipToStateProv, kEcmlBillToStateProv, '|');
   else
     pattern = l10n_util::GetStringUTF16(IDS_AUTOFILL_STATE_RE);
 
-  return ParseText(scanner, pattern, &address_field->state_);
+  return ParseText(scanner, pattern,
+                   MATCH_NAME | MATCH_LABEL | MATCH_TEXT | MATCH_SELECT,
+                   &address_field->state_);
 }
 
 AddressType AddressField::AddressTypeFromText(const string16 &text) {
   if (text.find(l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_TYPE_SAME_AS_RE))
           != string16::npos ||
       text.find(l10n_util::GetStringUTF16(IDS_AUTOFILL_ADDRESS_TYPE_USE_MY_RE))
           != string16::npos)
     // This text could be a checkbox label such as "same as my billing
     // address" or "use my shipping address".
     // ++ It would help if we generally skipped all text that appears
@@ skipping 15 matching lines @@
     return kBillingAddress;
 
   if (bill == string16::npos && ship != string16::npos)
     return kShippingAddress;
 
   if (bill > ship)
     return kBillingAddress;
 
   return kShippingAddress;
 }