Highlight fields we know to be invalid but have no way of locally checking.

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 1231 matching lines @@
   error_bubble_.reset();
 }
 
 void AutofillDialogViews::OnDidChangeFocus(
     views::View* focused_before,
     views::View* focused_now) {
   // If user leaves an edit-field, revalidate the group it belongs to.
   if (focused_before) {
     DetailsGroup* group = GroupForView(focused_before);
     if (group && group->container->visible())
-      ValidateGroup(*group, AutofillDialogController::VALIDATE_EDIT);
+      ValidateGroup(*group, VALIDATE_EDIT);
   }
 
   // Show an error bubble when the user focuses the input.
   if (focused_now)
     ShowErrorBubbleForViewIfNecessary(focused_now);
 }
 
 void AutofillDialogViews::LinkClicked(views::Link* source, int event_flags) {
   // Edit links.
   for (DetailGroupMap::iterator iter = detail_groups_.begin();
        iter != detail_groups_.end(); ++iter) {
     if (iter->second.suggested_info->Contains(source)) {
       controller_->EditClickedForSection(iter->first);
       return;
     }
   }
 }
 
 void AutofillDialogViews::OnSelectedIndexChanged(views::Combobox* combobox) {
   DetailsGroup* group = GroupForView(combobox);
-  ValidateGroup(*group, AutofillDialogController::VALIDATE_EDIT);
+  ValidateGroup(*group, VALIDATE_EDIT);
 }
 
 void AutofillDialogViews::StyledLabelLinkClicked(const ui::Range& range,
                                                  int event_flags) {
   controller_->LegalDocumentLinkClicked(range);
 }
 
 void AutofillDialogViews::InitChildViews() {
   button_strip_extra_view_ = new ButtonStripView();
   button_strip_extra_view_->SetLayoutManager(
@@ skipping 273 matching lines @@
 
   const bool has_menu = !!controller_->MenuModelForSection(group.section);
 
   if (group.suggested_button)
     group.suggested_button->SetVisible(has_menu);
 
   if (group.container) {
     group.container->SetForwardMouseEvents(has_menu && show_suggestions);
     group.container->SetVisible(controller_->SectionIsActive(group.section));
     if (group.container->visible())
-      ValidateGroup(group, AutofillDialogController::VALIDATE_EDIT);
+      ValidateGroup(group, VALIDATE_EDIT);
   }
 
   ContentsPreferredSizeChanged();
 }
 
 template<class T>
 void AutofillDialogViews::SetValidityForInput(
     T* input,
     const string16& message) {
   bool invalid = !message.empty();
@@ skipping 22 matching lines @@
 
   if (error_bubble_ && error_bubble_->anchor() == input)
     return;
 
   std::map<views::View*, string16>::iterator error_message =
       validity_map_.find(input);
   if (error_message != validity_map_.end())
     error_bubble_.reset(new ErrorBubble(input, error_message->second));
 }
 
-bool AutofillDialogViews::ValidateGroup(
-    const DetailsGroup& group,
-    AutofillDialogController::ValidationType validation_type) {
+bool AutofillDialogViews::ValidateGroup(const DetailsGroup& group,
+                                        ValidationType validation_type) {
   DCHECK(group.container->visible());
 
   scoped_ptr<DetailInput> cvc_input;
   DetailOutputMap detail_outputs;
   typedef std::map<AutofillFieldType, base::Callback<void(const string16&)> >
       FieldMap;
   FieldMap field_map;
 
   if (group.manual_input->visible()) {
     for (TextfieldMap::const_iterator iter = group.textfields.begin();
@@ skipping 53 matching lines @@
 }
 
 bool AutofillDialogViews::ValidateForm() {
   bool all_valid = true;
   for (DetailGroupMap::iterator iter = detail_groups_.begin();
        iter != detail_groups_.end(); ++iter) {
     const DetailsGroup& group = iter->second;
     if (!group.container->visible())
       continue;
 
-    if (!ValidateGroup(group, AutofillDialogController::VALIDATE_FINAL))
+    if (!ValidateGroup(group, VALIDATE_FINAL))
       all_valid = false;
   }
 
   return all_valid;
 }
 
 void AutofillDialogViews::TextfieldEditedOrActivated(
     views::Textfield* textfield,
     bool was_edit) {
   DetailsGroup* group = GroupForView(textfield);
@@ skipping 33 matching lines @@
   // correcting a minor mistake (i.e. a wrong CC digit) should immediately
   // result in validation - positive user feedback.
   if (decorated->invalid() && was_edit) {
     SetValidityForInput<DecoratedTextfield>(
         decorated,
         controller_->InputValidityMessage(type, textfield->text()));
 
     // 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, AutofillDialogController::VALIDATE_EDIT);
+      ValidateGroup(*group, VALIDATE_EDIT);
   }
 
   gfx::Image icon = controller_->IconForField(type, textfield->text());
   textfield->SetIcon(icon.AsImageSkia());
 }
 
 void AutofillDialogViews::UpdateSaveInChromeCheckbox() {
   save_in_chrome_checkbox_->SetVisible(
       controller_->ShouldOfferToSaveInChrome());
 }
@@ skipping 75 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