autofill: Rename FormGroup::GetPossibleFieldTypes() and ::GetAvailableFieldTypes() to be clearer.

GetPossibleFieldTypes() -> GetMatchingTypes().
GetAvailableFieldTypes() -> GetNonEmptyTypes().

BUG=81767
TEST=None

R=dhollowa@chromium.org,isherman@chromium.org

Review URL: http://codereview.chromium.org/6970005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@84645 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 224 insertions, 229 deletions

diff --git a/chrome/browser/autofill/address.cc b/chrome/browser/autofill/address.cc
index fa2cf0c..0a687a1 100644
--- a/chrome/browser/autofill/address.cc
+++ b/chrome/browser/autofill/address.cc
@@ -53,9 +53,9 @@ Address& Address::operator=(const Address& address) {
   return *this;
 }
 
-void Address::GetPossibleFieldTypes(const string16& text,
-                                    FieldTypeSet* possible_types) const {
-  DCHECK(possible_types);
+void Address::GetMatchingTypes(const string16& text,
+                               FieldTypeSet* matching_types) const {
+  DCHECK(matching_types);
 
   // If the text to match against the field types is empty, then no results will
   // match.
@@ -63,44 +63,44 @@ void Address::GetPossibleFieldTypes(const string16& text,
     return;
 
   if (IsLine1(text))
-    possible_types->insert(ADDRESS_HOME_LINE1);
+    matching_types->insert(ADDRESS_HOME_LINE1);
 
   if (IsLine2(text))
-    possible_types->insert(ADDRESS_HOME_LINE2);
+    matching_types->insert(ADDRESS_HOME_LINE2);
 
   if (IsCity(text))
-    possible_types->insert(ADDRESS_HOME_CITY);
+    matching_types->insert(ADDRESS_HOME_CITY);
 
   if (IsState(text))
-    possible_types->insert(ADDRESS_HOME_STATE);
+    matching_types->insert(ADDRESS_HOME_STATE);
 
   if (IsZipCode(text))
-    possible_types->insert(ADDRESS_HOME_ZIP);
+    matching_types->insert(ADDRESS_HOME_ZIP);
 
   if (IsCountry(text))
-    possible_types->insert(ADDRESS_HOME_COUNTRY);
+    matching_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
-void Address::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void Address::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
+  DCHECK(non_empty_types);
 
   if (!line1_.empty())
-    available_types->insert(ADDRESS_HOME_LINE1);
+    non_empty_types->insert(ADDRESS_HOME_LINE1);
 
   if (!line2_.empty())
-    available_types->insert(ADDRESS_HOME_LINE2);
+    non_empty_types->insert(ADDRESS_HOME_LINE2);
 
   if (!city_.empty())
-    available_types->insert(ADDRESS_HOME_CITY);
+    non_empty_types->insert(ADDRESS_HOME_CITY);
 
   if (!state_.empty())
-    available_types->insert(ADDRESS_HOME_STATE);
+    non_empty_types->insert(ADDRESS_HOME_STATE);
 
   if (!zip_code_.empty())
-    available_types->insert(ADDRESS_HOME_ZIP);
+    non_empty_types->insert(ADDRESS_HOME_ZIP);
 
   if (!country_code_.empty())
-    available_types->insert(ADDRESS_HOME_COUNTRY);
+    non_empty_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 string16 Address::GetInfo(AutofillFieldType type) const {
diff --git a/chrome/browser/autofill/address.h b/chrome/browser/autofill/address.h
index 432467b..1a4cf04 100644
--- a/chrome/browser/autofill/address.h
+++ b/chrome/browser/autofill/address.h
@@ -24,9 +24,9 @@ class Address : public FormGroup {
   Address& operator=(const Address& address);
 
   // FormGroup:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
 
diff --git a/chrome/browser/autofill/address_unittest.cc b/chrome/browser/autofill/address_unittest.cc
index fb5547f..7691ac0 100644
--- a/chrome/browser/autofill/address_unittest.cc
+++ b/chrome/browser/autofill/address_unittest.cc
@@ -90,11 +90,10 @@ TEST(AddressTest, IsCountry) {
   };
   for (size_t i = 0; i < arraysize(kValidMatches); ++i) {
     SCOPED_TRACE(kValidMatches[i]);
-    FieldTypeSet possible_field_types;
-    address.GetPossibleFieldTypes(ASCIIToUTF16(kValidMatches[i]),
-                                  &possible_field_types);
-    ASSERT_EQ(1U, possible_field_types.size());
-    EXPECT_EQ(ADDRESS_HOME_COUNTRY, *possible_field_types.begin());
+    FieldTypeSet matching_types;
+    address.GetMatchingTypes(ASCIIToUTF16(kValidMatches[i]), &matching_types);
+    ASSERT_EQ(1U, matching_types.size());
+    EXPECT_EQ(ADDRESS_HOME_COUNTRY, *matching_types.begin());
   }
 
   const char* const kInvalidMatches[] = {
@@ -102,17 +101,15 @@ TEST(AddressTest, IsCountry) {
     "Garbage"
   };
   for (size_t i = 0; i < arraysize(kInvalidMatches); ++i) {
-    FieldTypeSet possible_field_types;
-    address.GetPossibleFieldTypes(ASCIIToUTF16(kInvalidMatches[i]),
-                                  &possible_field_types);
-    EXPECT_EQ(0U, possible_field_types.size());
+    FieldTypeSet matching_types;
+    address.GetMatchingTypes(ASCIIToUTF16(kInvalidMatches[i]), &matching_types);
+    EXPECT_EQ(0U, matching_types.size());
   }
 
   // Make sure that garbage values don't match when the country code is empty.
   address.set_country_code("");
   EXPECT_EQ(std::string(), address.country_code());
-  FieldTypeSet possible_field_types;
-  address.GetPossibleFieldTypes(ASCIIToUTF16("Garbage"),
-                                &possible_field_types);
-  EXPECT_EQ(0U, possible_field_types.size());
+  FieldTypeSet matching_types;
+  address.GetMatchingTypes(ASCIIToUTF16("Garbage"), &matching_types);
+  EXPECT_EQ(0U, matching_types.size());
 }
diff --git a/chrome/browser/autofill/autofill_manager.cc b/chrome/browser/autofill/autofill_manager.cc
index c5f6781..9ccc797 100644
--- a/chrome/browser/autofill/autofill_manager.cc
+++ b/chrome/browser/autofill/autofill_manager.cc
@@ -633,7 +633,7 @@ void AutofillManager::DeterminePossibleFieldTypesForUpload(
   for (size_t i = 0; i < submitted_form->field_count(); i++) {
     const AutofillField* field = submitted_form->field(i);
     FieldTypeSet field_types;
-    personal_data_->GetPossibleFieldTypes(field->value, &field_types);
+    personal_data_->GetMatchingTypes(field->value, &field_types);
 
     DCHECK(!field_types.empty());
     submitted_form->set_possible_types(i, field_types);
@@ -671,11 +671,11 @@ void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
       was_autofilled = true;
   }
 
-  FieldTypeSet available_types;
-  personal_data_->GetAvailableFieldTypes(&available_types);
+  FieldTypeSet non_empty_types;
+  personal_data_->GetNonEmptyTypes(&non_empty_types);
 
   download_manager_.StartUploadRequest(submitted_form, was_autofilled,
-                                       available_types);
+                                       non_empty_types);
 }
 
 void AutofillManager::Reset() {
diff --git a/chrome/browser/autofill/autofill_profile.cc b/chrome/browser/autofill/autofill_profile.cc
index d21c712..f359799 100644
--- a/chrome/browser/autofill/autofill_profile.cc
+++ b/chrome/browser/autofill/autofill_profile.cc
@@ -213,19 +213,18 @@ AutofillProfile& AutofillProfile::operator=(const AutofillProfile& profile) {
   return *this;
 }
 
-void AutofillProfile::GetPossibleFieldTypes(
-    const string16& text,
-    FieldTypeSet* possible_types) const {
+void AutofillProfile::GetMatchingTypes(const string16& text,
+                                       FieldTypeSet* matching_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
-    (*it)->GetPossibleFieldTypes(text, possible_types);
+    (*it)->GetMatchingTypes(text, matching_types);
 }
 
-void AutofillProfile::GetAvailableFieldTypes(
-    FieldTypeSet* available_types) const {
+void AutofillProfile::GetNonEmptyTypes(
+    FieldTypeSet* non_empty_types) const {
   FormGroupList info = FormGroups();
   for (FormGroupList::const_iterator it = info.begin(); it != info.end(); ++it)
-    (*it)->GetAvailableFieldTypes(available_types);
+    (*it)->GetNonEmptyTypes(non_empty_types);
 }
 
 string16 AutofillProfile::GetInfo(AutofillFieldType type) const {
@@ -378,7 +377,7 @@ void AutofillProfile::CreateInferredLabels(
 
 bool AutofillProfile::IsEmpty() const {
   FieldTypeSet types;
-  GetAvailableFieldTypes(&types);
+  GetNonEmptyTypes(&types);
   return types.empty();
 }
 
@@ -466,7 +465,7 @@ const string16 AutofillProfile::PrimaryValue() const {
 
 void AutofillProfile::OverwriteWithOrAddTo(const AutofillProfile& profile) {
   FieldTypeSet field_types;
-  profile.GetAvailableFieldTypes(&field_types);
+  profile.GetNonEmptyTypes(&field_types);
 
   // Only transfer "full" types (e.g. full name) and not fragments (e.g.
   // first name, last name).
diff --git a/chrome/browser/autofill/autofill_profile.h b/chrome/browser/autofill/autofill_profile.h
index 4610482..80a54e8 100644
--- a/chrome/browser/autofill/autofill_profile.h
+++ b/chrome/browser/autofill/autofill_profile.h
@@ -37,9 +37,9 @@ class AutofillProfile : public FormGroup {
   AutofillProfile& operator=(const AutofillProfile& profile);
 
   // FormGroup:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
 
diff --git a/chrome/browser/autofill/contact_info.cc b/chrome/browser/autofill/contact_info.cc
index 53c3ccd..7010d2a 100644
--- a/chrome/browser/autofill/contact_info.cc
+++ b/chrome/browser/autofill/contact_info.cc
@@ -47,43 +47,43 @@ NameInfo& NameInfo::operator=(const NameInfo& info) {
   return *this;
 }
 
-void NameInfo::GetPossibleFieldTypes(const string16& text,
-                                        FieldTypeSet* possible_types) const {
-  DCHECK(possible_types);
+void NameInfo::GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const {
+  DCHECK(matching_types);
 
   if (IsFirstName(text))
-    possible_types->insert(NAME_FIRST);
+    matching_types->insert(NAME_FIRST);
 
   if (IsMiddleName(text))
-    possible_types->insert(NAME_MIDDLE);
+    matching_types->insert(NAME_MIDDLE);
 
   if (IsLastName(text))
-    possible_types->insert(NAME_LAST);
+    matching_types->insert(NAME_LAST);
 
   if (IsMiddleInitial(text))
-    possible_types->insert(NAME_MIDDLE_INITIAL);
+    matching_types->insert(NAME_MIDDLE_INITIAL);
 
   if (IsFullName(text))
-    possible_types->insert(NAME_FULL);
+    matching_types->insert(NAME_FULL);
 }
 
-void NameInfo::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void NameInfo::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
+  DCHECK(non_empty_types);
 
   if (!first().empty())
-    available_types->insert(NAME_FIRST);
+    non_empty_types->insert(NAME_FIRST);
 
   if (!middle().empty())
-    available_types->insert(NAME_MIDDLE);
+    non_empty_types->insert(NAME_MIDDLE);
 
   if (!last().empty())
-    available_types->insert(NAME_LAST);
+    non_empty_types->insert(NAME_LAST);
 
   if (!MiddleInitial().empty())
-    available_types->insert(NAME_MIDDLE_INITIAL);
+    non_empty_types->insert(NAME_MIDDLE_INITIAL);
 
   if (!FullName().empty())
-    available_types->insert(NAME_FULL);
+    non_empty_types->insert(NAME_FULL);
 }
 
 string16 NameInfo::GetInfo(AutofillFieldType type) const {
@@ -341,18 +341,18 @@ EmailInfo& EmailInfo::operator=(const EmailInfo& info) {
   return *this;
 }
 
-void EmailInfo::GetPossibleFieldTypes(const string16& text,
-                                      FieldTypeSet* possible_types) const {
-  DCHECK(possible_types);
+void EmailInfo::GetMatchingTypes(const string16& text,
+                                 FieldTypeSet* matching_types) const {
+  DCHECK(matching_types);
   // TODO(isherman): Investigate case-insensitive comparison.
   if (email_ == text)
-    possible_types->insert(EMAIL_ADDRESS);
+    matching_types->insert(EMAIL_ADDRESS);
 }
 
-void EmailInfo::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void EmailInfo::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
+  DCHECK(non_empty_types);
   if (!email_.empty())
-    available_types->insert(EMAIL_ADDRESS);
+    non_empty_types->insert(EMAIL_ADDRESS);
 }
 
 string16 EmailInfo::GetInfo(AutofillFieldType type) const {
@@ -383,19 +383,19 @@ CompanyInfo& CompanyInfo::operator=(const CompanyInfo& info) {
   return *this;
 }
 
-void CompanyInfo::GetPossibleFieldTypes(const string16& text,
-                                        FieldTypeSet* possible_types) const {
-  DCHECK(possible_types);
+void CompanyInfo::GetMatchingTypes(const string16& text,
+                                   FieldTypeSet* matching_types) const {
+  DCHECK(matching_types);
 
   if (company_name_ == text)
-    possible_types->insert(COMPANY_NAME);
+    matching_types->insert(COMPANY_NAME);
 }
 
-void CompanyInfo::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void CompanyInfo::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
+  DCHECK(non_empty_types);
 
   if (!company_name_.empty())
-    available_types->insert(COMPANY_NAME);
+    non_empty_types->insert(COMPANY_NAME);
 }
 
 string16 CompanyInfo::GetInfo(AutofillFieldType type) const {
diff --git a/chrome/browser/autofill/contact_info.h b/chrome/browser/autofill/contact_info.h
index e7d9341..2d9d043 100644
--- a/chrome/browser/autofill/contact_info.h
+++ b/chrome/browser/autofill/contact_info.h
@@ -23,9 +23,9 @@ class NameInfo : public FormGroup {
   NameInfo& operator=(const NameInfo& info);
 
   // FormGroup:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
 
@@ -103,9 +103,9 @@ class EmailInfo : public FormGroup {
   EmailInfo& operator=(const EmailInfo& info);
 
   // FormGroup:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
 
@@ -122,9 +122,9 @@ class CompanyInfo : public FormGroup {
   CompanyInfo& operator=(const CompanyInfo& info);
 
   // FormGroup:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
 
diff --git a/chrome/browser/autofill/credit_card.cc b/chrome/browser/autofill/credit_card.cc
index 224719d..d6ea407 100644
--- a/chrome/browser/autofill/credit_card.cc
+++ b/chrome/browser/autofill/credit_card.cc
@@ -157,53 +157,53 @@ CreditCard::CreditCard(const CreditCard& credit_card) : FormGroup() {
 
 CreditCard::~CreditCard() {}
 
-void CreditCard::GetPossibleFieldTypes(const string16& text,
-                                       FieldTypeSet* possible_types) const {
+void CreditCard::GetMatchingTypes(const string16& text,
+                                  FieldTypeSet* matching_types) const {
   if (IsNameOnCard(text))
-    possible_types->insert(CREDIT_CARD_NAME);
+    matching_types->insert(CREDIT_CARD_NAME);
 
   if (IsNumber(text))
-    possible_types->insert(CREDIT_CARD_NUMBER);
+    matching_types->insert(CREDIT_CARD_NUMBER);
 
   if (IsExpirationMonth(text))
-    possible_types->insert(CREDIT_CARD_EXP_MONTH);
+    matching_types->insert(CREDIT_CARD_EXP_MONTH);
 
   if (Is2DigitExpirationYear(text))
-    possible_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
+    matching_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
 
   if (Is4DigitExpirationYear(text))
-    possible_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
+    matching_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
 
   if (text == GetInfo(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR))
-    possible_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
+    matching_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
 
   if (text == GetInfo(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR))
-    possible_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
+    matching_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
 }
 
-void CreditCard::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void CreditCard::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
+  DCHECK(non_empty_types);
 
   if (!name_on_card_.empty())
-    available_types->insert(CREDIT_CARD_NAME);
+    non_empty_types->insert(CREDIT_CARD_NAME);
 
   if (!number_.empty())
-    available_types->insert(CREDIT_CARD_NUMBER);
+    non_empty_types->insert(CREDIT_CARD_NUMBER);
 
   if (!ExpirationMonthAsString().empty())
-    available_types->insert(CREDIT_CARD_EXP_MONTH);
+    non_empty_types->insert(CREDIT_CARD_EXP_MONTH);
 
   if (!Expiration2DigitYearAsString().empty())
-    available_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
+    non_empty_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
 
   if (!Expiration4DigitYearAsString().empty())
-    available_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
+    non_empty_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
 
   if (!GetInfo(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR).empty())
-    available_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
+    non_empty_types->insert(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR);
 
   if (!GetInfo(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR).empty())
-    available_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
+    non_empty_types->insert(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR);
 }
 
 string16 CreditCard::GetInfo(AutofillFieldType type) const {
@@ -453,7 +453,7 @@ bool CreditCard::IsValidCreditCardNumber(const string16& text) {
 
 bool CreditCard::IsEmpty() const {
   FieldTypeSet types;
-  GetAvailableFieldTypes(&types);
+  GetNonEmptyTypes(&types);
   return types.empty();
 }
 
diff --git a/chrome/browser/autofill/credit_card.h b/chrome/browser/autofill/credit_card.h
index 1b8cc97..57f0adc 100644
--- a/chrome/browser/autofill/credit_card.h
+++ b/chrome/browser/autofill/credit_card.h
@@ -25,9 +25,9 @@ class CreditCard : public FormGroup {
   virtual ~CreditCard();
 
   // FormGroup implementation:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);
   // Credit card preview summary, for example: ******1234, Exp: 01/2020
diff --git a/chrome/browser/autofill/form_group.cc b/chrome/browser/autofill/form_group.cc
index 1f17f07..ace91f4 100644
--- a/chrome/browser/autofill/form_group.cc
+++ b/chrome/browser/autofill/form_group.cc
@@ -12,8 +12,8 @@ const string16 FormGroup::Label() const { return string16(); }
 
 bool FormGroup::operator!=(const FormGroup& form_group) const {
   FieldTypeSet a, b, symmetric_difference;
-  GetAvailableFieldTypes(&a);
-  form_group.GetAvailableFieldTypes(&b);
+  GetNonEmptyTypes(&a);
+  form_group.GetNonEmptyTypes(&b);
   std::set_symmetric_difference(
       a.begin(), a.end(),
       b.begin(), b.end(),
@@ -27,7 +27,7 @@ bool FormGroup::operator!=(const FormGroup& form_group) const {
 
 bool FormGroup::IsSubsetOf(const FormGroup& form_group) const {
   FieldTypeSet types;
-  GetAvailableFieldTypes(&types);
+  GetNonEmptyTypes(&types);
 
   for (FieldTypeSet::const_iterator iter = types.begin(); iter != types.end();
        ++iter) {
@@ -42,8 +42,8 @@ bool FormGroup::IsSubsetOf(const FormGroup& form_group) const {
 bool FormGroup::IntersectionOfTypesHasEqualValues(
     const FormGroup& form_group) const {
   FieldTypeSet a, b, intersection;
-  GetAvailableFieldTypes(&a);
-  form_group.GetAvailableFieldTypes(&b);
+  GetNonEmptyTypes(&a);
+  form_group.GetNonEmptyTypes(&b);
   std::set_intersection(a.begin(), a.end(),
                         b.begin(), b.end(),
                         std::inserter(intersection, intersection.begin()));
@@ -64,8 +64,8 @@ bool FormGroup::IntersectionOfTypesHasEqualValues(
 
 void FormGroup::MergeWith(const FormGroup& form_group) {
   FieldTypeSet a, b, intersection;
-  GetAvailableFieldTypes(&a);
-  form_group.GetAvailableFieldTypes(&b);
+  GetNonEmptyTypes(&a);
+  form_group.GetNonEmptyTypes(&b);
   std::set_difference(b.begin(), b.end(),
                       a.begin(), a.end(),
                       std::inserter(intersection, intersection.begin()));
@@ -78,7 +78,7 @@ void FormGroup::MergeWith(const FormGroup& form_group) {
 
 void FormGroup::OverwriteWith(const FormGroup& form_group) {
   FieldTypeSet a;;
-  form_group.GetAvailableFieldTypes(&a);
+  form_group.GetNonEmptyTypes(&a);
 
   for (FieldTypeSet::const_iterator iter = a.begin(); iter != a.end(); ++iter) {
     SetInfo(*iter, form_group.GetInfo(*iter));
diff --git a/chrome/browser/autofill/form_group.h b/chrome/browser/autofill/form_group.h
index 537cc20..c976dc3 100644
--- a/chrome/browser/autofill/form_group.h
+++ b/chrome/browser/autofill/form_group.h
@@ -21,13 +21,13 @@ class FormGroup {
 
   // Used to determine the type of a field based on the text that a user enters
   // into the field. The field types can then be reported back to the server.
-  // This method is additive on |possible_types|.
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const = 0;
+  // This method is additive on |matching_types|.
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const = 0;
 
   // Returns a set of AutofillFieldTypes for which this FormGroup has non-empty
   // data.
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const = 0;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const = 0;
 
   // Returns the string that should be auto-filled into a text field given the
   // type of that field.
diff --git a/chrome/browser/autofill/personal_data_manager.cc b/chrome/browser/autofill/personal_data_manager.cc
index 54aa36b..39fa976 100644
--- a/chrome/browser/autofill/personal_data_manager.cc
+++ b/chrome/browser/autofill/personal_data_manager.cc
@@ -565,12 +565,11 @@ CreditCard* PersonalDataManager::GetCreditCardByGUID(const std::string& guid) {
   return NULL;
 }
 
-void PersonalDataManager::GetPossibleFieldTypes(
-    const string16& text,
-    FieldTypeSet* possible_types) const {
+void PersonalDataManager::GetMatchingTypes(const string16& text,
+                                           FieldTypeSet* matching_types) const {
   string16 clean_info = StringToLowerASCII(CollapseWhitespace(text, false));
   if (clean_info.empty()) {
-    possible_types->insert(EMPTY_TYPE);
+    matching_types->insert(EMPTY_TYPE);
     return;
   }
 
@@ -583,7 +582,7 @@ void PersonalDataManager::GetPossibleFieldTypes(
       continue;
     }
 
-    profile->GetPossibleFieldTypes(clean_info, possible_types);
+    profile->GetMatchingTypes(clean_info, matching_types);
   }
 
   for (ScopedVector<CreditCard>::const_iterator iter = credit_cards_.begin();
@@ -594,24 +593,24 @@ void PersonalDataManager::GetPossibleFieldTypes(
       continue;
     }
 
-    credit_card->GetPossibleFieldTypes(clean_info, possible_types);
+    credit_card->GetMatchingTypes(clean_info, matching_types);
   }
 
-  if (possible_types->empty())
-    possible_types->insert(UNKNOWN_TYPE);
+  if (matching_types->empty())
+    matching_types->insert(UNKNOWN_TYPE);
 }
 
-void PersonalDataManager::GetAvailableFieldTypes(
-    FieldTypeSet* available_types) const {
+void PersonalDataManager::GetNonEmptyTypes(
+    FieldTypeSet* non_empty_types) const {
   const std::vector<AutofillProfile*>& profiles = this->profiles();
   for (std::vector<AutofillProfile*>::const_iterator iter = profiles.begin();
        iter != profiles.end(); ++iter) {
-    (*iter)->GetAvailableFieldTypes(available_types);
+    (*iter)->GetNonEmptyTypes(non_empty_types);
   }
 
   for (ScopedVector<CreditCard>::const_iterator iter = credit_cards_.begin();
        iter != credit_cards_.end(); ++iter) {
-    (*iter)->GetAvailableFieldTypes(available_types);
+    (*iter)->GetNonEmptyTypes(non_empty_types);
   }
 }
 
diff --git a/chrome/browser/autofill/personal_data_manager.h b/chrome/browser/autofill/personal_data_manager.h
index ee76063..126818e 100644
--- a/chrome/browser/autofill/personal_data_manager.h
+++ b/chrome/browser/autofill/personal_data_manager.h
@@ -120,11 +120,11 @@ class PersonalDataManager
 
   // Gets the possible field types for the given text, determined by matching
   // the text with all known personal information and returning matching types.
-  void GetPossibleFieldTypes(const string16& text,
-                             FieldTypeSet* possible_types) const;
+  void GetMatchingTypes(const string16& text,
+                        FieldTypeSet* matching_types) const;
 
   // Gets the field types availabe in the stored address and credit card data.
-  void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  void GetNonEmptyTypes(FieldTypeSet* non_empty_types) const;
 
   // Returns true if the credit card information is stored with a password.
   bool HasPassword();
diff --git a/chrome/browser/autofill/personal_data_manager_unittest.cc b/chrome/browser/autofill/personal_data_manager_unittest.cc
index c56e9cd..a7af42c 100644
--- a/chrome/browser/autofill/personal_data_manager_unittest.cc
+++ b/chrome/browser/autofill/personal_data_manager_unittest.cc
@@ -1783,16 +1783,16 @@ TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) {
   EXPECT_EQ(0, expected2.Compare(*results2[0]));
 }
 
-TEST_F(PersonalDataManagerTest, GetAvailableFieldTypes) {
+TEST_F(PersonalDataManagerTest, GetNonEmptyTypes) {
   // Wait for the web database to be loaded.
   EXPECT_CALL(personal_data_observer_,
               OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop());
   MessageLoop::current()->Run();
 
   // Check that there are no available types with no profiles stored.
-  FieldTypeSet available_types;
-  personal_data_->GetAvailableFieldTypes(&available_types);
-  EXPECT_EQ(0U, available_types.size());
+  FieldTypeSet non_empty_types;
+  personal_data_->GetNonEmptyTypes(&non_empty_types);
+  EXPECT_EQ(0U, non_empty_types.size());
 
   // Test with one profile stored.
   AutofillProfile profile0;
@@ -1805,21 +1805,21 @@ TEST_F(PersonalDataManagerTest, GetAvailableFieldTypes) {
   profiles.push_back(profile0);
   personal_data_->SetProfiles(&profiles);
 
-  personal_data_->GetAvailableFieldTypes(&available_types);
-  EXPECT_EQ(13U, available_types.size());
-  EXPECT_TRUE(available_types.count(NAME_FIRST));
-  EXPECT_TRUE(available_types.count(NAME_LAST));
-  EXPECT_TRUE(available_types.count(NAME_FULL));
-  EXPECT_TRUE(available_types.count(EMAIL_ADDRESS));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_LINE1));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_CITY));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_STATE));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_ZIP));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_COUNTRY));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_AND_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_WHOLE_NUMBER));
+  personal_data_->GetNonEmptyTypes(&non_empty_types);
+  EXPECT_EQ(13U, non_empty_types.size());
+  EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
+  EXPECT_TRUE(non_empty_types.count(NAME_LAST));
+  EXPECT_TRUE(non_empty_types.count(NAME_FULL));
+  EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
 
   // Test with multiple profiles stored.
   AutofillProfile profile1;
@@ -1838,31 +1838,31 @@ TEST_F(PersonalDataManagerTest, GetAvailableFieldTypes) {
   profiles.push_back(profile2);
   personal_data_->SetProfiles(&profiles);
 
-  personal_data_->GetAvailableFieldTypes(&available_types);
-  EXPECT_EQ(23U, available_types.size());
-  EXPECT_TRUE(available_types.count(NAME_FIRST));
-  EXPECT_TRUE(available_types.count(NAME_MIDDLE));
-  EXPECT_TRUE(available_types.count(NAME_MIDDLE_INITIAL));
-  EXPECT_TRUE(available_types.count(NAME_LAST));
-  EXPECT_TRUE(available_types.count(NAME_FULL));
-  EXPECT_TRUE(available_types.count(EMAIL_ADDRESS));
-  EXPECT_TRUE(available_types.count(COMPANY_NAME));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_LINE1));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_LINE2));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_CITY));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_STATE));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_ZIP));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_COUNTRY));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_COUNTRY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_AND_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_WHOLE_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_CITY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_COUNTRY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_CITY_AND_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_WHOLE_NUMBER));
+  personal_data_->GetNonEmptyTypes(&non_empty_types);
+  EXPECT_EQ(23U, non_empty_types.size());
+  EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
+  EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
+  EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
+  EXPECT_TRUE(non_empty_types.count(NAME_LAST));
+  EXPECT_TRUE(non_empty_types.count(NAME_FULL));
+  EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
+  EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_CITY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_COUNTRY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_CITY_AND_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_WHOLE_NUMBER));
 
   // Test with credit card information also stored.
   CreditCard credit_card;
@@ -1874,36 +1874,36 @@ TEST_F(PersonalDataManagerTest, GetAvailableFieldTypes) {
   credit_cards.push_back(credit_card);
   personal_data_->SetCreditCards(&credit_cards);
 
-  personal_data_->GetAvailableFieldTypes(&available_types);
-  EXPECT_EQ(30U, available_types.size());
-  EXPECT_TRUE(available_types.count(NAME_FIRST));
-  EXPECT_TRUE(available_types.count(NAME_MIDDLE));
-  EXPECT_TRUE(available_types.count(NAME_MIDDLE_INITIAL));
-  EXPECT_TRUE(available_types.count(NAME_LAST));
-  EXPECT_TRUE(available_types.count(NAME_FULL));
-  EXPECT_TRUE(available_types.count(EMAIL_ADDRESS));
-  EXPECT_TRUE(available_types.count(COMPANY_NAME));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_LINE1));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_LINE2));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_CITY));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_STATE));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_ZIP));
-  EXPECT_TRUE(available_types.count(ADDRESS_HOME_COUNTRY));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_COUNTRY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_CITY_AND_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_HOME_WHOLE_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_CITY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_COUNTRY_CODE));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_CITY_AND_NUMBER));
-  EXPECT_TRUE(available_types.count(PHONE_FAX_WHOLE_NUMBER));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_NAME));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_NUMBER));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_EXP_MONTH));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_EXP_2_DIGIT_YEAR));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_EXP_4_DIGIT_YEAR));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR));
-  EXPECT_TRUE(available_types.count(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR));
+  personal_data_->GetNonEmptyTypes(&non_empty_types);
+  EXPECT_EQ(30U, non_empty_types.size());
+  EXPECT_TRUE(non_empty_types.count(NAME_FIRST));
+  EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE));
+  EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL));
+  EXPECT_TRUE(non_empty_types.count(NAME_LAST));
+  EXPECT_TRUE(non_empty_types.count(NAME_FULL));
+  EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS));
+  EXPECT_TRUE(non_empty_types.count(COMPANY_NAME));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP));
+  EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_CITY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_COUNTRY_CODE));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_CITY_AND_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(PHONE_FAX_WHOLE_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NAME));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NUMBER));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_MONTH));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_2_DIGIT_YEAR));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_4_DIGIT_YEAR));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR));
+  EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR));
 }
