Change DetailOutputMap to FieldValueMap

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/location.h"
@@ skipping 1297 matching lines @@
 void AutofillDialogViews::UpdateErrorBubble() {
   if (!delegate_->ShouldShowErrorBubble())
     HideErrorBubble();
 }
 
 void AutofillDialogViews::FillSection(DialogSection section,
                                       const DetailInput& originating_input) {
   DetailsGroup* group = GroupForSection(section);
   // Make sure to overwrite the originating input.
   TextfieldMap::iterator text_mapping =
-      group->textfields.find(&originating_input);
+      group->textfields.find(originating_input.type);
   if (text_mapping != group->textfields.end())
     text_mapping->second->SetText(base::string16());
 
   // If the Autofill data comes from a credit card, make sure to overwrite the
   // CC comboboxes (even if they already have something in them). If the
   // Autofill data comes from an AutofillProfile, leave the comboboxes alone.
   if (section == GetCreditCardSection() &&
       AutofillType(originating_input.type).group() == CREDIT_CARD) {
     for (ComboboxMap::const_iterator it = group->comboboxes.begin();
          it != group->comboboxes.end(); ++it) {
-      if (AutofillType(it->first->type).group() == CREDIT_CARD)
+      if (AutofillType(it->first).group() == CREDIT_CARD)
         it->second->SetSelectedIndex(it->second->model()->GetDefaultIndex());
     }
   }
 
   UpdateSectionImpl(section, false);
 }
 
 void AutofillDialogViews::GetUserInput(DialogSection section,
-                                       DetailOutputMap* output) {
+                                       FieldValueMap* output) {
   DetailsGroup* group = GroupForSection(section);
   for (TextfieldMap::const_iterator it = group->textfields.begin();
        it != group->textfields.end(); ++it) {
     output->insert(std::make_pair(it->first, it->second->text()));
   }
   for (ComboboxMap::const_iterator it = group->comboboxes.begin();
        it != group->comboboxes.end(); ++it) {
     output->insert(std::make_pair(it->first,
         it->second->model()->GetItemAt(it->second->selected_index())));
   }
@@ skipping 102 matching lines @@
 
   NOTREACHED();
   return base::string16();
 }
 
 void AutofillDialogViews::SetTextContentsOfInput(
     const DetailInput& input,
     const base::string16& contents) {
   views::Textfield* textfield = TextfieldForInput(input);
   if (textfield) {
-    TextfieldForInput(input)->SetText(contents);
+    textfield->SetText(contents);
     return;
   }
 
   views::Combobox* combobox = ComboboxForInput(input);
   if (combobox) {
     SelectComboboxValueOrSetToDefault(combobox, input.initial_value);
     return;
   }
 
   NOTREACHED();
@@ skipping 489 matching lines @@
 
   for (DetailInputs::const_iterator it = inputs.begin();
        it != inputs.end(); ++it) {
     const DetailInput& input = *it;
     ui::ComboboxModel* input_model =
         delegate_->ComboboxModelForAutofillType(input.type);
     scoped_ptr<views::View> view_to_add;
     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));
       SelectComboboxValueOrSetToDefault(combobox, input.initial_value);
       view_to_add.reset(combobox);
     } else {
       DecoratedTextfield* field = new DecoratedTextfield(
           input.initial_value,
           l10n_util::GetStringUTF16(input.placeholder_text_rid),
           this);
 
-      textfields->insert(std::make_pair(&input, field));
+      textfields->insert(std::make_pair(input.type, field));
       view_to_add.reset(field);
     }
 
     int kColumnSetId = input.row_id;
     if (kColumnSetId < 0) {
       other_owned_views_.push_back(view_to_add.release());
       continue;
     }
 
     views::ColumnSet* column_set = layout->GetColumnSet(kColumnSetId);
@@ skipping 47 matching lines @@
   if (clobber_inputs)
     MarkInputsInvalid(section, ValidityMessages(), true);
 
   const DetailInputs& updated_inputs =
       delegate_->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);
