[rAc] Move email address into billing address section.

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 241 matching lines @@
     case SECTION_BILLING:
       return "billing";
 
     case SECTION_CC_BILLING:
       // The SECTION_CC_BILLING section isn't active when using Autofill.
       NOTREACHED();
       return std::string();
 
     case SECTION_SHIPPING:
       return "shipping";
-
-    case SECTION_EMAIL:
-      return "email";
   }
 
   NOTREACHED();
   return std::string();
 }
 
 // Check if a given MaskedInstrument is allowed for the purchase.
 bool IsInstrumentAllowed(
     const wallet::WalletItems::MaskedInstrument& instrument) {
   switch (instrument.status()) {
@@ skipping 311 matching lines @@
   form_structure_.ParseFieldTypesFromAutocompleteAttributes(
       &has_types, &has_sections);
 
   // Fail if the author didn't specify autocomplete types.
   if (!has_types) {
     callback_.Run(NULL, std::string());
     delete this;
     return;
   }
 
-  common::BuildInputsForSection(SECTION_EMAIL,
-                                &requested_email_fields_);
   common::BuildInputsForSection(SECTION_CC,
                                 &requested_cc_fields_);
   common::BuildInputsForSection(SECTION_BILLING,
                                 &requested_billing_fields_);
   common::BuildInputsForSection(SECTION_CC_BILLING,
                                 &requested_cc_billing_fields_);
   common::BuildInputsForSection(SECTION_SHIPPING,
                                 &requested_shipping_fields_);
 
   // Test whether we need to show the shipping section. If filling that section
@@ skipping 495 matching lines @@
     }
   }
 
   if (should_update)
     view_->UpdateForErrors();
 }
 
 const DetailInputs& AutofillDialogControllerImpl::RequestedFieldsForSection(
     DialogSection section) const {
   switch (section) {
-    case SECTION_EMAIL:
-      return requested_email_fields_;
     case SECTION_CC:
       return requested_cc_fields_;
     case SECTION_BILLING:
       return requested_billing_fields_;
     case SECTION_CC_BILLING:
       return requested_cc_billing_fields_;
     case SECTION_SHIPPING:
       return requested_shipping_fields_;
   }
 
@@ skipping 71 matching lines @@
     return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
         IDR_WALLET_LOGO);
   }
 
   return gfx::Image();
 }
 
 string16 AutofillDialogControllerImpl::LabelForSection(DialogSection section)
     const {
   switch (section) {
-    case SECTION_EMAIL:
-      return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_EMAIL);
     case SECTION_CC:
       return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_CC);
     case SECTION_BILLING:
     case SECTION_CC_BILLING:
       return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_BILLING);
     case SECTION_SHIPPING:
       return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_SHIPPING);
-    default:
-      NOTREACHED();
-      return string16();
   }
+  NOTREACHED();
+  return string16();
 }
 
 SuggestionState AutofillDialogControllerImpl::SuggestionStateForSection(
     DialogSection section) {
   string16 vertically_compact, horizontally_compact;
   bool show_suggestion = SuggestionTextForSection(section,
                                                   &vertically_compact,
                                                   &horizontally_compact);
   return SuggestionState(show_suggestion,
                          vertically_compact,
@@ skipping 23 matching lines @@
   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))
     return false;
 
-  if (section == SECTION_EMAIL) {
-    *vertically_compact = *horizontally_compact =
-        model->GetLabelAt(model->checked_item());
-    return true;
-  }
-
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   return wrapper->GetDisplayText(vertically_compact, horizontally_compact);
 }
 
 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)
@@ skipping 96 matching lines @@
 
   if (section == SECTION_CC) {
     CreditCard* card = GetManager()->GetCreditCardByGUID(item_key);
     DCHECK(card);
     return scoped_ptr<DataModelWrapper>(new AutofillCreditCardWrapper(card));
   }
 
   AutofillProfile* profile = GetManager()->GetProfileByGUID(item_key);
   DCHECK(profile);
   size_t variant = GetSelectedVariantForModel(*model);
+  if (section == SECTION_SHIPPING) {
+    return scoped_ptr<DataModelWrapper>(
+        new AutofillShippingAddressWrapper(profile, variant));
+  }

[Evan Stade, 2013/09/05 16:54:09]