diff --git a/chrome/browser/autofill/phone_number.cc b/chrome/browser/autofill/phone_number.cc
index 5b7c939..d1ca32a 100644
--- a/chrome/browser/autofill/phone_number.cc
+++ b/chrome/browser/autofill/phone_number.cc
@@ -50,46 +50,46 @@ PhoneNumber& PhoneNumber::operator=(const PhoneNumber& number) {
   return *this;
 }
 
-void PhoneNumber::GetPossibleFieldTypes(const string16& text,
-                                        FieldTypeSet* possible_types) const {
+void PhoneNumber::GetMatchingTypes(const string16& text,
+                                   FieldTypeSet* matching_types) const {
   string16 stripped_text(text);
   StripPunctuation(&stripped_text);
   if (!Validate(stripped_text))
     return;
 
   if (IsNumber(stripped_text))
-    possible_types->insert(GetNumberType());
+    matching_types->insert(GetNumberType());
 
   if (IsCityCode(stripped_text))
-    possible_types->insert(GetCityCodeType());
+    matching_types->insert(GetCityCodeType());
 
   if (IsCountryCode(stripped_text))
-    possible_types->insert(GetCountryCodeType());
+    matching_types->insert(GetCountryCodeType());
 
   if (IsCityAndNumber(stripped_text))
-    possible_types->insert(GetCityAndNumberType());
+    matching_types->insert(GetCityAndNumberType());
 
   if (IsWholeNumber(stripped_text))
-    possible_types->insert(GetWholeNumberType());
+    matching_types->insert(GetWholeNumberType());
 }
 
-void PhoneNumber::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
-  DCHECK(available_types);
+void PhoneNumber::GetNonEmptyTypes(FieldTypeSet* non_empty_typess) const {
+  DCHECK(non_empty_typess);
 
   if (!number().empty())
-    available_types->insert(GetNumberType());
+    non_empty_typess->insert(GetNumberType());
 
   if (!city_code().empty())
-    available_types->insert(GetCityCodeType());
+    non_empty_typess->insert(GetCityCodeType());
 
   if (!country_code().empty())
-    available_types->insert(GetCountryCodeType());
+    non_empty_typess->insert(GetCountryCodeType());
 
   if (!CityAndNumber().empty())
-    available_types->insert(GetCityAndNumberType());
+    non_empty_typess->insert(GetCityAndNumberType());
 
   if (!WholeNumber().empty())
-    available_types->insert(GetWholeNumberType());
+    non_empty_typess->insert(GetWholeNumberType());
 }
 
 string16 PhoneNumber::GetInfo(AutofillFieldType type) const {
diff --git a/chrome/browser/autofill/phone_number.h b/chrome/browser/autofill/phone_number.h
index b590a61..9cbb6b2 100644
--- a/chrome/browser/autofill/phone_number.h
+++ b/chrome/browser/autofill/phone_number.h
@@ -23,9 +23,9 @@ class PhoneNumber : public FormGroup {
   PhoneNumber& operator=(const PhoneNumber& number);
 
   // FormGroup implementation:
-  virtual void GetPossibleFieldTypes(const string16& text,
-                                     FieldTypeSet* possible_types) const;
-  virtual void GetAvailableFieldTypes(FieldTypeSet* available_types) const;
+  virtual void GetMatchingTypes(const string16& text,
+                                FieldTypeSet* matching_types) const;
+  virtual void GetNonEmptyTypes(FieldTypeSet* non_empty_typess) const;
   virtual string16 GetInfo(AutofillFieldType type) const;
   virtual void SetInfo(AutofillFieldType type, const string16& value);