rAc: Get rid of dialog type in rAc, there is only one type left now.

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 483 matching lines @@
 }
 
 }  // namespace
 
 AutofillDialogViewDelegate::~AutofillDialogViewDelegate() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
-  GetMetricLogger().LogDialogInitialUserState(
-      GetDialogType(), initial_user_state_);
+  GetMetricLogger().LogDialogInitialUserState(initial_user_state_);
 }
 
 // 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();
 }
 
 // static
 void AutofillDialogControllerImpl::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       ::prefs::kAutofillDialogShowCount,
       0,
@@ skipping 13 matching lines @@
       ::prefs::kAutofillDialogSaveData,
       true,
       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(
-      GetDialogType(), AutofillMetrics::DIALOG_UI_SHOWN);
+  GetMetricLogger().LogDialogUiEvent(AutofillMetrics::DIALOG_UI_SHOWN);
 
   GetMetricLogger().LogDialogSecurityMetric(
-      GetDialogType(), AutofillMetrics::SECURITY_METRIC_DIALOG_SHOWN);
+      AutofillMetrics::SECURITY_METRIC_DIALOG_SHOWN);
 
   if (RequestingCreditCardInfo() && !TransmissionWillBeSecure()) {
     GetMetricLogger().LogDialogSecurityMetric(
-        GetDialogType(),
         AutofillMetrics::SECURITY_METRIC_CREDIT_CARD_OVER_HTTP);
   }
 
   if (!invoked_from_same_origin_) {
     GetMetricLogger().LogDialogSecurityMetric(
-        GetDialogType(),
         AutofillMetrics::SECURITY_METRIC_CROSS_ORIGIN_FRAME);
   }
 
   // Determine what field types should be included in the dialog.
   bool has_types = false;
   bool has_sections = false;
   form_structure_.ParseFieldTypesFromAutocompleteAttributes(
       &has_types, &has_sections);
 
   // Fail if the author didn't specify autocomplete types.
