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