Merge NativeTextfieldViews into views::Textfield.

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 1325 matching lines @@
   }
 
   UpdateSectionImpl(section, false);
 }
 
 void AutofillDialogViews::GetUserInput(DialogSection section,
                                        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()));
+    output->insert(std::make_pair(it->first, it->second->GetText()));
   }
   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())));
   }
 }
 
 base::string16 AutofillDialogViews::GetCvc() {
   return GroupForSection(GetCreditCardSection())->suggested_info->
-      decorated_textfield()->text();
+      decorated_textfield()->GetText();
 }
 
 bool AutofillDialogViews::HitTestInput(const DetailInput& input,
                                        const gfx::Point& screen_point) {
   views::View* view = TextfieldForType(input.type);
   if (!view)
     view = ComboboxForType(input.type);
 
   if (view) {
     gfx::Point target_point(screen_point);
@@ skipping 71 matching lines @@
 }
 
 void AutofillDialogViews::CancelForTesting() {
   GetDialogClientView()->CancelWindow();
 }
 
 base::string16 AutofillDialogViews::GetTextContentsOfInput(
     const DetailInput& input) {
   views::Textfield* textfield = TextfieldForType(input.type);
   if (textfield)
-    return textfield->text();
+    return textfield->GetText();
 
   views::Combobox* combobox = ComboboxForType(input.type);
   if (combobox)
     return combobox->model()->GetItemAt(combobox->selected_index());
 
   NOTREACHED();
   return base::string16();
 }
 
 void AutofillDialogViews::SetTextContentsOfInput(
@@ skipping 590 matching lines @@
       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.type);
 
     if (text_mapping != group->textfields.end()) {
       DecoratedTextfield* decorated = text_mapping->second;
-      if (decorated->text().empty() || clobber_inputs)
+      if (decorated->GetText().empty() || clobber_inputs)
         decorated->SetText(input.initial_value);
     }
 
     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);
       }
@@ skipping 137 matching lines @@
   DCHECK(group.container->visible());
 
   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();
+      detail_outputs[iter->first] = iter->second->GetText();
     }
     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())
-      detail_outputs[CREDIT_CARD_VERIFICATION_CODE] = decorated_cvc->text();
+      detail_outputs[CREDIT_CARD_VERIFICATION_CODE] = decorated_cvc->GetText();
   }
 
   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 27 matching lines @@
   // Look for the input in the manual inputs.
   for (TextfieldMap::const_iterator iter = group->textfields.begin();
        iter != group->textfields.end();
        ++iter) {
     decorated = iter->second;
     if (decorated == textfield) {
       delegate_->UserEditedOrActivatedInput(group->section,
                                             iter->first,
                                             GetWidget()->GetNativeView(),
                                             textfield->GetBoundsInScreen(),
-                                            textfield->text(),
+                                            textfield->GetText(),
                                             was_edit);
       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);
 
   // If the field is marked as invalid, check if the text is now valid.
   // Many fields (i.e. CC#) are invalid for most of the duration of editing,
   // so flagging them as invalid prematurely is not helpful. However,
   // correcting a minor mistake (i.e. a wrong CC digit) should immediately
   // result in validation - positive user feedback.
   if (decorated->invalid() && was_edit) {
     SetValidityForInput(
         decorated,
         delegate_->InputValidityMessage(group->section, type,
-                                        textfield->text()));
+                                        textfield->GetText()));
 
     // If the field transitioned from invalid to valid, re-validate the group,
     // since inter-field checks become meaningful with valid fields.
     if (!decorated->invalid())
       ValidateGroup(*group, VALIDATE_EDIT);
   }
 
   if (delegate_->FieldControlsIcons(type))
     SetIconsForSection(group->section);
 
@@ skipping 133 matching lines @@
 AutofillDialogViews::DetailsGroup::DetailsGroup(DialogSection section)
     : section(section),
       container(NULL),
       manual_input(NULL),
       suggested_info(NULL),
       suggested_button(NULL) {}
 
 AutofillDialogViews::DetailsGroup::~DetailsGroup() {}
 
 }  // namespace autofill