DCHECK_EQ(SECTION_BILLING, section)?

[Ilya Sherman, 2013/09/06 04:16:05]

Done.

   return scoped_ptr<DataModelWrapper>(
       new AutofillProfileWrapper(profile, variant));
 }
 
 gfx::Image AutofillDialogControllerImpl::SuggestionIconForSection(
     DialogSection section) {
   scoped_ptr<DataModelWrapper> model = CreateWrapper(section);
   if (!model.get())
     return gfx::Image();
 
@@ skipping 838 matching lines @@
       profile_(Profile::FromBrowserContext(contents->GetBrowserContext())),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       dialog_type_(dialog_type),
       form_structure_(form_structure),
       invoked_from_same_origin_(true),
       source_url_(source_url),
       callback_(callback),
       account_chooser_model_(this, profile_->GetPrefs(), metric_logger_,
                              dialog_type),
       wallet_client_(profile_->GetRequestContext(), this),
-      suggested_email_(this),
       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),
       should_show_wallet_promo_(!profile_->GetPrefs()->GetBoolean(
           ::prefs::kAutofillDialogHasPaidWithWallet)),
       has_shown_wallet_usage_confirmation_(false),
@@ skipping 99 matching lines @@
   SetIsSubmitting(false);
   wallet_error_notification_ = GetWalletError(error_type);
   account_chooser_model_.SetHadWalletError();
 }
 
 void AutofillDialogControllerImpl::SuggestionsUpdated() {
   ScopedViewUpdates updates(view_.get());
 
   const DetailOutputMap snapshot = TakeUserInputSnapshot();
 
-  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) {
       std::string key = base::IntToString(i);
       suggested_shipping_.AddKeyedItemWithSublabel(
           key,
           addresses[i]->DisplayName(),
           addresses[i]->DisplayNameDetail());
 
       const std::string default_shipping_address_id =
@@ skipping 74 matching lines @@
           cards[i]->guid(),
           cards[i]->Label(),
           rb.GetImageNamed(CreditCard::IconResourceId(cards[i]->type())));
     }
 
     const std::vector<AutofillProfile*>& profiles = manager->GetProfiles();
     const std::string app_locale = g_browser_process->GetApplicationLocale();
     for (size_t i = 0; i < profiles.size(); ++i) {
       if (!HasCompleteAndVerifiedData(*profiles[i],
                                       requested_shipping_fields_) ||
+          profiles[i]->GetRawInfo(EMAIL_ADDRESS).empty() ||

[Evan Stade, 2013/09/05 16:54:09]

I feel like this should be covered in one of the other 2 checks in this
condition.

[Ilya Sherman, 2013/09/06 04:16:05]

Moved to only affect the billing section.

           HasInvalidAddress(*profiles[i])) {
         continue;
       }
 
-      // Add all email addresses.
-      std::vector<string16> values;
-      profiles[i]->GetMultiInfo(
-          AutofillType(EMAIL_ADDRESS), app_locale, &values);
-      for (size_t j = 0; j < values.size(); ++j) {
-        if (IsValidEmailAddress(values[j]))
-          suggested_email_.AddKeyedItem(profiles[i]->guid(), values[j]);
-      }
-
-      // 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.
+      // Don't add variants for addresses: name is part of credit card and we'll
+      // just ignore email and phone number variants.

[Evan Stade, 2013/09/05 16:54:09]

:/

[Ilya Sherman, 2013/09/06 04:16:05]

I dunno, are email addresses more important than phone numbers when it comes to
variants?  It's a shame to drop them, but it seems like we ought to handle both
equally.

[Evan Stade, 2013/09/06 21:41:00]

I'd rather not drop either, but only dropping one is superior to dropping  both.
I don't have a better idea though.

       suggested_billing_.AddKeyedItem(profiles[i]->guid(),
                                       profiles[i]->Label());
       suggested_shipping_.AddKeyedItem(profiles[i]->guid(),
                                        profiles[i]->Label());
     }
 
     suggested_cc_.AddKeyedItem(
         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(
         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(
-      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(
       kAddNewItemKey,
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_SHIPPING_ADDRESS));
   if (!IsPayingWithWallet()) {
     suggested_shipping_.AddKeyedItem(
         kManageItemsKey,
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_SHIPPING_ADDRESS));
   } else if (!wallet_items_->HasRequiredAction(wallet::SETUP_WALLET)) {
     suggested_shipping_.AddKeyedItemWithSublabel(
         kManageItemsKey,
@@ skipping 35 matching lines @@
   }
 
   UpdateForErrors();
 }
 
 void AutofillDialogControllerImpl::FillOutputForSectionWithComparator(
     DialogSection section,
     const InputFieldComparator& compare) {
   const DetailInputs& inputs = RequestedFieldsForSection(section);
 
-  // Email is hidden while using Wallet, special case it.
-  if (section == SECTION_EMAIL && IsPayingWithWallet()) {
-    AutofillProfile profile;
-    profile.SetRawInfo(EMAIL_ADDRESS,
-                       account_chooser_model_.active_wallet_account_name());
-    AutofillProfileWrapper profile_wrapper(&profile, 0);
-    profile_wrapper.FillFormStructure(inputs, compare, &form_structure_);
-    return;
-  }
-
   if (!SectionIsActive(section))
     return;
 
   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)
-      SetCvcResult(view_->GetCvc());
+      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
+    // address.
+    if (section == SECTION_CC_BILLING) {
+      SetOutputForFieldsOfType(
+          EMAIL_ADDRESS, account_chooser_model_.active_wallet_account_name());
+    }
   } else {
     // The user manually input data. If using Autofill, save the info as new or
     // edited data. Always fill local data into |form_structure_|.
     DetailOutputMap output;
     view_->GetUserInput(section, &output);
 
     if (section == SECTION_CC) {
       CreditCard card;
       card.set_origin(kAutofillDialogOrigin);
       FillFormGroupFromOutputs(output, &card);
 
       // The card holder name comes from the billing address section.
       card.SetRawInfo(CREDIT_CARD_NAME,
                       GetValueFromSection(SECTION_BILLING, NAME_FULL));
 
       if (ShouldSaveDetailsLocally()) {
         GetManager()->SaveImportedCreditCard(card);
         DCHECK(!profile()->IsOffTheRecord());
         newly_saved_card_.reset(new CreditCard(card));
       }
 
       AutofillCreditCardWrapper card_wrapper(&card);
       card_wrapper.FillFormStructure(inputs, compare, &form_structure_);
 
       // Again, CVC needs special-casing. Fill it in directly from |output|.
-      SetCvcResult(GetValueForType(output, CREDIT_CARD_VERIFICATION_CODE));
+      SetOutputForFieldsOfType(
+          CREDIT_CARD_VERIFICATION_CODE,
+          GetValueForType(output, CREDIT_CARD_VERIFICATION_CODE));
     } else {
       AutofillProfile profile;
       profile.set_origin(kAutofillDialogOrigin);
       FillFormGroupFromOutputs(output, &profile);
 
-      // For billing, the email address comes from the separate email section.
-      if (section == SECTION_BILLING) {
-        profile.SetRawInfo(EMAIL_ADDRESS,
-                           GetValueFromSection(SECTION_EMAIL, EMAIL_ADDRESS));
-      }
-
       if (ShouldSaveDetailsLocally())
         SaveProfileGleanedFromSection(profile, section);
 
       AutofillProfileWrapper profile_wrapper(&profile, 0);
       profile_wrapper.FillFormStructure(inputs, compare, &form_structure_);
     }
   }
 }
 
 void AutofillDialogControllerImpl::FillOutputForSection(DialogSection section) {
   FillOutputForSectionWithComparator(
       section, base::Bind(common::DetailInputMatchesField, section));
 }
 
 bool AutofillDialogControllerImpl::FormStructureCaresAboutSection(
     DialogSection section) const {
   // For now, only SECTION_SHIPPING may be omitted due to a site not asking for
   // any of the fields.
   if (section == SECTION_SHIPPING)
     return cares_about_shipping_;
 
   return true;
 }
 
-void AutofillDialogControllerImpl::SetCvcResult(const string16& cvc) {
+void AutofillDialogControllerImpl::SetOutputForFieldsOfType(
+    ServerFieldType type,
+    const base::string16& output) {
   for (size_t i = 0; i < form_structure_.field_count(); ++i) {
     AutofillField* field = form_structure_.field(i);
-    if (field->Type().GetStorableType() == CREDIT_CARD_VERIFICATION_CODE) {
-      field->value = cvc;
-      break;
-    }
+    if (field->Type().GetStorableType() == type)
+      field->value = output;
   }
 }
 
 string16 AutofillDialogControllerImpl::GetValueFromSection(
     DialogSection section,
     ServerFieldType type) {
   DCHECK(SectionIsActive(section));
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   if (wrapper)
     return wrapper->GetInfo(AutofillType(type));
 
   DetailOutputMap output;
   view_->GetUserInput(section, &output);
   for (DetailOutputMap::iterator iter = output.begin(); iter != output.end();
        ++iter) {
     if (iter->first->type == type)
       return iter->second;
   }
 
   return string16();
 }
 
 void AutofillDialogControllerImpl::SaveProfileGleanedFromSection(
     const AutofillProfile& profile,
     DialogSection section) {
-  if (section == SECTION_EMAIL) {
-    // Save the email address to the existing (suggested) billing profile. If
-    // there is no existing profile, the newly created one will pick up this
-    // email, so in that case do nothing.
-    scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(SECTION_BILLING);
-    if (wrapper) {
-      std::string item_key = SuggestionsMenuModelForSection(SECTION_BILLING)->
-          GetItemKeyForCheckedItem();
-      AutofillProfile* billing_profile =
-          GetManager()->GetProfileByGUID(item_key);
-      billing_profile->OverwriteWithOrAddTo(
-          profile,
-          g_browser_process->GetApplicationLocale());
-    }
-  } else {
-    GetManager()->SaveImportedProfile(profile);
-  }
+  GetManager()->SaveImportedProfile(profile);
 }
 
 SuggestionsMenuModel* AutofillDialogControllerImpl::
     SuggestionsMenuModelForSection(DialogSection section) {
   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;
 
   if (&model == &suggested_cc_billing_)
     return SECTION_CC_BILLING;
 
   DCHECK_EQ(&model, &suggested_shipping_);
@@ skipping 301 matching lines @@
       // TODO(estade): implement overlays on other platforms.
       OverlayButtonPressed();
 #endif
       return;
     } else {
       profile_->GetPrefs()->SetBoolean(
         ::prefs::kAutofillDialogHasPaidWithWallet, true);
     }
   }
 
-  FillOutputForSection(SECTION_EMAIL);
   FillOutputForSection(SECTION_CC);
   FillOutputForSection(SECTION_BILLING);
   FillOutputForSection(SECTION_CC_BILLING);
 
   if (ShouldUseBillingForShipping()) {
     FillOutputForSectionWithComparator(
         SECTION_BILLING,
         base::Bind(DetailInputMatchesShippingField));
     FillOutputForSectionWithComparator(
         SECTION_CC,
@@ skipping 224 matching lines @@
       billing_profile.reset(new AutofillProfile);
       FillFormGroupFromOutputs(outputs, billing_profile.get());
     } else {
       // Just snag the currently suggested profile.
       std::string item_key = SuggestionsMenuModelForSection(SECTION_BILLING)->
           GetItemKeyForCheckedItem();
       AutofillProfile* profile = GetManager()->GetProfileByGUID(item_key);
       billing_profile.reset(new AutofillProfile(*profile));
     }
 
-    // The bubble also needs the associated email address.
-    billing_profile->SetRawInfo(
-        EMAIL_ADDRESS,
-        GetValueFromSection(SECTION_EMAIL, EMAIL_ADDRESS));
-
     ShowNewCreditCardBubble(newly_saved_card_.Pass(),
                             billing_profile.Pass());
     return;
   }
 
   if (!full_wallet_ || !full_wallet_->billing_address())
     return;
 
   base::string16 backing_last_four;
   if (ActiveInstrument()) {
     backing_last_four = ActiveInstrument()->TypeAndLastFourDigits();
   } else {
     DetailOutputMap output;
     view_->GetUserInput(SECTION_CC_BILLING, &output);
     CreditCard card;
     GetBillingInfoFromOutputs(output, &card, NULL, NULL);
     backing_last_four = card.TypeAndLastFourDigits();
   }
 #if !defined(OS_ANDROID)
   GeneratedCreditCardBubbleController::Show(
       web_contents(),
       full_wallet_->TypeAndLastFourDigits(),
       backing_last_four);
 #endif
 }
 
 }  // namespace autofill