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

chrome/browser/ui/views/autofill/autofill_dialog_views.cc

 // Copyright (c) 2012 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/views/autofill/autofill_dialog_views.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
@@ skipping 757 matching lines @@
   DCHECK(notification_area_);
   notification_area_->SetNotifications(controller_->CurrentNotifications());
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::UpdateSection(DialogSection section) {
   UpdateSectionImpl(section, true);
 }
 
 void AutofillDialogViews::FillSection(DialogSection section,
-                                      const DetailInput& originating_input) {
+                                      AutofillFieldType type) {
   DetailsGroup* group = GroupForSection(section);
-  TextfieldMap::iterator text_mapping =
-      group->textfields.find(&originating_input);
+  TextfieldMap::iterator text_mapping = group->textfields.find(type);
   if (text_mapping != group->textfields.end())
     text_mapping->second->textfield()->SetText(string16());
 
   UpdateSectionImpl(section, false);
 }
 
 void AutofillDialogViews::GetUserInput(DialogSection section,
                                        DetailOutputMap* output) {
   DetailsGroup* group = GroupForSection(section);
   for (TextfieldMap::const_iterator it = group->textfields.begin();
@@ skipping 61 matching lines @@
 
 void AutofillDialogViews::SubmitForTesting() {
   Accept();
 }
 
 void AutofillDialogViews::CancelForTesting() {
   if (Cancel())
     Hide();
 }
 
-string16 AutofillDialogViews::GetTextContentsOfInput(const DetailInput& input) {
-  views::Textfield* textfield = TextfieldForInput(input);
+string16 AutofillDialogViews::GetTextContentsOfInput(DialogSection section,
+                                                     AutofillFieldType type) {
+  views::Textfield* textfield = TextfieldForInput(section, type);
   if (textfield)
     return textfield->text();
 
-  views::Combobox* combobox = ComboboxForInput(input);
+  views::Combobox* combobox = ComboboxForInput(section, type);
   if (combobox)
     return combobox->model()->GetItemAt(combobox->selected_index());
 
   NOTREACHED();
   return string16();
 }
 
-void AutofillDialogViews::SetTextContentsOfInput(const DetailInput& input,
+void AutofillDialogViews::SetTextContentsOfInput(DialogSection section,
+                                                 AutofillFieldType type,
                                                  const string16& contents) {
-  views::Textfield* textfield = TextfieldForInput(input);
+  views::Textfield* textfield = TextfieldForInput(section, type);
   if (textfield) {
-    TextfieldForInput(input)->SetText(contents);
+    textfield->SetText(contents);
     return;
   }
 
-  views::Combobox* combobox = ComboboxForInput(input);
+  views::Combobox* combobox = ComboboxForInput(section, type);
   if (combobox) {
     for (int i = 0; i < combobox->model()->GetItemCount(); ++i) {
       if (contents == combobox->model()->GetItemAt(i)) {
         combobox->SetSelectedIndex(i);
         return;
       }
     }
     // If we don't find a match, return the combobox to its default state.
     combobox->SetSelectedIndex(combobox->model()->GetDefaultIndex());
     return;
   }
 
   NOTREACHED();
 }
 
-void AutofillDialogViews::ActivateInput(const DetailInput& input) {
-  TextfieldEditedOrActivated(TextfieldForInput(input), false);
+void AutofillDialogViews::ActivateInput(DialogSection section,
+                                        AutofillFieldType type) {
+  TextfieldEditedOrActivated(TextfieldForInput(section, type), false);
 }
 
 string16 AutofillDialogViews::GetWindowTitle() const {
   return controller_->DialogTitle();
 }
 
 void AutofillDialogViews::WindowClosing() {
   focus_manager_->RemoveFocusChangeListener(this);
 }
 
@@ skipping 368 matching lines @@
                           expand ? expand : 1,
                           views::GridLayout::USE_PREF,
                           0,
                           0);
 
     ui::ComboboxModel* input_model =
         controller_->ComboboxModelForAutofillType(input.type);
     if (input_model) {
       views::Combobox* combobox = new views::Combobox(input_model);
       combobox->set_listener(this);
-      comboboxes->insert(std::make_pair(&input, combobox));
+      comboboxes->insert(std::make_pair(input.type, combobox));
       layout->AddView(combobox);
 
       for (int i = 0; i < input_model->GetItemCount(); ++i) {
         if (input.initial_value == input_model->GetItemAt(i)) {
           combobox->SetSelectedIndex(i);
           break;
         }
       }
     } else {
       DecoratedTextfield* field = new DecoratedTextfield(
           input.initial_value,
           l10n_util::GetStringUTF16(input.placeholder_text_rid),
           this);
 
       gfx::Image icon =
           controller_->IconForField(input.type, input.initial_value);
       field->textfield()->SetIcon(icon.AsImageSkia());
 
-      textfields->insert(std::make_pair(&input, field));
+      textfields->insert(std::make_pair(input.type, field));
       layout->AddView(field);
     }
   }
 
   return view;
 }
 
 void AutofillDialogViews::UpdateSectionImpl(
     DialogSection section,
     bool clobber_inputs) {
   const DetailInputs& updated_inputs =
       controller_->RequestedFieldsForSection(section);
   DetailsGroup* group = GroupForSection(section);
 
   for (DetailInputs::const_iterator iter = updated_inputs.begin();
        iter != updated_inputs.end(); ++iter) {
-    const DetailInput& input = *iter;
-    TextfieldMap::iterator text_mapping = group->textfields.find(&input);
+    AutofillFieldType type = iter->type;
+    TextfieldMap::iterator text_mapping = group->textfields.find(type);
 
     if (text_mapping != group->textfields.end()) {
       views::Textfield* textfield = text_mapping->second->textfield();
       if (textfield->text().empty() || clobber_inputs) {
         textfield->SetText(iter->initial_value);
-        textfield->SetIcon(controller_->IconForField(
-            input.type, textfield->text()).AsImageSkia());
+        textfield->SetIcon(controller_->IconForField(type, textfield->text())
+                               .AsImageSkia());
       }
     }
 
-    ComboboxMap::iterator combo_mapping = group->comboboxes.find(&input);
+    ComboboxMap::iterator combo_mapping = group->comboboxes.find(type);
     if (combo_mapping != group->comboboxes.end()) {
       views::Combobox* combobox = combo_mapping->second;
       for (int i = 0; i < combobox->model()->GetItemCount(); ++i) {
-        if (input.initial_value == combobox->model()->GetItemAt(i)) {
+        if (iter->initial_value == combobox->model()->GetItemAt(i)) {
           combobox->SetSelectedIndex(i);
           break;
         }
       }
     }
   }
 
   UpdateDetailsGroupState(*group);
   if (group->container && group->container->visible())
     ValidateGroup(group, AutofillDialogController::VALIDATE_EDIT);
@@ skipping 34 matching lines @@
   }
 
   ContentsPreferredSizeChanged();
 }
 
 bool AutofillDialogViews::ValidateGroup(
     DetailsGroup* group,
     AutofillDialogController::ValidationType validation_type) {
   DCHECK(group->container->visible());
 
-  scoped_ptr<DetailInput> cvc_input;
   DetailOutputMap detail_outputs;
   std::map<AutofillFieldType, base::Callback<void(bool)> > field_map;
 
   if (group->manual_input->visible()) {
     for (TextfieldMap::iterator iter = group->textfields.begin();
          iter != group->textfields.end(); ++iter) {
       detail_outputs[iter->first] = iter->second->textfield()->text();
-      field_map[iter->first->type] =
-          base::Bind(&DecoratedTextfield::SetInvalid,
-                     base::Unretained(iter->second));
+      field_map[iter->first] = base::Bind(&DecoratedTextfield::SetInvalid,
+                                          base::Unretained(iter->second));
     }
     for (ComboboxMap::iterator iter = group->comboboxes.begin();
          iter != group->comboboxes.end(); ++iter) {
       views::Combobox* combobox = iter->second;
       string16 item =
           combobox->model()->GetItemAt(combobox->selected_index());
       detail_outputs[iter->first] = item;
-      field_map[iter->first->type] =
-          base::Bind(&views::Combobox::SetInvalid,
-                     base::Unretained(iter->second));
+      field_map[iter->first] = base::Bind(&views::Combobox::SetInvalid,
+                                          base::Unretained(iter->second));
     }
   } else if (group->section == SECTION_CC) {
     DecoratedTextfield* decorated_cvc =
         group->suggested_info->decorated_textfield();
-    cvc_input.reset(new DetailInput);
-    cvc_input->type = CREDIT_CARD_VERIFICATION_CODE;
-    detail_outputs[cvc_input.get()] = decorated_cvc->textfield()->text();
-    field_map[cvc_input->type] =
-        base::Bind(&DecoratedTextfield::SetInvalid,
-                   base::Unretained(decorated_cvc));
+    detail_outputs[CREDIT_CARD_VERIFICATION_CODE] =
+        decorated_cvc->textfield()->text();
+    field_map[CREDIT_CARD_VERIFICATION_CODE] = base::Bind(
+        &DecoratedTextfield::SetInvalid, base::Unretained(decorated_cvc));
   }
 
   std::vector<AutofillFieldType> invalid_inputs;
   invalid_inputs = controller_->InputsAreValid(detail_outputs, validation_type);
   // Flag invalid fields, removing them from |field_map|.
   for (std::vector<AutofillFieldType>::const_iterator iter =
            invalid_inputs.begin(); iter != invalid_inputs.end(); ++iter) {
     field_map[*iter].Run(true);
     field_map.erase(*iter);
   }
@@ skipping 33 matching lines @@
   DecoratedTextfield* decorated = NULL;
 
   // Look for the input in the manual inputs.
   views::View* ancestor =
       textfield->GetAncestorWithClassName(kDecoratedTextfieldClassName);
   for (TextfieldMap::const_iterator iter = group->textfields.begin();
        iter != group->textfields.end();
        ++iter) {
     decorated = iter->second;
     if (decorated == ancestor) {
-      controller_->UserEditedOrActivatedInput(iter->first,
+      controller_->UserEditedOrActivatedInput(group->section,
+                                              iter->first,
                                               GetWidget()->GetNativeView(),
                                               textfield->GetBoundsInScreen(),
                                               textfield->text(),
                                               was_edit);
-      type = iter->first->type;
+      type = iter->first;
       break;
     }
   }
 
   if (ancestor == group->suggested_info->decorated_textfield()) {
     decorated = group->suggested_info->decorated_textfield();
     type = CREDIT_CARD_VERIFICATION_CODE;
   }
   DCHECK_NE(UNKNOWN_TYPE, type);
 
@@ skipping 49 matching lines @@
     // accessed via |suggested_info|.
     if (ancestor &&
         ancestor == group->suggested_info->decorated_textfield()) {
       return group;
     }
   }
   return NULL;
 }
 
 views::Textfield* AutofillDialogViews::TextfieldForInput(
-    const DetailInput& input) {
-  for (DetailGroupMap::iterator iter = detail_groups_.begin();
-       iter != detail_groups_.end(); ++iter) {
-    const DetailsGroup& group = iter->second;
-    TextfieldMap::const_iterator text_mapping = group.textfields.find(&input);
-    if (text_mapping != group.textfields.end())
+    DialogSection section,
+    AutofillFieldType type) {
+  DetailsGroup* group = GroupForSection(section);
+  if (group) {
+    TextfieldMap::const_iterator text_mapping = group->textfields.find(type);
+    if (text_mapping != group->textfields.end())
       return text_mapping->second->textfield();
   }
 
   return NULL;
 }
 
-views::Combobox* AutofillDialogViews::ComboboxForInput(
-    const DetailInput& input) {
-  for (DetailGroupMap::iterator iter = detail_groups_.begin();
-       iter != detail_groups_.end(); ++iter) {
-    const DetailsGroup& group = iter->second;
-    ComboboxMap::const_iterator combo_mapping = group.comboboxes.find(&input);
-    if (combo_mapping != group.comboboxes.end())
+views::Combobox* AutofillDialogViews::ComboboxForInput(DialogSection section,
+                                                       AutofillFieldType type) {
+  DetailsGroup* group = GroupForSection(section);
+  if (group) {
+    ComboboxMap::const_iterator combo_mapping = group->comboboxes.find(type);
+    if (combo_mapping != group->comboboxes.end())
       return combo_mapping->second;
   }
 
   return NULL;
 }
 
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill