Rename AutofillDialogController to AutofillDialogViewDelegate.

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/strings/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/autofill/autofill_dialog_controller.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_sign_in_delegate.h"
+#include "chrome/browser/ui/autofill/autofill_dialog_view_delegate.h"
 #include "chrome/browser/ui/views/autofill/decorated_textfield.h"
 #include "chrome/browser/ui/views/constrained_window_views.h"
 #include "components/autofill/content/browser/wallet/wallet_service_url.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/web_modal/web_contents_modal_dialog_manager.h"
 #include "components/web_modal/web_contents_modal_dialog_manager_delegate.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
@@ skipping 460 matching lines @@
       (anchor_bounds.width() + bubble_bounds.width()) / 2);
   const int kErrorBubbleOverlap = 3;
   bubble_bounds.set_y(anchor_bounds.bottom() - kErrorBubbleOverlap);
 
   return bubble_bounds;
 }
 
 // AutofillDialogViews::AccountChooser -----------------------------------------
 
 AutofillDialogViews::AccountChooser::AccountChooser(
-    AutofillDialogController* controller)
+    AutofillDialogViewDelegate* delegate)
     : image_(new views::ImageView()),
       label_(new views::Label()),
       arrow_(new views::ImageView()),
       link_(new views::Link()),
-      controller_(controller) {
+      delegate_(delegate) {
   SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0,
                            kAroundTextPadding));
   AddChildView(image_);
   AddChildView(label_);
 
   arrow_->SetImage(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
       IDR_MENU_DROPARROW).ToImageSkia());
   AddChildView(arrow_);
 
   link_->set_listener(this);
   AddChildView(link_);
 }
 
 AutofillDialogViews::AccountChooser::~AccountChooser() {}
 
 void AutofillDialogViews::AccountChooser::Update() {
-  SetVisible(!controller_->ShouldShowSpinner());
+  SetVisible(!delegate_->ShouldShowSpinner());
 
-  gfx::Image icon = controller_->AccountChooserImage();
+  gfx::Image icon = delegate_->AccountChooserImage();
   image_->SetImage(icon.AsImageSkia());
-  label_->SetText(controller_->AccountChooserText());
+  label_->SetText(delegate_->AccountChooserText());
 
-  bool show_link = !controller_->MenuModelForAccountChooser();
+  bool show_link = !delegate_->MenuModelForAccountChooser();
   label_->SetVisible(!show_link);
   arrow_->SetVisible(!show_link);
-  link_->SetText(controller_->SignInLinkText());
+  link_->SetText(delegate_->SignInLinkText());
   link_->SetVisible(show_link);
 
   menu_runner_.reset();
 
   PreferredSizeChanged();
 }
 
 bool AutofillDialogViews::AccountChooser::OnMousePressed(
     const ui::MouseEvent& event) {
   // Return true so we get the release event.
-  if (controller_->MenuModelForAccountChooser())
+  if (delegate_->MenuModelForAccountChooser())
     return event.IsOnlyLeftMouseButton();
 
   return false;
 }
 
 void AutofillDialogViews::AccountChooser::OnMouseReleased(
     const ui::MouseEvent& event) {
   if (!HitTestPoint(event.location()))
     return;
 
-  ui::MenuModel* model = controller_->MenuModelForAccountChooser();
+  ui::MenuModel* model = delegate_->MenuModelForAccountChooser();
   if (!model)
     return;
 
   menu_runner_.reset(new views::MenuRunner(model));
   ignore_result(
       menu_runner_->RunMenuAt(GetWidget(),
                               NULL,
                               GetBoundsInScreen(),
                               views::MenuItemView::TOPRIGHT,
                               ui::MENU_SOURCE_MOUSE,
                               0));
 }
 
 void AutofillDialogViews::AccountChooser::LinkClicked(views::Link* source,
                                                       int event_flags) {
-  controller_->SignInLinkClicked();
+  delegate_->SignInLinkClicked();
 }
 
 // AutofillDialogViews::OverlayView --------------------------------------------
 
 AutofillDialogViews::OverlayView::OverlayView(views::ButtonListener* listener)
     : image_view_(new views::ImageView()),
       message_stack_(new views::View()),
       button_(new views::BlueButton(listener, base::string16())) {
   set_background(views::Background::CreateSolidBackground(GetNativeTheme()->
       GetSystemColor(ui::NativeTheme::kColorId_DialogBackground)));
@@ skipping 196 matching lines @@
   int bubble_width = 5;
   if (GetBubbleBorder())
     bubble_width = GetBubbleBorder()->GetBorderThickness();
   bounds.Inset(bubble_width, bubble_width, bubble_width, bubble_width);
   return bounds;
 }
 
 // AutofillDialogViews::NotificationArea ---------------------------------------
 
 AutofillDialogViews::NotificationArea::NotificationArea(
-    AutofillDialogController* controller)
-    : controller_(controller),
+    AutofillDialogViewDelegate* delegate)
+    : delegate_(delegate),
       checkbox_(NULL) {
   // Reserve vertical space for the arrow (regardless of whether one exists).
   // The -1 accounts for the border.
   set_border(views::Border::CreateEmptyBorder(kArrowHeight - 1, 0, 0, 0));
 
   views::BoxLayout* box_layout =
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0);
   SetLayoutManager(box_layout);
 }
 
