Enable the new dialog style by default; etc.

ui/views/controls/button/label_button.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/controls/button/label_button.h"
 
 #include "base/logging.h"
 #include "grit/ui_resources.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 49 matching lines @@
 
 LabelButton::~LabelButton() {}
 
 const gfx::ImageSkia& LabelButton::GetImage(ButtonState for_state) {
   if (for_state != STATE_NORMAL && button_state_images_[for_state].isNull())
     return button_state_images_[STATE_NORMAL];
   return button_state_images_[for_state];
 }
 
 void LabelButton::SetImage(ButtonState for_state, const gfx::ImageSkia& image) {
+  cached_size_.SetSize(0, 0);
   button_state_images_[for_state] = image;
   image_->SetImage(GetImage(state()));
 }
 
 const string16& LabelButton::GetText() const {
   return label_->text();
 }
 
 void LabelButton::SetText(const string16& text) {
+  cached_size_.SetSize(0, 0);
   SetAccessibleName(text);
   label_->SetText(text);
-  SetAccessibleName(text);
 }
 
 void LabelButton::SetTextColor(ButtonState for_state, SkColor color) {
   button_state_colors_[for_state] = color;
   if (for_state == STATE_DISABLED)
     label_->SetDisabledColor(color);
   else if (for_state == state())
     label_->SetEnabledColor(color);
   explicitly_set_colors_[for_state] = true;
 }
 
 bool LabelButton::GetTextMultiLine() const {
   return label_->is_multi_line();
 }
 
 void LabelButton::SetTextMultiLine(bool text_multi_line) {
+  cached_size_.SetSize(0, 0);
   label_->SetMultiLine(text_multi_line);
 }
 
 const gfx::Font& LabelButton::GetFont() const {
   return label_->font();
 }
 
 void LabelButton::SetFont(const gfx::Font& font) {
+  cached_size_.SetSize(0, 0);
   label_->SetFont(font);
 }
 
 gfx::HorizontalAlignment LabelButton::GetHorizontalAlignment() const {
   return label_->horizontal_alignment();
 }
 
 void LabelButton::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
