Revert 195316 "Remove "Use billing for shipping" checkbox in fav..."

trunk/src/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 <string>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
 
 // This is a pseudo-scientifically chosen maximum amount we want a fronting
 // (proxy) card to be able to charge. The current actual max is $2000. Using
 // only $1850 leaves some room for tax and shipping, etc. TODO(dbeam): send a
 // special value to the server to just ask for the maximum so we don't need to
 // hardcode it here (http://crbug.com/180731). TODO(dbeam): also maybe allow
 // users to give us this number via an <input> (http://crbug.com/180733).
 const int kCartMax = 1850;
 const char kCartCurrency[] = "USD";
 
-const char kAddNewItemKey[] = "add-new-item";
-const char kManageItemsKey[] = "manage-items";
-const char kSameAsBillingKey[] = "same-as-billing";
-
 // Returns true if |input| should be shown when |field| has been requested.
 bool InputTypeMatchesFieldType(const DetailInput& input,
                                const AutofillField& field) {
   // If any credit card expiration info is asked for, show both month and year
   // inputs.
   if (field.type() == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
       field.type() == CREDIT_CARD_EXP_2_DIGIT_YEAR ||
       field.type() == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR ||
       field.type() == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR ||
       field.type() == CREDIT_CARD_EXP_MONTH) {
@@ skipping 312 matching lines @@
 // AutofillDialogController implementation.
 
 string16 AutofillDialogControllerImpl::DialogTitle() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_TITLE);
 }
 
 string16 AutofillDialogControllerImpl::EditSuggestionText() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_EDIT);
 }
 
+string16 AutofillDialogControllerImpl::UseBillingForShippingText() const {
+  return l10n_util::GetStringUTF16(
+      IDS_AUTOFILL_DIALOG_USE_BILLING_FOR_SHIPPING);
+}
+
 string16 AutofillDialogControllerImpl::CancelButtonText() const {
   return l10n_util::GetStringUTF16(IDS_CANCEL);
 }
 
 string16 AutofillDialogControllerImpl::ConfirmButtonText() const {
   return l10n_util::GetStringUTF16(IsSubmitPausedOn(wallet::VERIFY_CVV) ?
       IDS_AUTOFILL_DIALOG_VERIFY_BUTTON : IDS_AUTOFILL_DIALOG_SUBMIT_BUTTON);
 }
 
 string16 AutofillDialogControllerImpl::CancelSignInText() const {
@@ skipping 288 matching lines @@
       return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_SHIPPING);
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 SuggestionState AutofillDialogControllerImpl::SuggestionStateForSection(
     DialogSection section) {
   return SuggestionState(SuggestionTextForSection(section),
-                         SuggestionTextStyleForSection(section),
                          SuggestionIconForSection(section),
                          ExtraSuggestionTextForSection(section),
                          ExtraSuggestionIconForSection(section),
                          EditEnabledForSection(section));
 }
 
 string16 AutofillDialogControllerImpl::SuggestionTextForSection(
     DialogSection section) {
   string16 action_text = RequiredActionTextForSection(section);
   if (!action_text.empty())
     return action_text;
 
   // When the user has clicked 'edit', don't show a suggestion (even though
   // there is a profile selected in the model).
   if (section_editing_state_[section])
     return string16();
 
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   std::string item_key = model->GetItemKeyForCheckedItem();
-  if (item_key == kSameAsBillingKey) {
-    return l10n_util::GetStringUTF16(
-        IDS_AUTOFILL_DIALOG_USING_BILLING_FOR_SHIPPING);
-  }
-
-  if (!IsASuggestionItemKey(item_key))
+  if (item_key.empty())
     return string16();
 
   if (section == SECTION_EMAIL)
     return model->GetLabelAt(model->checked_item());
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   return wrapper->GetDisplayText();
 }
 
