i18n address editing in chrome://settings/autofillEditAddress.

chrome/browser/ui/webui/options/autofill_options_handler.cc

 // Copyright (c) 2012 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/ui/webui/options/autofill_options_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/autofill/country_combobox_model.h"
 #include "chrome/common/url_constants.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/phone_number_i18n.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/component_strings.h"
 #include "grit/generated_resources.h"
+#include "grit/libaddressinput_strings.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_ui.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_ui_component.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/webui/web_ui_util.h"
 
 using autofill::AutofillCountry;
 using autofill::ServerFieldType;
 using autofill::AutofillProfile;
 using autofill::CreditCard;
 using autofill::PersonalDataManager;
 
 namespace {
 
 const char kSettingsOrigin[] = "Chrome settings";
 
 // Sets data related to the country <select>.
 void SetCountryData(const PersonalDataManager& manager,
                     base::DictionaryValue* localized_strings) {
   autofill::CountryComboboxModel model(
       manager, base::Callback<bool(const std::string&)>());
   const std::vector<AutofillCountry*>& countries = model.countries();
   localized_strings->SetString("defaultCountryCode",
                                countries.front()->country_code());
 
   // An ordered list of options to show in the <select>.
   scoped_ptr<base::ListValue> country_list(new base::ListValue());
-  // A dictionary of postal code and state info, keyed on country code.
-  scoped_ptr<base::DictionaryValue> country_data(new base::DictionaryValue());
   for (size_t i = 0; i < countries.size(); ++i) {
     scoped_ptr<base::DictionaryValue> option_details(
         new base::DictionaryValue());
     option_details->SetString("name", model.GetItemAt(i));
     option_details->SetString(
         "value",
         countries[i] ? countries[i]->country_code() : "separator");
     country_list->Append(option_details.release());
-
-    if (!countries[i])
-      continue;
-
-    scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue());
-    details->SetString("postalCodeLabel", countries[i]->postal_code_label());
-    details->SetString("stateLabel", countries[i]->state_label());
-    country_data->Set(countries[i]->country_code(), details.release());
-
   }
   localized_strings->Set("autofillCountrySelectList", country_list.release());
-  localized_strings->Set("autofillCountryData", country_data.release());
+}
+
+// Fills |components| with the address UI components that should be used to
+// input an address for |country_code| when UI BCP 47 language code is
+// |ui_language_code|. If |components_language_code| is not NULL, then sets it
+// the BCP 47 language code that should be used to format the address for
+// display.
+void GetAddressComponents(const std::string& country_code,
+                          const std::string& ui_language_code,
+                          base::ListValue* address_components,
+                          std::string* components_language_code) {
+  DCHECK(address_components);
+  std::vector<i18n::addressinput::AddressUiComponent> components =
+      i18n::addressinput::BuildComponents(
+          country_code, ui_language_code, components_language_code);
+  if (components.empty()) {
+    static const char kDefaultCountryCode[] = "US";
+    components = i18n::addressinput::BuildComponents(
+        kDefaultCountryCode, ui_language_code, components_language_code);
+  }
+  DCHECK(!components.empty());
+  static const char kField[] = "field";
+  static const char kLengthHint[] = "length";
+  for (std::vector<i18n::addressinput::AddressUiComponent>::const_iterator it =
+           components.begin();
+       it != components.end(); ++it) {
+    scoped_ptr<base::DictionaryValue> component(new base::DictionaryValue);
+    switch (it->field) {
+      case i18n::addressinput::COUNTRY:
+        component->SetString(kField, "country");
+        break;
+      case i18n::addressinput::ADMIN_AREA:
+        component->SetString(kField, "admin-area");
+        break;
+      case i18n::addressinput::LOCALITY:
+        component->SetString(kField, "locality");
+        break;
+      case i18n::addressinput::DEPENDENT_LOCALITY:
+        component->SetString(kField, "dependent-locality");
+        break;
+      case i18n::addressinput::SORTING_CODE:
+        component->SetString(kField, "sorting-code");
+        break;
+      case i18n::addressinput::POSTAL_CODE:
+        component->SetString(kField, "postal-code");
+        break;
+      case i18n::addressinput::STREET_ADDRESS:
+        component->SetString(kField, "street-address");
+        break;
+      case i18n::addressinput::ORGANIZATION:
+        component->SetString(kField, "organization");
+        break;
+      case i18n::addressinput::RECIPIENT:
+        component->SetString(kField, "recipient");
+        break;
+    }
+    component->SetString("name", l10n_util::GetStringUTF16(it->name_id));
+    switch (it->length_hint) {
+      case i18n::addressinput::AddressUiComponent::HINT_SHORT:
+        component->SetString(kLengthHint, "short");
+        break;
+      case i18n::addressinput::AddressUiComponent::HINT_LONG:
+        component->SetString(kLengthHint, "long");
+        break;
+    }
+    address_components->Append(component.release());
+  }
 }

[Evan Stade, 2014/04/22 00:51:58]

vertical whitespace in this function

[please use gerrit instead, 2014/04/24 20:10:59]

