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"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_field.h"
 #include "chrome/browser/autofill/autofill_scanner.h"
+#include "chrome/browser/autofill/email_field.h"
+#include "chrome/browser/autofill/phone_field.h"
 #include "grit/autofill_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 bool AddressField::GetFieldInfo(FieldTypeMap* field_type_map) const {
   AutofillFieldType address_company;
   AutofillFieldType address_line1;
   AutofillFieldType address_line2;
   AutofillFieldType address_city;
   AutofillFieldType address_state;
   AutofillFieldType address_zip;
@@ skipping 45 matching lines @@
   const AutofillField* initial_field = scanner->Cursor();
   scanner->SaveCursor();
 
   string16 attention_ignored =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_ATTENTION_IGNORED_RE);
   string16 region_ignored =
       l10n_util::GetStringUTF16(IDS_AUTOFILL_REGION_IGNORED_RE);
 
   // Allow address fields to appear in any order.
   while (!scanner->IsEnd()) {
+    // Every loop, we have to parse email and phone, and if we find it, we
+    // break the loop even while continuing address. Because we want to give
+    // email and phone more priority than address. We have to rewind |scanner|
+    // position after the email and phone parsing.
+    size_t cursor_position = scanner->SaveCursor();
+    bool is_email = EmailField::Parse(scanner, is_ecml);
+    scanner->RewindTo(cursor_position);
+    if (is_email)
+      break;
+
+    cursor_position = scanner->SaveCursor();
+    bool is_phone = PhoneField::Parse(scanner, is_ecml);
+    scanner->RewindTo(cursor_position);
+    if (is_phone)
+      break;

[Ilya Sherman, 2011/05/14 06:59:12]

David and I discussed this a bit offline today -- I'll try to rehash/summarize
that here:  Rather than changing the parsing for address fields, let's try
making multiple passes over the form in FormField::ParseFormFields().  In the
first pass, we can check for any email fields; in the second pass, we can check
for any phone fields; in the third pass, for any address fields; and so on. 
This should both add a bit more clarity to the code; and also give us a bit more
flexibility for parsing.

[Ilya Sherman, 2011/05/14 07:01:33]

Whoops, didn't mean to send this comment out -- wanted to let David think about
this some more and then add his thoughts.  So, I guess for now keep this in mind
as a possibility, but not necessarily the best one.

[honten.org, 2011/05/14 07:41:20]

I see, it might be better idea.

But, at first, I want to refactor ParseText() with bitmap. I want to commit
gradually;-)

On 2011/05/14 07:01:33, Ilya Sherman wrote:

+
     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)) {
       // We ignore the following:
@@ skipping 148 matching lines @@
   // 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, FormField::Pattern(pattern, true),
+                   &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 48 matching lines @@
   // 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, FormField::Pattern(pattern, true),
+                   &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, FormField::Pattern(pattern, true),
+                   &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;
 }