@@ skipping 56 matching lines @@
 }
 
 void AutofillDialogViews::OnWidgetBoundsChanged(views::Widget* widget,
                                                 const gfx::Rect& new_bounds) {
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::NotificationArea::ButtonPressed(
     views::Button* sender, const ui::Event& event) {
   DCHECK_EQ(sender, checkbox_);
-  controller_->NotificationCheckboxStateChanged(notifications_.front().type(),
+  delegate_->NotificationCheckboxStateChanged(notifications_.front().type(),
                                                 checkbox_->checked());
 }
 
 bool AutofillDialogViews::NotificationArea::HasArrow() {
   return !notifications_.empty() && notifications_[0].HasArrow() &&
       arrow_centering_anchor_.get();
 }
 
 // AutofillDialogViews::SectionContainer ---------------------------------------
 
@@ skipping 220 matching lines @@
 
 gfx::Size AutofillDialogViews::AutocheckoutProgressBar::GetPreferredSize() {
   return gfx::Size(kAutocheckoutProgressBarWidth,
                    kAutocheckoutProgressBarHeight);
 }
 
 // AutofillDialogView ----------------------------------------------------------
 
 // static
 AutofillDialogView* AutofillDialogView::Create(
-    AutofillDialogController* controller) {
-  return new AutofillDialogViews(controller);
+    AutofillDialogViewDelegate* delegate) {
+  return new AutofillDialogViews(delegate);
 }
 
 // AutofillDialogViews ---------------------------------------------------------
 
-AutofillDialogViews::AutofillDialogViews(AutofillDialogController* controller)
-    : controller_(controller),
+AutofillDialogViews::AutofillDialogViews(AutofillDialogViewDelegate* delegate)
+    : delegate_(delegate),
       window_(NULL),
       notification_area_(NULL),
       account_chooser_(NULL),
       sign_in_webview_(NULL),
       scrollable_area_(NULL),
       details_container_(NULL),
       loading_shield_(NULL),
       overlay_view_(NULL),
       button_strip_extra_view_(NULL),
       save_in_chrome_checkbox_(NULL),
       button_strip_image_(NULL),
       autocheckout_steps_area_(NULL),
       autocheckout_progress_bar_view_(NULL),
       autocheckout_progress_bar_(NULL),
       footnote_view_(NULL),
       legal_document_view_(NULL),
       focus_manager_(NULL),
       observer_(this) {
-  DCHECK(controller);
+  DCHECK(delegate);
   detail_groups_.insert(std::make_pair(SECTION_EMAIL,
                                        DetailsGroup(SECTION_EMAIL)));
   detail_groups_.insert(std::make_pair(SECTION_CC,
                                        DetailsGroup(SECTION_CC)));
   detail_groups_.insert(std::make_pair(SECTION_BILLING,
                                        DetailsGroup(SECTION_BILLING)));
   detail_groups_.insert(std::make_pair(SECTION_CC_BILLING,
                                        DetailsGroup(SECTION_CC_BILLING)));
   detail_groups_.insert(std::make_pair(SECTION_SHIPPING,
                                        DetailsGroup(SECTION_SHIPPING)));
 }
 
 AutofillDialogViews::~AutofillDialogViews() {
   DCHECK(!window_);
 }
 
 void AutofillDialogViews::Show() {
   InitChildViews();
   UpdateAccountChooser();
   UpdateNotificationArea();
   UpdateButtonStripExtraView();
 
   // Ownership of |contents_| is handed off by this call. The widget will take
   // care of deleting itself after calling DeleteDelegate().
   WebContentsModalDialogManager* web_contents_modal_dialog_manager =
       WebContentsModalDialogManager::FromWebContents(
-          controller_->web_contents());
+          delegate_->web_contents());
   window_ = CreateWebContentsModalDialogViews(
       this,
-      controller_->web_contents()->GetView()->GetNativeView(),
+      delegate_->web_contents()->GetView()->GetNativeView(),
       web_contents_modal_dialog_manager->delegate()->
           GetWebContentsModalDialogHost());
   web_contents_modal_dialog_manager->ShowDialog(window_->GetNativeView());
   focus_manager_ = window_->GetFocusManager();
   focus_manager_->AddFocusChangeListener(this);
 
   // Listen for size changes on the browser.
   views::Widget* browser_widget =
       views::Widget::GetTopLevelWidgetForNativeView(
-          controller_->web_contents()->GetView()->GetNativeView());
+          delegate_->web_contents()->GetView()->GetNativeView());
   observer_.Add(browser_widget);
 
-  gfx::Image splash_image = controller_->SplashPageImage();
+  gfx::Image splash_image = delegate_->SplashPageImage();
   if (!splash_image.IsEmpty()) {
     DialogOverlayState state;
     state.image = splash_image;
     overlay_view_->SetState(state, NULL);
     overlay_view_->BeginFadeOut();
   }
 }
 
 void AutofillDialogViews::Hide() {
   if (window_)
     window_->Close();
 }
 
 void AutofillDialogViews::UpdateAccountChooser() {
   account_chooser_->Update();
   // TODO(estade): replace this with a better loading image/animation.
   // See http://crbug.com/230932
-  base::string16 new_loading_message = (controller_->ShouldShowSpinner() ?
+  base::string16 new_loading_message = (delegate_->ShouldShowSpinner() ?
       ASCIIToUTF16("Loading...") : base::string16());
   if (new_loading_message != loading_shield_->text()) {
     loading_shield_->SetText(new_loading_message);
     loading_shield_->SetVisible(!new_loading_message.empty());
     Layout();
   }
 
   // Update legal documents for the account.
   if (footnote_view_) {
-    const base::string16 text = controller_->LegalDocumentsText();
+    const base::string16 text = delegate_->LegalDocumentsText();
     legal_document_view_->SetText(text);
 
     if (!text.empty()) {
       const std::vector<ui::Range>& link_ranges =
-          controller_->LegalDocumentLinks();
+          delegate_->LegalDocumentLinks();
       for (size_t i = 0; i < link_ranges.size(); ++i) {
         legal_document_view_->AddStyleRange(
             link_ranges[i],
             views::StyledLabel::RangeStyleInfo::CreateForLink());
       }
     }
 
     footnote_view_->SetVisible(!text.empty());
     ContentsPreferredSizeChanged();
   }
 }
 
 void AutofillDialogViews::UpdateAutocheckoutStepsArea() {
-  autocheckout_steps_area_->SetSteps(controller_->CurrentAutocheckoutSteps());
+  autocheckout_steps_area_->SetSteps(delegate_->CurrentAutocheckoutSteps());
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::UpdateButtonStrip() {
   button_strip_extra_view_->SetVisible(
       GetDialogButtons() != ui::DIALOG_BUTTON_NONE);
   UpdateButtonStripExtraView();
   GetDialogClientView()->UpdateDialogButtons();
 
-  overlay_view_->SetState(controller_->GetDialogOverlay(), this);
+  overlay_view_->SetState(delegate_->GetDialogOverlay(), this);
 
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::UpdateDetailArea() {
-  scrollable_area_->SetVisible(controller_->ShouldShowDetailArea());
+  scrollable_area_->SetVisible(delegate_->ShouldShowDetailArea());
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::UpdateForErrors() {
   ValidateForm();
 }
 
 void AutofillDialogViews::UpdateNotificationArea() {
   DCHECK(notification_area_);
-  notification_area_->SetNotifications(controller_->CurrentNotifications());
+  notification_area_->SetNotifications(delegate_->CurrentNotifications());
   ContentsPreferredSizeChanged();
 }
 
 void AutofillDialogViews::UpdateSection(DialogSection section) {
   UpdateSectionImpl(section, true);
 }
 
 void AutofillDialogViews::FillSection(DialogSection section,
                                       const DetailInput& originating_input) {
   DetailsGroup* group = GroupForSection(section);
@@ skipping 26 matching lines @@
     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())));
   }
 }
 
 base::string16 AutofillDialogViews::GetCvc() {
-  DialogSection billing_section = controller_->SectionIsActive(SECTION_CC) ?
+  DialogSection billing_section = delegate_->SectionIsActive(SECTION_CC) ?
       SECTION_CC : SECTION_CC_BILLING;
   return GroupForSection(billing_section)->suggested_info->
       decorated_textfield()->text();
 }
 
 bool AutofillDialogViews::SaveDetailsLocally() {
   DCHECK(save_in_chrome_checkbox_->visible());
   return save_in_chrome_checkbox_->checked();
 }
 
@@ skipping 125 matching lines @@
   gfx::Size preferred_size;
   // When the scroll area isn't visible, it still sets the width but doesn't
   // factor into height.
   if (!scrollable_area_->visible()) {
     preferred_size.SetSize(width, base_height);
   } else {
     // Show as much of the scroll view as is possible without going past the
     // bottom of the browser window.
     views::Widget* widget =
         views::Widget::GetTopLevelWidgetForNativeView(
-            controller_->web_contents()->GetView()->GetNativeView());
+            delegate_->web_contents()->GetView()->GetNativeView());
     int browser_window_height =
         widget ? widget->GetContentsView()->bounds().height() : INT_MAX;
     const int kWindowDecorationHeight = 200;
     int height = base_height + std::min(
         scroll_size.height(),
         std::max(kMinimumContentsHeight,
                  browser_window_height - base_height -
                      kWindowDecorationHeight));
     preferred_size.SetSize(width, height);
   }
@@ skipping 47 matching lines @@
 
   if (error_bubble_)
     error_bubble_->UpdatePosition();
 }
 
 void AutofillDialogViews::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   sign_in_delegate_->SetMinWidth(GetContentsBounds().width());
 }
 
 base::string16 AutofillDialogViews::GetWindowTitle() const {
-  return controller_->DialogTitle();
+  return delegate_->DialogTitle();
 }
 
 void AutofillDialogViews::WindowClosing() {
   focus_manager_->RemoveFocusChangeListener(this);
 }
 
 void AutofillDialogViews::DeleteDelegate() {
   window_ = NULL;
-  // |this| belongs to |controller_|.
-  controller_->ViewClosed();
+  // |this| belongs to the controller (|delegate_|).
+  delegate_->ViewClosed();
 }
 
 int AutofillDialogViews::GetDialogButtons() const {
   if (sign_in_webview_->visible())
     return ui::DIALOG_BUTTON_NONE;
 
-  return controller_->GetDialogButtons();
+  return delegate_->GetDialogButtons();
 }
 
 base::string16 AutofillDialogViews::GetDialogButtonLabel(
     ui::DialogButton button) const {
   return button == ui::DIALOG_BUTTON_OK ?
-      controller_->ConfirmButtonText() : controller_->CancelButtonText();
+      delegate_->ConfirmButtonText() : delegate_->CancelButtonText();
 }
 
 bool AutofillDialogViews::ShouldDefaultButtonBeBlue() const {
   return true;
 }
 
 bool AutofillDialogViews::IsDialogButtonEnabled(ui::DialogButton button) const {
-  return controller_->IsDialogButtonEnabled(button);
+  return delegate_->IsDialogButtonEnabled(button);
 }
 
 views::View* AutofillDialogViews::CreateExtraView() {
   return button_strip_extra_view_;
 }
 
 views::View* AutofillDialogViews::CreateTitlebarExtraView() {
   return account_chooser_;
 }
 
