Ask libaddressinput for address components to use in requestAutocomplete().

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 11 matching lines @@
 #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/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"
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/autofill/generated_credit_card_bubble_controller.h"
 #include "chrome/browser/ui/autofill/new_credit_card_bubble_controller.h"
 #endif
 #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"
@@ skipping 459 matching lines @@
     return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT_AMEX);
 
   return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT);
 }
 
 }  // namespace
 
 AutofillDialogViewDelegate::~AutofillDialogViewDelegate() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
+  billing_country_combobox_model_.RemoveObserver(this);
+  shipping_country_combobox_model_.RemoveObserver(this);
+
   if (popup_controller_)
     popup_controller_->Hide();
 
   GetMetricLogger().LogDialogInitialUserState(initial_user_state_);
 }
 
 // static
 base::WeakPtr<AutofillDialogControllerImpl>
     AutofillDialogControllerImpl::Create(
     content::WebContents* contents,
@@ skipping 75 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);
   }
 
+  // Fail if the author didn't specify autocomplete types.
+  if (!has_types) {
+    callback_.Run(NULL);
+    delete this;
+    return;
+  }
+
+  std::string country_code = GetManager()->GetDefaultCountryCodeForNewAddress();
   common::BuildInputsForSection(SECTION_CC,
-                                &requested_cc_fields_);
+                                &requested_cc_fields_,
+                                country_code);
   common::BuildInputsForSection(SECTION_BILLING,
-                                &requested_billing_fields_);
+                                &requested_billing_fields_,
+                                country_code);
   common::BuildInputsForSection(SECTION_CC_BILLING,
-                                &requested_cc_billing_fields_);
+                                &requested_cc_billing_fields_,
+                                country_code);
   common::BuildInputsForSection(SECTION_SHIPPING,
-                                &requested_shipping_fields_);
+                                &requested_shipping_fields_,
+                                country_code);
 
   // 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);
   EmptyDataModelWrapper empty_wrapper;
   cares_about_shipping_ = empty_wrapper.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 440 matching lines @@
     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);
+  std::string country_code = GetCountryCodeForSection(section);
   for (DetailInputs::iterator it = inputs->begin(); it != inputs->end(); ++it) {
-    it->initial_value = common::GetHardcodedValueForType(it->type);
+    it->initial_value = common::GetInitialValueForType(it->type, country_code);

[Evan Stade, 2014/01/02 22:59:26]

Isn't the purpose of setting the default index on the combobox model so that you
don't need to do this?

   }
 }
 
 void AutofillDialogControllerImpl::ShowEditUiIfBadSuggestion(
     DialogSection section) {
   // |CreateWrapper()| returns an empty wrapper if |IsEditingExistingData()|, so
   // get the wrapper before this potentially happens below.
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
 
   // 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);
   }
 
   DetailInputs* inputs = MutableRequestedFieldsForSection(section);
   if (wrapper && IsEditingExistingData(section))
-    wrapper->FillInputs(inputs);
+    wrapper->FillInputs(inputs, GetCountryCodeForSection(section));
 }
 
 bool AutofillDialogControllerImpl::InputWasEdited(ServerFieldType type,
                                                   const base::string16& value) {
   if (value.empty())
     return false;
 
   // If this is a combobox at the default value, don't preserve it.
   ui::ComboboxModel* model = ComboboxModelForAutofillType(type);
   if (model && model->GetItemAt(model->GetDefaultIndex()) == value)
@@ skipping 33 matching lines @@
   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);
+    wrapper.FillInputs(inputs, GetCountryCodeForSection(section));
 
     for (size_t i = 0; i < inputs->size(); ++i) {
       if (InputWasEdited((*inputs)[i].type, (*inputs)[i].initial_value)) {
         SuggestionsMenuModelForSection(section)->SetCheckedItem(kAddNewItemKey);
         break;
       }
     }
   }
 }
 
@@ skipping 105 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;
   }
 }
 
