[RFP, Autofill] Switching dialog field identification to int.

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 131 matching lines @@
     inputs->push_back(*input);
   }
 }
 
 // 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) {
     if (!iter->second.empty()) {
-      AutofillFieldType type = iter->first->type;
+      AutofillFieldType type = iter->first;
       if (type == ADDRESS_HOME_COUNTRY || type == ADDRESS_BILLING_COUNTRY) {
         form_group->SetInfo(type,
                             iter->second,
                             g_browser_process->GetApplicationLocale());
       } else {
-        form_group->SetRawInfo(iter->first->type, iter->second);
+        form_group->SetRawInfo(iter->first, iter->second);
       }
     }
   }
 }
 
 // Get billing info from |output| and put it into |card|, |cvc|, and |profile|.
 // These outparams are required because |card|/|profile| accept different types
 // of raw info, and CreditCard doesn't save CVCs.
 void GetBillingInfoFromOutputs(const DetailOutputMap& output,
                                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) {
+    if (it->first == CREDIT_CARD_VERIFICATION_CODE) {
       if (cvc)
         cvc->assign(trimmed);
-    } else if (it->first->type == ADDRESS_HOME_COUNTRY ||
-               it->first->type == ADDRESS_BILLING_COUNTRY) {
-        profile->SetInfo(it->first->type,
-                         trimmed,
-                         g_browser_process->GetApplicationLocale());
+    } else if (it->first == ADDRESS_HOME_COUNTRY ||
+               it->first == ADDRESS_BILLING_COUNTRY) {
+      profile->SetInfo(
+          it->first, 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 (profile && it->first->type == CREDIT_CARD_NAME)
+      if (profile && it->first == CREDIT_CARD_NAME)
         profile->SetRawInfo(NAME_FULL, trimmed);
 
-      if (IsCreditCardType(it->first->type)) {
+      if (IsCreditCardType(it->first)) {
         if (card)
-          card->SetRawInfo(it->first->type, trimmed);
+          card->SetRawInfo(it->first, trimmed);
       } else if (profile) {
-        profile->SetRawInfo(it->first->type, trimmed);
+        profile->SetRawInfo(it->first, 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);
   if (browser)
     return browser->window();
 
   gfx::NativeWindow native_window =
       web_contents->GetView()->GetTopLevelNativeWindow();
   ShellWindow* shell_window =
       extensions::ShellWindowRegistry::
           GetShellWindowForNativeWindowAnyProfile(native_window);
   return shell_window->GetBaseWindow();
 }
 
 // Extracts the string value of a field with |type| from |output|. This is
 // useful when you only need the value of 1 input from a section of view inputs.
 string16 GetValueForType(const DetailOutputMap& output,
                          AutofillFieldType type) {
-  for (DetailOutputMap::const_iterator it = output.begin();
-       it != output.end(); ++it) {
-    if (it->first->type == type)
-      return it->second;
-  }
-  NOTREACHED();
-  return string16();
+  DetailOutputMap::const_iterator it = output.find(type);
+  DCHECK(it != output.end());
+  return it->second;
 }
 
 }  // namespace
 
 AutofillDialogController::~AutofillDialogController() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
@@ skipping 770 matching lines @@
       NOTREACHED();  // Trying to validate unknown field.
       break;
   }
 
   return !value.empty();
 }
 
 std::vector<AutofillFieldType> AutofillDialogControllerImpl::InputsAreValid(
     const DetailOutputMap& inputs, ValidationType validation_type) const {
   std::vector<AutofillFieldType> invalid_fields;
-  std::map<AutofillFieldType, string16> field_values;
   for (DetailOutputMap::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     // Skip empty fields in edit mode.
     if (validation_type == VALIDATE_EDIT && iter->second.empty())
       continue;
 
-    field_values[iter->first->type] = iter->second;
-
-    if (!InputIsValid(iter->first->type, iter->second))
-      invalid_fields.push_back(iter->first->type);
+    if (!InputIsValid(iter->first, iter->second))
+      invalid_fields.push_back(iter->first);
   }
 
   // Validate the date formed by month and year field. (Autofill dialog is
   // never supposed to have 2-digit years, so not checked).
-  if (field_values.count(CREDIT_CARD_EXP_MONTH) &&
-      field_values.count(CREDIT_CARD_EXP_4_DIGIT_YEAR)) {
+  DetailOutputMap::const_iterator field1 = inputs.find(CREDIT_CARD_EXP_MONTH);
+  DetailOutputMap::const_iterator field2 =
+      inputs.find(CREDIT_CARD_EXP_4_DIGIT_YEAR);
+  if (field1 != inputs.end() && field2 != inputs.end()) {
     if (!autofill::IsValidCreditCardExpirationDate(
-            field_values[CREDIT_CARD_EXP_4_DIGIT_YEAR],
-            field_values[CREDIT_CARD_EXP_MONTH],
-            base::Time::Now())) {
+            field1->second, field2->second, base::Time::Now())) {
       invalid_fields.push_back(CREDIT_CARD_EXP_MONTH);
       invalid_fields.push_back(CREDIT_CARD_EXP_4_DIGIT_YEAR);
     }
   }
 
   // If there is a credit card number and a CVC, validate them together.
-  if (field_values.count(CREDIT_CARD_NUMBER) &&
-      field_values.count(CREDIT_CARD_VERIFICATION_CODE) &&
-      InputIsValid(CREDIT_CARD_NUMBER, field_values[CREDIT_CARD_NUMBER])) {
-    if (!autofill::IsValidCreditCardSecurityCode(
-            field_values[CREDIT_CARD_VERIFICATION_CODE],
-            field_values[CREDIT_CARD_NUMBER])) {
+  field1 = inputs.find(CREDIT_CARD_NUMBER);
+  field2 = inputs.find(CREDIT_CARD_VERIFICATION_CODE);
+  if (field1 != inputs.end() && field2 != inputs.end() &&
+      InputIsValid(CREDIT_CARD_NUMBER, field1->second)) {
+    if (!autofill::IsValidCreditCardSecurityCode(field2->second,
+                                                 field1->second)) {
       invalid_fields.push_back(CREDIT_CARD_VERIFICATION_CODE);
     }
   }
 
   // De-duplicate invalid fields.
   std::sort(invalid_fields.begin(), invalid_fields.end());
   invalid_fields.erase(std::unique(
       invalid_fields.begin(), invalid_fields.end()), invalid_fields.end());
 
   return invalid_fields;
 }
 
 void AutofillDialogControllerImpl::UserEditedOrActivatedInput(
-    const DetailInput* input,
+    DialogSection section,
+    AutofillFieldType type,
     gfx::NativeView parent_view,
     const gfx::Rect& content_bounds,
     const string16& field_contents,
     bool was_edit) {
   // If the field is edited down to empty, don't show a popup.
   if (was_edit && field_contents.empty()) {
     HidePopup();
     return;
   }
 
   // If the user clicks while the popup is already showing, be sure to hide
   // it.
   if (!was_edit && popup_controller_) {
     HidePopup();
     return;
   }
 
   std::vector<string16> popup_values, popup_labels, popup_icons;
-  if (IsCreditCardType(input->type)) {
-    GetManager()->GetCreditCardSuggestions(input->type,
+  if (IsCreditCardType(type)) {
+    GetManager()->GetCreditCardSuggestions(type,
                                            field_contents,
                                            &popup_values,
                                            &popup_labels,
                                            &popup_icons,
                                            &popup_guids_);
   } else {
     std::vector<AutofillFieldType> field_types;
     field_types.push_back(EMAIL_ADDRESS);
     for (DetailInputs::const_iterator iter = requested_shipping_fields_.begin();
          iter != requested_shipping_fields_.end(); ++iter) {
       field_types.push_back(iter->type);
     }
-    GetManager()->GetProfileSuggestions(input->type,
+    GetManager()->GetProfileSuggestions(type,
                                         field_contents,
                                         false,
                                         field_types,
                                         &popup_values,
                                         &popup_labels,
                                         &popup_icons,
                                         &popup_guids_);
   }
 
   if (popup_values.empty())
     return;
 
   // TODO(estade): do we need separators and control rows like 'Clear
   // Form'?
   std::vector<int> popup_ids;
   for (size_t i = 0; i < popup_guids_.size(); ++i) {
     popup_ids.push_back(i);
   }
 
   popup_controller_ = AutofillPopupControllerImpl::GetOrCreate(
       popup_controller_,
       weak_ptr_factory_.GetWeakPtr(),
       parent_view,
       content_bounds);
   popup_controller_->Show(popup_values,
                           popup_labels,
                           popup_icons,
                           popup_ids);
-  input_showing_popup_ = input;
+  input_showing_popup_type_ = type;
 }
 
 void AutofillDialogControllerImpl::FocusMoved() {
   HidePopup();
 }
 
 void AutofillDialogControllerImpl::ViewClosed() {
   GetManager()->RemoveObserver(this);
 
   if (autocheckout_is_running_ || had_autocheckout_error_) {
@@ skipping 182 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 (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));
-    view_->FillSection(section, *input_showing_popup_);
+    view_->FillSection(section, input_showing_popup_type_);
   }
 
   GetMetricLogger().LogDialogPopupEvent(
       dialog_type_, AutofillMetrics::DIALOG_POPUP_FORM_FILLED);
 
   // TODO(estade): not sure why it's necessary to do this explicitly.
   HidePopup();
 }
 
 void AutofillDialogControllerImpl::RemoveSuggestion(const string16& value,
@@ skipping 289 matching lines @@
   return source_url_.SchemeIs(chrome::kHttpsScheme) &&
          !net::IsCertStatusError(ssl_status_.cert_status) &&
          !net::IsCertStatusMinorError(ssl_status_.cert_status);
 }
 
 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)
+    const base::Callback<void(const FormStructure*, const std::string&)>&
+        callback)
     : profile_(Profile::FromBrowserContext(contents->GetBrowserContext())),
       contents_(contents),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       dialog_type_(dialog_type),
       form_structure_(form_structure, std::string()),
       invoked_from_same_origin_(true),
       source_url_(source_url),
       ssl_status_(form_structure.ssl_status),
       callback_(callback),
-      account_chooser_model_(this, profile_->GetPrefs(), metric_logger_,
+      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),
-      input_showing_popup_(NULL),
+      input_showing_popup_type_(UNKNOWN_TYPE),
       weak_ptr_factory_(this),
       is_first_run_(!profile_->GetPrefs()->HasPrefPath(
           ::prefs::kAutofillDialogPayWithoutWallet)),
       is_submitting_(false),
       autocheckout_is_running_(false),
       had_autocheckout_error_(false),
       was_ui_latency_logged_(false) {
   // TODO(estade): remove duplicates from |form_structure|?
   DCHECK(!callback_.is_null());
 }
@@ skipping 320 matching lines @@
 }
 
 DetailInputs* AutofillDialogControllerImpl::MutableRequestedFieldsForSection(
     DialogSection section) {
   return const_cast<DetailInputs*>(&RequestedFieldsForSection(section));
 }
 
 void AutofillDialogControllerImpl::HidePopup() {
   if (popup_controller_)
     popup_controller_->Hide();
-  input_showing_popup_ = NULL;
+  input_showing_popup_type_ = UNKNOWN_TYPE;
 }
 
 void AutofillDialogControllerImpl::LoadRiskFingerprintData() {
   // TODO(dbeam): Add a CHECK or otherwise strong guarantee that the ToS have
   // been accepted prior to calling into this method. Also, ensure that the UI
   // contains a clear indication to the user as to what data will be collected.
   // Until then, this code should not be called. http://crbug.com/173505
 
   int64 gaia_id = 0;
   bool success =
@@ skipping 350 matching lines @@
       url,
       content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 #else
   // TODO(estade): use TabModelList?
 #endif
 }
 
 }  // namespace autofill