@@ skipping 18 matching lines @@
   footnote_view_->SetVisible(false);
 
   return footnote_view_;
 }
 
 views::View* AutofillDialogViews::CreateOverlayView() {
   return overlay_view_;
 }
 
 bool AutofillDialogViews::Cancel() {
-  return controller_->OnCancel();
+  return delegate_->OnCancel();
 }
 
 bool AutofillDialogViews::Accept() {
   if (ValidateForm())
-    return controller_->OnAccept();
+    return delegate_->OnAccept();
 
   if (!validity_map_.empty())
     validity_map_.begin()->first->RequestFocus();
   return false;
 }
 
 // TODO(wittman): Remove this override once we move to the new style frame view
 // on all dialogs.
 views::NonClientFrameView* AutofillDialogViews::CreateNonClientFrameView(
     views::Widget* widget) {
   return CreateConstrainedStyleNonClientFrameView(
       widget,
-      controller_->web_contents()->GetBrowserContext());
+      delegate_->web_contents()->GetBrowserContext());
 }
 
 void AutofillDialogViews::ButtonPressed(views::Button* sender,
                                         const ui::Event& event) {
   if (sender->GetAncestorWithClassName(kOverlayViewClassName)) {
-    controller_->OverlayButtonPressed();
+    delegate_->OverlayButtonPressed();
     return;
   }
 
   // TODO(estade): Should the menu be shown on mouse down?
   DetailsGroup* group = NULL;
   for (DetailGroupMap::iterator iter = detail_groups_.begin();
        iter != detail_groups_.end(); ++iter) {
     if (sender == iter->second.suggested_button) {
       group = &iter->second;
       break;
     }
   }
   DCHECK(group);
 
   if (!group->suggested_button->visible())
     return;
 
   menu_runner_.reset(new views::MenuRunner(
-                         controller_->MenuModelForSection(group->section)));
+                         delegate_->MenuModelForSection(group->section)));
 
   group->container->SetActive(true);
   views::Button::ButtonState state = group->suggested_button->state();
   group->suggested_button->SetState(views::Button::STATE_PRESSED);
   // Ignore the result since we don't need to handle a deleted menu specially.
   gfx::Rect bounds = group->suggested_button->GetBoundsInScreen();
   bounds.Inset(group->suggested_button->GetInsets());
   ignore_result(
       menu_runner_->RunMenuAt(sender->GetWidget(),
                               NULL,
@@ skipping 11 matching lines @@
 }
 
 bool AutofillDialogViews::HandleKeyEvent(views::Textfield* sender,
                                          const ui::KeyEvent& key_event) {
   scoped_ptr<ui::KeyEvent> copy(key_event.Copy());
 #if defined(OS_WIN) && !defined(USE_AURA)
   content::NativeWebKeyboardEvent event(copy->native_event());
 #else
   content::NativeWebKeyboardEvent event(copy.get());
 #endif
-  return controller_->HandleKeyPressEventInInput(event);
+  return delegate_->HandleKeyPressEventInInput(event);
 }
 
 bool AutofillDialogViews::HandleMouseEvent(views::Textfield* sender,
                                            const ui::MouseEvent& mouse_event) {
   if (mouse_event.IsLeftMouseButton() && sender->HasFocus()) {
     TextfieldEditedOrActivated(sender, false);
     // Show an error bubble if a user clicks on an input that's already focused
     // (and invalid).
     ShowErrorBubbleForViewIfNecessary(sender);
   }
 
   return false;
 }
 
 void AutofillDialogViews::OnWillChangeFocus(
     views::View* focused_before,
     views::View* focused_now) {
-  controller_->FocusMoved();
+  delegate_->FocusMoved();
   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, VALIDATE_EDIT);
   }
 
   // Show an error bubble when the user focuses the input.
   if (focused_now)
     ShowErrorBubbleForViewIfNecessary(focused_now);
 }
 
 void AutofillDialogViews::OnSelectedIndexChanged(views::Combobox* combobox) {
   DetailsGroup* group = GroupForView(combobox);
   ValidateGroup(*group, VALIDATE_EDIT);
 }
 
 void AutofillDialogViews::StyledLabelLinkClicked(const ui::Range& range,
                                                  int event_flags) {
-  controller_->LegalDocumentLinkClicked(range);
+  delegate_->LegalDocumentLinkClicked(range);
 }
 
 void AutofillDialogViews::InitChildViews() {
   button_strip_extra_view_ = new LayoutPropagationView();
   button_strip_extra_view_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
 
   save_in_chrome_checkbox_ =
-      new views::Checkbox(controller_->SaveLocallyText());
+      new views::Checkbox(delegate_->SaveLocallyText());
   save_in_chrome_checkbox_->SetChecked(true);
   button_strip_extra_view_->AddChildView(save_in_chrome_checkbox_);
 
   button_strip_image_ = new views::ImageView();
   button_strip_extra_view_->AddChildView(button_strip_image_);
 
   autocheckout_progress_bar_view_ = new views::View();
   views::GridLayout* progress_bar_layout =
       new views::GridLayout(autocheckout_progress_bar_view_);
   autocheckout_progress_bar_view_->SetLayoutManager(progress_bar_layout);
   const int kColumnSetId = 0;
   views::ColumnSet* columns = progress_bar_layout->AddColumnSet(kColumnSetId);
   columns->AddColumn(views::GridLayout::LEADING,
                      views::GridLayout::CENTER,
                      0,
                      views::GridLayout::USE_PREF,
                      0,
                      0);
   progress_bar_layout->StartRow(1.0, kColumnSetId);
 
   autocheckout_progress_bar_ = new AutocheckoutProgressBar();
   progress_bar_layout->AddView(autocheckout_progress_bar_);
   button_strip_extra_view_->AddChildView(autocheckout_progress_bar_view_);
 
-  account_chooser_ = new AccountChooser(controller_);
-  notification_area_ = new NotificationArea(controller_);
+  account_chooser_ = new AccountChooser(delegate_);
+  notification_area_ = new NotificationArea(delegate_);
   notification_area_->set_arrow_centering_anchor(account_chooser_->AsWeakPtr());
   AddChildView(notification_area_);
 
   scrollable_area_ = new views::ScrollView();
   scrollable_area_->set_hide_horizontal_scrollbar(true);
   scrollable_area_->SetContents(CreateDetailsContainer());
   AddChildView(scrollable_area_);
 
   autocheckout_steps_area_ = new AutocheckoutStepsArea();
   AddChildView(autocheckout_steps_area_);
 
   loading_shield_ = new views::Label();
   loading_shield_->SetVisible(false);
   loading_shield_->set_background(views::Background::CreateSolidBackground(
       GetNativeTheme()->GetSystemColor(
           ui::NativeTheme::kColorId_DialogBackground)));
   loading_shield_->SetFont(ui::ResourceBundle::GetSharedInstance().GetFont(
       ui::ResourceBundle::BaseFont).DeriveFont(15));
   AddChildView(loading_shield_);
 
-  sign_in_webview_ = new views::WebView(controller_->profile());
+  sign_in_webview_ = new views::WebView(delegate_->profile());
   sign_in_webview_->SetVisible(false);
   AddChildView(sign_in_webview_);
   sign_in_delegate_.reset(
       new AutofillDialogSignInDelegate(this,
                                        sign_in_webview_->GetWebContents()));
 
   overlay_view_ = new OverlayView(this);
   overlay_view_->SetVisible(false);
 }
 
