Remove "Use billing for shipping" checkbox in favor of item in suggestions menu.

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 61 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 275 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.empty())
+  if (item_key == kSameAsBillingKey) {
+    return l10n_util::GetStringUTF16(
+        IDS_AUTOFILL_DIALOG_USING_BILLING_FOR_SHIPPING);
+  }
+
+  if (!IsASuggestionItemKey(item_key))
     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 83 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 {
-  return section != SECTION_CC_BILLING || !IsSubmitPausedOn(wallet::VERIFY_CVV);
+  if (SuggestionsMenuModelForSection(section)->GetItemKeyForCheckedItem() ==
+      kSameAsBillingKey) {
+    return false;
+  }
+
+  if (section == SECTION_CC_BILLING && IsSubmitPausedOn(wallet::VERIFY_CVV))
+    return false;
+
+  return true;
 }
 
 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 466 matching lines @@
     EndSignInFlow();
     if (account_chooser_model_.WalletIsSelected())
       GetWalletItems();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SuggestionsMenuModelDelegate implementation.
 
 void AutofillDialogControllerImpl::SuggestionItemSelected(
-    const SuggestionsMenuModel& model) {
-  const DialogSection section = SectionForSuggestionsMenuModel(model);
-  EditCancelledForSection(section);
+    SuggestionsMenuModel* model,
+    const std::string& item_key) {
+  if (item_key == kManageItemsKey) {
+    // TODO(estade): show chrome://settings or a wallet URL.

[Dan Beam, 2013/04/17 22:24:26]

can you file a bug for this?

+    return;
+  }
 
-  LogSuggestionItemSelectedMetric(model);
+  model->SetCheckedItem(item_key);
+  EditCancelledForSection(SectionForSuggestionsMenuModel(*model));
+
+  LogSuggestionItemSelectedMetric(*model);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wallet::WalletClientDelegate implementation.
 
 const AutofillMetrics& AutofillDialogControllerImpl::GetMetricLogger() const {
   return metric_logger_;
 }
 
 DialogType AutofillDialogControllerImpl::GetDialogType() const {
@@ skipping 276 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()) {
     // TODO(estade): fill in the email address.
 
     const std::vector<wallet::Address*>& addresses =
         wallet_items_->addresses();
     for (size_t i = 0; i < addresses.size(); ++i) {
       // TODO(dbeam): respect wallet_items_->default_instrument_id().
       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 wallet_items_->default_address_id().
         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(
-          std::string(),
+          kAddNewItemKey,
           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(
-        std::string(),
+        kAddNewItemKey,
         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(
-        std::string(),
+        kAddNewItemKey,
         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(
-      std::string(),
+      kAddNewItemKey,
       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(
-      std::string(),
+      kAddNewItemKey,
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_SHIPPING_ADDRESS));
+  suggested_shipping_.AddKeyedItem(
+      kManageItemsKey,
+      l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_SHIPPING_ADDRESS));
 
   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().empty();
+             GetItemKeyForCheckedItem() == kAddNewItemKey;
+}
+
+bool AutofillDialogControllerImpl::IsASuggestionItemKey(
+    const std::string& key) {
+  return !key.empty() &&
+      key != kAddNewItemKey &&
+      key != kManageItemsKey &&
+      key != kSameAsBillingKey;
 }
 
 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() {
-  // 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;
+  return suggested_shipping_.GetItemKeyForCheckedItem() == kSameAsBillingKey;
 }
 
 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 13 matching lines @@
 void AutofillDialogControllerImpl::SubmitWithWallet() {
   // TODO(dbeam): disallow interacting with the dialog while submitting.
 
   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 (!billing->GetItemKeyForCheckedItem().empty() &&
+    if (IsASuggestionItemKey(billing->GetItemKeyForCheckedItem()) &&
         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): does re-using instrument address IDs work?
       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 (!shipping->GetItemKeyForCheckedItem().empty() &&
+    if (IsASuggestionItemKey(shipping->GetItemKeyForCheckedItem()) &&
         shipping->checked_item() <
             static_cast<int>(wallet_items_->addresses().size())) {
       active_address_id_ =
           wallet_items_->addresses()[shipping->checked_item()]->object_id();
     }
   }
 
   GetWalletClient()->AcceptLegalDocuments(
       wallet_items_->legal_documents(),
       wallet_items_->google_transaction_id(),
@@ skipping 140 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().empty()) {
+  if (model.GetItemKeyForCheckedItem() == kAddNewItemKey) {
     // Selected to add a new item.
     dialog_ui_event = DialogSectionToUiItemAddedEvent(section);
-  } else {
+  } else if (base::IsValidGUID(model.GetItemKeyForCheckedItem())) {
     // 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"?

[Dan Beam, 2013/04/17 22:24:26]

can you file a bug for this?

+    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 1 because
   // an "empty" menu still has the "add new" menu item.
@@ skipping 16 matching lines @@
         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