+bool AutofillDialogControllerImpl::IsCountryComboboxModel(
+    const ui::ComboboxModel* model) const {
+  return model == &billing_country_combobox_model_ ||
+         model == &shipping_country_combobox_model_;
+}
+
 ui::MenuModel* AutofillDialogControllerImpl::MenuModelForSection(
     DialogSection section) {
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   // The shipping section menu is special. It will always show because there is
   // a choice between "Use billing" and "enter new".
   if (section == SECTION_SHIPPING)
     return model;
 
   // For other sections, only show a menu if there's at least one suggestion.
   for (int i = 0; i < model->GetItemCount(); ++i) {
@@ skipping 367 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)) {
         return l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_VALIDATION_INVALID_REGION);
       }
       break;
 
     case ADDRESS_HOME_ZIP:
       if (!value.empty() && !autofill::IsValidZip(value)) {
         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;
 
+    case COMPANY_NAME:
+      break;
+
     case PHONE_HOME_WHOLE_NUMBER:  // Used in shipping section.
       break;
 
     case PHONE_BILLING_WHOLE_NUMBER:  // Used in billing section.
       break;
 
     default:
       NOTREACHED();  // Trying to validate unknown field.
       break;
   }
@@ skipping 12 matching lines @@
   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.
     bool sure = InputWasEdited(type, iter->second) ||
-                ComboboxModelForAutofillType(type) == &country_combobox_model_;
+                IsCountryComboboxModel(ComboboxModelForAutofillType(type));
 
     // 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 152 matching lines @@
       content_bounds,
       base::i18n::IsRTL() ?
           base::i18n::RIGHT_TO_LEFT : base::i18n::LEFT_TO_RIGHT);
   popup_controller_->set_hide_on_outside_click(true);
   popup_controller_->Show(popup_values,
                           popup_labels,
                           popup_icons,
                           popup_ids);
 }
 
+void AutofillDialogControllerImpl::ComboboxItemSelected(ServerFieldType type,
+                                                        int index) {
+  ui::ComboboxModel* model = ComboboxModelForAutofillType(type);
+  if (IsCountryComboboxModel(model))

[Evan Stade, 2014/01/02 22:59:26]

imo avoid the cast by doing:

if (type == ADDRESS_HOME_COUNTRY) {
  shipping_country_combobox_model_.SetDefaultIndex(index);
} else if (type == ADDRESS_BILLING_COUNTRY) {
  ...
}

+    static_cast<CountryComboboxModel*>(model)->SetDefaultIndex(index);

[Evan Stade, 2014/01/02 22:59:26]

can you call OnComboboxModelChanged from here instead of setting up |this| as an
observer?

+}
+
 void AutofillDialogControllerImpl::FocusMoved() {
   HidePopup();
 }
 
 bool AutofillDialogControllerImpl::ShouldShowErrorBubble() const {
   return !input_showing_popup_;
 }
 
 void AutofillDialogControllerImpl::ViewClosed() {
   GetManager()->RemoveObserver(this);
@@ skipping 216 matching lines @@
         GetManager()->GetCreditCardByGUID(pair.first)));
   } else {
     wrapper.reset(new AutofillProfileWrapper(
         GetManager()->GetProfileByGUID(pair.first),
         AutofillType(input_showing_popup_->type),
         pair.second));
   }
 
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
     DialogSection section = static_cast<DialogSection>(i);
-    wrapper->FillInputs(MutableRequestedFieldsForSection(section));
+    wrapper->FillInputs(MutableRequestedFieldsForSection(section),
+                        GetCountryCodeForSection(section));
     view_->FillSection(section, *input_showing_popup_);
   }
 
   GetMetricLogger().LogDialogPopupEvent(
       AutofillMetrics::DIALOG_POPUP_FORM_FILLED);
 
   // TODO(estade): not sure why it's necessary to do this explicitly.
   HidePopup();
 }
 
