[Autofill] Check for full state name and abbreviation when determining types to upload.

components/autofill/core/browser/address.cc

 // Copyright 2013 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 "components/autofill/core/browser/address.h"
 
 #include <stddef.h>
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_field.h"
+#include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
+#include "components/autofill/core/browser/state_names.h"
+#include "components/autofill/core/common/autofill_l10n_util.h"
 
 namespace autofill {
 
 Address::Address() {}
 
 Address::Address(const Address& address) : FormGroup() {
   *this = address;
 }
 
 Address::~Address() {}
@@ skipping 163 matching lines @@
 
 void Address::GetMatchingTypes(const base::string16& text,
                                const std::string& app_locale,
                                ServerFieldTypeSet* matching_types) const {
   FormGroup::GetMatchingTypes(text, app_locale, matching_types);
 
   // Check to see if the |text| canonicalized as a country name is a match.
   std::string country_code = CountryNames::GetInstance()->GetCountryCode(text);
   if (!country_code.empty() && country_code_ == country_code)
     matching_types->insert(ADDRESS_HOME_COUNTRY);
+
+  // Check to see if the |text| could be the full name or abbreviation of a
+  // state.
+  base::string16 canon_text = AutofillProfile::CanonicalizeProfileString(text);
+  base::string16 state_name;
+  base::string16 state_abbreviation;
+  state_names::GetNameAndAbbreviation(canon_text, &state_name,
+                                      &state_abbreviation);
+  if (!state_name.empty() || !state_abbreviation.empty()) {

[Mathieu, 2016/03/18 13:56:04]

At this point, we're pretty certain the field is a state field, right? We've
looked it up in our state database and it's a match (Note that this may become
an expensive lookup when we add tons more countries and their regions). I wonder
why/if we need to check the person's profile to make sure it's their own state.
WDYT, is it good to be cautious? Or does GetMatchingTypes get used for *other*
things other than uploading votes?

[sebsg, 2016/03/18 14:25:54]

It was to be cautious and also consistent with all the other cases where we
check if it matches an information from a profile. The only case I can think of
is New York city (which would be detected as a state since it's in the New York
state). However, this problem seems inevitable and happens regardless of
checking the person's state or not. It should also not happen often enough to be
a problem (compared with all the uploads). 

Since the only place GetMatchingTypes is called from is
DeterminePossibleFieldTypesForUpload, I think we could probably remove the
matching with the person's state.

So I'll go ahead and remove it unless there are objections. Thanks!

[Mathieu, 2016/03/18 14:35:20]

Another case of the New York, New York case is Quebec, Quebec. But that one is
irrelevant like you said. What interests me is if you live in a city that is
another country's state name. For example, if there is a city in the world named
California. In that case we DON'T want to vote for STATE, because it's a city
field. I think we should keep your code as is.

+    l10n::CaseInsensitiveCompare compare;
+    base::string16 canon_profile_state =
+        AutofillProfile::CanonicalizeProfileString(
+            GetInfo(AutofillType(ADDRESS_HOME_STATE), app_locale));
+    if ((!state_name.empty() &&
+         compare.StringsEqual(state_name, canon_profile_state)) ||
+        (!state_abbreviation.empty() &&
+         compare.StringsEqual(state_abbreviation, canon_profile_state))) {
+      matching_types->insert(ADDRESS_HOME_STATE);
+    }
+  }
 }
 
 void Address::GetSupportedTypes(ServerFieldTypeSet* supported_types) const {
   supported_types->insert(ADDRESS_HOME_LINE1);
   supported_types->insert(ADDRESS_HOME_LINE2);
   supported_types->insert(ADDRESS_HOME_LINE3);
   supported_types->insert(ADDRESS_HOME_STREET_ADDRESS);
   supported_types->insert(ADDRESS_HOME_DEPENDENT_LOCALITY);
   supported_types->insert(ADDRESS_HOME_CITY);
   supported_types->insert(ADDRESS_HOME_STATE);
   supported_types->insert(ADDRESS_HOME_ZIP);
   supported_types->insert(ADDRESS_HOME_SORTING_CODE);
   supported_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 void Address::TrimStreetAddress() {
   while (!street_address_.empty() && street_address_.back().empty()) {
     street_address_.pop_back();
   }
 }
 
 }  // namespace autofill