Done.

 
 // Get the multi-valued element for |type| and return it in |ListValue| form.
 void GetValueList(const AutofillProfile& profile,
                   ServerFieldType type,
                   scoped_ptr<base::ListValue>* list) {
   list->reset(new base::ListValue);
 
   std::vector<base::string16> values;
   profile.GetRawMultiInfo(type, &values);
 
@@ skipping 211 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "removeData",
       base::Bind(&AutofillOptionsHandler::RemoveData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "loadAddressEditor",
       base::Bind(&AutofillOptionsHandler::LoadAddressEditor,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "loadAddressEditorComponents",
+      base::Bind(&AutofillOptionsHandler::LoadAddressEditorComponents,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "loadCreditCardEditor",
       base::Bind(&AutofillOptionsHandler::LoadCreditCardEditor,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setAddress",
       base::Bind(&AutofillOptionsHandler::SetAddress, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setCreditCard",
       base::Bind(&AutofillOptionsHandler::SetCreditCard,
                  base::Unretained(this)));
@@ skipping 12 matching lines @@
 void AutofillOptionsHandler::SetAddressOverlayStrings(
     base::DictionaryValue* localized_strings) {
   localized_strings->SetString("autofillEditAddressTitle",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_EDIT_ADDRESS_CAPTION));
   localized_strings->SetString("autofillFirstNameLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_FIRST_NAME));
   localized_strings->SetString("autofillMiddleNameLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_MIDDLE_NAME));
   localized_strings->SetString("autofillLastNameLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_LAST_NAME));
-  localized_strings->SetString("autofillCompanyNameLabel",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_COMPANY_NAME));
-  localized_strings->SetString("autofillAddrLine1Label",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADDRESS_LINE_1));
-  localized_strings->SetString("autofillAddrLine2Label",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADDRESS_LINE_2));
-  localized_strings->SetString("autofillCityLabel",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_CITY));
   localized_strings->SetString("autofillCountryLabel",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_COUNTRY));
+      l10n_util::GetStringUTF16(IDS_LIBADDRESSINPUT_I18N_COUNTRY_LABEL));
   localized_strings->SetString("autofillPhoneLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_PHONE));
   localized_strings->SetString("autofillEmailLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_EMAIL));
   localized_strings->SetString("autofillAddFirstNamePlaceholder",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_FIRST_NAME));
   localized_strings->SetString("autofillAddMiddleNamePlaceholder",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_MIDDLE_NAME));
   localized_strings->SetString("autofillAddLastNamePlaceholder",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_LAST_NAME));
   localized_strings->SetString("autofillAddPhonePlaceholder",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_PHONE));
   localized_strings->SetString("autofillAddEmailPlaceholder",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_EMAIL));
+  localized_strings->SetString("addStreetAddressLinePlaceholder",
+      l10n_util::GetStringUTF16(
+          IDS_AUTOFILL_FIELD_LABEL_ADD_STREET_ADDRESS_LINE));
   SetCountryData(*personal_data_, localized_strings);
 }
 
 void AutofillOptionsHandler::SetCreditCardOverlayStrings(
     base::DictionaryValue* localized_strings) {
   localized_strings->SetString("autofillEditCreditCardTitle",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_EDIT_CREDITCARD_CAPTION));
   localized_strings->SetString("nameOnCardLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_NAME_ON_CARD));
   localized_strings->SetString("creditCardNumberLabel",
@@ skipping 70 matching lines @@
     // the list is not updated until the model tells the list an item has been
     // removed). This will activate the editor for a profile that has been
     // removed. Do nothing in that case.
     return;
   }
 
   base::DictionaryValue address;
   address.SetString("guid", profile->guid());
   scoped_ptr<base::ListValue> list;
   GetNameList(*profile, &list);
-  address.Set("fullName", list.release());
-  address.SetString("companyName", profile->GetRawInfo(autofill::COMPANY_NAME));
-  address.SetString("addrLine1",
-                    profile->GetRawInfo(autofill::ADDRESS_HOME_LINE1));
-  address.SetString("addrLine2",
-                    profile->GetRawInfo(autofill::ADDRESS_HOME_LINE2));
-  address.SetString("city", profile->GetRawInfo(autofill::ADDRESS_HOME_CITY));
-  address.SetString("state", profile->GetRawInfo(autofill::ADDRESS_HOME_STATE));
+  address.Set("recipient", list.release());
+  address.SetString(
+      "organization", profile->GetRawInfo(autofill::COMPANY_NAME));
+
+  std::vector<base::string16> street_address;
+  base::SplitString(profile->GetRawInfo(autofill::ADDRESS_HOME_STREET_ADDRESS),
+                    '\n', &street_address);
+  scoped_ptr<base::ListValue> street_address_list(new base::ListValue);
+  street_address_list->AppendStrings(street_address);
+  address.Set("streetAddress", street_address_list.release());
+
+  address.SetString(
+      "locality", profile->GetRawInfo(autofill::ADDRESS_HOME_CITY));
+  address.SetString(
+      "adminArea", profile->GetRawInfo(autofill::ADDRESS_HOME_STATE));
+  address.SetString(
+      "dependentLocality",
+      profile->GetRawInfo(autofill::ADDRESS_HOME_DEPENDENT_LOCALITY));
+  address.SetString("sortingCode",
+                    profile->GetRawInfo(autofill::ADDRESS_HOME_SORTING_CODE));
   address.SetString("postalCode",
                     profile->GetRawInfo(autofill::ADDRESS_HOME_ZIP));
   address.SetString("country",
                     profile->GetRawInfo(autofill::ADDRESS_HOME_COUNTRY));
   GetValueList(*profile, autofill::PHONE_HOME_WHOLE_NUMBER, &list);
   address.Set("phone", list.release());
   GetValueList(*profile, autofill::EMAIL_ADDRESS, &list);
   address.Set("email", list.release());
+  address.SetString("languageCode", profile->language_code());
+
+  scoped_ptr<base::ListValue> components(new base::ListValue);
+  GetAddressComponents(
+      UTF16ToUTF8(profile->GetRawInfo(autofill::ADDRESS_HOME_COUNTRY)),
+      profile->language_code(), components.get(), NULL);
+  address.Set("components", components.release());
 
   web_ui()->CallJavascriptFunction("AutofillOptions.editAddress", address);
 }
 
