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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_UI_VIEWS_AUTOFILL_AUTOFILL_DIALOG_VIEWS_H_
   6 #define CHROME_BROWSER_UI_VIEWS_AUTOFILL_AUTOFILL_DIALOG_VIEWS_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/memory/scoped_vector.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/scoped_observer.h"
  14 #include "chrome/browser/ui/autofill/autofill_dialog_types.h"
  15 #include "chrome/browser/ui/autofill/autofill_dialog_view.h"
  16 #include "chrome/browser/ui/autofill/autofill_dialog_view_delegate.h"
  17 #include "ui/views/controls/button/button.h"
  18 #include "ui/views/controls/button/menu_button.h"
  19 #include "ui/views/controls/button/menu_button_listener.h"
  20 #include "ui/views/controls/combobox/combobox_listener.h"
  21 #include "ui/views/controls/link_listener.h"
  22 #include "ui/views/controls/progress_bar.h"
  23 #include "ui/views/controls/scroll_view.h"
  24 #include "ui/views/controls/styled_label_listener.h"
  25 #include "ui/views/controls/textfield/textfield_controller.h"
  26 #include "ui/views/focus/focus_manager.h"
  27 #include "ui/views/view_targeter_delegate.h"
  28 #include "ui/views/widget/widget_observer.h"
  29 #include "ui/views/window/dialog_delegate.h"
  30
  31 namespace gfx {
  32 class Image;
  33 }
  34
  35 namespace views {
  36 class BubbleBorder;
  37 class Checkbox;
  38 class Combobox;
  39 class FocusManager;
  40 class ImageView;
  41 class Label;
  42 class LabelButton;
  43 class Link;
  44 class MenuRunner;
  45 class StyledLabel;
  46 class WebView;
  47 class Widget;
  48 }  // namespace views
  49
  50 namespace ui {
  51 class ComboboxModel;
  52 class EventHandler;
  53 class KeyEvent;
  54 }
  55
  56 namespace autofill {
  57
  58 class AutofillDialogSignInDelegate;
  59 class ExpandingTextfield;
  60 class InfoBubble;
  61
  62 // Views toolkit implementation of the Autofill dialog that handles the
  63 // imperative autocomplete API call.
  64 class AutofillDialogViews : public AutofillDialogView,
  65                             public views::DialogDelegateView,
  66                             public views::WidgetObserver,
  67                             public views::TextfieldController,
  68                             public views::FocusChangeListener,
  69                             public views::ComboboxListener,
  70                             public views::StyledLabelListener,
  71                             public views::MenuButtonListener {
  72  public:
  73   explicit AutofillDialogViews(AutofillDialogViewDelegate* delegate);
  74   ~AutofillDialogViews() override;
  75
  76   // AutofillDialogView implementation:
  77   void Show() override;
  78   void Hide() override;
  79   void UpdatesStarted() override;
  80   void UpdatesFinished() override;
  81   void UpdateAccountChooser() override;
  82   void UpdateButtonStrip() override;
  83   void UpdateOverlay() override;
  84   void UpdateDetailArea() override;
  85   void UpdateForErrors() override;
  86   void UpdateNotificationArea() override;
  87   void UpdateSection(DialogSection section) override;
  88   void UpdateErrorBubble() override;
  89   void FillSection(DialogSection section,
  90                    ServerFieldType originating_type) override;
  91   void GetUserInput(DialogSection section, FieldValueMap* output) override;
  92   base::string16 GetCvc() override;
  93   bool SaveDetailsLocally() override;
  94   const content::NavigationController* ShowSignIn(const GURL& url) override;
  95   void HideSignIn() override;
  96   void ModelChanged() override;
  97   void OnSignInResize(const gfx::Size& pref_size) override;
  98   void ValidateSection(DialogSection section) override;
  99
 100   // views::View implementation.
 101   gfx::Size GetPreferredSize() const override;
 102   gfx::Size GetMinimumSize() const override;
 103   void Layout() override;
 104   void OnNativeThemeChanged(const ui::NativeTheme* theme) override;
 105
 106   // views::DialogDelegate implementation:
 107   ui::ModalType GetModalType() const override;
 108   base::string16 GetWindowTitle() const override;
 109   void WindowClosing() override;
 110   void DeleteDelegate() override;
 111   views::View* CreateOverlayView() override;
 112   int GetDialogButtons() const override;
 113   int GetDefaultDialogButton() const override;
 114   base::string16 GetDialogButtonLabel(ui::DialogButton button) const override;
 115   bool ShouldDefaultButtonBeBlue() const override;
 116   bool IsDialogButtonEnabled(ui::DialogButton button) const override;
 117   views::View* GetInitiallyFocusedView() override;
 118   views::View* CreateExtraView() override;
 119   views::View* CreateTitlebarExtraView() override;
 120   views::View* CreateFootnoteView() override;
 121   bool Cancel() override;
 122   bool Accept() override;
 123
 124   // views::WidgetObserver implementation:
 125   void OnWidgetClosing(views::Widget* widget) override;
 126   void OnWidgetDestroying(views::Widget* widget) override;
 127   void OnWidgetBoundsChanged(views::Widget* widget,
 128                              const gfx::Rect& new_bounds) override;
 129
 130   // views::TextfieldController implementation:
 131   void ContentsChanged(views::Textfield* sender,
 132                        const base::string16& new_contents) override;
 133   bool HandleKeyEvent(views::Textfield* sender,
 134                       const ui::KeyEvent& key_event) override;
 135   bool HandleMouseEvent(views::Textfield* sender,
 136                         const ui::MouseEvent& key_event) override;
 137
 138   // views::FocusChangeListener implementation.
 139   void OnWillChangeFocus(views::View* focused_before,
 140                          views::View* focused_now) override;
 141   void OnDidChangeFocus(views::View* focused_before,
 142                         views::View* focused_now) override;
 143
 144   // views::ComboboxListener implementation:
 145   void OnPerformAction(views::Combobox* combobox) override;
 146
 147   // views::StyledLabelListener implementation:
 148   void StyledLabelLinkClicked(const gfx::Range& range,
 149                               int event_flags) override;
 150
 151   // views::MenuButtonListener implementation.
 152   void OnMenuButtonClicked(views::View* source,
 153                            const gfx::Point& point) override;
 154
 155  protected:
 156   // Exposed for testing.
 157   views::View* GetLoadingShieldForTesting();
 158   views::WebView* GetSignInWebViewForTesting();
 159   views::View* GetNotificationAreaForTesting();
 160   views::View* GetScrollableAreaForTesting();
 161
 162  private:
 163   friend class AutofillDialogViewTesterViews;
 164
 165   // What the entire dialog should be doing (e.g. gathering info from the user,
 166   // asking the user to sign in, etc.).
 167   enum DialogMode {
 168     DETAIL_INPUT,
 169     LOADING,
 170     SIGN_IN,
 171   };
 172
 173   // A View which displays the currently selected account and lets the user
 174   // switch accounts.
 175   class AccountChooser : public views::View,
 176                          public views::LinkListener,
 177                          public views::MenuButtonListener,
 178                          public base::SupportsWeakPtr<AccountChooser> {
 179    public:
 180     explicit AccountChooser(AutofillDialogViewDelegate* delegate);
 181     ~AccountChooser() override;
 182
 183     // Updates the view based on the state that |delegate_| reports.
 184     void Update();
 185
 186     // views::LinkListener implementation.
 187     void LinkClicked(views::Link* source, int event_flags) override;
 188
 189     // views::MenuButtonListener implementation.
 190     void OnMenuButtonClicked(views::View* source,
 191                              const gfx::Point& point) override;
 192
 193    private:
 194     // The icon for the currently in-use account.
 195     views::ImageView* image_;
 196
 197     // The button for showing a menu to change the currently in-use account.
 198     views::MenuButton* menu_button_;
 199
 200     // The sign in link.
 201     views::Link* link_;
 202
 203     // The delegate |this| queries for logic and state.
 204     AutofillDialogViewDelegate* delegate_;
 205
 206     // Runs the suggestion menu (triggered by each section's |suggested_button|.
 207     scoped_ptr<views::MenuRunner> menu_runner_;
 208
 209     DISALLOW_COPY_AND_ASSIGN(AccountChooser);
 210   };
 211
 212   // A view which displays an image, optionally some messages and a button. Used
 213   // for the Wallet interstitial.
 214   class OverlayView : public views::View {
 215    public:
 216     explicit OverlayView(AutofillDialogViewDelegate* delegate);
 217     ~OverlayView() override;
 218
 219     // Returns a height which should be used when the contents view has width
 220     // |w|. Note that the value returned should be used as the height of the
 221     // dialog's contents.
 222     int GetHeightForContentsForWidth(int width);
 223
 224     // Sets the state to whatever |delegate_| says it should be.
 225     void UpdateState();
 226
 227     // views::View implementation:
 228     gfx::Insets GetInsets() const override;
 229     void Layout() override;
 230     const char* GetClassName() const override;
 231     void OnPaint(gfx::Canvas* canvas) override;
 232     void OnNativeThemeChanged(const ui::NativeTheme* theme) override;
 233
 234    private:
 235     // Gets the border of the non-client frame view as a BubbleBorder.
 236     views::BubbleBorder* GetBubbleBorder();
 237
 238     // Gets the bounds of this view without the frame view's bubble border.
 239     gfx::Rect ContentBoundsSansBubbleBorder();
 240
 241     // The delegate that provides |state| when UpdateState is called.
 242     AutofillDialogViewDelegate* delegate_;
 243
 244     // Child View. Front and center.
 245     views::ImageView* image_view_;
 246     // Child View. When visible, below |image_view_|.
 247     views::Label* message_view_;
 248
 249     DISALLOW_COPY_AND_ASSIGN(OverlayView);
 250   };
 251
 252   // An area for notifications. Some notifications point at the account chooser.
 253   class NotificationArea : public views::View {
 254    public:
 255     explicit NotificationArea(AutofillDialogViewDelegate* delegate);
 256     ~NotificationArea() override;
 257
 258     // Displays the given notifications.
 259     void SetNotifications(const std::vector<DialogNotification>& notifications);
 260
 261     // views::View implementation.
 262     gfx::Size GetPreferredSize() const override;
 263     const char* GetClassName() const override;
 264     void PaintChildren(const ui::PaintContext& context) override;
 265
 266     void set_arrow_centering_anchor(
 267         const base::WeakPtr<views::View>& arrow_centering_anchor) {
 268       arrow_centering_anchor_ = arrow_centering_anchor;
 269     }
 270
 271    private:
 272     // Utility function for determining whether an arrow should be drawn
 273     // pointing at |arrow_centering_anchor_|.
 274     bool HasArrow();
 275
 276     // A reference to the delegate/controller than owns this view.
 277     // Used to report when checkboxes change their values.
 278     AutofillDialogViewDelegate* delegate_;  // weak
 279
 280     // If HasArrow() is true, the arrow should point at this.
 281     base::WeakPtr<views::View> arrow_centering_anchor_;
 282
 283     std::vector<DialogNotification> notifications_;
 284
 285     DISALLOW_COPY_AND_ASSIGN(NotificationArea);
 286   };
 287
 288   typedef std::map<ServerFieldType, ExpandingTextfield*> TextfieldMap;
 289   typedef std::map<ServerFieldType, views::Combobox*> ComboboxMap;
 290
 291   // A view that packs a label on the left and some related controls
 292   // on the right.
 293   class SectionContainer : public views::View,
 294                            public views::ViewTargeterDelegate {
 295    public:
 296     SectionContainer(const base::string16& label,
 297                      views::View* controls,
 298                      views::Button* proxy_button);
 299     ~SectionContainer() override;
 300
 301     // Sets the visual appearance of the section to active (considered active
 302     // when showing the menu or hovered by the mouse cursor).
 303     void SetActive(bool active);
 304
 305     // Sets whether mouse events should be forwarded to |proxy_button_|.
 306     void SetForwardMouseEvents(bool forward);
 307
 308     // views::View implementation.
 309     const char* GetClassName() const override;
 310     void OnMouseMoved(const ui::MouseEvent& event) override;
 311     void OnMouseEntered(const ui::MouseEvent& event) override;
 312     void OnMouseExited(const ui::MouseEvent& event) override;
 313     bool OnMousePressed(const ui::MouseEvent& event) override;
 314     void OnMouseReleased(const ui::MouseEvent& event) override;
 315     void OnGestureEvent(ui::GestureEvent* event) override;
 316
 317    private:
 318     // views::ViewTargeterDelegate:
 319     views::View* TargetForRect(views::View* root,
 320                                const gfx::Rect& rect) override;
 321
 322     // Converts |event| to one suitable for |proxy_button_|.
 323     static ui::MouseEvent ProxyEvent(const ui::MouseEvent& event);
 324
 325     // Returns true if the given event should be forwarded to |proxy_button_|.
 326     bool ShouldForwardEvent(const ui::LocatedEvent& event);
 327
 328     // Mouse events on |this| are sent to this button.
 329     views::Button* proxy_button_;  // Weak reference.
 330
 331     // When true, all mouse events will be forwarded to |proxy_button_|.
 332     bool forward_mouse_events_;
 333
 334     DISALLOW_COPY_AND_ASSIGN(SectionContainer);
 335   };
 336
 337   // A button to show address or billing suggestions.
 338   class SuggestedButton : public views::MenuButton {
 339    public:
 340     explicit SuggestedButton(views::MenuButtonListener* listener);
 341     ~SuggestedButton() override;
 342
 343     // views::MenuButton implementation.
 344     gfx::Size GetPreferredSize() const override;
 345     const char* GetClassName() const override;
 346     void OnPaint(gfx::Canvas* canvas) override;
 347
 348    private:
 349     // Returns the corred resource ID (i.e. IDR_*) for the current |state()|.
 350     int ResourceIDForState() const;
 351
 352     DISALLOW_COPY_AND_ASSIGN(SuggestedButton);
 353   };
 354
 355   // A view that runs a callback whenever its bounds change, and which can
 356   // optionally suppress layout.
 357   class DetailsContainerView : public views::View {
 358    public:
 359     explicit DetailsContainerView(const base::Closure& callback);
 360     ~DetailsContainerView() override;
 361
 362     void set_ignore_layouts(bool ignore_layouts) {
 363       ignore_layouts_ = ignore_layouts;
 364     }
 365
 366     // views::View implementation.
 367     void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
 368     void Layout() override;
 369
 370    private:
 371     base::Closure bounds_changed_callback_;
 372
 373     // The view ignores Layout() calls when this is true.
 374     bool ignore_layouts_;
 375
 376     DISALLOW_COPY_AND_ASSIGN(DetailsContainerView);
 377   };
 378
 379   // A view that contains a suggestion (such as a known address).
 380   class SuggestionView : public views::View {
 381    public:
 382     explicit SuggestionView(AutofillDialogViews* autofill_dialog);
 383     ~SuggestionView() override;
 384
 385     void SetState(const SuggestionState& state);
 386
 387     // views::View implementation.
 388     gfx::Size GetPreferredSize() const override;
 389     int GetHeightForWidth(int width) const override;
 390     void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
 391
 392     ExpandingTextfield* textfield() { return textfield_; }
 393
 394    private:
 395     // Returns whether there's room to display |state_.vertically_compact_text|
 396     // without resorting to an ellipsis for a pixel width of |available_width|.
 397     // Fills in |resulting_height| with the amount of space required to display
 398     // |vertically_compact_text| or |horizontally_compact_text| as the case may
 399     // be.
 400     bool CanUseVerticallyCompactText(int available_width,
 401                                      int* resulting_height) const;
 402
 403     // Sets the display text of the suggestion.
 404     void SetLabelText(const base::string16& text);
 405
 406     // Sets the icon which should be displayed ahead of the text.
 407     void SetIcon(const gfx::Image& image);
 408
 409     // Shows an auxiliary textfield to the right of the suggestion icon and
 410     // text. This is currently only used to show a CVC field for the CC section.
 411     void SetTextfield(const base::string16& placeholder_text,
 412                       const gfx::Image& icon);
 413
 414     // Calls SetLabelText() with the appropriate text based on current bounds.
 415     void UpdateLabelText();
 416
 417     // The state of |this|.
 418     SuggestionState state_;
 419
 420     // This caches preferred heights for given widths. The key is a preferred
 421     // width, the value is a cached result of CanUseVerticallyCompactText.
 422     mutable std::map<int, std::pair<bool, int> > calculated_heights_;
 423
 424     // The label that holds the suggestion description text.
 425     views::Label* label_;
 426     // The second (and greater) line of text that describes the suggestion.
 427     views::Label* label_line_2_;
 428     // The icon that comes just before |label_|.
 429     views::ImageView* icon_;
 430     // The input set by ShowTextfield.
 431     ExpandingTextfield* textfield_;
 432
 433     DISALLOW_COPY_AND_ASSIGN(SuggestionView);
 434   };
 435
 436   // A convenience struct for holding pointers to views within each detail
 437   // section. None of the member pointers are owned.
 438   struct DetailsGroup {
 439     explicit DetailsGroup(DialogSection section);
 440     ~DetailsGroup();
 441
 442     // The section this group is associated with.
 443     const DialogSection section;
 444     // The view that contains the entire section (label + input).
 445     SectionContainer* container;
 446     // The view that allows manual input.
 447     views::View* manual_input;
 448     // The textfields in |manual_input|, tracked by their ServerFieldType.
 449     TextfieldMap textfields;
 450     // The comboboxes in |manual_input|, tracked by their ServerFieldType.
 451     ComboboxMap comboboxes;
 452     // The view that holds the text of the suggested data. This will be
 453     // visible IFF |manual_input| is not visible.
 454     SuggestionView* suggested_info;
 455     // The view that allows selecting other data suggestions.
 456     SuggestedButton* suggested_button;
 457   };
 458
 459   typedef std::map<DialogSection, DetailsGroup> DetailGroupMap;
 460
 461   // Returns the preferred size or minimum size (if |get_minimum_size| is true).
 462   gfx::Size CalculatePreferredSize(bool get_minimum_size) const;
 463
 464   // Returns the minimum size of the sign in view for this dialog.
 465   gfx::Size GetMinimumSignInViewSize() const;
 466
 467   // Returns the maximum size of the sign in view for this dialog.
 468   gfx::Size GetMaximumSignInViewSize() const;
 469
 470   // Returns which section should currently be used for credit card info.
 471   DialogSection GetCreditCardSection() const;
 472
 473   void InitChildViews();
 474
 475   // Creates and returns a view that holds all detail sections.
 476   views::View* CreateDetailsContainer();
 477
 478   // Creates and returns a view that holds the requesting host and intro text.
 479   views::View* CreateNotificationArea();
 480
 481   // Creates and returns a view that holds the main controls of this dialog.
 482   views::View* CreateMainContainer();
 483
 484   // Creates a detail section (Shipping, Email, etc.) with the given label,
 485   // inputs View, and suggestion model. Relevant pointers are stored in |group|.
 486   void CreateDetailsSection(DialogSection section);
 487
 488   // Creates the view that holds controls for inputing or selecting data for
 489   // a given section.
 490   views::View* CreateInputsContainer(DialogSection section);
 491
 492   // Creates a grid of inputs for the given section.
 493   void InitInputsView(DialogSection section);
 494
 495   // Changes the function of the whole dialog. Currently this can show a loading
 496   // shield, an embedded sign in web view, or the more typical detail input mode
 497   // (suggestions and form inputs).
 498   void ShowDialogInMode(DialogMode dialog_mode);
 499
 500   // Updates the given section to match the state provided by |delegate_|. If
 501   // |clobber_inputs| is true, the current state of the textfields will be
 502   // ignored, otherwise their contents will be preserved.
 503   void UpdateSectionImpl(DialogSection section, bool clobber_inputs);
 504
 505   // Updates the visual state of the given group as per the model.
 506   void UpdateDetailsGroupState(const DetailsGroup& group);
 507
 508   // Gets a pointer to the DetailsGroup that's associated with the given section
 509   // of the dialog.
 510   DetailsGroup* GroupForSection(DialogSection section);
 511
 512   // Gets a pointer to the DetailsGroup that's associated with a given |view|.
 513   // Returns NULL if no DetailsGroup was found.
 514   DetailsGroup* GroupForView(views::View* view);
 515
 516   // Erases all views in |group| from |validity_map_|.
 517   void EraseInvalidViewsInGroup(const DetailsGroup* group);
 518
 519   // Explicitly focuses the initially focusable view.
 520   void FocusInitialView();
 521
 522   // Sets the visual state for an input to be either valid or invalid. This
 523   // should work on Comboboxes or ExpandingTextfields. If |message| is empty,
 524   // the input is valid.
 525   template<class T>
 526   void SetValidityForInput(T* input, const base::string16& message);
 527
 528   // Shows an error bubble pointing at |view| if |view| has a message in
 529   // |validity_map_|.
 530   void ShowErrorBubbleForViewIfNecessary(views::View* view);
 531
 532   // Hides |error_bubble_| (if it exists).
 533   void HideErrorBubble();
 534
 535   // Updates validity of the inputs in |section| with new |validity_messages|.
 536   // Fields are only updated with unsure messages if |overwrite_valid| is true.
 537   void MarkInputsInvalid(DialogSection section,
 538                          const ValidityMessages& validity_messages,
 539                          bool overwrite_invalid);
 540
 541   // Checks all manual inputs in |group| for validity. Decorates the invalid
 542   // ones and returns true if all were valid.
 543   bool ValidateGroup(const DetailsGroup& group, ValidationType type);
 544
 545   // Checks all manual inputs in the form for validity. Decorates the invalid
 546   // ones and returns true if all were valid.
 547   bool ValidateForm();
 548
 549   // When an input is edited (its contents change) or activated (clicked while
 550   // focused), this function will inform the delegate to take the appropriate
 551   // action (textfields may show a suggestion popup, comboboxes may rebuild the
 552   // section inputs). May also reset the validity state of the input.
 553   void InputEditedOrActivated(ServerFieldType type,
 554                               const gfx::Rect& bounds,
 555                               bool was_edit);
 556
 557   // Updates the views in the button strip.
 558   void UpdateButtonStripExtraView();
 559
 560   // Call this when the size of anything in the contents might have changed.
 561   void ContentsPreferredSizeChanged();
 562   void DoContentsPreferredSizeChanged();
 563
 564   // Gets the textfield view that is shown for the given |type| or NULL.
 565   ExpandingTextfield* TextfieldForType(ServerFieldType type);
 566
 567   // Returns the associated ServerFieldType for |textfield|.
 568   ServerFieldType TypeForTextfield(const views::View* textfield);
 569
 570   // Gets the combobox view that is shown for the given |type|, or NULL.
 571   views::Combobox* ComboboxForType(ServerFieldType type);
 572
 573   // Returns the associated ServerFieldType for |combobox|.
 574   ServerFieldType TypeForCombobox(const views::Combobox* combobox) const;
 575
 576   // Called when the details container changes in size or position.
 577   void DetailsContainerBoundsChanged();
 578
 579   // Sets the icons in |section| according to the field values. For example,
 580   // sets the credit card and CVC icons according to the credit card number.
 581   void SetIconsForSection(DialogSection section);
 582
 583   // Iterates over all the inputs in |section| and sets their enabled/disabled
 584   // state.
 585   void SetEditabilityForSection(DialogSection section);
 586
 587   // Handles mouse presses on the non-client view.
 588   void NonClientMousePressed();
 589
 590   // The delegate that drives this view. Weak pointer, always non-NULL.
 591   AutofillDialogViewDelegate* const delegate_;
 592
 593   // The preferred size of the view, cached to avoid needless recomputation.
 594   mutable gfx::Size preferred_size_;
 595
 596   // The current number of unmatched calls to UpdatesStarted.
 597   int updates_scope_;
 598
 599   // True when there's been a call to ContentsPreferredSizeChanged() suppressed
 600   // due to an unmatched UpdatesStarted.
 601   bool needs_update_;
 602
 603   // The window that displays the dialog contents. Weak pointer; may be NULL
 604   // when the dialog is closing.
 605   views::Widget* window_;
 606
 607   // A DialogSection-keyed map of the DetailGroup structs.
 608   DetailGroupMap detail_groups_;
 609
 610   // Somewhere to show notification messages about errors, warnings, or promos.
 611   NotificationArea* notification_area_;
 612
 613   // Runs the suggestion menu (triggered by each section's |suggested_button|.
 614   scoped_ptr<views::MenuRunner> menu_runner_;
 615
 616   // The view that allows the user to toggle the data source.
 617   AccountChooser* account_chooser_;
 618
 619   // A WebView to that navigates to a Google sign-in page to allow the user to
 620   // sign-in.
 621   views::WebView* sign_in_web_view_;
 622
 623   // View that wraps |details_container_| and makes it scroll vertically.
 624   views::ScrollView* scrollable_area_;
 625
 626   // View to host details sections.
 627   DetailsContainerView* details_container_;
 628
 629   // A view that overlays |this| (for "loading..." messages).
 630   views::View* loading_shield_;
 631
 632   // The height for |loading_shield_|. This prevents the height of the dialog
 633   // from changing while the loading shield is showing.
 634   int loading_shield_height_;
 635
 636   // The view that completely overlays the dialog (used for the splash page).
 637   OverlayView* overlay_view_;
 638
 639   // The "Extra view" is on the same row as the dialog buttons.
 640   views::View* button_strip_extra_view_;
 641
 642   // This checkbox controls whether new details are saved to the Autofill
 643   // database. It lives in |extra_view_|.
 644   views::Checkbox* save_in_chrome_checkbox_;
 645
 646   // Holds the above checkbox and an associated tooltip icon.
 647   views::View* save_in_chrome_checkbox_container_;
 648
 649   // Used to display an image in the button strip extra view.
 650   views::ImageView* button_strip_image_;
 651
 652   // View that aren't in the hierarchy but are owned by |this|. Currently
 653   // just holds the (hidden) country comboboxes.
 654   ScopedVector<views::View> other_owned_views_;
 655
 656   // The view that is appended to the bottom of the dialog, below the button
 657   // strip. Used to display legal document links.
 658   views::View* footnote_view_;
 659
 660   // The legal document text and links.
 661   views::StyledLabel* legal_document_view_;
 662
 663   // The focus manager for |window_|.
 664   views::FocusManager* focus_manager_;
 665
 666   // The object that manages the error bubble widget.
 667   InfoBubble* error_bubble_;  // Weak; owns itself.
 668
 669   // Map from input view (textfield or combobox) to error string.
 670   std::map<views::View*, base::string16> validity_map_;
 671
 672   ScopedObserver<views::Widget, AutofillDialogViews> observer_;
 673
 674   // Delegate for the sign-in dialog's webview.
 675   scoped_ptr<AutofillDialogSignInDelegate> sign_in_delegate_;
 676
 677   // Used to tell the delegate when focus moves to hide the Autofill popup.
 678   scoped_ptr<ui::EventHandler> event_handler_;
 679
 680   DISALLOW_COPY_AND_ASSIGN(AutofillDialogViews);
 681 };
 682
 683 }  // namespace autofill
 684
 685 #endif  // CHROME_BROWSER_UI_VIEWS_AUTOFILL_AUTOFILL_DIALOG_VIEWS_H_