[Autofill] Add support for three pairs of new server field types.

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 "base/basictypes.h"
 #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_type.h"
 
 namespace autofill {
 
 Address::Address() {}
 
@@ skipping 30 matching lines @@
 
     case ADDRESS_HOME_STATE:
       return state_;
 
     case ADDRESS_HOME_ZIP:
       return zip_code_;
 
     case ADDRESS_HOME_COUNTRY:
       return ASCIIToUTF16(country_code_);
 
+    case ADDRESS_HOME_STREET_ADDRESS: {
+      base::string16 address = line1_;
+      if (!line2_.empty())
+        address += ASCIIToUTF16("\n") + line2_;
+      return address;
+    }
+
+    // TODO(isherman): Add support for these field types in support of i18n.
+    case ADDRESS_HOME_SORTING_CODE:
+    case ADDRESS_HOME_DEPENDENT_LOCALITY:
+      return base::string16();
+
     default:
+      NOTREACHED();
       return base::string16();
   }
 }
 
 void Address::SetRawInfo(ServerFieldType type, const base::string16& value) {
   DCHECK_EQ(ADDRESS_HOME, AutofillType(type).group());
   switch (type) {
     case ADDRESS_HOME_LINE1:
       line1_ = value;
       break;
@@ skipping 13 matching lines @@
     case ADDRESS_HOME_COUNTRY:
       DCHECK(value.empty() ||
              (value.length() == 2u && IsStringASCII(value)));
       country_code_ = UTF16ToASCII(value);
       break;
 
     case ADDRESS_HOME_ZIP:
       zip_code_ = value;
       break;
 
+    case ADDRESS_HOME_STREET_ADDRESS: {
+      // Clear any stale values, which might or might not get overwritten below.
+      line1_.clear();
+      line2_.clear();
+
+      std::vector<base::string16> lines;
+      base::SplitString(value, char16('\n'), &lines);
+      if (lines.size() > 0)
+        line1_ = lines[0];
+      if (lines.size() > 1)
+        line2_ = lines[1];
+
+      // TODO(isherman): Add support for additional address lines.
+      break;
+    }
+
+    // TODO(isherman): Add support for these field types in support of i18n.
+    case ADDRESS_HOME_SORTING_CODE:
+    case ADDRESS_HOME_DEPENDENT_LOCALITY:
+      break;
+
     default:
       NOTREACHED();
   }
 }
 
 base::string16 Address::GetInfo(const AutofillType& type,
                                 const std::string& app_locale) const {
-  if (type.html_type() == HTML_TYPE_COUNTRY_CODE) {
+  if (type.html_type() == HTML_TYPE_COUNTRY_CODE)
     return ASCIIToUTF16(country_code_);
-  } else if (type.html_type() == HTML_TYPE_STREET_ADDRESS) {
+
+  ServerFieldType storable_type = type.GetStorableType();
+  if (storable_type == ADDRESS_HOME_COUNTRY && !country_code_.empty())
+    return AutofillCountry(country_code_, app_locale).name();
+
+  if (storable_type == ADDRESS_HOME_STREET_ADDRESS) {
+    // TODO(isherman): Remove this special-case.
     base::string16 address = line1_;
     if (!line2_.empty())
       address += ASCIIToUTF16(", ") + line2_;
     return address;
   }
 
-  ServerFieldType storable_type = type.GetStorableType();
-  if (storable_type == ADDRESS_HOME_COUNTRY && !country_code_.empty())
-    return AutofillCountry(country_code_, app_locale).name();
-
   return GetRawInfo(storable_type);
 }
 
 bool Address::SetInfo(const AutofillType& type,
                       const base::string16& value,
                       const std::string& app_locale) {
   if (type.html_type() == HTML_TYPE_COUNTRY_CODE) {
     if (!value.empty() && (value.size() != 2u || !IsStringASCII(value))) {
       country_code_ = std::string();
       return false;
     }
 
     country_code_ = StringToUpperASCII(UTF16ToASCII(value));
     return true;
-  } else if (type.html_type() == HTML_TYPE_STREET_ADDRESS) {
-    // Don't attempt to parse the address into lines, since this is potentially
-    // a user-entered address in the user's own format, so the code would have
-    // to rely on iffy heuristics at best.  Instead, just give up when importing
-    // addresses like this.
-    line1_ = line2_ = base::string16();
-    return false;
   }
 
   ServerFieldType storable_type = type.GetStorableType();
   if (storable_type == ADDRESS_HOME_COUNTRY && !value.empty()) {
     country_code_ = AutofillCountry::GetCountryCode(value, app_locale);
     return !country_code_.empty();
   }
 
+  // If the address doesn't have any newlines, don't attempt to parse it into
+  // lines, since this is potentially a user-entered address in the user's own
+  // format, so the code would have to rely on iffy heuristics at best.
+  // Instead, just give up when importing addresses like this.
+  if (storable_type == ADDRESS_HOME_STREET_ADDRESS && !value.empty() &&
+      value.find(char16('\n')) == base::string16::npos) {

[Evan Stade, 2013/10/16 23:18:33]

is it possible to put this check at a layer which would know whether newlines
were possible? i.e. typing a single line address into a textarea should work
because then it's not that the website was limiting.

[Ilya Sherman, 2013/10/17 01:12:35]

I thought about it and couldn't come up with a good way to do so.  In general,
it's o.k. to be conservative about when calls to SetInfo() will fail, as it just
means that it takes longer for valid data to be automagically aggregated.  So
while I agree that this heuristic isn't perfect, I think it's Good Enough™.

[Evan Stade, 2013/10/17 02:27:30]

would it be too much of a hack or not work if you just appended an extra \n to
the value you extract from the textarea?

[Ilya Sherman, 2013/10/17 02:53:26]

Leading and trailing whitespace is trimmed off by the time the code flow reaches
here.  I guess we could special-case that at several layers, but it gets pretty
hacky.

+    line1_ = line2_ = base::string16();
+    return false;
+  }
+
   SetRawInfo(storable_type, value);
   return true;
 }
 
 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 = AutofillCountry::GetCountryCode(text, app_locale);
   if (!country_code.empty() && country_code_ == country_code)
     matching_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 void Address::GetSupportedTypes(ServerFieldTypeSet* supported_types) const {
   supported_types->insert(ADDRESS_HOME_LINE1);
   supported_types->insert(ADDRESS_HOME_LINE2);
   supported_types->insert(ADDRESS_HOME_CITY);
   supported_types->insert(ADDRESS_HOME_STATE);
   supported_types->insert(ADDRESS_HOME_ZIP);
   supported_types->insert(ADDRESS_HOME_COUNTRY);
 }
 
 }  // namespace autofill