@@ skipping 159 matching lines @@
 
     return true;
   }
 
   DCHECK_EQ(ui::DIALOG_BUTTON_CANCEL, button);
   return !is_submitting_ || IsSubmitPausedOn(wallet::VERIFY_CVV);
 }
 
 DialogOverlayState AutofillDialogControllerImpl::GetDialogOverlay() const {
   bool show_wallet_interstitial = IsPayingWithWallet() && is_submitting_ &&
-      !IsSubmitPausedOn(wallet::VERIFY_CVV) &&
-      GetDialogType() == DIALOG_TYPE_REQUEST_AUTOCOMPLETE;
+      !IsSubmitPausedOn(wallet::VERIFY_CVV);
   if (!show_wallet_interstitial)
     return DialogOverlayState();
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   DialogOverlayState state;
 
   state.strings.push_back(DialogOverlayString());
   DialogOverlayString& string = state.strings.back();
   string.font = rb.GetFont(ui::ResourceBundle::BaseFont).DeriveFont(4);
   string.alignment = gfx::ALIGN_CENTER;
@@ skipping 650 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(), common::DialogSectionToUiEditEvent(section));
+      common::DialogSectionToUiEditEvent(section));
 }
 
 gfx::Image AutofillDialogControllerImpl::IconForField(
     ServerFieldType type, const string16& user_input) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (type == CREDIT_CARD_VERIFICATION_CODE)
     return rb.GetImageNamed(IDR_CREDIT_CARD_CVC_HINT);
 
   if (type == CREDIT_CARD_NUMBER) {
     const int input_card_idr = CreditCard::IconResourceId(
@@ skipping 382 matching lines @@
   if (signin_registrar_.IsEmpty()) {
     // Start sign in.
     DCHECK(!IsPayingWithWallet());
 
     content::Source<content::NavigationController> source(view_->ShowSignIn());
     signin_registrar_.Add(
         this, content::NOTIFICATION_NAV_ENTRY_COMMITTED, source);
     view_->UpdateAccountChooser();
 
     GetMetricLogger().LogDialogUiEvent(
-        GetDialogType(), AutofillMetrics::DIALOG_UI_SIGNIN_SHOWN);
+        AutofillMetrics::DIALOG_UI_SIGNIN_SHOWN);
   } else {
     HideSignIn();
   }
 }
 
 void AutofillDialogControllerImpl::NotificationCheckboxStateChanged(
     DialogNotification::Type type, bool checked) {
   if (type == DialogNotification::WALLET_USAGE_CONFIRMATION) {
     if (checked)
       account_chooser_model_.SelectActiveWalletAccount();
@@ skipping 50 matching lines @@
 
 content::WebContents* AutofillDialogControllerImpl::GetWebContents() {
   return web_contents();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AutofillPopupDelegate implementation.
 
 void AutofillDialogControllerImpl::OnPopupShown(
     content::RenderWidgetHost::KeyPressEventCallback* callback) {
-  GetMetricLogger().LogDialogPopupEvent(
-      GetDialogType(), AutofillMetrics::DIALOG_POPUP_SHOWN);
+  GetMetricLogger().LogDialogPopupEvent(AutofillMetrics::DIALOG_POPUP_SHOWN);
 }
 
 void AutofillDialogControllerImpl::OnPopupHidden(
     content::RenderWidgetHost::KeyPressEventCallback* callback) {}
 
 bool AutofillDialogControllerImpl::ShouldRepostEvent(
     const ui::MouseEvent& event) {
   // If the event would be reposted inside |input_showing_popup_|, just ignore.
   return !view_->HitTestInput(*input_showing_popup_, event.location());
 }
@@ skipping 16 matching lines @@
         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));
     view_->FillSection(section, *input_showing_popup_);
   }
 
   GetMetricLogger().LogDialogPopupEvent(
-      GetDialogType(), AutofillMetrics::DIALOG_POPUP_FORM_FILLED);
+      AutofillMetrics::DIALOG_POPUP_FORM_FILLED);
 
   // TODO(estade): not sure why it's necessary to do this explicitly.
   HidePopup();
 }
 
 void AutofillDialogControllerImpl::RemoveSuggestion(const string16& value,
                                                     int identifier) {
   // TODO(estade): implement.
 }
 
@@ skipping 57 matching lines @@
   LogSuggestionItemSelectedMetric(*model);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wallet::WalletClientDelegate implementation.
 
 const AutofillMetrics& AutofillDialogControllerImpl::GetMetricLogger() const {
   return metric_logger_;
 }
 
-DialogType AutofillDialogControllerImpl::GetDialogType() const {
-  return dialog_type_;
-}
-
 std::string AutofillDialogControllerImpl::GetRiskData() const {
   DCHECK(!risk_data_.empty());
   return risk_data_;
 }
 
 std::string AutofillDialogControllerImpl::GetWalletCookieValue() const {
   return wallet_cookie_value_;
 }
 
 bool AutofillDialogControllerImpl::IsShippingAddressRequired() const {
@@ skipping 186 matching lines @@
   NewCreditCardBubbleController::Show(profile(),
                                       new_card.Pass(),
                                       billing_profile.Pass());
 #endif
 }
 
 AutofillDialogControllerImpl::AutofillDialogControllerImpl(
     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)
     : WebContentsObserver(contents),
       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),
+      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(
@@ skipping 40 matching lines @@
   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(),
+      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);
@@ skipping 802 matching lines @@
   }
 
   LogOnFinishSubmitMetrics();
 
   // Callback should be called as late as possible.
   callback_.Run(&form_structure_, !wallet_items_ ? std::string() :
       wallet_items_->google_transaction_id());
   data_was_passed_back_ = true;
 
   // This might delete us.