+    TextfieldMap::iterator text_mapping = group->textfields.find(input.type);
 
     if (text_mapping != group->textfields.end()) {
       DecoratedTextfield* decorated = text_mapping->second;
       if (decorated->text().empty() || clobber_inputs)
-        decorated->SetText(iter->initial_value);
+        decorated->SetText(input.initial_value);
     }
 
-    ComboboxMap::iterator combo_mapping = group->comboboxes.find(&input);
+    ComboboxMap::iterator combo_mapping = group->comboboxes.find(input.type);
     if (combo_mapping != group->comboboxes.end()) {
       views::Combobox* combobox = combo_mapping->second;
       if (combobox->selected_index() == combobox->model()->GetDefaultIndex() ||
           clobber_inputs) {
         SelectComboboxValueOrSetToDefault(combobox, input.initial_value);
       }
     }
   }
 
   SetIconsForSection(section);
@@ skipping 92 matching lines @@
     DialogSection section,
     const ValidityMessages& messages,
     bool overwrite_unsure) {
   DetailsGroup* group = GroupForSection(section);
   DCHECK(group->container->visible());
 
   if (group->manual_input->visible()) {
     for (TextfieldMap::const_iterator iter = group->textfields.begin();
          iter != group->textfields.end(); ++iter) {
       const ValidityMessage& message =
-          messages.GetMessageOrDefault(iter->first->type);
+          messages.GetMessageOrDefault(iter->first);
       if (overwrite_unsure || message.sure)
         SetValidityForInput(iter->second, message.text);
     }
     for (ComboboxMap::const_iterator iter = group->comboboxes.begin();
          iter != group->comboboxes.end(); ++iter) {
       const ValidityMessage& message =
-          messages.GetMessageOrDefault(iter->first->type);
+          messages.GetMessageOrDefault(iter->first);
       if (overwrite_unsure || message.sure)
         SetValidityForInput(iter->second, message.text);
     }
   } else {
     // Purge invisible views from |validity_map_|.
     std::map<views::View*, base::string16>::iterator it;
     for (it = validity_map_.begin(); it != validity_map_.end();) {
       DCHECK(GroupForView(it->first));
       if (GroupForView(it->first) == group)
         validity_map_.erase(it++);
@@ skipping 10 matching lines @@
                             message.text);
       }
     }
   }
 }
 
 bool AutofillDialogViews::ValidateGroup(const DetailsGroup& group,
                                         ValidationType validation_type) {
   DCHECK(group.container->visible());
 
-  scoped_ptr<DetailInput> cvc_input;
-  DetailOutputMap detail_outputs;
+  FieldValueMap detail_outputs;
 
   if (group.manual_input->visible()) {
     for (TextfieldMap::const_iterator iter = group.textfields.begin();
          iter != group.textfields.end(); ++iter) {
       if (!iter->second->editable())
         continue;
 
       detail_outputs[iter->first] = iter->second->text();
     }
     for (ComboboxMap::const_iterator iter = group.comboboxes.begin();
          iter != group.comboboxes.end(); ++iter) {
       if (!iter->second->enabled())
         continue;
 
       views::Combobox* combobox = iter->second;
       base::string16 item =
           combobox->model()->GetItemAt(combobox->selected_index());
       detail_outputs[iter->first] = item;
     }
   } else if (group.section == GetCreditCardSection()) {
     DecoratedTextfield* decorated_cvc =
         group.suggested_info->decorated_textfield();
-    if (decorated_cvc->visible()) {
-      cvc_input.reset(new DetailInput);
-      cvc_input->type = CREDIT_CARD_VERIFICATION_CODE;
-      detail_outputs[cvc_input.get()] = decorated_cvc->text();
-    }
+    if (decorated_cvc->visible())
+      detail_outputs[CREDIT_CARD_VERIFICATION_CODE] = decorated_cvc->text();
   }
 
   ValidityMessages validity = delegate_->InputsAreValid(group.section,
                                                         detail_outputs);
   MarkInputsInvalid(group.section, validity, validation_type == VALIDATE_FINAL);
 
   // If there are any validation errors, sure or unsure, the group is invalid.
   return !validity.HasErrors();
 }
 