-gfx::Font::FontStyle
-    AutofillDialogControllerImpl::SuggestionTextStyleForSection(
-        DialogSection section) const {
-  const SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
-  if (model->GetItemKeyForCheckedItem() == kSameAsBillingKey)
-    return gfx::Font::ITALIC;
-
-  return gfx::Font::NORMAL;
-}
-
 string16 AutofillDialogControllerImpl::RequiredActionTextForSection(
     DialogSection section) const {
   if (section == SECTION_CC_BILLING && IsSubmitPausedOn(wallet::VERIFY_CVV)) {
     const wallet::WalletItems::MaskedInstrument* current_instrument =
         wallet_items_->GetInstrumentById(active_instrument_id_);
     if (current_instrument)
       return current_instrument->TypeAndLastFourDigits();
 
     DetailOutputMap output;
     view_->GetUserInput(section, &output);
@@ skipping 22 matching lines @@
     if (section == SECTION_CC_BILLING) {
       return scoped_ptr<DataModelWrapper>(
           new FullWalletBillingWrapper(full_wallet_.get()));
     }
     if (section == SECTION_SHIPPING) {
       return scoped_ptr<DataModelWrapper>(
           new FullWalletShippingWrapper(full_wallet_.get()));
     }
   }
 
+  if (IsManuallyEditingSection(section))
+    return scoped_ptr<DataModelWrapper>();
+
   SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
   std::string item_key = model->GetItemKeyForCheckedItem();
-  if (!IsASuggestionItemKey(item_key) || IsManuallyEditingSection(section))
-    return scoped_ptr<DataModelWrapper>();
 
   if (IsPayingWithWallet()) {
     int index;
     bool success = base::StringToInt(item_key, &index);
     DCHECK(success);
 
     if (section == SECTION_CC_BILLING) {
       return scoped_ptr<DataModelWrapper>(
           new WalletInstrumentWrapper(wallet_items_->instruments()[index]));
     }
@@ skipping 41 matching lines @@
 gfx::Image AutofillDialogControllerImpl::ExtraSuggestionIconForSection(
     DialogSection section) const {
   if (section == SECTION_CC || section == SECTION_CC_BILLING)
     return IconForField(CREDIT_CARD_VERIFICATION_CODE, string16());
 
   return gfx::Image();
 }
 
 bool AutofillDialogControllerImpl::EditEnabledForSection(
     DialogSection section) const {
-  if (SuggestionsMenuModelForSection(section)->GetItemKeyForCheckedItem() ==
-      kSameAsBillingKey) {
-    return false;
-  }
-
-  if (section == SECTION_CC_BILLING && IsSubmitPausedOn(wallet::VERIFY_CVV))
-    return false;
-
-  return true;
+  return section != SECTION_CC_BILLING || !IsSubmitPausedOn(wallet::VERIFY_CVV);
 }
 
 void AutofillDialogControllerImpl::EditClickedForSection(
     DialogSection section) {
   DetailInputs* inputs = MutableRequestedFieldsForSection(section);
   scoped_ptr<DataModelWrapper> model = CreateWrapper(section);
   model->FillInputs(inputs);
   section_editing_state_[section] = true;
   view_->UpdateSection(section, CLEAR_USER_INPUT);
 
@@ skipping 474 matching lines @@
       // to the Wallet. This will trigger AccountChoiceChanged.
       account_chooser_model_.SelectActiveWalletAccount();
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SuggestionsMenuModelDelegate implementation.
 
 void AutofillDialogControllerImpl::SuggestionItemSelected(
-    SuggestionsMenuModel* model,
-    size_t index) {
-  if (model->GetItemKeyAt(index) == kManageItemsKey) {
-    // TODO(estade): show chrome://settings or a wallet URL.
-    return;
-  }
+    const SuggestionsMenuModel& model) {
+  const DialogSection section = SectionForSuggestionsMenuModel(model);
+  EditCancelledForSection(section);
 
-  model->SetCheckedIndex(index);
-  EditCancelledForSection(SectionForSuggestionsMenuModel(*model));
-
-  LogSuggestionItemSelectedMetric(*model);
+  LogSuggestionItemSelectedMetric(model);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wallet::WalletClientDelegate implementation.
 
 const AutofillMetrics& AutofillDialogControllerImpl::GetMetricLogger() const {
   return metric_logger_;
 }
 
 DialogType AutofillDialogControllerImpl::GetDialogType() const {
@@ skipping 296 matching lines @@
 }
 
 void AutofillDialogControllerImpl::SuggestionsUpdated() {
   suggested_email_.Reset();
   suggested_cc_.Reset();
   suggested_billing_.Reset();
   suggested_cc_billing_.Reset();
   suggested_shipping_.Reset();
   HidePopup();
 
-  suggested_shipping_.AddKeyedItem(
-      kSameAsBillingKey,
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_USE_BILLING_FOR_SHIPPING));
-
   if (IsPayingWithWallet()) {
     if (!account_chooser_model_.active_wallet_account_name().empty()) {
       suggested_email_.AddKeyedItem(
           base::IntToString(0),
           account_chooser_model_.active_wallet_account_name());
     }
 
     const std::vector<wallet::Address*>& addresses =
         wallet_items_->addresses();
     for (size_t i = 0; i < addresses.size(); ++i) {
       // TODO(dbeam): respect the default instrument ID. http://crbug.com/232954
       suggested_shipping_.AddKeyedItemWithSublabel(
           base::IntToString(i),
           addresses[i]->DisplayName(),
           addresses[i]->DisplayNameDetail());
-
     }
 
     if (!IsSubmitPausedOn(wallet::VERIFY_CVV)) {
       const std::vector<wallet::WalletItems::MaskedInstrument*>& instruments =
           wallet_items_->instruments();
       for (size_t i = 0; i < instruments.size(); ++i) {
         // TODO(dbeam): respect the default address ID. http://crbug.com/232954
         suggested_cc_billing_.AddKeyedItemWithSublabelAndIcon(
             base::IntToString(i),
             instruments[i]->DisplayName(),
             instruments[i]->DisplayNameDetail(),
             instruments[i]->CardIcon());
       }
 
-      // TODO(estade): this should have a URL sublabel.
       suggested_cc_billing_.AddKeyedItem(
-          kAddNewItemKey,
+          std::string(),
           l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_BILLING_DETAILS));
-      suggested_cc_billing_.AddKeyedItem(
-          kManageItemsKey,
-          l10n_util::GetStringUTF16(
-              IDS_AUTOFILL_DIALOG_MANAGE_BILLING_DETAILS));
     }
   } else {
     PersonalDataManager* manager = GetManager();
     const std::vector<CreditCard*>& cards = manager->credit_cards();
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     for (size_t i = 0; i < cards.size(); ++i) {
       suggested_cc_.AddKeyedItemWithIcon(
           cards[i]->guid(),
           cards[i]->Label(),
           rb.GetImageNamed(cards[i]->IconResourceId()));
@@ skipping 16 matching lines @@
       // Don't add variants for addresses: the email variants are handled above,
       // name is part of credit card and we'll just ignore phone number
       // variants.
       suggested_billing_.AddKeyedItem(profiles[i]->guid(),
                                       profiles[i]->Label());
       suggested_shipping_.AddKeyedItem(profiles[i]->guid(),
                                        profiles[i]->Label());
     }
 
     suggested_cc_.AddKeyedItem(
-        kAddNewItemKey,
+        std::string(),
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_CREDIT_CARD));
-    suggested_cc_.AddKeyedItem(
-        kManageItemsKey,
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_CREDIT_CARD));
     suggested_billing_.AddKeyedItem(
-        kAddNewItemKey,
+        std::string(),
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_BILLING_ADDRESS));
-    suggested_billing_.AddKeyedItem(
-        kManageItemsKey,
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_BILLING_ADDRESS));
   }
 
   suggested_email_.AddKeyedItem(
-      kAddNewItemKey,
+      std::string(),
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_EMAIL_ADDRESS));
-  if (!IsPayingWithWallet()) {
-    suggested_email_.AddKeyedItem(
-        kManageItemsKey,
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_EMAIL_ADDRESS));
-  }
-
   suggested_shipping_.AddKeyedItem(
-      kAddNewItemKey,
+      std::string(),
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_SHIPPING_ADDRESS));
-  suggested_shipping_.AddKeyedItem(
-      kManageItemsKey,
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_SHIPPING_ADDRESS));
-
-  // Default shipping address is the first suggestion, if one exists. Otherwise
-  // it's the "Use shipping for billing" item.
-  const std::string& first_real_suggestion_item_key =
-      suggested_shipping_.GetItemKeyAt(1);
-  if (IsASuggestionItemKey(first_real_suggestion_item_key))
-      suggested_shipping_.SetCheckedItem(first_real_suggestion_item_key);
 
   if (view_)
     view_->ModelChanged();
 }
 
 bool AutofillDialogControllerImpl::IsCompleteProfile(
     const AutofillProfile& profile) {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   for (size_t i = 0; i < requested_shipping_fields_.size(); ++i) {
     AutofillFieldType type = requested_shipping_fields_[i].type;
@@ skipping 81 matching lines @@
     AutofillField* field = form_structure_.field(i);
     if (field->type() == CREDIT_CARD_VERIFICATION_CODE) {
       field->value = cvc;
       break;
     }
   }
 }
 
 SuggestionsMenuModel* AutofillDialogControllerImpl::
     SuggestionsMenuModelForSection(DialogSection section) {
+  const AutofillDialogControllerImpl* const_this =
+      static_cast<const AutofillDialogControllerImpl*>(this);
+  return const_cast<SuggestionsMenuModel*>(
+      const_this->SuggestionsMenuModelForSection(section));
+}
+
+const SuggestionsMenuModel* AutofillDialogControllerImpl::
+    SuggestionsMenuModelForSection(DialogSection section) const {
   switch (section) {
     case SECTION_EMAIL:
       return &suggested_email_;
     case SECTION_CC:
       return &suggested_cc_;
     case SECTION_BILLING:
       return &suggested_billing_;
     case SECTION_SHIPPING:
       return &suggested_shipping_;
     case SECTION_CC_BILLING:
       return &suggested_cc_billing_;
   }
 
   NOTREACHED();
   return NULL;
 }
 
