Update ConstrainedWindowViews appearance according to mock

ui/views/window/dialog_client_view.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 "ui/views/window/dialog_client_view.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
 #endif
 
 #include <algorithm>
 
 #include "base/utf_string_conversions.h"
 #include "grit/ui_strings.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/native_theme/native_theme.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/views/controls/button/text_button.h"
+#include "ui/views/controls/button/chrome_style.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 
 namespace views {
 namespace {
 
 const int kDialogMinButtonWidth = 75;
 const int kDialogButtonLabelSpacing = 16;
 const int kDialogButtonContentSpacing = 5;
 
 // The group used by the buttons.  This name is chosen voluntarily big not to
 // conflict with other groups that could be in the dialog content.
 const int kButtonGroup = 6666;
 
 const gfx::Font& GetDialogButtonFont() {
   static gfx::Font* font = NULL;
   if (!font) {
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     font = new gfx::Font(rb.GetFont(ui::ResourceBundle::BaseFont));
   }
   return *font;
 }
 
 // Updates any of the standard buttons according to the delegate.
-void UpdateButtonHelper(NativeTextButton* button_view,
+void UpdateButtonHelper(TextButton* button_view,
                         DialogDelegate* delegate,
                         ui::DialogButton button) {
   string16 label = delegate->GetDialogButtonLabel(button);
   if (!label.empty())
     button_view->SetText(label);
   button_view->SetEnabled(delegate->IsDialogButtonEnabled(button));
   button_view->SetVisible(delegate->IsDialogButtonVisible(button));
 }
 
 // DialogButton ----------------------------------------------------------------
 
-// DialogButtons is used for the ok/cancel buttons of the window. DialogButton
-// forwards AcceleratorPressed to the delegate.
+// DialogButton forwards AcceleratorPressed to the delegate.  It is used
+// for the ok/cancel buttons of the window.
 
-class DialogButton : public NativeTextButton {
+template <class ButtonBase>
+class DialogButton : public ButtonBase {
  public:
+  // The button's class name.
+  static const char kViewClassName[];
+
   DialogButton(ButtonListener* listener,
                Widget* owner,
                ui::DialogButton type,
-               const string16& title,
-               bool is_default)
-      : NativeTextButton(listener, title),
+               const string16& title)
+      : ButtonBase(listener, title),
         owner_(owner),
         type_(type) {
-    SetIsDefault(is_default);
   }
 
   // Overridden to forward to the delegate.
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) {
     if (!owner_->widget_delegate()->AsDialogDelegate()->
         AreAcceleratorsEnabled(type_)) {
       return false;
     }
-    return NativeTextButton::AcceleratorPressed(accelerator);
+    return ButtonBase::AcceleratorPressed(accelerator);
+  }
+
+  // Overridden from TextButton:
+  virtual std::string GetClassName() const {
+    return kViewClassName;
   }
 
  private:
   Widget* owner_;
   const ui::DialogButton type_;
 
   DISALLOW_COPY_AND_ASSIGN(DialogButton);
 };
 
+const char DialogButton<NativeTextButton>::kViewClassName[] =
+    "NativeDialogButton";
+
+const char DialogButton<TextButton>::kViewClassName[] =
+    "TextDialogButton";
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DialogClientView, public:
 
-DialogClientView::DialogClientView(Widget* owner, View* contents_view)
+DialogClientView::StyleParams::StyleParams()
+    : button_vedge_margin(kButtonVEdgeMargin),
+      button_hedge_margin(kButtonHEdgeMargin),
+      min_button_width(kDialogMinButtonWidth),
+      button_label_spacing(kDialogButtonLabelSpacing),
+      button_content_spacing(kDialogButtonContentSpacing),
+      text_button_factory(&DialogClientView::CreateNativeStyleDialogButton) {
+}
+
+DialogClientView::DialogClientView(Widget* owner,
+                                   View* contents_view,
+                                   const StyleParams &params)
     : ClientView(owner, contents_view),
+      style_params_(params),
       ok_button_(NULL),
       cancel_button_(NULL),
       default_button_(NULL),
       extra_view_(NULL),
       size_extra_view_height_to_buttons_(false),
       notified_delegate_(false),
       listening_to_focus_(false),
       saved_focus_manager_(NULL) {
+  SkColor bg_color = ui::NativeTheme::instance()->GetSystemColor(
+      ui::NativeTheme::kColorId_DialogBackground);
+  set_background(views::Background::CreateSolidBackground(bg_color));
 }
 
 DialogClientView::~DialogClientView() {
 }
 
 void DialogClientView::ShowDialogButtons() {
   DialogDelegate* dd = GetDialogDelegate();
   int buttons = dd->GetDialogButtons();
   if (buttons & ui::DIALOG_BUTTON_OK && !ok_button_) {
     string16 label = dd->GetDialogButtonLabel(ui::DIALOG_BUTTON_OK);
     if (label.empty())
       label = l10n_util::GetStringUTF16(IDS_APP_OK);
     bool is_default_button =
         (dd->GetDefaultDialogButton() & ui::DIALOG_BUTTON_OK) != 0;
-    ok_button_ = new DialogButton(this,
-                                  GetWidget(),
-                                  ui::DIALOG_BUTTON_OK,
-                                  label,
-                                  is_default_button);
+    ok_button_ = style_params_.text_button_factory(this,
+                                                   GetWidget(),
+                                                   ui::DIALOG_BUTTON_OK,
+                                                   label);
     ok_button_->SetGroup(kButtonGroup);
-    if (is_default_button)
+    if (is_default_button) {
       default_button_ = ok_button_;
+      default_button_->SetIsDefault(true);
+    }
     if (!(buttons & ui::DIALOG_BUTTON_CANCEL))
       ok_button_->AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
     AddChildView(ok_button_);
   }
   if (buttons & ui::DIALOG_BUTTON_CANCEL && !cancel_button_) {
     string16 label =
         dd->GetDialogButtonLabel(ui::DIALOG_BUTTON_CANCEL);
     if (label.empty()) {
       if (buttons & ui::DIALOG_BUTTON_OK) {
         label = l10n_util::GetStringUTF16(IDS_APP_CANCEL);
       } else {
         label = l10n_util::GetStringUTF16(IDS_APP_CLOSE);
       }
     }
     bool is_default_button =
         (dd->GetDefaultDialogButton() & ui::DIALOG_BUTTON_CANCEL)
         != 0;
-    cancel_button_ = new DialogButton(this,
-                                      GetWidget(),
-                                      ui::DIALOG_BUTTON_CANCEL,
-                                      label,
-                                      is_default_button);
+    cancel_button_ =
+        style_params_.text_button_factory(this,
+                                          GetWidget(),
+                                          ui::DIALOG_BUTTON_CANCEL,
+                                          label);
     cancel_button_->SetGroup(kButtonGroup);
     cancel_button_->AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE,
                                                    ui::EF_NONE));
-    if (is_default_button)
+    if (is_default_button) {
       default_button_ = ok_button_;
+      default_button_->SetIsDefault(true);
+    }
     AddChildView(cancel_button_);
   }
   if (!buttons) {
     // Register the escape key as an accelerator which will close the window
     // if there are no dialog buttons.
     AddAccelerator(ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE));
   }
 }
 
-void DialogClientView::SetDefaultButton(NativeTextButton* new_default_button) {
+void DialogClientView::SetDefaultButton(TextButton* new_default_button) {
   if (default_button_ && default_button_ != new_default_button) {
     default_button_->SetIsDefault(false);
     default_button_ = NULL;
   }
 
   if (new_default_button) {
     default_button_ = new_default_button;
     default_button_->SetIsDefault(true);
   }
 }
 
 void DialogClientView::OnWillChangeFocus(View* focused_before,
                                          View* focused_now) {
-  NativeTextButton* new_default_button = NULL;
+  TextButton* new_default_button = NULL;
   if (focused_now &&
-      focused_now->GetClassName() == NativeTextButton::kViewClassName) {
-    new_default_button = static_cast<NativeTextButton*>(focused_now);
+      ((focused_now->GetClassName() ==
+        DialogButton<NativeTextButton>::kViewClassName) ||
+       (focused_now->GetClassName() ==
+        DialogButton<TextButton>::kViewClassName))) {
+    new_default_button = static_cast<TextButton*>(focused_now);
   } else {
     // The focused view is not a button, get the default button from the
     // delegate.
     DialogDelegate* dd = GetDialogDelegate();
     if ((dd->GetDefaultDialogButton() & ui::DIALOG_BUTTON_OK) != 0)
       new_default_button = ok_button_;
     if ((dd->GetDefaultDialogButton() & ui::DIALOG_BUTTON_CANCEL)
         != 0)
       new_default_button = cancel_button_;
   }
@@ skipping 32 matching lines @@
   }
 }
 
 void DialogClientView::CancelWindow() {
   // Call the standard Close handler, which checks with the delegate before
   // proceeding. This checking _isn't_ done here, but in the WM_CLOSE handler,
   // so that the close box on the window also shares this code path.
   Close();
 }
 
+// static
+TextButton* DialogClientView::CreateNativeStyleDialogButton(
+    ButtonListener* listener,
+    Widget* owner,
+    ui::DialogButton type,
+    const string16& title)
+{
+  return new DialogButton<NativeTextButton>(listener, owner, type, title);
+}
+
+// static
+TextButton* DialogClientView::CreateChromeStyleDialogButton(
+    ButtonListener* listener,
+    Widget* owner,
+    ui::DialogButton type,
+    const string16& title)
+{
+  DialogButton<TextButton>* button =
+      new DialogButton<TextButton>(listener, owner, type, title);
+  ApplyChromeStyle(button);
+  return button;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // DialogClientView, View overrides:
 
 void DialogClientView::NativeViewHierarchyChanged(
     bool attached,
     gfx::NativeView native_view,
     internal::RootView* root_view) {
   if (attached) {
     UpdateFocusListener();
   }
@@ skipping 35 matching lines @@
   return this;
 }
 
 const DialogClientView* DialogClientView::AsDialogClientView() const {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DialogClientView, View overrides:
 
-void DialogClientView::OnPaint(gfx::Canvas* canvas) {
-  SkColor bg_color = ui::NativeTheme::instance()->GetSystemColor(
-      ui::NativeTheme::kColorId_DialogBackground);
-  canvas->FillRect(GetLocalBounds(), bg_color);
-}
-
 void DialogClientView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
   if (!GetWidget()->IsMaximized() && !GetWidget()->IsMinimized())
     PaintSizeBox(canvas);
 }
 
 void DialogClientView::Layout() {
   if (has_dialog_buttons())
     LayoutDialogButtons();
   LayoutContentsView();
@@ skipping 31 matching lines @@
       width += GetButtonWidth(ui::DIALOG_BUTTON_OK);
       if (cancel_button_)
         width += kRelatedButtonHSpacing;
     }
     if (extra_view_) {
       width += extra_view_->GetPreferredSize().width();
       if (cancel_button_ || ok_button_)
         width += kRelatedButtonHSpacing;
     }
     if (width > 0) {
-      width += 2 * kButtonHEdgeMargin;
+      width += 2 * style_params_.button_hedge_margin;
       prefsize.set_width(std::max(prefsize.width(), width));
     }
   }
   prefsize.Enlarge(0, button_height);
   return prefsize;
 }
 
 bool DialogClientView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   // We only expect Escape key.
   DCHECK(accelerator.key_code() == ui::VKEY_ESCAPE);