@@ skipping 340 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()->GetDefaultCountryCodeForNewAddress()),
+      shipping_country_combobox_model_(
+          GetManager()->GetDefaultCountryCodeForNewAddress()),
       suggested_cc_(this),
       suggested_billing_(this),
       suggested_cc_billing_(this),
       suggested_shipping_(this),
       cares_about_shipping_(true),
       input_showing_popup_(NULL),
       weak_ptr_factory_(this),
       waiting_for_explicit_sign_in_response_(false),
       has_accepted_legal_documents_(false),
       is_submitting_(false),
@@ skipping 214 matching lines @@
       suggested_cc_.AddKeyedItemWithIcon(
           cards[i]->guid(),
           cards[i]->Label(),
           rb.GetImageNamed(CreditCard::IconResourceId(cards[i]->type())));
     }
 
     const std::vector<AutofillProfile*>& profiles = manager->GetProfiles();
     std::vector<base::string16> labels;
     AutofillProfile::CreateDifferentiatingLabels(profiles, &labels);
     DCHECK_EQ(labels.size(), profiles.size());
-    const std::string app_locale = g_browser_process->GetApplicationLocale();
     for (size_t i = 0; i < profiles.size(); ++i) {
       const AutofillProfile& profile = *profiles[i];
       if (!HasCompleteAndVerifiedData(profile, requested_shipping_fields_) ||
           HasInvalidAddress(*profiles[i])) {
         continue;
       }
 
       // Don't add variants for addresses: name is part of credit card and we'll
       // just ignore email and phone number variants.
       suggested_shipping_.AddKeyedItem(profile.guid(), labels[i]);
@@ skipping 65 matching lines @@
     ShowEditUiIfBadSuggestion(section);
     UpdateSection(section);
   }
 
   UpdateForErrors();
 }
 
 void AutofillDialogControllerImpl::FillOutputForSectionWithComparator(
     DialogSection section,
     const InputFieldComparator& compare) {
-  const DetailInputs& inputs = RequestedFieldsForSection(section);
-
   if (!SectionIsActive(section))
     return;
 
+  const DetailInputs& inputs = RequestedFieldsForSection(section);
   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)
@@ skipping 126 matching lines @@
 
   DCHECK_EQ(&model, &suggested_shipping_);
   return SECTION_SHIPPING;
 }
 
 DetailInputs* AutofillDialogControllerImpl::MutableRequestedFieldsForSection(
     DialogSection section) {
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
+std::string AutofillDialogControllerImpl::GetCountryCodeForSection(
+    DialogSection section) const {
+  if (section == SECTION_BILLING || section == SECTION_CC_BILLING)
+    return billing_country_combobox_model_.GetDefaultCountryCode();
+  if (section == SECTION_SHIPPING)
+    return shipping_country_combobox_model_.GetDefaultCountryCode();
+  return "US";
+}
+
+void AutofillDialogControllerImpl::OnComboboxModelChanged(
+    ui::ComboboxModel* model) {
+  DCHECK(IsCountryComboboxModel(model));
+
+  ScopedViewUpdates updates(view_.get());
+  const FieldValueMap snapshot = TakeUserInputSnapshot();
+
+  const bool is_shipping = model == &shipping_country_combobox_model_;
+  const std::string country_code =
+      static_cast<CountryComboboxModel*>(model)->GetDefaultCountryCode();
+  for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
+    DialogSection section = static_cast<DialogSection>(i);
+
+    if ((is_shipping && section != SECTION_SHIPPING) ||
+        !(section == SECTION_BILLING || section == SECTION_CC_BILLING)) {
+      continue;
+    }
+
+    DetailInputs* inputs = MutableRequestedFieldsForSection(section);
+    inputs->clear();
+    common::BuildInputsForSection(section, inputs, country_code);
+  }
+
+  RestoreUserInputFromSnapshot(snapshot);
+
+  UpdateSection(is_shipping ? SECTION_SHIPPING :
+      IsPayingWithWallet() ? SECTION_CC_BILLING : SECTION_BILLING);
+}
+
 void AutofillDialogControllerImpl::HidePopup() {
   if (popup_controller_.get())
     popup_controller_->Hide();
   input_showing_popup_ = NULL;
 }
 
 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