Add country combobox to change country and rebuild address inputs.

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>
 
@@ skipping 586 matching lines @@
   // access checks.
   const GURL& current_url = web_contents()->GetLastCommittedURL();
   invoked_from_same_origin_ =
       current_url.GetOrigin() == source_url_.GetOrigin();
 
   if (!invoked_from_same_origin_) {
     GetMetricLogger().LogDialogSecurityMetric(
         AutofillMetrics::SECURITY_METRIC_CROSS_ORIGIN_FRAME);
   }
 
-  // TODO(dbeam): use GetManager()->GetDefaultCountryCodeForNewAddress()
-  // instead when the country combobox is visible. http://crbug.com/331544
-  std::string country_code = "US";
-  common::BuildInputsForSection(SECTION_CC,
-                                country_code,
-                                &requested_cc_fields_);
-  common::BuildInputsForSection(SECTION_BILLING,
-                                country_code,
-                                &requested_billing_fields_);
-  common::BuildInputsForSection(SECTION_CC_BILLING,
-                                country_code,
-                                &requested_cc_billing_fields_);
-  common::BuildInputsForSection(SECTION_SHIPPING,
-                                country_code,
-                                &requested_shipping_fields_);
+  // TODO(dbeam): does SECTION_CC need to be internationalized?

[Evan Stade, 2014/01/15 23:12:29]

I don't think so. I think you can leave out this TODO.

[Dan Beam, 2014/01/16 01:39:13]

Done.

+  common::BuildInputsForSection(SECTION_CC, "US", &requested_cc_fields_);

[Evan Stade, 2014/01/15 23:12:29]

pass an empty country code to make it clear it's not used/relevant.

[Dan Beam, 2014/01/16 01:39:13]

Done.

+  OnComboboxModelChanged(&billing_country_combobox_model_);
+  OnComboboxModelChanged(&shipping_country_combobox_model_);
 
   // Test whether we need to show the shipping section. If filling that section
   // would be a no-op, don't show it.
   const DetailInputs& inputs = RequestedFieldsForSection(SECTION_SHIPPING);
   cares_about_shipping_ = EmptyDataModelWrapper().FillFormStructure(
       inputs,
       base::Bind(common::DetailInputMatchesField, SECTION_SHIPPING),
       &form_structure_);
 
   account_chooser_model_.reset(
       new AccountChooserModel(this,
                               profile_,
                               !ShouldShowAccountChooser(),
                               metric_logger_));
 
   if (account_chooser_model_->WalletIsSelected())
     FetchWalletCookie();
 
   // 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);
+  billing_country_combobox_model_.AddObserver(this);
+  shipping_country_combobox_model_.AddObserver(this);
 
   if (!account_chooser_model_->WalletIsSelected())
     LogDialogLatencyToShow();
 }
 
 void AutofillDialogControllerImpl::Hide() {
   if (view_)
     view_->Hide();
 }
 
