Implementing VERIFY_CVV required action.

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 153 matching lines @@
                                CreditCard* card,
                                string16* cvc,
                                AutofillProfile* profile) {
   for (DetailOutputMap::const_iterator it = output.begin();
        it != output.end(); ++it) {
     string16 trimmed;
     TrimWhitespace(it->second, TRIM_ALL, &trimmed);
 
     // Special case CVC as CreditCard just swallows it.
     if (it->first->type == CREDIT_CARD_VERIFICATION_CODE) {
-      cvc->assign(trimmed);
+      if (cvc)
+        cvc->assign(trimmed);
     } else {
       // Copy the credit card name to |profile| in addition to |card| as
       // wallet::Instrument requires a recipient name for its billing address.
-      if (it->first->type == CREDIT_CARD_NAME)
+      if (profile && it->first->type == CREDIT_CARD_NAME)
         profile->SetRawInfo(NAME_FULL, trimmed);
 
-      if (IsCreditCardType(it->first->type))
-        card->SetRawInfo(it->first->type, trimmed);
-      else
+      if (IsCreditCardType(it->first->type)) {
+        if (card)
+          card->SetRawInfo(it->first->type, trimmed);
+      } else if (profile) {
         profile->SetRawInfo(it->first->type, trimmed);
+      }
     }
   }
 }
 
 // Returns the containing window for the given |web_contents|.  The containing
 // window might be a browser window for a Chrome tab, or it might be a shell
 // window for a platform app.
 BaseWindow* GetBaseWindowForWebContents(
     const content::WebContents* web_contents) {
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
@@ skipping 46 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_email_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_cc_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_billing_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_cc_billing_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_shipping_(this)),
       section_showing_popup_(SECTION_BILLING),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       metric_logger_(metric_logger),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       dialog_type_(dialog_type),
-      did_submit_(false),
+      is_submitting_(false),
       autocheckout_is_running_(false),
       had_autocheckout_error_(false) {
   // TODO(estade): remove duplicates from |form|?
 }
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
   metric_logger_.LogDialogInitialUserState(dialog_type_, initial_user_state_);
@@ skipping 158 matching lines @@
 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(IDS_AUTOFILL_DIALOG_SUBMIT_BUTTON);
+  return l10n_util::GetStringUTF16(IsSubmitPausedOn(wallet::VERIFY_CVV) ?
+      IDS_AUTOFILL_DIALOG_VERIFY_BUTTON : IDS_AUTOFILL_DIALOG_SUBMIT_BUTTON);
 }
 
 string16 AutofillDialogControllerImpl::CancelSignInText() const {
   // TODO(abodenha): real strings and l10n.
   return ASCIIToUTF16("Don't sign in.");
 }
 
 string16 AutofillDialogControllerImpl::SaveLocallyText() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SAVE_LOCALLY_CHECKBOX);
 }
@@ skipping 45 matching lines @@
   return autocheckout_is_running_;
 }
 
 bool AutofillDialogControllerImpl::HadAutocheckoutError() const {
   return had_autocheckout_error_;
 }
 
 bool AutofillDialogControllerImpl::IsDialogButtonEnabled(
     ui::DialogButton button) const {
   if (button == ui::DIALOG_BUTTON_OK)
-    return !did_submit_;
+    return !is_submitting_ || IsSubmitPausedOn(wallet::VERIFY_CVV);
+
   DCHECK_EQ(ui::DIALOG_BUTTON_CANCEL, button);
   // TODO(ahutter): Make it possible for the user to cancel out of the dialog
   // while Autocheckout is in progress.
-  return had_autocheckout_error_ || !did_submit_;
+  return had_autocheckout_error_ ||
+         dialog_type_ == DIALOG_TYPE_REQUEST_AUTOCOMPLETE;

[Ilya Sherman, 2013/03/28 05:28:57]

Hrm, I think you've just globally disabled the cancel button for Autocheckout
unless there was an error.

[Dan Beam, 2013/03/29 00:43:10]

Added back !is_submitting_

 }
 
 bool AutofillDialogControllerImpl::SectionIsActive(DialogSection section)
     const {
+  if (IsSubmitPausedOn(wallet::VERIFY_CVV))
+    return section == SECTION_CC_BILLING;
+
   if (IsPayingWithWallet())
     return section != SECTION_BILLING && section != SECTION_CC;
 
   return section != SECTION_CC_BILLING;
 }
 
 bool AutofillDialogControllerImpl::HasCompleteWallet() const {
   return wallet_items_.get() != NULL &&
          !wallet_items_->instruments().empty() &&
          !wallet_items_->addresses().empty();
 }
 
