rAc - Only show countries we're able to fill in.

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 615 matching lines @@
   form_structure_.ParseFieldTypesFromAutocompleteAttributes(
       &has_types, &has_sections);
 
   // Fail if the author didn't specify autocomplete types.
   if (!has_types) {
     callback_.Run(NULL);
     delete this;
     return;
   }
 
+  billing_country_combobox_model_.reset(new CountryComboboxModel(
+      *GetManager(),
+      form_structure_.PossibleValues(ADDRESS_BILLING_COUNTRY),
+      false));
+  shipping_country_combobox_model_.reset(new CountryComboboxModel(
+      *GetManager(),
+      form_structure_.PossibleValues(ADDRESS_HOME_COUNTRY),
+      false));
+
   // Log any relevant UI metrics and security exceptions.
   GetMetricLogger().LogDialogUiEvent(AutofillMetrics::DIALOG_UI_SHOWN);
 
   GetMetricLogger().LogDialogSecurityMetric(
       AutofillMetrics::SECURITY_METRIC_DIALOG_SHOWN);
 
   // The Autofill dialog is shown in response to a message from the renderer and
   // as such, it can only be made in the context of the current document. A call
   // to GetActiveEntry would return a pending entry, if there was one, which
   // would be a security bug. Therefore, we use the last committed URL for the
@@ skipping 722 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_;
+      return billing_country_combobox_model_.get();
 
     case ADDRESS_HOME_COUNTRY:
-      return &shipping_country_combobox_model_;
+      return shipping_country_combobox_model_.get();
 
     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 90 matching lines @@
     return false;
 
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   std::string item_key = model->GetItemKeyForCheckedItem();
   if (item_key == kSameAsBillingKey) {
     *vertically_compact = *horizontally_compact = l10n_util::GetStringUTF16(
         IDS_AUTOFILL_DIALOG_USING_BILLING_FOR_SHIPPING);
     return true;
   }
 
-  if (!IsASuggestionItemKey(item_key))
+  if (!IsASuggestionItemKey(item_key)) {
     return false;
+  }

[Dan Beam, 2014/03/01 03:38:10]

nit: revert

[Evan Stade, 2014/03/04 00:11:30]

Done.

 
   if (!IsPayingWithWallet() &&
       (section == SECTION_BILLING || section == SECTION_SHIPPING)) {
     // Also check if the address is invalid (rules may have loaded since
     // the dialog was shown).
     if (HasInvalidAddress(*GetManager()->GetProfileByGUID(item_key)))
       return false;
   }
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
@@ skipping 1186 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),
-      billing_country_combobox_model_(*GetManager(), false),
-      shipping_country_combobox_model_(*GetManager(), false),
       suggested_cc_(this),
       suggested_billing_(this),
       suggested_cc_billing_(this),
       suggested_shipping_(this),
       cares_about_shipping_(true),
       popup_input_type_(UNKNOWN_TYPE),
       waiting_for_explicit_sign_in_response_(false),
       has_accepted_legal_documents_(false),
       is_submitting_(false),
       choose_another_instrument_or_address_(false),
@@ skipping 135 matching lines @@
 
     if (shipping_same_as_billing)
       suggested_shipping_.SetCheckedItem(kSameAsBillingKey);
 
     for (size_t i = 0; i < addresses.size(); ++i) {
       std::string key = base::IntToString(i);
       suggested_shipping_.AddKeyedItemWithMinorText(
           key,
           addresses[i]->DisplayName(),
           addresses[i]->DisplayNameDetail());
+      suggested_shipping_.SetEnabled(
+          key,
+          CanAcceptCountry(SECTION_SHIPPING,
+                           addresses[i]->country_name_code()));
 
       // TODO(scr): Move this assignment outside the loop or comment why it
       // can't be there.
       const std::string default_shipping_address_id =
           GetIdToSelect(wallet_items_->default_address_id(),
                         previous_default_shipping_address_id_,
                         previously_selected_shipping_address_id_);
 
       if (!shipping_same_as_billing &&
           addresses[i]->object_id() == default_shipping_address_id) {
         suggested_shipping_.SetCheckedItem(key);
       }
     }
 
     if (!IsSubmitPausedOn(wallet::VERIFY_CVV)) {
       const std::vector<wallet::WalletItems::MaskedInstrument*>& instruments =
           wallet_items_->instruments();
       std::string first_active_instrument_key;
       std::string default_instrument_key;
       for (size_t i = 0; i < instruments.size(); ++i) {
-        bool allowed = IsInstrumentAllowed(*instruments[i]);
+        bool allowed = IsInstrumentAllowed(*instruments[i]) &&
+            CanAcceptCountry(SECTION_BILLING,
+                             instruments[i]->address().country_name_code());
         gfx::Image icon = instruments[i]->CardIcon();
         if (!allowed && !icon.IsEmpty()) {
           // Create a grayed disabled icon.
           SkBitmap disabled_bitmap = SkBitmapOperations::CreateHSLShiftedBitmap(
               *icon.ToSkBitmap(), kGrayImageShift);
           icon = gfx::Image(
               gfx::ImageSkia::CreateFrom1xBitmap(disabled_bitmap));
         }
         std::string key = base::IntToString(i);
         suggested_cc_billing_.AddKeyedItemWithMinorTextAndIcon(
@@ skipping 50 matching lines @@
             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());
       for (size_t i = 0; i < profiles.size(); ++i) {
         const AutofillProfile& profile = *profiles[i];
         if (!i18ninput::AddressHasCompleteAndVerifiedData(profile) ||
-            !i18ninput::CountryIsFullySupported(
-                UTF16ToASCII(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))) ||
             (!i18ninput::Enabled() && 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]);
+        suggested_shipping_.SetEnabled(
+            profile.guid(),
+            CanAcceptCountry(
+                SECTION_SHIPPING,
+                UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))));
         if (!profile.GetRawInfo(EMAIL_ADDRESS).empty() &&
             !profile.IsPresentButInvalid(EMAIL_ADDRESS)) {
           suggested_billing_.AddKeyedItem(profile.guid(), labels[i]);
+          suggested_billing_.SetEnabled(
+              profile.guid(),
+              CanAcceptCountry(
+                  SECTION_BILLING,
+                  UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))));
         }
       }
     }
 
     suggested_cc_.AddKeyedItem(
         kAddNewItemKey,
         l10n_util::GetStringUTF16(IsAutofillEnabled() ?
             IDS_AUTOFILL_DIALOG_ADD_CREDIT_CARD :
             IDS_AUTOFILL_DIALOG_ENTER_CREDIT_CARD));
     suggested_cc_.AddKeyedItem(
@@ skipping 186 matching lines @@
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper)
     return wrapper->GetInfo(AutofillType(type));
 
   FieldValueMap output;
   view_->GetUserInput(section, &output);
   return output[type];
 }
 