@@ skipping 434 matching lines @@
 
   for (size_t i = 0; i < documents.size(); ++i) {
     size_t link_start = offsets[i] + base_offset;
     legal_document_link_ranges_.push_back(gfx::Range(
         link_start, link_start + documents[i]->display_name().size()));
   }
   legal_documents_text_ = text;
 }
 
 void AutofillDialogControllerImpl::ResetSectionInput(DialogSection section) {
-  SetEditingExistingData(section, false);
-
   DetailInputs* inputs = MutableRequestedFieldsForSection(section);
   for (DetailInputs::iterator it = inputs->begin(); it != inputs->end(); ++it) {
     it->initial_value = common::GetHardcodedValueForType(it->type);
   }
 }
 
 void AutofillDialogControllerImpl::ShowEditUiIfBadSuggestion(
     DialogSection section) {
   // |CreateWrapper()| returns an empty wrapper if |IsEditingExistingData()|, so
   // get the wrapper before this potentially happens below.
@@ skipping 50 matching lines @@
   }
 
   return snapshot;
 }
 
 void AutofillDialogControllerImpl::RestoreUserInputFromSnapshot(
     const FieldValueMap& snapshot) {
   if (snapshot.empty())
     return;
 
+  FieldValueMap::const_iterator it = snapshot.find(ADDRESS_BILLING_COUNTRY);
+  if (it != snapshot.end()) {
+    billing_country_combobox_model_.SetDefaultCountry(
+        AutofillCountry::GetCountryCode(
+            it->second, g_browser_process->GetApplicationLocale()));
+  }
+
+  FieldValueMap::const_iterator ship_it = snapshot.find(ADDRESS_HOME_COUNTRY);
+  if (ship_it != snapshot.end()) {
+    shipping_country_combobox_model_.SetDefaultCountry(
+        AutofillCountry::GetCountryCode(
+            ship_it->second, g_browser_process->GetApplicationLocale()));
+  }
+
   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) {
@@ skipping 113 matching lines @@
 
 ui::ComboboxModel* AutofillDialogControllerImpl::ComboboxModelForAutofillType(
     ServerFieldType type) {
   switch (type) {
     case CREDIT_CARD_EXP_MONTH:
       return &cc_exp_month_combobox_model_;
 
     case CREDIT_CARD_EXP_4_DIGIT_YEAR:
       return &cc_exp_year_combobox_model_;
 
+    case ADDRESS_BILLING_COUNTRY:
+      return &billing_country_combobox_model_;
+
     case ADDRESS_HOME_COUNTRY:
-    case ADDRESS_BILLING_COUNTRY:
-      return &country_combobox_model_;
+      return &shipping_country_combobox_model_;
 
     default:
       return NULL;
   }
 }
 
 ui::MenuModel* AutofillDialogControllerImpl::MenuModelForSection(
     DialogSection section) {
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   // The shipping section menu is special. It will always show because there is
@@ skipping 373 matching lines @@
       }
       break;
 
     case ADDRESS_HOME_LINE1:
       break;
 
     case ADDRESS_HOME_LINE2:
       return base::string16();  // Line 2 is optional - always valid.
 
     case ADDRESS_HOME_CITY:
+    case ADDRESS_HOME_DEPENDENT_LOCALITY:
     case ADDRESS_HOME_COUNTRY:
       break;
 
     case ADDRESS_HOME_STATE:
-      if (!value.empty() && !autofill::IsValidState(value)) {
+      if (!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 (!value.empty() && !autofill::IsValidZip(value) &&
+          CountryCodeForSection(section) == "US") {
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_ZIP_CODE);
       }
       break;
 
+    case ADDRESS_HOME_SORTING_CODE:
+      break;
+
     case NAME_FULL:
       // Wallet requires a first and last billing name.
       if (section == SECTION_CC_BILLING && !value.empty() &&
           !IsCardHolderNameValidForWallet(value)) {
         DCHECK(IsPayingWithWallet());
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_WALLET_REQUIRES_TWO_NAMES);
       }
       break;
 
@@ skipping 11 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;
-  std::map<ServerFieldType, base::string16> field_values;
+  FieldValueMap field_values;
   for (FieldValueMap::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     const ServerFieldType type = iter->first;
 
     base::string16 text = InputValidityMessage(section, type, iter->second);
 
-    // Skip empty/unchanged fields in edit mode. Ignore country code as it
-    // always has a value. If the individual field does not have validation
-    // errors, assume it to be valid unless later proven otherwise.
+    // 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) ||
-                ComboboxModelForAutofillType(type) == &country_combobox_model_;
+                AutofillType(type).GetStorableType() == ADDRESS_HOME_COUNTRY;
 
     // Consider only individually valid fields for inter-field validation.
     if (text.empty()) {
       field_values[type] = iter->second;
       // If the field is valid but can be invalidated by inter-field validation,
       // assume it to be unsure.
       if (type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
           type == CREDIT_CARD_EXP_MONTH ||
           type == CREDIT_CARD_VERIFICATION_CODE ||
           type == PHONE_HOME_WHOLE_NUMBER ||
@@ skipping 74 matching lines @@
   return messages;
 }
 
 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) {
+    FieldValueMap snapshot = TakeUserInputSnapshot();
+    snapshot[type] = field_contents;
+    RestoreUserInputFromSnapshot(snapshot);
+    const bool is_billing = type == ADDRESS_BILLING_COUNTRY;
+    UpdateSection(is_billing ? ActiveBillingSection() : SECTION_SHIPPING);
+  }
+
+  // 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;
   }
 
   // If the user clicks while the popup is already showing, be sure to hide
   // it.
   if (!was_edit && popup_controller_.get()) {
     HidePopup();
@@ skipping 57 matching lines @@
 
 void AutofillDialogControllerImpl::FocusMoved() {
   HidePopup();
 }
 
 bool AutofillDialogControllerImpl::ShouldShowErrorBubble() const {
   return popup_input_type_ == UNKNOWN_TYPE;
 }
 
 void AutofillDialogControllerImpl::ViewClosed() {
   GetManager()->RemoveObserver(this);

[Evan Stade, 2014/01/15 23:12:29]

why is this here and not in the destructor?

why are the new RemoveObserver calls here and not in the destructor?

Can we use base::ScopedObserver instead?

[Dan Beam, 2014/01/16 01:39:13]

Done.

+  billing_country_combobox_model_.RemoveObserver(this);
+  shipping_country_combobox_model_.RemoveObserver(this);
 
   // Called from here rather than in ~AutofillDialogControllerImpl as this
   // relies on virtual methods that change to their base class in the dtor.
   MaybeShowCreditCardBubble();
 
   delete this;
 }
 
 std::vector<DialogNotification> AutofillDialogControllerImpl::
     CurrentNotifications() {
@@ skipping 207 matching lines @@
   if (common::IsCreditCardType(popup_input_type_)) {
     wrapper.reset(new AutofillCreditCardWrapper(
         GetManager()->GetCreditCardByGUID(pair.first)));
   } else {
     wrapper.reset(new AutofillProfileWrapper(
         GetManager()->GetProfileByGUID(pair.first),
         AutofillType(popup_input_type_),
         pair.second));
   }
 
+  if (i18ninput::Enabled()) {
+    // If country will change while filling, rebuild inputs now.

[Evan Stade, 2014/01/15 23:12:29]

I can't make sense of this sentence.

[Dan Beam, 2014/01/16 01:39:13]

Removed.

+    base::string16 billing_country;
+    if (!billing_country_combobox_model_.GetDefaultIndex())
+      billing_country = wrapper->GetInfo(AutofillType(ADDRESS_BILLING_COUNTRY));
+
+    base::string16 shipping_country;
+    if (!shipping_country_combobox_model_.GetDefaultIndex())
+      shipping_country = wrapper->GetInfo(AutofillType(ADDRESS_HOME_COUNTRY));
+
+    if (!billing_country.empty() || !shipping_country.empty()) {
+      FieldValueMap snapshot = TakeUserInputSnapshot();
+
+      if (!billing_country.empty())
+        snapshot[ADDRESS_BILLING_COUNTRY] = billing_country;
+
+      if (!shipping_country.empty())
+        snapshot[ADDRESS_HOME_COUNTRY] = shipping_country;
+
+      RestoreUserInputFromSnapshot(snapshot);
+
+      if (!billing_country.empty())
+        UpdateSection(ActiveBillingSection());
+
+      if (!shipping_country.empty())
+        UpdateSection(SECTION_SHIPPING);
+    }
+  }
+
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
     DialogSection section = static_cast<DialogSection>(i);
     wrapper->FillInputs(MutableRequestedFieldsForSection(section));
     view_->FillSection(section, popup_input_type_);
   }
 
   GetMetricLogger().LogDialogPopupEvent(
       AutofillMetrics::DIALOG_POPUP_FORM_FILLED);
 
   // TODO(estade): not sure why it's necessary to do this explicitly.
@@ skipping 59 matching lines @@
       url = SectionForSuggestionsMenuModel(*model) == SECTION_SHIPPING ?
           wallet::GetManageAddressesUrl(user_index) :
           wallet::GetManageInstrumentsUrl(user_index);
     }
 
     OpenTabWithUrl(url);
     return;
   }
 
   model->SetCheckedIndex(index);