+bool AutofillDialogControllerImpl::IsSubmitPausedOn(
+    wallet::RequiredAction required_action) const {
+  return full_wallet_ && full_wallet_->HasRequiredAction(required_action);
+}
+
 void AutofillDialogControllerImpl::StartFetchingWalletItems() {
   DCHECK(IsPayingWithWallet());
   // TODO(dbeam): Add Risk capabilites once the UI supports risk challenges.
   GetWalletClient()->GetWalletItems(
       source_url_,
       std::vector<wallet::WalletClient::RiskCapability>());
 }
 
 void AutofillDialogControllerImpl::OnWalletOrSigninUpdate() {
   if (wallet_items_.get()) {
@@ skipping 114 matching lines @@
     case SECTION_SHIPPING:
       return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECTION_SHIPPING);
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 string16 AutofillDialogControllerImpl::SuggestionTextForSection(
     DialogSection section) {
+  string16 action_text = RequiredActionSuggestionTextForSection(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())
     return string16();
 
   if (section == SECTION_EMAIL)
     return model->GetLabelAt(model->checked_item());
 
   scoped_ptr<DataModelWrapper> wrapper = CreateWrapper(section);
   return wrapper->GetDisplayText();
 }
 
+string16 AutofillDialogControllerImpl::RequiredActionSuggestionTextForSection(
+    DialogSection section) {
+  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);
+    CreditCard card;
+    GetBillingInfoFromOutputs(output, &card, NULL, NULL);
+    return card.TypeAndLastFourDigits();
+  }
+
+  return string16();
+}
+
 scoped_ptr<DataModelWrapper> AutofillDialogControllerImpl::CreateWrapper(
     DialogSection section) {
-  if (IsPayingWithWallet() && full_wallet_) {
+  if (IsPayingWithWallet() && full_wallet_ &&
+      !IsSubmitPausedOn(wallet::VERIFY_CVV)) {
     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()));
     }
   }
 
