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/bind_helpers.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.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/personal_data_manager_factory.h"
+#include "chrome/browser/autofill/validation_rules_storage_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"
@@ skipping 33 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/chrome_storage_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::AddressField;
+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 37 matching lines @@
  private:
   AutofillDialogView* view_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedViewUpdates);
 };
 
 base::string16 NullGetInfo(const AutofillType& type) {
   return base::string16();
 }
 
+// Extract |type| from |inputs| using |section| to determine whether the info
+// should be billing or shipping specific (for sections with address info).
+base::string16 GetInfoFromInputs(const FieldValueMap& inputs,
+                                 DialogSection section,
+                                 const AutofillType& type) {
+  ServerFieldType field_type = type.GetStorableType();
+  if (section != SECTION_SHIPPING)
+    field_type = AutofillType::GetEquivalentBillingFieldType(field_type);
+
+  base::string16 info;
+  FieldValueMap::const_iterator it = inputs.find(field_type);
+  if (it != inputs.end())
+    info = it->second;
+
+  if (!info.empty() && type.html_type() == HTML_TYPE_COUNTRY_CODE) {
+    info = base::ASCIIToUTF16(AutofillCountry::GetCountryCode(
+        info, g_browser_process->GetApplicationLocale()));
+  }
+
+  return info;
+}
+
 // Returns true if |input| should be used to fill a site-requested |field| which
 // is notated with a "shipping" tag, for use when the user has decided to use
 // the billing address as the shipping address.
 bool ServerTypeMatchesShippingField(ServerFieldType type,
                                     const AutofillField& field) {
   // Equivalent billing field type is used to support UseBillingAsShipping
   // usecase.
   return common::ServerTypeMatchesFieldType(
       type,
       AutofillType(AutofillType::GetEquivalentBillingFieldType(
@@ skipping 453 matching lines @@
 
   account_chooser_model_.reset(
       new AccountChooserModel(this,
                               profile_,
                               !ShouldShowAccountChooser(),
                               metric_logger_));
 
   if (account_chooser_model_->WalletIsSelected())
     FetchWalletCookie();
 
+  if (i18ninput::Enabled()) {
+    scoped_ptr< ::i18n::addressinput::Downloader> downloader(
+        new autofill::ChromeDownloaderImpl(profile_->GetRequestContext()));
+    validator_ = AddressValidator::Build(
+        downloader.Pass(),
+        ValidationRulesStorageFactory::CreateStorage(),
+        this);
+    GetValidator()->LoadRules(
+        GetManager()->GetDefaultCountryCodeForNewAddress());
+  }
+
   // TODO(estade): don't show the dialog if the site didn't specify the right
   // fields. First we must figure out what the "right" fields are.
   SuggestionsUpdated();
   SubmitButtonDelayBegin();
   view_.reset(CreateView());
   view_->Show();
   GetManager()->AddObserver(this);
 
   if (!account_chooser_model_->WalletIsSelected())
     LogDialogLatencyToShow();
@@ skipping 524 matching lines @@
   }
 
   return snapshot;
 }
 
 void AutofillDialogControllerImpl::RestoreUserInputFromSnapshot(
     const FieldValueMap& snapshot) {
   if (snapshot.empty())
     return;
 
-  FieldMapWrapper wrapper(snapshot);
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
     DialogSection section = static_cast<DialogSection>(i);
     if (!SectionIsActive(section))
       continue;
 
     DetailInputs* inputs = MutableRequestedFieldsForSection(section);
-    wrapper.FillInputs(inputs);
-
     for (size_t i = 0; i < inputs->size(); ++i) {
-      if (InputWasEdited((*inputs)[i].type, (*inputs)[i].initial_value)) {
+      DetailInput* input = &(*inputs)[i];
+      input->initial_value =
+          GetInfoFromInputs(snapshot, section, AutofillType(input->type));
+      if (InputWasEdited(input->type, input->initial_value))
         SuggestionsMenuModelForSection(section)->SetCheckedItem(kAddNewItemKey);
-        break;
-      }
     }
   }
 }
 
 void AutofillDialogControllerImpl::UpdateSection(DialogSection section) {
   if (view_)
     view_->UpdateSection(section);
 }
 
 void AutofillDialogControllerImpl::UpdateForErrors() {
@@ skipping 452 matching lines @@
     if (it != wallet_errors_.end()) {
       TypeErrorInputMap::const_iterator iter = it->second.find(type);
       if (iter != it->second.end()) {
         if (iter->second.second == value)
           return iter->second.first;
         it->second.erase(type);
       }
     }
   }
 
-  switch (AutofillType(type).GetStorableType()) {
+  AutofillType autofill_type(type);
+  if (i18ninput::Enabled() &&
+      (autofill_type.group() == ADDRESS_HOME ||
+       autofill_type.group() == ADDRESS_BILLING)) {
+    // TODO(dbeam): delete all US-specific address validation when
+    // --enable-autofill-address-i18n is removed.
+    return base::string16();
+  }
+
+  switch (autofill_type.GetStorableType()) {
     case EMAIL_ADDRESS:
       if (!value.empty() && !IsValidEmailAddress(value)) {
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_EMAIL_ADDRESS);
       }
       break;
 
     case CREDIT_CARD_NUMBER: {
       if (!value.empty()) {
         base::string16 message = CreditCardNumberValidityMessage(value);
@@ skipping 30 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 (!value.empty() &&!autofill::IsValidState(value) &&
           CountryCodeForSection(section) == "US") {
+        DCHECK(!i18ninput::Enabled());
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_REGION);
       }
       break;
 
     case ADDRESS_HOME_ZIP:
       if (!value.empty() && !autofill::IsValidZip(value) &&
           CountryCodeForSection(section) == "US") {
+        DCHECK(!i18ninput::Enabled());
         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)) {
         DCHECK(IsPayingWithWallet());
@@ skipping 16 matching lines @@
   return value.empty() ?
       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;
+  if (inputs.empty())
+    return messages;
+
   FieldValueMap field_values;
+
+  if (i18ninput::Enabled() && section != SECTION_CC) {
+    AddressData address_data;
+    i18ninput::CreateAddressData(
+        base::Bind(&GetInfoFromInputs, base::ConstRef(inputs), section),
+        &address_data);
+
+    AddressProblems problems;
+    if (GetValidator()->ValidateAddress(
+            address_data,
+            AddressProblemFilter(),
+            &problems) == 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));
+      }
+    } else {
+      // TODO(dbeam): disable submit button until able to successfully validate.
+    }
+  }
+
   for (FieldValueMap::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     const ServerFieldType type = iter->first;
+    if (!messages.GetMessageOrDefault(type).text.empty())
+      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 85 matching lines @@
 void AutofillDialogControllerImpl::UserEditedOrActivatedInput(
     DialogSection section,
     ServerFieldType type,
     gfx::NativeView parent_view,
     const gfx::Rect& content_bounds,
     const base::string16& field_contents,
     bool was_edit) {
   ScopedViewUpdates updates(view_.get());
 
   if (type == ADDRESS_BILLING_COUNTRY || type == ADDRESS_HOME_COUNTRY) {
+    DCHECK(i18ninput::Enabled());
+
     const FieldValueMap snapshot = TakeUserInputSnapshot();
+
     // Clobber the inputs because the view's already been updated.
     RebuildInputsForCountry(section, field_contents, true);
     RestoreUserInputFromSnapshot(snapshot);
     UpdateSection(section);
+
+    GetValidator()->LoadRules(AutofillCountry::GetCountryCode(
+        field_contents, g_browser_process->GetApplicationLocale()));
   }
 
   // The rest of this method applies only to textfields. If a combobox, bail.
   if (ComboboxModelForAutofillType(type))
     return;
 
   // If the field is edited down to empty, don't show a popup.
   if (was_edit && field_contents.empty()) {
     HidePopup();
     return;
@@ skipping 696 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());
 }
 
 AutofillDialogView* AutofillDialogControllerImpl::CreateView() {
   return AutofillDialogView::Create(this);
 }
 
 PersonalDataManager* AutofillDialogControllerImpl::GetManager() const {
   return PersonalDataManagerFactory::GetForProfile(profile_);
 }
 
+AddressValidator* AutofillDialogControllerImpl::GetValidator() {
+  return validator_.get();
+}
+
 const wallet::WalletClient* AutofillDialogControllerImpl::GetWalletClient()
     const {
   return const_cast<AutofillDialogControllerImpl*>(this)->GetWalletClient();
 }
 
 wallet::WalletClient* AutofillDialogControllerImpl::GetWalletClient() {
   return &wallet_client_;
 }
 
 bool AutofillDialogControllerImpl::IsPayingWithWallet() const {
@@ skipping 457 matching lines @@
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
 std::vector<ServerFieldType> AutofillDialogControllerImpl::
     RequestedTypesForSection(DialogSection section) const {
   return common::TypesFromInputs(RequestedFieldsForSection(section));
 }
 
 std::string AutofillDialogControllerImpl::CountryCodeForSection(
     DialogSection section) {
+  base::string16 country;
+
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper) {
-    return AutofillCountry::GetCountryCode(
-        wrapper->GetInfo(AutofillType(CountryTypeForSection(section))),
-        g_browser_process->GetApplicationLocale());
+    country = wrapper->GetInfo(AutofillType(CountryTypeForSection(section)));
+  } else {
+    FieldValueMap outputs;
+    view_->GetUserInput(section, &outputs);
+    country = outputs[CountryTypeForSection(section)];
   }
 
-  CountryComboboxModel* model = CountryComboboxModelForSection(section);
-  return model ? model->GetDefaultCountryCode() : std::string();
+  return AutofillCountry::GetCountryCode(
+      country, g_browser_process->GetApplicationLocale());
 }
 
 bool AutofillDialogControllerImpl::RebuildInputsForCountry(
     DialogSection section,
     const base::string16& country_name,
     bool should_clobber) {
   DCHECK_NE(SECTION_CC, section);
 
   if (view_ && !should_clobber) {
     FieldValueMap outputs;
@@ skipping 296 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): should we retry on failure?
+  // TODO(dbeam): disable the submit button until rules are successfully loaded.
+  // 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