@@ skipping 13 matching lines @@
   return details_container_;
 }
 
 void AutofillDialogViews::CreateDetailsSection(DialogSection section) {
   // Inputs container (manual inputs + combobox).
   views::View* inputs_container = CreateInputsContainer(section);
 
   DetailsGroup* group = GroupForSection(section);
   // Container (holds label + inputs).
   group->container = new SectionContainer(
-      controller_->LabelForSection(section),
+      delegate_->LabelForSection(section),
       inputs_container,
       group->suggested_button);
   DCHECK(group->suggested_button->parent());
   UpdateDetailsGroupState(*group);
 }
 
 views::View* AutofillDialogViews::CreateInputsContainer(DialogSection section) {
   // The |info_view| holds |manual_inputs| and |suggested_info|, allowing the
   // dialog to toggle which is shown.
   views::View* info_view = new views::View();
   info_view->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
 
   views::View* manual_inputs = InitInputsView(section);
   info_view->AddChildView(manual_inputs);
   SuggestionView* suggested_info =
-      new SuggestionView(controller_->EditSuggestionText(), this);
+      new SuggestionView(delegate_->EditSuggestionText(), this);
   info_view->AddChildView(suggested_info);
 
   // TODO(estade): It might be slightly more OO if this button were created
   // and listened to by the section container.
   views::ImageButton* menu_button = new views::ImageButton(this);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   menu_button->SetImage(views::Button::STATE_NORMAL,
       rb.GetImageSkiaNamed(IDR_AUTOFILL_DIALOG_MENU_BUTTON));
   menu_button->SetImage(views::Button::STATE_PRESSED,
       rb.GetImageSkiaNamed(IDR_AUTOFILL_DIALOG_MENU_BUTTON_P));
@@ skipping 10 matching lines @@
   DetailsGroup* group = GroupForSection(section);
   group->suggested_button = menu_button;
   group->manual_input = manual_inputs;
   group->suggested_info = suggested_info;
   return info_view;
 }
 
 // TODO(estade): we should be using Chrome-style constrained window padding
 // values.
 views::View* AutofillDialogViews::InitInputsView(DialogSection section) {
-  const DetailInputs& inputs = controller_->RequestedFieldsForSection(section);
+  const DetailInputs& inputs = delegate_->RequestedFieldsForSection(section);
   TextfieldMap* textfields = &GroupForSection(section)->textfields;
   ComboboxMap* comboboxes = &GroupForSection(section)->comboboxes;
 
   views::View* view = new views::View();
   views::GridLayout* layout = new views::GridLayout(view);
   view->SetLayoutManager(layout);
 
   for (DetailInputs::const_iterator it = inputs.begin();
        it != inputs.end(); ++it) {
     const DetailInput& input = *it;
     ui::ComboboxModel* input_model =
-        controller_->ComboboxModelForAutofillType(input.type);
+        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));
 
       for (int i = 0; i < input_model->GetItemCount(); ++i) {
         if (input.initial_value == input_model->GetItemAt(i)) {
           combobox->SetSelectedIndex(i);
           break;
         }
       }
 
       view_to_add.reset(combobox);
     } 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);