@@ skipping 293 matching lines @@
 std::vector<DialogNotification>
     AutofillDialogControllerImpl::CurrentNotifications() const {
   std::vector<DialogNotification> notifications;
 
   if (IsPayingWithWallet()) {
     // TODO(dbeam): what about REQUIRES_PASSIVE_SIGN_IN?
     if (SignedInState() == SIGNED_IN) {
       // On first run with a complete wallet profile, show a notification
       // explaining where this data came from.
       if (IsFirstRun() && HasCompleteWallet()) {
-        notifications.push_back(
-            DialogNotification(
-                DialogNotification::EXPLANATORY_MESSAGE,
-                l10n_util::GetStringUTF16(
-                    IDS_AUTOFILL_DIALOG_DETAILS_FROM_WALLET)));
+        notifications.push_back(DialogNotification(
+            DialogNotification::EXPLANATORY_MESSAGE,
+            l10n_util::GetStringUTF16(
+                IDS_AUTOFILL_DIALOG_DETAILS_FROM_WALLET)));
       } else {
-        notifications.push_back(
-            DialogNotification(
-                DialogNotification::WALLET_PROMO,
-                l10n_util::GetStringUTF16(
-                    IDS_AUTOFILL_DIALOG_SAVE_DETAILS_IN_WALLET)));
+        notifications.push_back(DialogNotification(
+            DialogNotification::WALLET_PROMO,
+            l10n_util::GetStringUTF16(
+                IDS_AUTOFILL_DIALOG_SAVE_DETAILS_IN_WALLET)));
       }
     } else if (IsFirstRun()) {
       // If the user is not signed in, show an upsell notification on first run.
-      notifications.push_back(
-          DialogNotification(
-              DialogNotification::WALLET_PROMO,
-              l10n_util::GetStringUTF16(
-                  IDS_AUTOFILL_DIALOG_SIGN_IN_AND_SAVE_DETAILS)));
+      notifications.push_back(DialogNotification(
+          DialogNotification::WALLET_PROMO,
+          l10n_util::GetStringUTF16(
+              IDS_AUTOFILL_DIALOG_SIGN_IN_AND_SAVE_DETAILS)));
     }
   }
 
   if (RequestingCreditCardInfo() && !TransmissionWillBeSecure()) {
-    notifications.push_back(
-        DialogNotification(
-            DialogNotification::SECURITY_WARNING,
-            l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECURITY_WARNING)));
+    notifications.push_back(DialogNotification(
+        DialogNotification::SECURITY_WARNING,
+        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECURITY_WARNING)));
   }
 
   if (!invoked_from_same_origin_) {
-    notifications.push_back(
-        DialogNotification(
-            DialogNotification::SECURITY_WARNING,
-            l10n_util::GetStringFUTF16(
-                IDS_AUTOFILL_DIALOG_SITE_WARNING,
-                UTF8ToUTF16(source_url_.host()))));
+    notifications.push_back(DialogNotification(
+        DialogNotification::SECURITY_WARNING,
+        l10n_util::GetStringFUTF16(IDS_AUTOFILL_DIALOG_SITE_WARNING,
+                                   UTF8ToUTF16(source_url_.host()))));
+  }
+
+  if (IsSubmitPausedOn(wallet::VERIFY_CVV)) {
+    notifications.push_back(DialogNotification(
+            DialogNotification::REQUIRED_ACTION,
+            l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_VERIFY_CVV)));
   }
 
   if (had_autocheckout_error_) {
-    notifications.push_back(
-        DialogNotification(
-            DialogNotification::AUTOCHECKOUT_ERROR,
-            l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_AUTOCHECKOUT_ERROR)));
+    notifications.push_back(DialogNotification(
+        DialogNotification::AUTOCHECKOUT_ERROR,
+        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_AUTOCHECKOUT_ERROR)));
   }
 
   if (account_chooser_model_.had_wallet_error()) {
     // TODO(dbeam): pass along the Wallet error or remove from the translation.
     // TODO(dbeam): figure out a way to dismiss this error after a while.
     notifications.push_back(DialogNotification(
         DialogNotification::WALLET_ERROR,
         l10n_util::GetStringFUTF16(
             IDS_AUTOFILL_DIALOG_COMPLETE_WITHOUT_WALLET,
             ASCIIToUTF16("Oops, [Wallet-Error]."))));
   }
 
   return notifications;
 }
 
 void AutofillDialogControllerImpl::StartSignInFlow() {
   DCHECK(registrar_.IsEmpty());
 
   content::Source<content::NavigationController> source(view_->ShowSignIn());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED, source);
 }
 
 void AutofillDialogControllerImpl::EndSignInFlow() {
   DCHECK(!registrar_.IsEmpty());
   registrar_.RemoveAll();
   view_->HideSignIn();
 }
 
 void AutofillDialogControllerImpl::OnCancel() {
-  if (!did_submit_) {
+  if (!is_submitting_) {

[Ilya Sherman, 2013/03/28 05:28:57]

I don't think this is desirable.  The goal is to *not* log this metric if
canceling out of the Autocheckout progress dialog view; but IMO it *should* be
logged if the user cancels during a CVC challenge.

[Dan Beam, 2013/03/29 00:43:10]

Changed to use callback_.is_null()

     metric_logger_.LogDialogUiDuration(
         base::Time::Now() - dialog_shown_timestamp_,
         dialog_type_,
         AutofillMetrics::DIALOG_CANCELED);
   }
 
   // If Autocheckout has an error, it's possible that the dialog will be
   // submitted to start the flow and then cancelled to close the dialog after
   // the error.
   if (!callback_.is_null()) {
     callback_.Run(NULL);
     callback_ = base::Callback<void(const FormStructure*)>();
   }
 }
 
-void AutofillDialogControllerImpl::OnSubmit() {
-  did_submit_ = true;
-  metric_logger_.LogDialogUiDuration(
-      base::Time::Now() - dialog_shown_timestamp_,
-      dialog_type_,
-      AutofillMetrics::DIALOG_ACCEPTED);
+void AutofillDialogControllerImpl::OnAccept() {
+  // Update the button strip after Autocheckout may have started.
+  is_submitting_ = true;
+  view_->UpdateButtonStrip();
 
-  if (dialog_type_ == DIALOG_TYPE_AUTOCHECKOUT) {
-    // Stop observing PersonalDataManager to avoid the dialog redrawing while
-    // in an Autocheckout flow.
-    GetManager()->RemoveObserver(this);
-    autocheckout_is_running_ = true;
-    autocheckout_started_timestamp_ = base::Time::Now();
-    view_->UpdateButtonStrip();
+  if (IsSubmitPausedOn(wallet::VERIFY_CVV)) {
+    DCHECK(!active_instrument_id_.empty());
+    GetWalletClient()->AuthenticateInstrument(
+        active_instrument_id_,
+        UTF16ToUTF8(view_->GetCvc()),
+        wallet_items_->obfuscated_gaia_id());
+  } else if (IsPayingWithWallet()) {
+    SubmitWithWallet();
+  } else {
+    FinishSubmit();
   }
-
-  if (IsPayingWithWallet())
-    SubmitWithWallet();
-  else
-    FinishSubmit();
 }
 
 Profile* AutofillDialogControllerImpl::profile() {
   return profile_;
 }
 
 content::WebContents* AutofillDialogControllerImpl::web_contents() {
   return contents_;
 }
 
@@ skipping 95 matching lines @@
 void AutofillDialogControllerImpl::OnDidAuthenticateInstrument(bool success) {
   // TODO(dbeam): use the returned full wallet. b/8332329
   if (success)
     GetFullWallet();
   else
     DisableWallet();
 }
 
 void AutofillDialogControllerImpl::OnDidGetFullWallet(
     scoped_ptr<wallet::FullWallet> full_wallet) {
-  // TODO(dbeam): handle more required actions.
   full_wallet_ = full_wallet.Pass();
 
-  if (full_wallet_->HasRequiredAction(wallet::VERIFY_CVV))
-    DisableWallet();
-  else
+  if (full_wallet_->required_actions().empty()) {
     FinishSubmit();
+    return;
+  }
+
+  GenerateSuggestionsModels();
+  view_->ModelChanged();
+  view_->UpdateNotificationArea();
+  view_->UpdateButtonStrip();
 }
 
 void AutofillDialogControllerImpl::OnPassiveSigninSuccess(
     const std::string& username) {
   DCHECK(IsPayingWithWallet());
   current_username_ = username;
   signin_helper_.reset();
   wallet_items_.reset();
   StartFetchingWalletItems();
 }
@@ skipping 165 matching lines @@
 
 bool AutofillDialogControllerImpl::IsPayingWithWallet() const {
   return account_chooser_model_.WalletIsSelected();
 }
 
 void AutofillDialogControllerImpl::DisableWallet() {
   signin_helper_.reset();
   current_username_.clear();
   account_chooser_model_.SetHadWalletError();
   GetWalletClient()->CancelPendingRequests();
+  full_wallet_.reset();
 }
 
 void AutofillDialogControllerImpl::OnWalletSigninError() {
   signin_helper_.reset();
   current_username_.clear();
   account_chooser_model_.SetHadWalletSigninError();
   GetWalletClient()->CancelPendingRequests();
 }
 
 bool AutofillDialogControllerImpl::IsFirstRun() const {
   PrefService* prefs = profile_->GetPrefs();
   return !prefs->HasPrefPath(prefs::kAutofillDialogPayWithoutWallet);
 }
 
 void AutofillDialogControllerImpl::GenerateSuggestionsModels() {
   suggested_email_.Reset();
   suggested_cc_.Reset();
   suggested_billing_.Reset();
   suggested_cc_billing_.Reset();
   suggested_shipping_.Reset();
 
   if (IsPayingWithWallet()) {
-    if (wallet_items_.get()) {
+    if (wallet_items_) {
       // TODO(estade): seems we need to hardcode 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());
       }
 
-      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());
+      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());
+        }
       }
     }
 
-    suggested_cc_billing_.AddKeyedItem(
-        std::string(),
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_BILLING_DETAILS));
+    if (!IsSubmitPausedOn(wallet::VERIFY_CVV)) {
+      suggested_cc_billing_.AddKeyedItem(
+          std::string(),
+          l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_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 313 matching lines @@
                                       wallet_items_->obfuscated_gaia_id(),
                                       source_url_);
   } else if (new_address.get()) {
     GetWalletClient()->SaveAddress(*new_address, source_url_);
   } else {
     GetFullWallet();
   }
 }
 
 void AutofillDialogControllerImpl::GetFullWallet() {
-  DCHECK(did_submit_);
+  DCHECK(is_submitting_);
   DCHECK(IsPayingWithWallet());
   DCHECK(wallet_items_);
   DCHECK(!active_instrument_id_.empty());
   DCHECK(!active_address_id_.empty());
 
   GetWalletClient()->GetFullWallet(wallet::WalletClient::FullWalletRequest(
       active_instrument_id_,
       active_address_id_,
       source_url_,
       wallet::Cart(base::IntToString(kCartMax), kCartCurrency),
       wallet_items_->google_transaction_id(),
       std::vector<wallet::WalletClient::RiskCapability>()));
 }
 
 void AutofillDialogControllerImpl::FinishSubmit() {
   FillOutputForSection(SECTION_EMAIL);
   FillOutputForSection(SECTION_CC);
   FillOutputForSection(SECTION_BILLING);
   FillOutputForSection(SECTION_CC_BILLING);
+
   if (ShouldUseBillingForShipping()) {
     FillOutputForSectionWithComparator(
         SECTION_BILLING,
         base::Bind(DetailInputMatchesShippingField));
     FillOutputForSectionWithComparator(
         SECTION_CC,
         base::Bind(DetailInputMatchesShippingField));
   } else {
     FillOutputForSection(SECTION_SHIPPING);
   }
+
   callback_.Run(&form_structure_);
   callback_ = base::Callback<void(const FormStructure*)>();
 
-  if (dialog_type_ == DIALOG_TYPE_REQUEST_AUTOCOMPLETE) {
-    // This may delete us.
-    Hide();
+  metric_logger_.LogDialogUiDuration(
+      base::Time::Now() - dialog_shown_timestamp_,
+      dialog_type_,
+      AutofillMetrics::DIALOG_ACCEPTED);
+
+  switch (dialog_type_) {
+    case DIALOG_TYPE_AUTOCHECKOUT:
+      // Stop observing PersonalDataManager to avoid the dialog redrawing while
+      // in an Autocheckout flow.
+      GetManager()->RemoveObserver(this);
+      autocheckout_is_running_ = true;
+      autocheckout_started_timestamp_ = base::Time::Now();
+      view_->UpdateButtonStrip();
+      break;
+
+    case DIALOG_TYPE_REQUEST_AUTOCOMPLETE:
+      // This may delete us.
+      Hide();
+      break;
   }
 }
 
 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.
   const bool has_autofill_profiles =
       suggested_cc_.GetItemCount() > 1 ||
@@ skipping 14 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