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