rAc: use libaddressinput to validate international addresses.

chrome/browser/ui/autofill/autofill_dialog_controller_impl.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 "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "base/base64.h"
 #include "base/bind.h"
+#include "base/files/file_path.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
+#include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "chrome/browser/autofill/address_storage_factory.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/autofill_dialog_common.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_i18n_input.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_view.h"
 #include "chrome/browser/ui/autofill/data_model_wrapper.h"
 #include "chrome/browser/ui/autofill/generated_credit_card_bubble_controller.h"
 #include "chrome/browser/ui/autofill/new_credit_card_bubble_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "components/autofill/content/browser/risk/fingerprint.h"
 #include "components/autofill/content/browser/risk/proto/fingerprint.pb.h"
 #include "components/autofill/content/browser/wallet/form_field_error.h"
 #include "components/autofill/content/browser/wallet/full_wallet.h"
 #include "components/autofill/content/browser/wallet/gaia_account.h"
 #include "components/autofill/content/browser/wallet/instrument.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/url_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/component_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "grit/theme_resources.h"
 #include "grit/webkit_resources.h"
 #include "net/cert/cert_status_flags.h"
+#include "third_party/libaddressinput/chromium/chrome_downloader_impl.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_data.h"
+#include "third_party/libaddressinput/chromium/cpp/include/libaddressinput/address_problem.h"
 #include "ui/base/base_window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
 
+using ::i18n::addressinput::AddressData;
+using ::i18n::addressinput::AddressProblem;
+using ::i18n::addressinput::AddressProblemFilter;
+using ::i18n::addressinput::AddressProblems;
+using ::i18n::addressinput::AddressValidator;
+
 namespace autofill {
 
 namespace {
 
 const char kAddNewItemKey[] = "add-new-item";
 const char kManageItemsKey[] = "manage-items";
 const char kSameAsBillingKey[] = "same-as-billing";
 
 // URLs for Wallet error messages.
 const char kBuyerLegalAddressStatusUrl[] =
@@ skipping 372 matching lines @@
 }
 
 gfx::Image CvcIconForCreditCardType(const base::string16& credit_card_type) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (credit_card_type == l10n_util::GetStringUTF16(IDS_AUTOFILL_CC_AMEX))
     return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT_AMEX);
 
   return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT);
 }
 
-ServerFieldType CountryTypeForSection(DialogSection section) {
-  return section == SECTION_SHIPPING ? ADDRESS_HOME_COUNTRY :
-                                       ADDRESS_BILLING_COUNTRY;
+ServerFieldType TypeForSection(DialogSection section, ServerFieldType type) {
+  return section == SECTION_SHIPPING ?
+      AutofillType(type).GetStorableType() :
+      AutofillType::GetEquivalentBillingFieldType(type);
 }
 
 }  // namespace
 
 AutofillDialogViewDelegate::~AutofillDialogViewDelegate() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
@@ skipping 604 matching lines @@
   // If the chosen item in |model| yields an empty suggestion text, it is
   // invalid. In this case, show the edit UI and highlight invalid fields.
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   base::string16 unused, unused2;
   if (IsASuggestionItemKey(model->GetItemKeyForCheckedItem()) &&
       !SuggestionTextForSection(section, &unused, &unused2)) {
     SetEditingExistingData(section, true);
   }
 
   if (wrapper && IsEditingExistingData(section)) {
-    base::string16 country =
-        wrapper->GetInfo(AutofillType(CountryTypeForSection(section)));
+    base::string16 country = wrapper->GetInfo(AutofillType(
+        TypeForSection(section, ADDRESS_HOME_COUNTRY)));
     if (!country.empty()) {
       // There's no user input to restore here as this is only called after
       // resetting all section input.
       if (RebuildInputsForCountry(section, country, false))
         UpdateSection(section);
     }
     wrapper->FillInputs(MutableRequestedFieldsForSection(section));
   }
 }
 
@@ skipping 571 matching lines @@
     case ADDRESS_HOME_LINE2:
     case ADDRESS_HOME_DEPENDENT_LOCALITY:
     case ADDRESS_HOME_SORTING_CODE:
       return base::string16();  // Optional until we have better validation.
 
     case ADDRESS_HOME_CITY:
     case ADDRESS_HOME_COUNTRY:
       break;
 
     case ADDRESS_HOME_STATE:
-      if (!value.empty() && !autofill::IsValidState(value) &&
+      if (!i18ninput::Enabled() && !value.empty() &&
+          !autofill::IsValidState(value) &&
           CountryCodeForSection(section) == "US") {
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_REGION);
       }
       break;
 
     case ADDRESS_HOME_ZIP:
-      if (!value.empty() && !autofill::IsValidZip(value) &&
+      if (!i18ninput::Enabled() && !value.empty() &&
+          !autofill::IsValidZip(value) &&
           CountryCodeForSection(section) == "US") {
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_ZIP_CODE);
       }
       break;
 
     case NAME_FULL:
       // Wallet requires a first and last billing name.
       if (section == SECTION_CC_BILLING && !value.empty() &&
           !IsCardHolderNameValidForWallet(value)) {
@@ skipping 18 matching lines @@
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_VALIDATION_MISSING_VALUE) :
       base::string16();
 }
 
 // TODO(groby): Also add tests.
 ValidityMessages AutofillDialogControllerImpl::InputsAreValid(
     DialogSection section,
     const FieldValueMap& inputs) {
   ValidityMessages messages;
   FieldValueMap field_values;
+
+  if (section != SECTION_CC) {
+    FieldValueMap values = inputs;
+
+    AddressData address_data;
+    address_data.language_code = g_browser_process->GetApplicationLocale();
+    address_data.country_code = AutofillCountry::GetCountryCode(
+        values[TypeForSection(section, ADDRESS_HOME_COUNTRY)],
+        g_browser_process->GetApplicationLocale());
+    address_data.administrative_area = UTF16ToUTF8(
+        values[TypeForSection(section, ADDRESS_HOME_STATE)]);
+    address_data.locality = UTF16ToUTF8(
+        values[TypeForSection(section, ADDRESS_HOME_CITY)]);
+    address_data.dependent_locality = UTF16ToUTF8(
+        values[TypeForSection(section, ADDRESS_HOME_DEPENDENT_LOCALITY)]);
+    address_data.sorting_code = UTF16ToUTF8(
+        values[TypeForSection(section, ADDRESS_HOME_SORTING_CODE)]);
+    address_data.postal_code = UTF16ToUTF8(
+        values[TypeForSection(section, ADDRESS_HOME_ZIP)]);
+    address_data.recipient = UTF16ToUTF8(
+        values[TypeForSection(section, NAME_FULL)]);
+
+    base::string16 street_line1 =
+        values[TypeForSection(section, ADDRESS_HOME_LINE1)];
+    if (!street_line1.empty())
+      address_data.address_lines.push_back(UTF16ToUTF8(street_line1));
+
+    base::string16 street_line2 =
+        values[TypeForSection(section, ADDRESS_HOME_LINE2)];
+    if (!street_line2.empty())
+      address_data.address_lines.push_back(UTF16ToUTF8(street_line2));
+
+    AddressProblems problems;
+    AddressValidator::Status status = validator_->ValidateAddress(
+        address_data, AddressProblemFilter(), &problems);
+    if (status == AddressValidator::SUCCESS) {
+      common::AddressType address_type = section == SECTION_SHIPPING ?
+          common::ADDRESS_TYPE_SHIPPING : common::ADDRESS_TYPE_BILLING;
+      for (size_t i = 0; i < problems.size(); ++i) {
+        const AddressProblem& problem = problems[i];
+        bool sure = problem.type != AddressProblem::MISSING_REQUIRED_FIELD;
+        base::string16 text = l10n_util::GetStringUTF16(problem.description_id);
+        messages.Set(i18ninput::TypeForField(problem.field, address_type),
+                     ValidityMessage(text, sure));
+      }
+    }
+  }
+
   for (FieldValueMap::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     const ServerFieldType type = iter->first;
+    if (messages.HasSureError(type))
+      continue;
 
     base::string16 text = InputValidityMessage(section, type, iter->second);
 
     // Skip empty/unchanged fields in edit mode. Ignore country as it always has
     // a value. If the individual field does not have validation errors, assume
     // it to be valid unless later proven otherwise.
     bool sure = InputWasEdited(type, iter->second) ||
                 AutofillType(type).GetStorableType() == ADDRESS_HOME_COUNTRY;
 
     // Consider only individually valid fields for inter-field validation.
@@ skipping 810 matching lines @@
       handling_use_wallet_link_click_(false),
       passive_failed_(false),
       billing_country_combobox_model_(*GetManager()),
       shipping_country_combobox_model_(*GetManager()),
       suggested_cc_(this),
       suggested_billing_(this),
       suggested_cc_billing_(this),
       suggested_shipping_(this),
       cares_about_shipping_(true),
       popup_input_type_(UNKNOWN_TYPE),
-      weak_ptr_factory_(this),
       waiting_for_explicit_sign_in_response_(false),
       has_accepted_legal_documents_(false),
       is_submitting_(false),
       choose_another_instrument_or_address_(false),
       wallet_server_validation_recoverable_(true),
       data_was_passed_back_(false),
       was_ui_latency_logged_(false),
-      card_generated_animation_(2000, 60, this) {
+      card_generated_animation_(2000, 60, this),
+      weak_ptr_factory_(this) {
   // TODO(estade): remove duplicates from |form_structure|?
   DCHECK(!callback_.is_null());
+
+  scoped_ptr<autofill::ChromeDownloaderImpl> downloader(

[Evan Stade, 2014/01/27 23:11:15]

change this type then you don't have to PassAs (I think)

[Dan Beam, 2014/01/28 02:22:36]

Done.

+      new autofill::ChromeDownloaderImpl(profile_->GetRequestContext()));
+  validator_ = AddressValidator::Build(
+      downloader.PassAs< ::i18n::addressinput::Downloader>(),
+      AddressStorageFactory::CreateStorage(),
+      this);
+
+  validator_->LoadRules(
+      billing_country_combobox_model_.GetDefaultCountryCode());

[Evan Stade, 2014/01/27 23:11:15]

I think you could just make this:

validator_->LoadRules(GetManager()->GetDefaultCountryCodeForNewAddress())

[Dan Beam, 2014/01/28 02:22:36]

Done.

+  validator_->LoadRules(
+      shipping_country_combobox_model_.GetDefaultCountryCode());
 }
 
 AutofillDialogView* AutofillDialogControllerImpl::CreateView() {
   return AutofillDialogView::Create(this);
 }
 
 PersonalDataManager* AutofillDialogControllerImpl::GetManager() const {
   return PersonalDataManagerFactory::GetForProfile(profile_);
 }
 
@@ skipping 464 matching lines @@
 DetailInputs* AutofillDialogControllerImpl::MutableRequestedFieldsForSection(
     DialogSection section) {
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
 std::string AutofillDialogControllerImpl::CountryCodeForSection(
     DialogSection section) {
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper) {
     return AutofillCountry::GetCountryCode(
-        wrapper->GetInfo(AutofillType(CountryTypeForSection(section))),
+        wrapper->GetInfo(
+            AutofillType(TypeForSection(section, ADDRESS_HOME_COUNTRY))),
         g_browser_process->GetApplicationLocale());
   }
 
   CountryComboboxModel* model = CountryComboboxModelForSection(section);
   return model ? model->GetDefaultCountryCode() : std::string();
 }
 
 bool AutofillDialogControllerImpl::RebuildInputsForCountry(
     DialogSection section,
     const base::string16& country_name,
     bool should_clobber) {
   DCHECK_NE(SECTION_CC, section);
 
   if (view_ && !should_clobber) {
     FieldValueMap outputs;
     view_->GetUserInput(section, &outputs);
 
     // If |country_name| is the same as the view, no-op and let the caller know.
-    if (outputs[CountryTypeForSection(section)] == country_name)
+    if (outputs[TypeForSection(section, ADDRESS_HOME_COUNTRY)] == country_name)
       return false;
   }
 
   DetailInputs* inputs = MutableRequestedFieldsForSection(section);
   inputs->clear();
 
   std::string country_code = AutofillCountry::GetCountryCode(
       country_name, g_browser_process->GetApplicationLocale());
   common::BuildInputsForSection(section, country_code, inputs);
   return true;
@@ skipping 282 matching lines @@
   DCHECK_EQ(animation, &card_generated_animation_);
   PushOverlayUpdate();
 }
 
 void AutofillDialogControllerImpl::AnimationEnded(
     const gfx::Animation* animation) {
   DCHECK_EQ(animation, &card_generated_animation_);
   DoFinishSubmit();
 }
 
+void AutofillDialogControllerImpl::OnAddressValidationRulesLoaded(
+    const std::string& country_code,
+    bool success) {
+  // TODO(dbeam): ask |view_| to re-validate its contents if necessary.
+}
+
 void AutofillDialogControllerImpl::DoFinishSubmit() {
   FillOutputForSection(SECTION_CC);
   FillOutputForSection(SECTION_BILLING);
   FillOutputForSection(SECTION_CC_BILLING);
 
   if (ShouldUseBillingForShipping()) {
     FillOutputForSectionWithComparator(
         SECTION_BILLING,
         base::Bind(ServerTypeMatchesShippingField));
     FillOutputForSectionWithComparator(
@@ skipping 237 matching lines @@
   view_->UpdateButtonStrip();
 }
 
 void AutofillDialogControllerImpl::FetchWalletCookie() {
   net::URLRequestContextGetter* request_context = profile_->GetRequestContext();
   signin_helper_.reset(new wallet::WalletSigninHelper(this, request_context));
   signin_helper_->StartWalletCookieValueFetch();
 }
 
 }  // namespace autofill