-  if (GetDialogType() == DIALOG_TYPE_REQUEST_AUTOCOMPLETE)
-    Hide();
+  Hide();
 }
 
 void AutofillDialogControllerImpl::PersistAutofillChoice(
     DialogSection section,
     const std::string& guid,
     int variant) {
   DCHECK(!IsPayingWithWallet());
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString(kGuidPrefKey, guid);
   value->SetInteger(kVariantPrefKey, variant);
@@ skipping 49 matching lines @@
       variant++;
     else
       break;
   }
   return variant;
 }
 
 void AutofillDialogControllerImpl::LogOnFinishSubmitMetrics() {
   GetMetricLogger().LogDialogUiDuration(
       base::Time::Now() - dialog_shown_timestamp_,
-      GetDialogType(),
       AutofillMetrics::DIALOG_ACCEPTED);
 
-  GetMetricLogger().LogDialogUiEvent(
-      GetDialogType(), AutofillMetrics::DIALOG_UI_ACCEPTED);
+  GetMetricLogger().LogDialogUiEvent(AutofillMetrics::DIALOG_UI_ACCEPTED);
 
   AutofillMetrics::DialogDismissalState dismissal_state;
   if (!IsManuallyEditingAnySection())
     dismissal_state = AutofillMetrics::DIALOG_ACCEPTED_EXISTING_DATA;
   else if (IsPayingWithWallet())
     dismissal_state = AutofillMetrics::DIALOG_ACCEPTED_SAVE_TO_WALLET;
   else if (ShouldSaveDetailsLocally())
     dismissal_state = AutofillMetrics::DIALOG_ACCEPTED_SAVE_TO_AUTOFILL;
   else
     dismissal_state = AutofillMetrics::DIALOG_ACCEPTED_NO_SAVE;
 
-  GetMetricLogger().LogDialogDismissalState(GetDialogType(), dismissal_state);
+  GetMetricLogger().LogDialogDismissalState(dismissal_state);
 }
 
 void AutofillDialogControllerImpl::LogOnCancelMetrics() {
-  GetMetricLogger().LogDialogUiEvent(
-      GetDialogType(), AutofillMetrics::DIALOG_UI_CANCELED);
+  GetMetricLogger().LogDialogUiEvent(AutofillMetrics::DIALOG_UI_CANCELED);
 
   AutofillMetrics::DialogDismissalState dismissal_state;
   if (!signin_registrar_.IsEmpty())
     dismissal_state = AutofillMetrics::DIALOG_CANCELED_DURING_SIGNIN;
   else if (!IsManuallyEditingAnySection())
     dismissal_state = AutofillMetrics::DIALOG_CANCELED_NO_EDITS;
   else if (AllSectionsAreValid())
     dismissal_state = AutofillMetrics::DIALOG_CANCELED_NO_INVALID_FIELDS;
   else
     dismissal_state = AutofillMetrics::DIALOG_CANCELED_WITH_INVALID_FIELDS;
 
-  GetMetricLogger().LogDialogDismissalState(GetDialogType(), dismissal_state);
+  GetMetricLogger().LogDialogDismissalState(dismissal_state);
 
   GetMetricLogger().LogDialogUiDuration(
       base::Time::Now() - dialog_shown_timestamp_,
-      GetDialogType(),
       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 = common::DialogSectionToUiItemAddedEvent(section);
   } else if (IsASuggestionItemKey(model.GetItemKeyForCheckedItem())) {
     // Selected an existing item.
     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);
+  GetMetricLogger().LogDialogUiEvent(dialog_ui_event);
 }
 
 void AutofillDialogControllerImpl::LogDialogLatencyToShow() {
   if (was_ui_latency_logged_)
     return;
 
   GetMetricLogger().LogDialogLatencyToShow(
-      GetDialogType(),
       base::Time::Now() - dialog_shown_timestamp_);
   was_ui_latency_logged_ = true;
 }
 
 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 2 because
   // an "empty" menu still has the "add new" menu item and "manage" menu item.
   const bool has_autofill_profiles =
@@ skipping 66 matching lines @@
   }
 #if !defined(OS_ANDROID)
   GeneratedCreditCardBubbleController::Show(
       web_contents(),
       full_wallet_->TypeAndLastFourDigits(),
       backing_last_four);
 #endif
 }
 
 }  // namespace autofill