autofill: be more open minded about filling in states in <option>s.

components/autofill/core/browser/autofill_field.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/autofill_field.h"
 
 #include "base/logging.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 48 matching lines @@
     }
   }
 
   if (best_match.empty())
     return false;
 
   field->value = best_match;
   return true;
 }
 
+// Like SetSelectControlValue, but searches within the field values and options
+// for |value|. For example, "NC - North Carolina" would match "north carolina".

[Ilya Sherman, 2014/07/01 00:59:08]

Would "WV - West Virginia" match "virginia"?  It seems like it would, and it
seems like that's problematic...

[Evan Stade, 2014/07/01 01:04:56]

hmm, yes I suppose it would. Perhaps I could make it choose the shortest option
that has a substring match, so it would prefer "VA - Virginia" over "WV - West
Virginia" if both were present. If only "WV - West Virginia" is present, it
would fill it incorrectly, but that seems like a rare case.

[Ilya Sherman, 2014/07/01 01:17:47]

Yeah, maybe.  Alternately, we could just kinda assume that lists will be
alphabetically sorted, and hence things will Just Work(TM).  But it's at least
worth documenting this potential failure case.  (The only other pair with this
property that I can think of is "Washington" and "Washington, D.C.".  Though,
our canonical list of state names lists DC as "district of columbia", so in
practice that pair shouldn't tickle this particular issue.)

+bool SetSelectControlValueSubstringMatch(const base::string16& value,
+                                         FormFieldData* field) {
+  base::string16 value_lowercase = StringToLowerASCII(value);
+  DCHECK_EQ(field->option_values.size(), field->option_contents.size());
+
+  for (size_t i = 0; i < field->option_values.size(); ++i) {
+    if (StringToLowerASCII(field->option_values[i]).find(value_lowercase) !=
+            std::string::npos ||
+        StringToLowerASCII(field->option_contents[i]).find(value_lowercase) !=
+            std::string::npos) {
+      field->value = field->option_values[i];
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Like SetSelectControlValue, but searches within the field values and options
+// for |value|. First it tokenizes the options, then tries to match against
+// tokens. For example, "NC - North Carolina" would match "nc" but not "ca".
+bool SetSelectControlValueTokenMatch(const base::string16& value,
+                                     FormFieldData* field) {
+  base::string16 value_lowercase = StringToLowerASCII(value);
+  std::vector<base::string16> tokenized;
+  DCHECK_EQ(field->option_values.size(), field->option_contents.size());
+
+  for (size_t i = 0; i < field->option_values.size(); ++i) {
+    SplitStringAlongWhitespace(StringToLowerASCII(field->option_values[i]),
+                               &tokenized);
+    if (std::find(tokenized.begin(), tokenized.end(), value_lowercase) !=
+        tokenized.end()) {
+      field->value = field->option_values[i];
+      return true;
+    }
+
+    SplitStringAlongWhitespace(StringToLowerASCII(field->option_contents[i]),
+                               &tokenized);
+    if (std::find(tokenized.begin(), tokenized.end(), value_lowercase) !=
+        tokenized.end()) {
+      field->value = field->option_values[i];
+      return true;
+    }
+  }
+
+  return false;
+}
 
 // Try to fill a numeric |value| into the given |field|.
 bool FillNumericSelectControl(int value,
                               FormFieldData* field) {
   DCHECK_EQ(field->option_values.size(), field->option_contents.size());
   for (size_t i = 0; i < field->option_values.size(); ++i) {
     int option;
     if ((StringToInt(field->option_values[i], &option) && option == value) ||
         (StringToInt(field->option_contents[i], &option) && option == value)) {
       field->value = field->option_values[i];
       return true;
     }
   }
 
   return false;
 }
 
 bool FillStateSelectControl(const base::string16& value,
                             FormFieldData* field) {
   base::string16 full, abbreviation;
   state_names::GetNameAndAbbreviation(value, &full, &abbreviation);
 
-  // Try the abbreviation first.
-  if (!abbreviation.empty() && SetSelectControlValue(abbreviation, field))
+  // Try an exact match of the abbreviation first.
+  if (!abbreviation.empty() && SetSelectControlValue(abbreviation, field)) {
     return true;
+  }

[Dan Beam, 2014/07/01 00:34:32]

why so curly?

 
-  return !full.empty() && SetSelectControlValue(full, field);
+  // Try an exact match of the full name.
+  if (!full.empty() && SetSelectControlValue(full, field)) {
+    return true;
+  }
+
+  // Then try an inexact match of the full name.
+  if (!full.empty() && SetSelectControlValueSubstringMatch(full, field)) {
+    return true;
+  }
+
+  // Then try an inexact match of the abbreviation name.
+  return !abbreviation.empty() &&
+      SetSelectControlValueTokenMatch(abbreviation, field);
 }
 
 bool FillCountrySelectControl(const base::string16& value,
                               const std::string& app_locale,
                               FormFieldData* field_data) {
   std::string country_code = AutofillCountry::GetCountryCode(value, app_locale);
   if (country_code.empty())
     return false;
 
   DCHECK_EQ(field_data->option_values.size(),
@@ skipping 298 matching lines @@
   } else if (type.GetStorableType() == ADDRESS_HOME_STREET_ADDRESS) {
     FillStreetAddress(value, field_data);
     return true;
   }
 
   field_data->value = value;
   return true;
 }
 
 }  // namespace autofill