+  cached_size_.SetSize(0, 0);
   label_->SetHorizontalAlignment(alignment);
   InvalidateLayout();
 }
 
 void LabelButton::SetIsDefault(bool is_default) {
   if (is_default == is_default_)
     return;
   is_default_ = is_default;
   ui::Accelerator accel(ui::VKEY_RETURN, ui::EF_NONE);
   is_default_ ? AddAccelerator(accel) : RemoveAccelerator(accel);
 
   // STYLE_BUTTON uses bold text to indicate default buttons.
   if (style_ == STYLE_BUTTON) {
     int style = label_->font().GetStyle();
     style = is_default ? style | gfx::Font::BOLD : style & !gfx::Font::BOLD;
     label_->SetFont(label_->font().DeriveFont(0, style));
   }
 }
 
 void LabelButton::SetStyle(ButtonStyle style) {
+  cached_size_.SetSize(0, 0);
+
   // Use the new button style instead of the native button style.
   // TODO(msw): Officialy deprecate and remove STYLE_NATIVE_TEXTBUTTON.
   if (DialogDelegate::UseNewStyle() && style == STYLE_NATIVE_TEXTBUTTON)
     style = STYLE_BUTTON;
 
   style_ = style;
   set_border(new LabelButtonBorder(style));
   // Inset the button focus rect from the actual border; roughly match Windows.
   set_focus_border(style == STYLE_BUTTON ?
       NULL : FocusBorder::CreateDashedFocusBorder(3, 3, 3, 3));
   if (style == STYLE_BUTTON || style == STYLE_NATIVE_TEXTBUTTON) {
     label_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
     set_focusable(true);
   }
   if (style == STYLE_BUTTON) {
     set_min_size(gfx::Size(70, 31));
     const SkColor color = GetNativeTheme()->GetSystemColor(
       ui::NativeTheme::kColorId_WindowBackground);
     label_->SetShadowColors(color, color);
     label_->SetShadowOffset(0, 1);
   }
   // Invalidate the layout to pickup the new insets from the border.
   InvalidateLayout();
   ResetColorsFromNativeTheme();
 }
 
 gfx::Size LabelButton::GetPreferredSize() {
-  // Accommodate bold text in case this STYLE_BUTTON button is made default.
-  const gfx::Font font = label_->font();
-  if (style_ == STYLE_BUTTON)
-    label_->SetFont(font.DeriveFont(0, font.GetStyle() | gfx::Font::BOLD));
+  if (cached_size_.IsEmpty()) {
+    gfx::Font font = label_->font();
+    // Accommodate bold text in case this STYLE_BUTTON button is made default.
+    if (style_ == STYLE_BUTTON)
+      font = font.DeriveFont(0, font.GetStyle() | gfx::Font::BOLD);
+    // Use a temporary label copy for sizing to avoid calculation side-effects.
+    Label label(label_->text(), font);
 
-  // Resize multi-line labels paired with images to use their available width.
-  const gfx::Size image_size(image_->GetPreferredSize());
-  if (GetTextMultiLine() && !image_size.IsEmpty() && !GetText().empty() &&
-      GetHorizontalAlignment() == gfx::ALIGN_CENTER) {
-    label_->SizeToFit(GetLocalBounds().width() - image_size.width() - kSpacing);
+    // Resize multi-line labels paired with images to use their available width.
+    const gfx::Size image_size(image_->GetPreferredSize());
+    if (GetTextMultiLine() && !image_size.IsEmpty() && !GetText().empty() &&
+        GetHorizontalAlignment() == gfx::ALIGN_CENTER) {
+      label.SizeToFit(GetLocalBounds().width() - image_size.width() - kSpacing);
+    }
+
+    // Calculate the required size.
+    cached_size_ = label.GetPreferredSize();
+    if (image_size.width() > 0 && cached_size_.width() > 0)
+      cached_size_.Enlarge(kSpacing, 0);
+    cached_size_.ClampToMin(gfx::Size(0, image_size.height()));
+    cached_size_.Enlarge(image_size.width(), 0);
+    cached_size_.Enlarge(GetInsets().width(), GetInsets().height());
   }
 
-  // Calculate the required size.
-  gfx::Size size(label_->GetPreferredSize());
-  if (image_size.width() > 0 && size.width() > 0)
-    size.Enlarge(kSpacing, 0);
-  size.set_height(std::max(size.height(), image_size.height()));
-  size.Enlarge(image_size.width() + GetInsets().width(), GetInsets().height());
-
-  // Restore the label's original font without the temporary bold style.
-  if (style_ == STYLE_BUTTON)
-    label_->SetFont(font);
-
   // Increase the minimum size monotonically with the preferred size.
-  size.SetSize(std::max(min_size_.width(), size.width()),
-               std::max(min_size_.height(), size.height()));
+  gfx::Size size(cached_size_);
+  size.ClampToMin(min_size_);

[Mike Wittman, 2013/05/11 04:35:58]

Should this be ClampToMax?

[msw, 2013/05/11 04:40:26]

No, I think it's correct as-is (this will ensure that the size is greater than
or equal to |min_size_|, right?)

   min_size_ = size;
 
   // Return the largest known size clamped to the maximum size (if valid).
   if (max_size_.width() > 0)
     size.set_width(std::min(max_size_.width(), size.width()));
   if (max_size_.height() > 0)
     size.set_height(std::min(max_size_.height(), size.height()));
   return size;
 }
 
@@ skipping 74 matching lines @@
 
   gfx::Point label_origin(child_area.origin());
   if (!image_size.IsEmpty() && GetHorizontalAlignment() != gfx::ALIGN_RIGHT)
     label_origin.set_x(image_origin.x() + image_size.width() + kSpacing);
 
   image_->SetBoundsRect(gfx::Rect(image_origin, image_size));
   label_->SetBoundsRect(gfx::Rect(label_origin, label_size));
 }
 
 void LabelButton::ChildPreferredSizeChanged(View* child) {
+  cached_size_.SetSize(0, 0);
   PreferredSizeChanged();
 }
 
 void LabelButton::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   ResetColorsFromNativeTheme();
 }
 
 ui::NativeTheme::Part LabelButton::GetThemePart() const {
   return ui::NativeTheme::kPushButton;
 }
@@ skipping 43 matching lines @@
   params->button.indeterminate = false;
   params->button.is_default = is_default_;
   params->button.is_focused = HasFocus() && IsAccessibilityFocusable();
   params->button.has_border = style() == STYLE_NATIVE_TEXTBUTTON;
   params->button.classic_state = 0;
   params->button.background_color = GetNativeTheme()->GetSystemColor(
       ui::NativeTheme::kColorId_TextButtonBackgroundColor);
 }
 
 }  // namespace views