+
   DialogSection section = SectionForSuggestionsMenuModel(*model);
+  SetEditingExistingData(section, false);
+
+  if (i18ninput::Enabled()) {
+    if (section == SECTION_SHIPPING)
+      shipping_country_combobox_model_.ResetDefault();
+    else if (section == SECTION_BILLING || section == SECTION_CC_BILLING)
+      billing_country_combobox_model_.ResetDefault();
+  }
+
   ResetSectionInput(section);
+
   ShowEditUiIfBadSuggestion(section);
   UpdateSection(section);
   view_->UpdateNotificationArea();
   UpdateForErrors();
 
   LogSuggestionItemSelectedMetric(*model);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wallet::WalletClientDelegate implementation.
@@ skipping 262 matching lines @@
       profile_(Profile::FromBrowserContext(contents->GetBrowserContext())),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       form_structure_(form_structure),
       invoked_from_same_origin_(true),
       source_url_(source_url),
       callback_(callback),
       wallet_client_(profile_->GetRequestContext(), this, source_url),
       wallet_items_requested_(false),
       handling_use_wallet_link_click_(false),
       passive_failed_(false),
-      country_combobox_model_(*GetManager()),
+      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),
@@ skipping 67 matching lines @@
 
 void AutofillDialogControllerImpl::OpenTabWithUrl(const GURL& url) {
   chrome::NavigateParams params(
       chrome::FindBrowserWithWebContents(web_contents()),
       url,
       content::PAGE_TRANSITION_LINK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 }
 
+DialogSection AutofillDialogControllerImpl::ActiveBillingSection() const {
+  return IsPayingWithWallet() ? SECTION_CC_BILLING : SECTION_BILLING;
+}
+
 bool AutofillDialogControllerImpl::IsEditingExistingData(
     DialogSection section) const {
   return section_editing_state_.count(section) > 0;
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingSection(
     DialogSection section) const {
   return IsEditingExistingData(section) ||
          SuggestionsMenuModelForSection(section)->
              GetItemKeyForCheckedItem() == kAddNewItemKey;
@@ skipping 192 matching lines @@
       model->SetCheckedItem(guid);
       if (GetAutofillChoice(section, &guid))
         model->SetCheckedItem(guid);
     }
   }
 
   if (view_)
     view_->ModelChanged();
 
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
-    ResetSectionInput(static_cast<DialogSection>(i));
+    DialogSection section = static_cast<DialogSection>(i);
+    SetEditingExistingData(section, false);
+    ResetSectionInput(section);
   }
 
   RestoreUserInputFromSnapshot(snapshot);
 
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
     DialogSection section = static_cast<DialogSection>(i);
     if (!SectionIsActive(section))
       continue;
 
     ShowEditUiIfBadSuggestion(section);
     UpdateSection(section);
   }
 
   UpdateForErrors();
 }
 
 void AutofillDialogControllerImpl::FillOutputForSectionWithComparator(
     DialogSection section,
     const InputFieldComparator& compare) {
   if (!SectionIsActive(section))
     return;
 
-  const DetailInputs& inputs = RequestedFieldsForSection(section);
+  DetailInputs inputs;
+  std::string country_code = CountryCodeForSection(section);
+  common::BuildInputsForSection(section, country_code, &inputs);
+
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper) {
     // Only fill in data that is associated with this section.
-    const DetailInputs& inputs = RequestedFieldsForSection(section);
     wrapper->FillFormStructure(inputs, compare, &form_structure_);
 
     // CVC needs special-casing because the CreditCard class doesn't store or
     // handle them. This isn't necessary when filling the combined CC and
     // billing section as CVC comes from |full_wallet_| in this case.
     if (section == SECTION_CC)
       SetOutputForFieldsOfType(CREDIT_CARD_VERIFICATION_CODE, view_->GetCvc());
 
     // When filling from Wallet data, use the email address associated with the
     // account. There is no other email address stored as part of a Wallet
@@ skipping 122 matching lines @@
 
   DCHECK_EQ(&model, &suggested_shipping_);
   return SECTION_SHIPPING;
 }
 
 DetailInputs* AutofillDialogControllerImpl::MutableRequestedFieldsForSection(
     DialogSection section) {
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
+void AutofillDialogControllerImpl::OnComboboxModelChanged(
+    ui::ComboboxModel* model) {
+  DCHECK(model == &billing_country_combobox_model_ ||
+         model == &shipping_country_combobox_model_);
+
+  const bool is_shipping = model == &shipping_country_combobox_model_;
+  const std::string country_code = AutofillCountry::GetCountryCode(
+      model->GetItemAt(model->GetDefaultIndex()),
+      g_browser_process->GetApplicationLocale());
+
+  for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
+    DialogSection section = static_cast<DialogSection>(i);
+
+    if ((is_shipping && section != SECTION_SHIPPING) ||

[Evan Stade, 2014/01/15 23:12:29]

this is the second place in this CL I've seen so far where a
CountryComboboxModelForSection fn would come in handy (the first was in
SuggestionItemSelected)

for this case, even better would be a SectionForComboboxModel function

[Dan Beam, 2014/01/16 01:39:13]

Done.
this code rebuilds 2 sections of input

+        (!is_shipping && (section != SECTION_BILLING &&
+                          section != SECTION_CC_BILLING))) {
+      continue;
+    }
+
+    DetailInputs* inputs = MutableRequestedFieldsForSection(section);
+    inputs->clear();
+
+    common::BuildInputsForSection(section, country_code, inputs);
+  }
+}
+
+std::string AutofillDialogControllerImpl::CountryCodeForSection(
+    DialogSection section) {
+  if (section == SECTION_CC)
+    return "US";

[Evan Stade, 2014/01/15 23:12:29]

ditto -- return "" as it's international.

[Dan Beam, 2014/01/16 01:39:13]

Done.

+
+  base::string16 country_name;
+  if (IsEditingExistingData(section)) {
+    ServerFieldType type = SECTION_SHIPPING ? ADDRESS_HOME_COUNTRY :
+                                              ADDRESS_BILLING_COUNTRY;
+    return AutofillCountry::GetCountryCode(
+        CreateWrapper(section)->GetInfo(AutofillType(type)),
+        g_browser_process->GetApplicationLocale());
+  }
+
+  CountryComboboxModel* model = section == SECTION_SHIPPING ?

[Evan Stade, 2014/01/15 23:12:29]

third place

[Dan Beam, 2014/01/16 01:39:13]

Done.

+      &shipping_country_combobox_model_ : &billing_country_combobox_model_;
+  return model->countries()[model->GetDefaultIndex()]->country_code();
+}
+
 void AutofillDialogControllerImpl::HidePopup() {
   if (popup_controller_.get())
     popup_controller_->Hide();
   popup_input_type_ = UNKNOWN_TYPE;
 }
 
 void AutofillDialogControllerImpl::SetEditingExistingData(
     DialogSection section, bool editing) {
   if (editing)
     section_editing_state_.insert(section);
@@ skipping 529 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