+          delegate_->IconForField(input.type, input.initial_value);
       field->SetIcon(icon);
 
       textfields->insert(std::make_pair(&input, field));
       view_to_add.reset(field);
     }
 
     int kColumnSetId = input.row_id;
     if (kColumnSetId < 0) {
       other_owned_views_.push_back(view_to_add.release());
       continue;
@@ skipping 30 matching lines @@
                     1, 0);
   }
 
   return view;
 }
 
 void AutofillDialogViews::UpdateSectionImpl(
     DialogSection section,
     bool clobber_inputs) {
   const DetailInputs& updated_inputs =
-      controller_->RequestedFieldsForSection(section);
+      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);
 
     if (text_mapping != group->textfields.end()) {
       DecoratedTextfield* decorated = text_mapping->second;
       decorated->SetEnabled(input.editable);
       if (decorated->text().empty() || clobber_inputs) {
         decorated->SetText(iter->initial_value);
         decorated->SetIcon(
-            controller_->IconForField(input.type, decorated->text()));
+            delegate_->IconForField(input.type, decorated->text()));
       }
     }
 
     ComboboxMap::iterator combo_mapping = group->comboboxes.find(&input);
     if (combo_mapping != group->comboboxes.end()) {
       views::Combobox* combobox = combo_mapping->second;
       combobox->SetEnabled(input.editable);
       if (combobox->selected_index() == combobox->model()->GetDefaultIndex() ||
           clobber_inputs) {
         for (int i = 0; i < combobox->model()->GetItemCount(); ++i) {
           if (input.initial_value == combobox->model()->GetItemAt(i)) {
             combobox->SetSelectedIndex(i);
             break;
           }
         }
       }
     }
   }
 
   UpdateDetailsGroupState(*group);
 }
 
 void AutofillDialogViews::UpdateDetailsGroupState(const DetailsGroup& group) {
   const SuggestionState& suggestion_state =
-      controller_->SuggestionStateForSection(group.section);
+      delegate_->SuggestionStateForSection(group.section);
   bool show_suggestions = !suggestion_state.text.empty();
   group.suggested_info->SetVisible(show_suggestions);
   group.suggested_info->SetSuggestionText(suggestion_state.text,
                                           suggestion_state.text_style);
   group.suggested_info->SetSuggestionIcon(suggestion_state.icon);
 
   if (!suggestion_state.extra_text.empty()) {
     group.suggested_info->ShowTextfield(
         suggestion_state.extra_text,
         suggestion_state.extra_icon);
   }
 
   group.manual_input->SetVisible(!show_suggestions);
 
   UpdateButtonStripExtraView();
 
-  const bool has_menu = !!controller_->MenuModelForSection(group.section);
+  const bool has_menu = !!delegate_->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));
+    group.container->SetVisible(delegate_->SectionIsActive(group.section));
     if (group.container->visible())
       ValidateGroup(group, VALIDATE_EDIT);
   }
 
   ContentsPreferredSizeChanged();
 }
 
 template<class T>
 void AutofillDialogViews::SetValidityForInput(
     T* input,
@@ skipping 113 matching lines @@
       detail_outputs[iter->first] = item;
     }
   } 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->text();
   }
 
