Autofill refactor form_field.h/cc.

chrome/browser/autofill/phone_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/phone_field.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_ecml.h"
 #include "chrome/browser/autofill/autofill_field.h"
 #include "chrome/browser/autofill/autofill_scanner.h"
 #include "chrome/browser/autofill/fax_number.h"
 #include "chrome/browser/autofill/home_phone_number.h"
 #include "grit/autofill_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using autofill::GetEcmlPattern;
+
 // Phone field grammars - first matched grammar will be parsed. Grammars are
 // separated by { REGEX_SEPARATOR, FIELD_NONE, 0 }. Suffix and extension are
 // parsed separately unless they are necessary parts of the match.
 // The following notation is used to describe the patterns:
 // <cc> - country code field.
 // <ac> - area code field.
 // <phone> - phone or prefix.
 // <suffix> - suffix.
 // <ext> - extension.
 // :N means field is limited to N characters, otherwise it is unlimited.
@@ skipping 88 matching lines @@
   }
 
   return NULL;
 }
 
 // static
 PhoneField* PhoneField::ParseECML(AutofillScanner* scanner) {
   string16 pattern(GetEcmlPattern(kEcmlShipToPhone, kEcmlBillToPhone, '|'));
 
   const AutofillField* field;
-  if (ParseText(scanner, pattern, &field)) {
+  if (ParseField(scanner, pattern, &field)) {
     PhoneField* phone_field = new PhoneField();
     phone_field->parsed_phone_fields_[FIELD_PHONE] = field;
     return phone_field;
   }
 
   return NULL;
 }
 
-bool PhoneField::GetFieldInfo(FieldTypeMap* field_type_map) const {
+PhoneField::PhoneField() {
+  memset(parsed_phone_fields_, 0, sizeof(parsed_phone_fields_));
+  SetPhoneType(HOME_PHONE);
+}
+
+bool PhoneField::ClassifyField(FieldTypeMap* map) const {
   bool ok = true;
 
   DCHECK(parsed_phone_fields_[FIELD_PHONE]);  // Phone was correctly parsed.
 
   if ((parsed_phone_fields_[FIELD_COUNTRY_CODE] != NULL) ||
       (parsed_phone_fields_[FIELD_AREA_CODE] != NULL) ||
       (parsed_phone_fields_[FIELD_SUFFIX] != NULL)) {
     if (parsed_phone_fields_[FIELD_COUNTRY_CODE] != NULL) {
-      ok = ok && Add(field_type_map,
-                     parsed_phone_fields_[FIELD_COUNTRY_CODE],
-                     number_->GetCountryCodeType());
+      ok = ok && AddClassification(parsed_phone_fields_[FIELD_COUNTRY_CODE],
+                                   number_->GetCountryCodeType(),
+                                   map);
     }
     if (parsed_phone_fields_[FIELD_AREA_CODE] != NULL) {
-      ok = ok && Add(field_type_map,
-                     parsed_phone_fields_[FIELD_AREA_CODE],
-                     number_->GetCityCodeType());
+      ok = ok && AddClassification(parsed_phone_fields_[FIELD_AREA_CODE],
+                                   number_->GetCityCodeType(),
+                                   map);
     }
     // We tag the prefix as PHONE_HOME_NUMBER, then when filling the form
     // we fill only the prefix depending on the size of the input field.
-    ok = ok && Add(field_type_map,
-                   parsed_phone_fields_[FIELD_PHONE],
-                   number_->GetNumberType());
+    ok = ok && AddClassification(parsed_phone_fields_[FIELD_PHONE],
+                                 number_->GetNumberType(),
+                                 map);
     // We tag the suffix as PHONE_HOME_NUMBER, then when filling the form
     // we fill only the suffix depending on the size of the input field.
     if (parsed_phone_fields_[FIELD_SUFFIX] != NULL) {
-      ok = ok && Add(field_type_map,
-                     parsed_phone_fields_[FIELD_SUFFIX],
-                     number_->GetNumberType());
+      ok = ok && AddClassification(parsed_phone_fields_[FIELD_SUFFIX],
+                                   number_->GetNumberType(),
+                                   map);
     }
   } else {
-    ok = Add(field_type_map,
-             parsed_phone_fields_[FIELD_PHONE],
-             number_->GetWholeNumberType());
+    ok = AddClassification(parsed_phone_fields_[FIELD_PHONE],
+                           number_->GetWholeNumberType(),
+                           map);
   }
 
   return ok;
 }
 
-PhoneField::PhoneField() {
-  memset(parsed_phone_fields_, 0, sizeof(parsed_phone_fields_));
-  SetPhoneType(HOME_PHONE);
-}
-
 string16  PhoneField::GetCountryRegex() const {
   // This one is the same for Home and Fax numbers.
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_COUNTRY_CODE_RE);
 }
 
 string16 PhoneField::GetAreaRegex() const {
   // This one is the same for Home and Fax numbers.
   string16 area_code = l10n_util::GetStringUTF16(IDS_AUTOFILL_AREA_CODE_RE);
   area_code.append(ASCIIToUTF16("|"));  // Regexp separator.
   area_code.append(GetAreaNoTextRegex());
@@ skipping 69 matching lines @@
   const AutofillField* parsed_fields[FIELD_MAX];
 
   for (size_t i = 0; i < arraysize(phone_field_grammars_); ++i) {
     memset(parsed_fields, 0, sizeof(parsed_fields));
     scanner->Rewind();
     scanner->SaveCursor();
 
     // Attempt to parse according to the next grammar.
     for (; i < arraysize(phone_field_grammars_) &&
          phone_field_grammars_[i].regex != REGEX_SEPARATOR; ++i) {
-      if (!ParseText(scanner,
-                     phone_field->GetRegExp(phone_field_grammars_[i].regex),
-                     &parsed_fields[phone_field_grammars_[i].phone_part]))
+      if (!ParseField(scanner,
+                      phone_field->GetRegExp(phone_field_grammars_[i].regex),
+                      &parsed_fields[phone_field_grammars_[i].phone_part]))
         break;
       if (phone_field_grammars_[i].max_size &&
           (!parsed_fields[phone_field_grammars_[i].phone_part]->max_length ||
             phone_field_grammars_[i].max_size <
             parsed_fields[phone_field_grammars_[i].phone_part]->max_length)) {
         break;
       }
     }
 
     if (i >= arraysize(phone_field_grammars_)) {
@@ skipping 20 matching lines @@
     return false;
   }
 
   for (int i = 0; i < FIELD_MAX; ++i)
     phone_field->parsed_phone_fields_[i] = parsed_fields[i];
 
   // Look for optional fields.
 
   // Look for a third text box.
   if (!phone_field->parsed_phone_fields_[FIELD_SUFFIX]) {
-    if (!ParseText(scanner, phone_field->GetSuffixRegex(),
-                   &phone_field->parsed_phone_fields_[FIELD_SUFFIX])) {
-      ParseText(scanner, phone_field->GetSuffixSeparatorRegex(),
-                &phone_field->parsed_phone_fields_[FIELD_SUFFIX]);
+    if (!ParseField(scanner, phone_field->GetSuffixRegex(),
+                    &phone_field->parsed_phone_fields_[FIELD_SUFFIX])) {
+      ParseField(scanner, phone_field->GetSuffixSeparatorRegex(),
+                 &phone_field->parsed_phone_fields_[FIELD_SUFFIX]);
     }
   }
 
   // Now look for an extension.
-  ParseText(scanner, phone_field->GetExtensionRegex(),
-            &phone_field->parsed_phone_fields_[FIELD_EXTENSION]);
+  ParseField(scanner, phone_field->GetExtensionRegex(),
+             &phone_field->parsed_phone_fields_[FIELD_EXTENSION]);
 
   return true;
 }
 
 void PhoneField::SetPhoneType(PhoneType phone_type) {
   // Field types are different as well, so we create a temporary phone number,
   // to get relevant field types.
   if (phone_type == HOME_PHONE)
     number_.reset(new HomePhoneNumber);
   else
     number_.reset(new FaxNumber);
   phone_type_ = phone_type;
 }