@@ skipping 48 matching lines @@
     // TODO(port): paint size box
 #endif
   }
 }
 
 int DialogClientView::GetButtonWidth(int button) const {
   DialogDelegate* dd = GetDialogDelegate();
   string16 button_label = dd->GetDialogButtonLabel(
       static_cast<ui::DialogButton>(button));
   int string_width = GetDialogButtonFont().GetStringWidth(button_label);
-  return std::max(string_width + kDialogButtonLabelSpacing,
-                  kDialogMinButtonWidth);
+  return std::max(string_width + style_params_.button_label_spacing,
+                  style_params_.min_button_width);
 }
 
 int DialogClientView::GetButtonsHeight() const {
   int button_height = 0;
   if (cancel_button_)
     button_height = std::max(button_height,
                              cancel_button_->GetPreferredSize().height());
   if (ok_button_)
     button_height = std::max(button_height,
                              ok_button_->GetPreferredSize().height());
   return button_height;
 }
 
 int DialogClientView::GetDialogButtonsAreaHeight() const {
   return !has_dialog_buttons() ? 0 :
-      GetButtonsHeight() + kDialogButtonContentSpacing + kButtonVEdgeMargin;
+      GetButtonsHeight() + style_params_.button_content_spacing +
+      style_params_.button_vedge_margin;
 }
 
 void DialogClientView::LayoutDialogButtons() {
   gfx::Rect lb = GetContentsBounds();
   gfx::Rect extra_bounds;
-  int bottom_y = lb.bottom() - kButtonVEdgeMargin;
+  int bottom_y = lb.bottom() - style_params_.button_vedge_margin;
   int button_height = GetButtonsHeight();
   if (cancel_button_) {
     gfx::Size ps = cancel_button_->GetPreferredSize();
     int button_width = std::max(
         GetButtonWidth(ui::DIALOG_BUTTON_CANCEL), ps.width());
-    int button_x = lb.right() - button_width - kButtonHEdgeMargin;
+    int button_x = lb.right() - button_width -
+        style_params_.button_hedge_margin;
     int button_y = bottom_y - ps.height();
     cancel_button_->SetBounds(button_x, button_y, button_width, ps.height());
     // The extra view bounds are dependent on this button.
     extra_bounds.set_width(std::max(0, cancel_button_->x()));
     extra_bounds.set_y(cancel_button_->y());
   }
   if (ok_button_) {
     gfx::Size ps = ok_button_->GetPreferredSize();
     int button_width = std::max(
         GetButtonWidth(ui::DIALOG_BUTTON_OK), ps.width());
-    int ok_button_right = lb.right() - kButtonHEdgeMargin;
+    int ok_button_right = lb.right() - style_params_.button_hedge_margin;
     if (cancel_button_)
       ok_button_right = cancel_button_->x() - kRelatedButtonHSpacing;
     int button_x = ok_button_right - button_width;
     int button_y = bottom_y - ps.height();
     ok_button_->SetBounds(button_x, button_y, ok_button_right - button_x,
                           ps.height());
     // The extra view bounds are dependent on this button.
     extra_bounds.set_width(std::max(0, ok_button_->x()));
     extra_bounds.set_y(ok_button_->y());
   }
   if (extra_view_) {
     gfx::Size ps = extra_view_->GetPreferredSize();
-    extra_bounds.set_x(lb.x() + kButtonHEdgeMargin);
+    extra_bounds.set_x(lb.x() + style_params_.button_hedge_margin);
     int height = size_extra_view_height_to_buttons_ ?
         std::max(ps.height(), button_height) : ps.height();
     extra_bounds.set_height(height);
     extra_view_->SetBoundsRect(extra_bounds);
   }
 }
 
 void DialogClientView::LayoutContentsView() {
   gfx::Rect lb = GetContentsBounds();
   lb.set_height(std::max(0, lb.height() - GetDialogButtonsAreaHeight()));
@@ skipping 37 matching lines @@
   }
   saved_focus_manager_ = focus_manager;
   // Listen for focus change events so we can update the default button.
   if (focus_manager) {
     focus_manager->AddFocusChangeListener(this);
     listening_to_focus_ = true;
   }
 }
 
 }  // namespace views