-  ValidityData invalid_inputs = controller_->InputsAreValid(
+  ValidityData invalid_inputs = delegate_->InputsAreValid(
       group.section, detail_outputs, validation_type);
   MarkInputsInvalid(group.section, invalid_inputs);
 
   return invalid_inputs.empty();
 }
 
 bool AutofillDialogViews::ValidateForm() {
   bool all_valid = true;
   validity_map_.clear();
 
@@ skipping 19 matching lines @@
   // Figure out the AutofillFieldType this textfield represents.
   AutofillFieldType type = UNKNOWN_TYPE;
   DecoratedTextfield* decorated = NULL;
 
   // 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) {
-      controller_->UserEditedOrActivatedInput(group->section,
+      delegate_->UserEditedOrActivatedInput(group->section,
                                               iter->first,
                                               GetWidget()->GetNativeView(),
                                               textfield->GetBoundsInScreen(),
                                               textfield->text(),
                                               was_edit);
       type = iter->first->type;
       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<DecoratedTextfield>(
         decorated,
-        controller_->InputValidityMessage(group->section, type,
+        delegate_->InputValidityMessage(group->section, 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, VALIDATE_EDIT);
   }
 
-  gfx::Image icon = controller_->IconForField(type, textfield->text());
+  gfx::Image icon = delegate_->IconForField(type, textfield->text());
   decorated->SetIcon(icon);
 }
 
 void AutofillDialogViews::UpdateButtonStripExtraView() {
   save_in_chrome_checkbox_->SetVisible(
-      controller_->ShouldOfferToSaveInChrome());
+      delegate_->ShouldOfferToSaveInChrome());
 
-  gfx::Image image = controller_->ButtonStripImage();
+  gfx::Image image = delegate_->ButtonStripImage();
   button_strip_image_->SetVisible(!image.IsEmpty());
   button_strip_image_->SetImage(image.AsImageSkia());
 
   autocheckout_progress_bar_view_->SetVisible(
-      controller_->ShouldShowProgressBar());
+      delegate_->ShouldShowProgressBar());
 }
 
 void AutofillDialogViews::ContentsPreferredSizeChanged() {
   if (GetWidget()) {
     GetWidget()->SetSize(GetWidget()->non_client_view()->GetPreferredSize());
     // If the above line does not cause the dialog's size to change, |contents_|
     // may not be laid out. This will trigger a layout only if it's needed.
     SetBoundsRect(bounds());
   }
 }
@@ skipping 61 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