-const SuggestionsMenuModel* AutofillDialogControllerImpl::
-    SuggestionsMenuModelForSection(DialogSection section) const {
-  return const_cast<AutofillDialogControllerImpl*>(this)->
-      SuggestionsMenuModelForSection(section);
-}
-
 DialogSection AutofillDialogControllerImpl::SectionForSuggestionsMenuModel(
     const SuggestionsMenuModel& model) {
   if (&model == &suggested_email_)
     return SECTION_EMAIL;
 
   if (&model == &suggested_cc_)
     return SECTION_CC;
 
   if (&model == &suggested_billing_)
     return SECTION_BILLING;
@@ skipping 49 matching lines @@
     scoped_ptr<risk::Fingerprint> fingerprint) {
   NOTIMPLEMENTED();
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingSection(
     DialogSection section) const {
   std::map<DialogSection, bool>::const_iterator it =
       section_editing_state_.find(section);
   return (it != section_editing_state_.end() && it->second) ||
          SuggestionsMenuModelForSection(section)->
-             GetItemKeyForCheckedItem() == kAddNewItemKey;
-}
-
-bool AutofillDialogControllerImpl::IsASuggestionItemKey(
-    const std::string& key) {
-  return !key.empty() &&
-      key != kAddNewItemKey &&
-      key != kManageItemsKey &&
-      key != kSameAsBillingKey;
+             GetItemKeyForCheckedItem().empty();
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingAnySection() const {
   for (size_t section = SECTION_MIN; section <= SECTION_MAX; ++section) {
     if (IsManuallyEditingSection(static_cast<DialogSection>(section)))
       return true;
   }
   return false;
 }
 
 bool AutofillDialogControllerImpl::AllSectionsAreValid() const {
   for (size_t section = SECTION_MIN; section <= SECTION_MAX; ++section) {
     if (!SectionIsValid(static_cast<DialogSection>(section)))
       return false;
   }
   return true;
 }
 
 bool AutofillDialogControllerImpl::SectionIsValid(
     DialogSection section) const {
   if (!IsManuallyEditingSection(section))
     return true;
 
   DetailOutputMap detail_outputs;
   view_->GetUserInput(SECTION_EMAIL, &detail_outputs);
   return InputsAreValid(detail_outputs, VALIDATE_EDIT).empty();
 }
 
 bool AutofillDialogControllerImpl::ShouldUseBillingForShipping() {
-  return suggested_shipping_.GetItemKeyForCheckedItem() == kSameAsBillingKey;
+  // If the user is editing or inputting data, ask the view.
+  if (IsManuallyEditingSection(SECTION_SHIPPING))
+    return view_->UseBillingForShipping();
+
+  // Otherwise, the checkbox should be hidden so its state is irrelevant.
+  // Always use the shipping suggestion model.
+  return false;
 }
 
 bool AutofillDialogControllerImpl::ShouldSaveDetailsLocally() {
   // It's possible that the user checked [X] Save details locally before
   // switching payment methods, so only ask the view whether to save details
   // locally if that checkbox is showing (currently if not paying with wallet).
   // Also, if the user isn't editing any sections, there's no data to save
   // locally.
   return ShouldOfferToSaveInChrome() && view_->SaveDetailsLocally();
 }
@@ skipping 14 matching lines @@
   // TODO(dbeam): disallow interacting with the dialog while submitting.
   // http://crbug.com/230932
 
   active_instrument_id_.clear();
   active_address_id_.clear();
   full_wallet_.reset();
 
   if (!section_editing_state_[SECTION_CC_BILLING]) {
     SuggestionsMenuModel* billing =
         SuggestionsMenuModelForSection(SECTION_CC_BILLING);
-    if (IsASuggestionItemKey(billing->GetItemKeyForCheckedItem()) &&
+    if (!billing->GetItemKeyForCheckedItem().empty() &&
         billing->checked_item() <
             static_cast<int>(wallet_items_->instruments().size())) {
       const wallet::WalletItems::MaskedInstrument* active_instrument =
           wallet_items_->instruments()[billing->checked_item()];
       active_instrument_id_ = active_instrument->object_id();
 
       // TODO(dbeam): save this as a shipping address. http://crbug.com/225442
       if (ShouldUseBillingForShipping())
         active_address_id_ = active_instrument->address().object_id();
     }
   }
 
   if (!section_editing_state_[SECTION_SHIPPING] && active_address_id_.empty()) {
     SuggestionsMenuModel* shipping =
         SuggestionsMenuModelForSection(SECTION_SHIPPING);
-    if (IsASuggestionItemKey(shipping->GetItemKeyForCheckedItem()) &&
-        shipping->checked_item() - 1 <
+    if (!shipping->GetItemKeyForCheckedItem().empty() &&
+        shipping->checked_item() <
             static_cast<int>(wallet_items_->addresses().size())) {
       active_address_id_ =
-          wallet_items_->addresses()[shipping->checked_item() - 1]->object_id();
+          wallet_items_->addresses()[shipping->checked_item()]->object_id();
     }
   }
 
   GetWalletClient()->AcceptLegalDocuments(
       wallet_items_->legal_documents(),
       wallet_items_->google_transaction_id(),
       source_url_);
 
   scoped_ptr<wallet::Instrument> new_instrument;
   if (active_instrument_id_.empty()) {
@@ skipping 136 matching lines @@
       base::Time::Now() - dialog_shown_timestamp_,
       dialog_type_,
       AutofillMetrics::DIALOG_CANCELED);
 }
 
 void AutofillDialogControllerImpl::LogSuggestionItemSelectedMetric(
     const SuggestionsMenuModel& model) {
   DialogSection section = SectionForSuggestionsMenuModel(model);
 
   AutofillMetrics::DialogUiEvent dialog_ui_event;
-  if (model.GetItemKeyForCheckedItem() == kAddNewItemKey) {
+  if (model.GetItemKeyForCheckedItem().empty()) {
     // Selected to add a new item.
     dialog_ui_event = DialogSectionToUiItemAddedEvent(section);
-  } else if (IsASuggestionItemKey(model.GetItemKeyForCheckedItem())) {
+  } else {
     // Selected an existing item.
     DCHECK(!section_editing_state_[section]);
     dialog_ui_event = DialogSectionToUiSelectionChangedEvent(section);
-  } else {
-    // TODO(estade): add logging for "Manage items" or "Use billing for
-    // shipping"?
-    return;
   }
 
   GetMetricLogger().LogDialogUiEvent(dialog_type_, dialog_ui_event);
 }
 
 AutofillMetrics::DialogInitialUserStateMetric
     AutofillDialogControllerImpl::GetInitialUserState() const {
   // Consider a user to be an Autofill user if the user has any credit cards
-  // or addresses saved. Check that the item count is greater than 2 because
-  // an "empty" menu still has the "add new" menu item and "manage" menu item.
+  // or addresses saved. Check that the item count is greater than 1 because
+  // an "empty" menu still has the "add new" menu item.
   const bool has_autofill_profiles =
-      suggested_cc_.GetItemCount() > 2 ||
-      suggested_billing_.GetItemCount() > 2;
+      suggested_cc_.GetItemCount() > 1 ||
+      suggested_billing_.GetItemCount() > 1;
 
   if (SignedInState() != SIGNED_IN) {
     // Not signed in.
     return has_autofill_profiles ?
         AutofillMetrics::DIALOG_USER_NOT_SIGNED_IN_HAS_AUTOFILL :
         AutofillMetrics::DIALOG_USER_NOT_SIGNED_IN_NO_AUTOFILL;
   }
 
   // Signed in.
   if (wallet_items_->instruments().empty()) {
     // No Wallet items.
     return has_autofill_profiles ?
         AutofillMetrics::DIALOG_USER_SIGNED_IN_NO_WALLET_HAS_AUTOFILL :
         AutofillMetrics::DIALOG_USER_SIGNED_IN_NO_WALLET_NO_AUTOFILL;
   }
 
   // Has Wallet items.
   return has_autofill_profiles ?
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_HAS_AUTOFILL :
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_NO_AUTOFILL;
 }
 
 }  // namespace autofill