@@ skipping 29 matching lines @@
        iter != group->textfields.end();
        ++iter) {
     decorated = iter->second;
     if (decorated == textfield) {
       delegate_->UserEditedOrActivatedInput(group->section,
                                             iter->first,
                                             GetWidget()->GetNativeView(),
                                             textfield->GetBoundsInScreen(),
                                             textfield->text(),
                                             was_edit);
-      type = iter->first->type;
+      type = iter->first;
       break;
     }
   }
 
   if (textfield == group->suggested_info->decorated_textfield()) {
     decorated = group->suggested_info->decorated_textfield();
     type = CREDIT_CARD_VERIFICATION_CODE;
   }
   DCHECK_NE(UNKNOWN_TYPE, type);
 
@@ skipping 74 matching lines @@
     }
   }
   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);
+    TextfieldMap::const_iterator text_mapping =
+        group.textfields.find(input.type);
     if (text_mapping != group.textfields.end())
       return text_mapping->second;
   }
 
   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);
+    ComboboxMap::const_iterator combo_mapping =
+        group.comboboxes.find(input.type);
     if (combo_mapping != group.comboboxes.end())
       return combo_mapping->second;
   }
 
   return NULL;
 }
 
 void AutofillDialogViews::DetailsContainerBoundsChanged() {
   if (error_bubble_)
     error_bubble_->UpdatePosition();
 }
 
 void AutofillDialogViews::SetIconsForSection(DialogSection section) {
-  DetailOutputMap user_input;
+  FieldValueMap user_input;
   GetUserInput(section, &user_input);
-  FieldValueMap field_values;
-  for (DetailOutputMap::const_iterator user_input_it = user_input.begin();
-       user_input_it != user_input.end();
-       ++user_input_it) {
-    const DetailInput* field_detail = user_input_it->first;
-    const string16& field_value = user_input_it->second;
-    field_values[field_detail->type] = field_value;
-  }
-  FieldIconMap field_icons = delegate_->IconsForFields(field_values);
+  FieldIconMap field_icons = delegate_->IconsForFields(user_input);
   TextfieldMap* textfields = &GroupForSection(section)->textfields;
   for (TextfieldMap::const_iterator textfield_it = textfields->begin();
        textfield_it != textfields->end();
        ++textfield_it) {
-    ServerFieldType field_type = textfield_it->first->type;
+    ServerFieldType field_type = textfield_it->first;
     FieldIconMap::const_iterator field_icon_it = field_icons.find(field_type);
     DecoratedTextfield* textfield = textfield_it->second;
     if (field_icon_it != field_icons.end())
       textfield->SetIcon(field_icon_it->second);
     else
       textfield->SetTooltipIcon(delegate_->TooltipForField(field_type));
   }
 }
 
 void AutofillDialogViews::SetEditabilityForSection(DialogSection section) {
   const DetailInputs& inputs =
       delegate_->RequestedFieldsForSection(section);
   DetailsGroup* group = GroupForSection(section);
 
   for (DetailInputs::const_iterator iter = inputs.begin();
        iter != inputs.end(); ++iter) {
     const DetailInput& input = *iter;
     bool editable = delegate_->InputIsEditable(input, section);
 
-    TextfieldMap::iterator text_mapping = group->textfields.find(&input);
+    TextfieldMap::iterator text_mapping = group->textfields.find(input.type);
     if (text_mapping != group->textfields.end()) {
       DecoratedTextfield* decorated = text_mapping->second;
       decorated->SetEditable(editable);
       continue;
     }
 
-    ComboboxMap::iterator combo_mapping = group->comboboxes.find(&input);
+    ComboboxMap::iterator combo_mapping = group->comboboxes.find(input.type);
     if (combo_mapping != group->comboboxes.end()) {
       views::Combobox* combobox = combo_mapping->second;
       combobox->SetEnabled(editable);
     }
   }
 }
 
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill