[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 243 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 17 matching lines @@
 
 // Returns whether |data_model| is complete, i.e. can fill out all the
 // |requested_fields|, and verified, i.e. not just automatically aggregated.
 // Incomplete or unverifed data will not be displayed in the dropdown menu.
 bool HasCompleteAndVerifiedData(const AutofillDataModel& data_model,
                                 const DetailInputs& requested_fields) {
   if (!data_model.IsVerified())
     return false;
 
   for (size_t i = 0; i < requested_fields.size(); ++i) {
-    ServerFieldType type = requested_fields[i].type;
+    ServerFieldType type =
+        AutofillType(requested_fields[i].type).GetStorableType();
     if (type != ADDRESS_HOME_LINE2 &&
         type != CREDIT_CARD_VERIFICATION_CODE &&
-        data_model.GetRawInfo(AutofillType(type).GetStorableType()).empty()) {
+        data_model.GetRawInfo(type).empty()) {
       return false;
     }
   }
 
   return true;
 }
 
 // Returns true if |profile| has an invalid address, i.e. an invalid state, zip
-// code, or phone number. Otherwise returns false. Profiles with invalid
-// addresses are not suggested in the dropdown menu for billing and shipping
-// addresses.
+// code, phone number, or email address. Otherwise returns false. Profiles with
+// invalid addresses are not suggested in the dropdown menu for billing and
+// shipping addresses.
 bool HasInvalidAddress(const AutofillProfile& profile) {
   return profile.IsPresentButInvalid(ADDRESS_HOME_STATE) ||
          profile.IsPresentButInvalid(ADDRESS_HOME_ZIP) ||
          profile.IsPresentButInvalid(PHONE_HOME_WHOLE_NUMBER);
 }
 
 // Loops through |addresses_| comparing to |address| ignoring ID. If a match
 // is not found, NULL is returned.
 const wallet::Address* FindDuplicateAddress(
     const std::vector<wallet::Address*>& addresses,
@@ skipping 265 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 505 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));
+  }
+  DCHECK_EQ(SECTION_BILLING, section);
   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 822 matching lines @@
                               const std::string&)>& callback)
     : WebContentsObserver(contents),
       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),
       account_chooser_model_(this, profile_->GetPrefs(), metric_logger_),
       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_.AddKeyedItemWithMinorText(
           key,
           addresses[i]->DisplayName(),
           addresses[i]->DisplayNameDetail());
 
       const std::string default_shipping_address_id =
@@ skipping 72 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();
     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_) ||
+      const AutofillProfile& profile = *profiles[i];
+      if (!HasCompleteAndVerifiedData(profile, requested_shipping_fields_) ||
           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: name is part of credit card and we'll
+      // just ignore email and phone number variants.
+      suggested_shipping_.AddKeyedItem(profile.guid(), profile.Label());
+      if (!profile.GetRawInfo(EMAIL_ADDRESS).empty() &&
+          !profile.IsPresentButInvalid(EMAIL_ADDRESS)) {
+        suggested_billing_.AddKeyedItem(profile.guid(), profile.Label());
       }
-
-      // 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,
         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_.AddKeyedItemWithMinorText(
         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 307 matching lines @@
 
   DoFinishSubmit();
 }
 
 void AutofillDialogControllerImpl::DoFinishSubmit() {
   if (IsPayingWithWallet()) {
     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 221 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