Extract AutofillDialogController interface and common utilities.

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>
 
 #include "apps/native_app_window.h"
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/autofill/autofill_credit_card_bubble_controller.h"
+#include "chrome/browser/ui/autofill/autofill_dialog_common.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_view.h"
 #include "chrome/browser/ui/autofill/data_model_wrapper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
@@ skipping 64 matching lines @@
 // Limit Wallet items refresh rate to at most once per minute.
 const int kWalletItemsRefreshRateSeconds = 60;
 
 // Returns true if |card_type| is supported by Wallet.
 bool IsWalletSupportedCard(const std::string& card_type) {
   return card_type == autofill::kVisaCard ||
          card_type == autofill::kMasterCard ||
          card_type == autofill::kDiscoverCard;
 }
 
-// Returns true if |input| should be shown when |field_type| has been requested.
-bool InputTypeMatchesFieldType(const DetailInput& input,
-                               const AutofillType& field_type) {
-  // If any credit card expiration info is asked for, show both month and year
-  // inputs.
-  ServerFieldType server_type = field_type.GetStorableType();
-  if (server_type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
-      server_type == CREDIT_CARD_EXP_2_DIGIT_YEAR ||
-      server_type == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR ||
-      server_type == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR ||
-      server_type == CREDIT_CARD_EXP_MONTH) {
-    return input.type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
-           input.type == CREDIT_CARD_EXP_MONTH;
-  }
-
-  if (server_type == CREDIT_CARD_TYPE)
-    return input.type == CREDIT_CARD_NUMBER;
-
-  // Check the groups to distinguish billing types from shipping ones.
-  AutofillType input_type = AutofillType(input.type);
-  return input_type.GetStorableType() == server_type &&
-         input_type.group() == field_type.group();
-}
-
-// Returns true if |input| in the given |section| should be used for a
-// site-requested |field|.
-bool DetailInputMatchesField(DialogSection section,
-                             const DetailInput& input,
-                             const AutofillField& field) {
-  AutofillType field_type = field.Type();
-
-  // The credit card name is filled from the billing section's data.
-  if (field_type.GetStorableType() == CREDIT_CARD_NAME &&
-      (section == SECTION_BILLING || section == SECTION_CC_BILLING)) {
-    return input.type == NAME_BILLING_FULL;
-  }
-
-  return InputTypeMatchesFieldType(input, field_type);
-}
-
-bool IsCreditCardType(ServerFieldType type) {
-  return AutofillType(type).group() == CREDIT_CARD;
-}
-
 // Returns true if |input| should be used to fill a site-requested |field| which
 // is notated with a "shipping" tag, for use when the user has decided to use
 // the billing address as the shipping address.
 bool DetailInputMatchesShippingField(const DetailInput& input,
                                      const AutofillField& field) {
   // Equivalent billing field type is used to support UseBillingAsShipping
   // usecase.
   ServerFieldType field_type =
       AutofillType::GetEquivalentBillingFieldType(
           field.Type().GetStorableType());
 
-  return InputTypeMatchesFieldType(input, AutofillType(field_type));
-}
-
-// Constructs |inputs| from template data.
-void BuildInputs(const DetailInput* input_template,
-                 size_t template_size,
-                 DetailInputs* inputs) {
-  for (size_t i = 0; i < template_size; ++i) {
-    const DetailInput* input = &input_template[i];
-    inputs->push_back(*input);
-  }
+  return common::InputTypeMatchesFieldType(input, AutofillType(field_type));
 }
 
 // Initializes |form_group| from user-entered data.
 void FillFormGroupFromOutputs(const DetailOutputMap& detail_outputs,
                               FormGroup* form_group) {
   for (DetailOutputMap::const_iterator iter = detail_outputs.begin();
        iter != detail_outputs.end(); ++iter) {
     ServerFieldType type = iter->first->type;
     if (!iter->second.empty()) {
       if (type == ADDRESS_HOME_COUNTRY || type == ADDRESS_BILLING_COUNTRY) {
@@ skipping 29 matching lines @@
         profile->SetInfo(AutofillType(it->first->type),
                          trimmed,
                          g_browser_process->GetApplicationLocale());
       }
     } else {
       // Copy the credit card name to |profile| in addition to |card| as
       // wallet::Instrument requires a recipient name for its billing address.
       if (card && it->first->type == NAME_FULL)
         card->SetRawInfo(CREDIT_CARD_NAME, trimmed);
 
-      if (IsCreditCardType(it->first->type)) {
+      if (common::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
@@ skipping 198 matching lines @@
   return base::string16();
 }
 
 gfx::Image GetGeneratedCardImage(const string16& card_number) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   const gfx::ImageSkia* card =
       rb.GetImageSkiaNamed(IDR_AUTOFILL_GENERATED_CARD);
   gfx::Canvas canvas(card->size(), ui::SCALE_FACTOR_100P, false);
   canvas.DrawImageInt(*card, 0, 0);
 
-#if !defined(OS_ANDROID)
   gfx::Rect display_rect(gfx::Point(), card->size());
   display_rect.Inset(14, 0, 14, 0);
   // TODO(estade): fallback font for systems that don't have Helvetica?
   gfx::Font helvetica("Helvetica", 14);
   gfx::ShadowValues shadows;
   shadows.push_back(gfx::ShadowValue(gfx::Point(0, 1),
                     0.0,
                     SkColorSetARGB(85, 0, 0, 0)));
   canvas.DrawStringWithShadows(
       card_number,
       helvetica,
       SK_ColorWHITE,
       display_rect, 0, 0, shadows);
-#endif
 
   gfx::ImageSkia skia(canvas.ExtractImageRep());
   return gfx::Image(skia);
 }
 
 }  // namespace
 
 AutofillDialogViewDelegate::~AutofillDialogViewDelegate() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
   GetMetricLogger().LogDialogInitialUserState(
       GetDialogType(), initial_user_state_);
 
   if (deemphasized_render_view_ && web_contents()) {
     web_contents()->GetRenderViewHost()->Send(
         new ChromeViewMsg_SetVisuallyDeemphasized(
             web_contents()->GetRenderViewHost()->GetRoutingID(), false));
   }
 }
 
-#if !defined(OS_ANDROID)
 // static
 base::WeakPtr<AutofillDialogControllerImpl>
     AutofillDialogControllerImpl::Create(
     content::WebContents* contents,
     const FormData& form_structure,
     const GURL& source_url,
     const DialogType dialog_type,
     const base::Callback<void(const FormStructure*,
                               const std::string&)>& callback) {
   // AutofillDialogControllerImpl owns itself.
   AutofillDialogControllerImpl* autofill_dialog_controller =
       new AutofillDialogControllerImpl(contents,
                                        form_structure,
                                        source_url,
                                        dialog_type,
                                        callback);
   return autofill_dialog_controller->weak_ptr_factory_.GetWeakPtr();
 }
-#endif  // !defined(OS_ANDROID)
 
 // static
 void AutofillDialogControllerImpl::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       ::prefs::kAutofillDialogShowCount,
       0,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterBooleanPref(
       ::prefs::kAutofillDialogHasPaidWithWallet,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterBooleanPref(
       ::prefs::kAutofillDialogPayWithoutWallet,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       ::prefs::kAutofillDialogAutofillDefault,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
+// static
+base::WeakPtr<AutofillDialogController> AutofillDialogController::Create(
+    content::WebContents* contents,
+    const FormData& form_structure,
+    const GURL& source_url,
+    const DialogType dialog_type,
+    const base::Callback<void(const FormStructure*,
+                              const std::string&)>& callback) {
+  return AutofillDialogControllerImpl::Create(contents,
+                                              form_structure,
+                                              source_url,
+                                              dialog_type,
+                                              callback);
+}
+
+// static
+void AutofillDialogController::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  AutofillDialogControllerImpl::RegisterProfilePrefs(registry);
+}
+
 void AutofillDialogControllerImpl::Show() {
   dialog_shown_timestamp_ = base::Time::Now();
 
   content::NavigationEntry* entry =
       web_contents()->GetController().GetActiveEntry();
   const GURL& active_url = entry ? entry->GetURL() : web_contents()->GetURL();
   invoked_from_same_origin_ = active_url.GetOrigin() == source_url_.GetOrigin();
 
   // Log any relevant UI metrics and security exceptions.
   GetMetricLogger().LogDialogUiEvent(
@@ skipping 20 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;
   }
 
-  const DetailInput kEmailInputs[] = {
-    { 1, EMAIL_ADDRESS, IDS_AUTOFILL_DIALOG_PLACEHOLDER_EMAIL },
-  };
-
-  const DetailInput kCCInputs[] = {
-    { 2, CREDIT_CARD_NUMBER, IDS_AUTOFILL_DIALOG_PLACEHOLDER_CARD_NUMBER },
-    { 3, CREDIT_CARD_EXP_MONTH, IDS_AUTOFILL_DIALOG_PLACEHOLDER_EXPIRY_MONTH },
-    { 3, CREDIT_CARD_EXP_4_DIGIT_YEAR,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_EXPIRY_YEAR },
-    { 3, CREDIT_CARD_VERIFICATION_CODE, IDS_AUTOFILL_DIALOG_PLACEHOLDER_CVC,
-      1.5 },
-  };
-
-  const DetailInput kBillingInputs[] = {
-    { 4, NAME_BILLING_FULL, IDS_AUTOFILL_DIALOG_PLACEHOLDER_CARDHOLDER_NAME },
-    { 5, ADDRESS_BILLING_LINE1,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_ADDRESS_LINE_1 },
-    { 6, ADDRESS_BILLING_LINE2,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_ADDRESS_LINE_2 },
-    { 7, ADDRESS_BILLING_CITY,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_LOCALITY },
-    // TODO(estade): state placeholder should depend on locale.
-    { 8, ADDRESS_BILLING_STATE, IDS_AUTOFILL_FIELD_LABEL_STATE },
-    { 8, ADDRESS_BILLING_ZIP,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_POSTAL_CODE },
-    // We don't allow the user to change the country: http://crbug.com/247518
-    { -1, ADDRESS_BILLING_COUNTRY, 0 },
-    { 10, PHONE_BILLING_WHOLE_NUMBER,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_PHONE_NUMBER },
-  };
-
-  const DetailInput kShippingInputs[] = {
-    { 11, NAME_FULL, IDS_AUTOFILL_DIALOG_PLACEHOLDER_ADDRESSEE_NAME },
-    { 12, ADDRESS_HOME_LINE1, IDS_AUTOFILL_DIALOG_PLACEHOLDER_ADDRESS_LINE_1 },
-    { 13, ADDRESS_HOME_LINE2, IDS_AUTOFILL_DIALOG_PLACEHOLDER_ADDRESS_LINE_2 },
-    { 14, ADDRESS_HOME_CITY, IDS_AUTOFILL_DIALOG_PLACEHOLDER_LOCALITY },
-    { 15, ADDRESS_HOME_STATE, IDS_AUTOFILL_FIELD_LABEL_STATE },
-    { 15, ADDRESS_HOME_ZIP, IDS_AUTOFILL_DIALOG_PLACEHOLDER_POSTAL_CODE },
-    { -1, ADDRESS_HOME_COUNTRY, 0 },
-    { 17, PHONE_HOME_WHOLE_NUMBER,
-      IDS_AUTOFILL_DIALOG_PLACEHOLDER_PHONE_NUMBER },
-  };
-
-  BuildInputs(kEmailInputs,
-              arraysize(kEmailInputs),
-              &requested_email_fields_);
-
-  BuildInputs(kCCInputs,
-              arraysize(kCCInputs),
-              &requested_cc_fields_);
-
-  BuildInputs(kBillingInputs,
-              arraysize(kBillingInputs),
-              &requested_billing_fields_);
-
-  BuildInputs(kCCInputs,
-              arraysize(kCCInputs),
-              &requested_cc_billing_fields_);
-  BuildInputs(kBillingInputs,
-              arraysize(kBillingInputs),
-              &requested_cc_billing_fields_);
-
-  BuildInputs(kShippingInputs,
-              arraysize(kShippingInputs),
-              &requested_shipping_fields_);
+  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
   // would be a no-op, don't show it.
   const DetailInputs& inputs = RequestedFieldsForSection(SECTION_SHIPPING);
   EmptyDataModelWrapper empty_wrapper;
   cares_about_shipping_ = empty_wrapper.FillFormStructure(
       inputs,
-      base::Bind(DetailInputMatchesField, SECTION_SHIPPING),
+      base::Bind(common::DetailInputMatchesField, SECTION_SHIPPING),
       &form_structure_);
 
   SuggestionsUpdated();
 
   int show_count =
       profile_->GetPrefs()->GetInteger(::prefs::kAutofillDialogShowCount);
   profile_->GetPrefs()->SetInteger(::prefs::kAutofillDialogShowCount,
                                    show_count + 1);
 
   // TODO(estade): don't show the dialog if the site didn't specify the right
@@ skipping 211 matching lines @@
       !IsSubmitPausedOn(wallet::VERIFY_CVV) &&
       GetDialogType() == DIALOG_TYPE_REQUEST_AUTOCOMPLETE;
   if (!show_wallet_interstitial)
     return DialogOverlayState();
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   DialogOverlayState state;
 
   state.strings.push_back(DialogOverlayString());
   DialogOverlayString& string = state.strings.back();
-#if !defined(OS_ANDROID)
-  // gfx::Font isn't implemented on Android; DeriveFont() causes a null deref.
   string.font = rb.GetFont(ui::ResourceBundle::BaseFont).DeriveFont(4);
-#endif
 
   // First-run, post-submit, Wallet expository page.
   if (full_wallet_ && full_wallet_->required_actions().empty()) {
     string16 cc_number =
         full_wallet_->GetInfo(AutofillType(CREDIT_CARD_NUMBER));
     DCHECK_EQ(16U, cc_number.size());
     state.image = GetGeneratedCardImage(
         ASCIIToUTF16("xxxx xxxx xxxx ") +
         cc_number.substr(cc_number.size() - 4));
     string.text = l10n_util::GetStringUTF16(
@@ skipping 630 matching lines @@
 
   DetailInputs* inputs = MutableRequestedFieldsForSection(section);
   for (DetailInputs::iterator it = inputs->begin(); it != inputs->end(); ++it) {
     it->editable = InputIsEditable(*it, section);
   }
   model->FillInputs(inputs);
 
   UpdateSection(section);
 
   GetMetricLogger().LogDialogUiEvent(
-      GetDialogType(), DialogSectionToUiEditEvent(section));
+      GetDialogType(), common::DialogSectionToUiEditEvent(section));
 }
 
 void AutofillDialogControllerImpl::EditCancelledForSection(
     DialogSection section) {
   ResetSectionInput(section);
   UpdateSection(section);
 }
 
 gfx::Image AutofillDialogControllerImpl::IconForField(
     ServerFieldType type, const string16& user_input) const {
@@ skipping 252 matching lines @@
   }
 
   // If the user clicks while the popup is already showing, be sure to hide
   // it.
   if (!was_edit && popup_controller_.get()) {
     HidePopup();
     return;
   }
 
   std::vector<string16> popup_values, popup_labels, popup_icons;
-  if (IsCreditCardType(input->type)) {
+  if (common::IsCreditCardType(input->type)) {
     GetManager()->GetCreditCardSuggestions(AutofillType(input->type),
                                            field_contents,
                                            &popup_values,
                                            &popup_labels,
                                            &popup_icons,
                                            &popup_guids_);
   } else {
     std::vector<ServerFieldType> field_types;
     field_types.push_back(EMAIL_ADDRESS);
     for (DetailInputs::const_iterator iter = requested_shipping_fields_.begin();
@@ skipping 281 matching lines @@
 
 void AutofillDialogControllerImpl::DidSelectSuggestion(int identifier) {
   // TODO(estade): implement.
 }
 
 void AutofillDialogControllerImpl::DidAcceptSuggestion(const string16& value,
                                                        int identifier) {
   const PersonalDataManager::GUIDPair& pair = popup_guids_[identifier];
 
   scoped_ptr<DataModelWrapper> wrapper;
-  if (IsCreditCardType(input_showing_popup_->type)) {
+  if (common::IsCreditCardType(input_showing_popup_->type)) {
     wrapper.reset(new AutofillCreditCardWrapper(
         GetManager()->GetCreditCardByGUID(pair.first)));
   } else {
     wrapper.reset(new AutofillProfileWrapper(
         GetManager()->GetProfileByGUID(pair.first), pair.second));
   }
 
   for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
     DialogSection section = static_cast<DialogSection>(i);
     wrapper->FillInputs(MutableRequestedFieldsForSection(section));
@@ skipping 254 matching lines @@
     return popup_controller_->HandleKeyPressEvent(event);
 
   return false;
 }
 
 bool AutofillDialogControllerImpl::RequestingCreditCardInfo() const {
   DCHECK_GT(form_structure_.field_count(), 0U);
 
   for (size_t i = 0; i < form_structure_.field_count(); ++i) {
     AutofillType type = form_structure_.field(i)->Type();
-    if (IsCreditCardType(type.GetStorableType()))
+    if (common::IsCreditCardType(type.GetStorableType()))
       return true;
   }
 
   return false;
 }
 
 bool AutofillDialogControllerImpl::TransmissionWillBeSecure() const {
   return source_url_.SchemeIs(chrome::kHttpsScheme);
 }
 
@@ skipping 57 matching lines @@
 
 void AutofillDialogControllerImpl::LoadRiskFingerprintData() {
   risk_data_.clear();
 
   uint64 obfuscated_gaia_id = 0;
   bool success = base::StringToUint64(wallet_items_->obfuscated_gaia_id(),
                                       &obfuscated_gaia_id);
   DCHECK(success);
 
   gfx::Rect window_bounds;
-#if !defined(OS_ANDROID)
   window_bounds = GetBaseWindowForWebContents(web_contents())->GetBounds();
-#endif
 
   PrefService* user_prefs = profile_->GetPrefs();
   std::string charset = user_prefs->GetString(::prefs::kDefaultCharset);
   std::string accept_languages =
       user_prefs->GetString(::prefs::kAcceptLanguages);
   base::Time install_time = base::Time::FromTimeT(
       g_browser_process->local_state()->GetInt64(::prefs::kInstallDate));
 
   risk::GetFingerprint(
       obfuscated_gaia_id, window_bounds, *web_contents(),
       chrome::VersionInfo().Version(), charset, accept_languages, install_time,
       dialog_type_, g_browser_process->GetApplicationLocale(),
       base::Bind(&AutofillDialogControllerImpl::OnDidLoadRiskFingerprintData,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void AutofillDialogControllerImpl::OnDidLoadRiskFingerprintData(
     scoped_ptr<risk::Fingerprint> fingerprint) {
   DCHECK(AreLegalDocumentsCurrent());
 
   std::string proto_data;
   fingerprint->SerializeToString(&proto_data);
   bool success = base::Base64Encode(proto_data, &risk_data_);
   DCHECK(success);
 
   SubmitWithWallet();
 }
 
 void AutofillDialogControllerImpl::OpenTabWithUrl(const GURL& url) {
-#if !defined(OS_ANDROID)
   chrome::NavigateParams params(
       chrome::FindBrowserWithWebContents(web_contents()),
       url,
       content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
-#endif
 }
 
 bool AutofillDialogControllerImpl::IsEditingExistingData(
     DialogSection section) const {
   return section_editing_state_.count(section) > 0;
 }
 
 bool AutofillDialogControllerImpl::IsManuallyEditingSection(
     DialogSection section) const {
   return IsEditingExistingData(section) ||
@@ skipping 306 matching lines @@
         SaveProfileGleanedFromSection(profile, section);
 
       AutofillProfileWrapper profile_wrapper(&profile, 0);
       profile_wrapper.FillFormStructure(inputs, compare, &form_structure_);
     }
   }
 }
 
 void AutofillDialogControllerImpl::FillOutputForSection(DialogSection section) {
   FillOutputForSectionWithComparator(
-      section, base::Bind(DetailInputMatchesField, section));
+      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;
@@ skipping 581 matching lines @@
       AutofillMetrics::DIALOG_CANCELED);
 }
 
 void AutofillDialogControllerImpl::LogSuggestionItemSelectedMetric(
     const SuggestionsMenuModel& model) {
   DialogSection section = SectionForSuggestionsMenuModel(model);
 
   AutofillMetrics::DialogUiEvent dialog_ui_event;
   if (model.GetItemKeyForCheckedItem() == kAddNewItemKey) {
     // Selected to add a new item.
-    dialog_ui_event = DialogSectionToUiItemAddedEvent(section);
+    dialog_ui_event = common::DialogSectionToUiItemAddedEvent(section);
   } else if (IsASuggestionItemKey(model.GetItemKeyForCheckedItem())) {
     // Selected an existing item.
-    dialog_ui_event = DialogSectionToUiSelectionChangedEvent(section);
+    dialog_ui_event = common::DialogSectionToUiSelectionChangedEvent(section);
   } else {
     // TODO(estade): add logging for "Manage items" or "Use billing for
     // shipping"?
     return;
   }
 
   GetMetricLogger().LogDialogUiEvent(GetDialogType(), dialog_ui_event);
 }
 
 void AutofillDialogControllerImpl::LogDialogLatencyToShow() {
@@ skipping 84 matching lines @@
     view_->GetUserInput(SECTION_CC_BILLING, &output);
     CreditCard card;
     GetBillingInfoFromOutputs(output, &card, NULL, NULL);
     backing_last_four = card.TypeAndLastFourDigits();
   }
   AutofillCreditCardBubbleController::ShowGeneratedCardUI(
       web_contents(), backing_last_four, full_wallet_->TypeAndLastFourDigits());
 }
 
 }  // namespace autofill