+bool AutofillDialogControllerImpl::CanAcceptCountry(
+    DialogSection section,
+    const std::string& country_code) {
+  CountryComboboxModel* model = CountryComboboxModelForSection(section);
+  const std::vector<AutofillCountry*>& countries = model->countries();
+  for (size_t i = 0; i < countries.size(); ++i) {
+    if (countries[i] && countries[i]->country_code() == country_code)
+      return true;
+  }
+
+  return false;
+}
+
 SuggestionsMenuModel* AutofillDialogControllerImpl::
     SuggestionsMenuModelForSection(DialogSection section) {
   switch (section) {
     case SECTION_CC:
       return &suggested_cc_;
     case SECTION_BILLING:
       return &suggested_billing_;
     case SECTION_SHIPPING:
       return &suggested_shipping_;
     case SECTION_CC_BILLING:
@@ skipping 21 matching lines @@
   if (&model == &suggested_cc_billing_)
     return SECTION_CC_BILLING;
 
   DCHECK_EQ(&model, &suggested_shipping_);
   return SECTION_SHIPPING;
 }
 
 CountryComboboxModel* AutofillDialogControllerImpl::
     CountryComboboxModelForSection(DialogSection section) {
   if (section == SECTION_BILLING)
-    return &billing_country_combobox_model_;
+    return billing_country_combobox_model_.get();
 
   if (section == SECTION_SHIPPING)
-    return &shipping_country_combobox_model_;
+    return shipping_country_combobox_model_.get();
 
   return NULL;
 }
 
 DetailInputs* AutofillDialogControllerImpl::MutableRequestedFieldsForSection(
     DialogSection section) {
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
 std::vector<ServerFieldType> AutofillDialogControllerImpl::
@@ skipping 477 matching lines @@
 }
 
 void AutofillDialogControllerImpl::GetDefaultAutofillChoice(
     DialogSection section,
     std::string* guid) {
   DCHECK(!IsPayingWithWallet() && IsAutofillEnabled());
   // The default choice is the first thing in the menu that is a suggestion
   // item.
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   for (int i = 0; i < model->GetItemCount(); ++i) {
-    if (IsASuggestionItemKey(model->GetItemKeyAt(i))) {
+    // Try the first suggestion item that is enabled.
+    if (IsASuggestionItemKey(model->GetItemKeyAt(i)) && model->IsEnabledAt(i)) {
       *guid = model->GetItemKeyAt(i);
-      break;
+      return;
+    // Fall back to the first non-suggestion key.

[Ilya Sherman, 2014/03/03 23:55:54]

I think this code chooses the last non-suggestion key, not the first, since
there's no break stmt or anything like that.

[Evan Stade, 2014/03/04 00:11:30]

that's what the guid->empty() check is for

[Ilya Sherman, 2014/03/04 00:53:57]

Ah, true dat.  Maybe DCHECK at the beginning of this method, then, that the
|guid| starts out empty?

+    } else if (!IsASuggestionItemKey(model->GetItemKeyAt(i)) && guid->empty()) {
+      *guid = model->GetItemKeyAt(i);
     }
   }
 }
 
 bool AutofillDialogControllerImpl::GetAutofillChoice(DialogSection section,
                                                      std::string* guid) {
   DCHECK(!IsPayingWithWallet() && IsAutofillEnabled());
   const base::DictionaryValue* choices = profile()->GetPrefs()->GetDictionary(
       ::prefs::kAutofillDialogAutofillDefault);
   if (!choices)
@@ skipping 147 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