LabelButton: cache the last computed preferred size

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/resource/resource_bundle.h"
 #include "ui/gfx/animation/throb_animation.h"
@@ skipping 126 matching lines @@
 
 gfx::HorizontalAlignment LabelButton::GetHorizontalAlignment() const {
   return label_->GetHorizontalAlignment();
 }
 
 void LabelButton::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   label_->SetHorizontalAlignment(alignment);
   InvalidateLayout();
 }
 
+void LabelButton::SetMinSize(const gfx::Size& min_size) {
+  min_size_ = min_size;
+  ResetCachedPreferredSize();
+}
+
+void LabelButton::SetMaxSize(const gfx::Size& max_size) {
+  max_size_ = max_size;
+  ResetCachedPreferredSize();
+}
+
 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) {
     label_->SetFontList(
         is_default ? cached_bold_font_list_ : cached_normal_font_list_);
   }
 }
 
 void LabelButton::SetStyle(ButtonStyle style) {
   style_ = style;
   // Inset the button focus rect from the actual border; roughly match Windows.
   if (style == STYLE_BUTTON) {
     SetFocusPainter(scoped_ptr<Painter>());
   } else {
     SetFocusPainter(Painter::CreateDashedFocusPainterWithInsets(
                         gfx::Insets(3, 3, 3, 3)));
   }
   if (style == STYLE_BUTTON) {
     label_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
     SetFocusable(true);
   }
   if (style == STYLE_BUTTON)
-    set_min_size(gfx::Size(70, 33));
-
+    SetMinSize(gfx::Size(70, 33));
   OnNativeThemeChanged(GetNativeTheme());
+  ResetCachedPreferredSize();
 }
 
 void LabelButton::SetFocusPainter(scoped_ptr<Painter> focus_painter) {
   focus_painter_ = focus_painter.Pass();
 }
 
 gfx::Size LabelButton::GetPreferredSize() const {
+  if (cached_preferred_size_valid_)
+    return cached_preferred_size_;
+
   // Use a temporary label copy for sizing to avoid calculation side-effects.
   Label label(GetText(), cached_normal_font_list_);
   label.SetShadows(label_->shadows());
   label.SetMultiLine(GetTextMultiLine());
 
   if (style() == STYLE_BUTTON) {
     // Some text appears wider when rendered normally than when rendered bold.
     // Accommodate the widest, as buttons may show bold and shouldn't resize.
     const int current_width = label.GetPreferredSize().width();
     label.SetFontList(cached_bold_font_list_);
@@ skipping 15 matching lines @@
 
   // Increase the minimum size monotonically with the preferred size.
   size.SetToMax(min_size_);
   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;
+
+  // Cache this computed size, as recomputing it is an expensive operation.
+  cached_preferred_size_valid_ = true;
+  cached_preferred_size_ = size;
+  return cached_preferred_size_;
 }
 
 int LabelButton::GetHeightForWidth(int w) const {
   w -= GetInsets().width();
   const gfx::Size image_size(image_->GetPreferredSize());
   w -= image_size.width();
   if (image_size.width() > 0 && !GetText().empty())
     w -= kSpacing;
 
   int height = std::max(image_size.height(), label_->GetHeightForWidth(w));
@@ skipping 54 matching lines @@
   return kViewClassName;
 }
 
 scoped_ptr<LabelButtonBorder> LabelButton::CreateDefaultBorder() const {
   return scoped_ptr<LabelButtonBorder>(new LabelButtonBorder(style_));
 }
 
 void LabelButton::SetBorder(scoped_ptr<Border> border) {
   border_is_themed_border_ = false;
   View::SetBorder(border.Pass());
+  ResetCachedPreferredSize();
 }
 
 gfx::Rect LabelButton::GetChildAreaBounds() {
   return GetLocalBounds();
 }
 
 void LabelButton::OnPaint(gfx::Canvas* canvas) {
   View::OnPaint(canvas);
   Painter::PaintFocusPainter(this, canvas, focus_painter_.get());
 }
@@ skipping 64 matching lines @@
   for (size_t state = STATE_NORMAL; state < STATE_COUNT; ++state) {
     if (!explicitly_set_colors_[state]) {
       SetTextColor(static_cast<ButtonState>(state), colors[state]);
       explicitly_set_colors_[state] = false;
     }
   }
 }
 
 void LabelButton::UpdateImage() {
   image_->SetImage(GetImage(state()));
+  ResetCachedPreferredSize();
 }
 
 void LabelButton::UpdateThemedBorder() {
   // Don't override borders set by others.
   if (!border_is_themed_border_)
     return;
 
   scoped_ptr<LabelButtonBorder> label_button_border = CreateDefaultBorder();
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
@@ skipping 15 matching lines @@
   UpdateImage();
   const SkColor color = button_state_colors_[state()];
   if (state() != STATE_DISABLED && label_->enabled_color() != color)
     label_->SetEnabledColor(color);
   label_->SetEnabled(state() != STATE_DISABLED);
   if (image_->GetPreferredSize() != previous_image_size)
     Layout();
 }
 
 void LabelButton::ChildPreferredSizeChanged(View* child) {
+  ResetCachedPreferredSize();
   PreferredSizeChanged();
 }
 
 void LabelButton::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   ResetColorsFromNativeTheme();
   UpdateThemedBorder();
   // Invalidate the layout to pickup the new insets from the border.
   InvalidateLayout();
 }
 
@@ skipping 27 matching lines @@
   GetExtraParams(params);
   return ui::NativeTheme::kNormal;
 }
 
 ui::NativeTheme::State LabelButton::GetForegroundThemeState(
     ui::NativeTheme::ExtraParams* params) const {
   GetExtraParams(params);
   return ui::NativeTheme::kHovered;
 }
 
+void LabelButton::ResetCachedPreferredSize() {
+  cached_preferred_size_valid_ = false;
+  cached_preferred_size_= gfx::Size();
+}
+
 }  // namespace views