+void AutofillOptionsHandler::LoadAddressEditorComponents(
+    const base::ListValue* args) {
+  std::string country_code;
+  if (!args->GetString(0, &country_code)) {
+    NOTREACHED();
+    return;
+  }
+
+  base::DictionaryValue input;
+  scoped_ptr<base::ListValue> components(new base::ListValue);
+  std::string language_code;
+  GetAddressComponents(country_code, g_browser_process->GetApplicationLocale(),
+                       components.get(), &language_code);
+  input.Set("components", components.release());
+  input.SetString("languageCode", language_code);
+
+  web_ui()->CallJavascriptFunction(
+      "AutofillEditAddressOverlay.loadAddressComponents", input);
+}
+
 void AutofillOptionsHandler::LoadCreditCardEditor(const base::ListValue* args) {
   DCHECK(IsPersonalDataLoaded());
 
   std::string guid;
   if (!args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
 
   CreditCard* credit_card = personal_data_->GetCreditCardByGUID(guid);
@@ skipping 31 matching lines @@
 
   std::string guid;
   if (!args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
 
   AutofillProfile profile(guid, kSettingsOrigin);
 
   std::string country_code;
+  std::string language_code;
   base::string16 value;
   const base::ListValue* list_value;
   if (args->GetList(1, &list_value))
     SetNameList(list_value, &profile);
 
   if (args->GetString(2, &value))
     profile.SetRawInfo(autofill::COMPANY_NAME, value);
 
-  if (args->GetString(3, &value))
-    profile.SetRawInfo(autofill::ADDRESS_HOME_LINE1, value);
+  if (args->GetList(3, &list_value)) {
+    std::vector<base::string16> street_address;
+    for (size_t i = 0; i < list_value->GetSize(); ++i) {
+      if (list_value->GetString(i, &value))
+        street_address.push_back(value);
+    }
+    profile.SetRawInfo(autofill::ADDRESS_HOME_STREET_ADDRESS,
+                       JoinString(street_address, '\n'));
+  }
 
   if (args->GetString(4, &value))
-    profile.SetRawInfo(autofill::ADDRESS_HOME_LINE2, value);
+    profile.SetRawInfo(autofill::ADDRESS_HOME_DEPENDENT_LOCALITY, value);
 
   if (args->GetString(5, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_CITY, value);
 
   if (args->GetString(6, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_STATE, value);
 
   if (args->GetString(7, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_ZIP, value);
 
-  if (args->GetString(8, &country_code))
+  if (args->GetString(8, &value))
+    profile.SetRawInfo(autofill::ADDRESS_HOME_SORTING_CODE, value);
+
+  if (args->GetString(9, &country_code))
     profile.SetRawInfo(autofill::ADDRESS_HOME_COUNTRY,
                        base::ASCIIToUTF16(country_code));
 
-  if (args->GetList(9, &list_value))
+  if (args->GetList(10, &list_value))
     SetValueList(list_value, autofill::PHONE_HOME_WHOLE_NUMBER, &profile);
 
-  if (args->GetList(10, &list_value))
+  if (args->GetList(11, &list_value))
     SetValueList(list_value, autofill::EMAIL_ADDRESS, &profile);
 
+  if (args->GetString(12, &language_code))
+    profile.set_language_code(language_code);
+
   if (!base::IsValidGUID(profile.guid())) {
     profile.set_guid(base::GenerateGUID());
     personal_data_->AddProfile(profile);
   } else {
     personal_data_->UpdateProfile(profile);
   }
 }
 
 void AutofillOptionsHandler::SetCreditCard(const base::ListValue* args) {
   if (!IsPersonalDataLoaded())
@@ skipping 36 matching lines @@
 
   web_ui()->CallJavascriptFunction(
     "AutofillEditAddressOverlay.setValidatedPhoneNumbers", *list_value);
 }
 
 bool AutofillOptionsHandler::IsPersonalDataLoaded() const {
   return personal_data_ && personal_data_->IsDataLoaded();
 }
 
 }  // namespace options