Cache DrawStringParams in views::Label

ui/views/controls/label.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/label.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <vector>
@@ skipping 38 matching lines @@
 Label::Label(const base::string16& text, const gfx::FontList& font_list) {
   Init(text, font_list);
 }
 
 Label::~Label() {
 }
 
 void Label::SetFontList(const gfx::FontList& font_list) {
   is_first_paint_text_ = true;
   font_list_ = font_list;
-  ResetCachedSize();
+  ResetLayoutCache();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 void Label::SetText(const base::string16& text) {
   if (text != text_)
     SetTextInternal(text);
 }
 
 void Label::SetTextInternal(const base::string16& text) {
   is_first_paint_text_ = true;
   text_ = text;
 
   if (obscured_) {
     size_t obscured_text_length =
         static_cast<size_t>(gfx::UTF16IndexToOffset(text_, 0, text_.length()));
     layout_text_.assign(obscured_text_length, kPasswordReplacementChar);
   } else {
     layout_text_ = text_;
   }
 
-  ResetCachedSize();
+  ResetLayoutCache();
   PreferredSizeChanged();
   SchedulePaint();
 }
 
 void Label::SetAutoColorReadabilityEnabled(bool enabled) {
   is_first_paint_text_ = true;
   auto_color_readability_ = enabled;
   RecalculateColors();
 }
 
@@ skipping 14 matching lines @@
 void Label::SetBackgroundColor(SkColor color) {
   is_first_paint_text_ = true;
   background_color_ = color;
   background_color_set_ = true;
   RecalculateColors();
 }
 
 void Label::SetShadows(const gfx::ShadowValues& shadows) {
   is_first_paint_text_ = true;
   shadows_ = shadows;
-  text_size_valid_ = false;
+  ResetLayoutCache();
 }
 
 void Label::SetSubpixelRenderingEnabled(bool subpixel_rendering_enabled) {
   is_first_paint_text_ = true;
   subpixel_rendering_enabled_ = subpixel_rendering_enabled;
 }
 
 void Label::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
   is_first_paint_text_ = true;
   // If the UI layout is right-to-left, flip the alignment direction.
@@ skipping 14 matching lines @@
 
   const base::i18n::TextDirection dir =
       base::i18n::GetFirstStrongCharacterDirection(layout_text_);
   return dir == base::i18n::RIGHT_TO_LEFT ? gfx::ALIGN_RIGHT : gfx::ALIGN_LEFT;
 }
 
 void Label::SetLineHeight(int height) {
   is_first_paint_text_ = true;
   if (height != line_height_) {
     line_height_ = height;
-    ResetCachedSize();
+    ResetLayoutCache();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetMultiLine(bool multi_line) {
   is_first_paint_text_ = true;
   DCHECK(!multi_line || (elide_behavior_ == gfx::ELIDE_TAIL ||
                          elide_behavior_ == gfx::NO_ELIDE));
   if (multi_line != multi_line_) {
     multi_line_ = multi_line;
-    ResetCachedSize();
+    ResetLayoutCache();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetObscured(bool obscured) {
   is_first_paint_text_ = true;
   if (obscured != obscured_) {
     obscured_ = obscured;
     SetTextInternal(text_);
   }
 }
 
 void Label::SetAllowCharacterBreak(bool allow_character_break) {
   is_first_paint_text_ = true;
   if (allow_character_break != allow_character_break_) {
     allow_character_break_ = allow_character_break;
-    ResetCachedSize();
+    ResetLayoutCache();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetElideBehavior(gfx::ElideBehavior elide_behavior) {
   is_first_paint_text_ = true;
   DCHECK(!multi_line_ || (elide_behavior_ == gfx::ELIDE_TAIL ||
                           elide_behavior_ == gfx::NO_ELIDE));
   if (elide_behavior != elide_behavior_) {
     elide_behavior_ = elide_behavior;
-    ResetCachedSize();
+    ResetLayoutCache();
     PreferredSizeChanged();
     SchedulePaint();
   }
 }
 
 void Label::SetTooltipText(const base::string16& tooltip_text) {
   DCHECK(handles_tooltips_);
   tooltip_text_ = tooltip_text;
 }
 
@@ skipping 80 matching lines @@
 
   for (size_t i = 0; i < cached_heights_.size(); ++i) {
     const gfx::Size& s = cached_heights_[i];
     if (s.width() == w)
       return s.height() + GetInsets().height();
   }
 
   int cache_width = w;
 
   int h = font_list_.GetHeight();
+  // Flags returned in the cached |DrawStringParams| has a different value
+  // from the result of |ComputeDrawStringFlags()|. The latter is needed here.
   const int flags = ComputeDrawStringFlags();
   gfx::Canvas::SizeStringInt(
       layout_text_, font_list_, &w, &h, line_height_, flags);
   cached_heights_[cached_heights_cursor_] = gfx::Size(cache_width, h);
   cached_heights_cursor_ = (cached_heights_cursor_ + 1) % kCachedSizeLimit;
   return h + GetInsets().height();
 }
 
 const char* Label::GetClassName() const {
   return kViewClassName;
@@ skipping 62 matching lines @@
 
     // For single-line strings, we supply the largest possible width, because
     // while adding NO_ELLIPSIS to the flags works on Windows for forcing
     // SizeStringInt() to calculate the desired width, it doesn't seem to work
     // on Linux.
     int w = multi_line_ ?
         GetAvailableRect().width() : std::numeric_limits<int>::max();
     int h = font_list_.GetHeight();
     // For single-line strings, ignore the available width and calculate how
     // wide the text wants to be.
+    // Call |ComputeDrawStringFlags()| instead of |CalculateDrawStringParams()|
+    // here since the latter calls this function and causes infinite recursion.
     int flags = ComputeDrawStringFlags();
     if (!multi_line_)
       flags |= gfx::Canvas::NO_ELLIPSIS;
     {
       // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is
       // fixed.
       tracked_objects::ScopedTracker tracking_profile2(
           FROM_HERE_WITH_EXPLICIT_FUNCTION("431326 Label::GetTextSize2"));
 
       gfx::Canvas::SizeStringInt(layout_text_, font_list_, &w, &h, line_height_,
                                  flags);
     }
     text_size_.SetSize(w, h);
     const gfx::Insets shadow_margin = -gfx::ShadowValue::GetMargin(shadows_);
     text_size_.Enlarge(shadow_margin.width(), shadow_margin.height());
     text_size_valid_ = true;
   }
 
   return text_size_;
 }
 
 void Label::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   text_size_valid_ &= !multi_line_;
+  cached_draw_params_.text.clear();
 }
 
 void Label::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
   // We skip painting the focus border because it is being handled seperately by
   // some subclasses of Label. We do not want View's focus border painting to
   // interfere with that.
   OnPaintBorder(canvas);
+  if (layout_text_.empty())
+    return;
 
-  base::string16 paint_text;
-  gfx::Rect text_bounds;
-  int flags = 0;
-  CalculateDrawStringParams(&paint_text, &text_bounds, &flags);
+  const DrawStringParams* params = CalculateDrawStringParams();
   if (is_first_paint_text_) {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("431326 Label::PaintText first"));
 
     is_first_paint_text_ = false;
-    PaintText(canvas, paint_text, text_bounds, flags);
+    PaintText(canvas, params->text, params->bounds, params->flags);
   } else {
     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("431326 Label::PaintText not first"));
 
-    PaintText(canvas, paint_text, text_bounds, flags);
+    PaintText(canvas, params->text, params->bounds, params->flags);
   }
 }
 
 void Label::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   UpdateColorsFromTheme(theme);
 }
 
 void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
   font_list_ = font_list;
   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
   subpixel_rendering_enabled_ = true;
   auto_color_readability_ = true;
   UpdateColorsFromTheme(ui::NativeTheme::instance());
   horizontal_alignment_ = gfx::ALIGN_CENTER;
   line_height_ = 0;
   multi_line_ = false;
   obscured_ = false;
   allow_character_break_ = false;
   elide_behavior_ = gfx::ELIDE_TAIL;
   handles_tooltips_ = true;
   collapse_when_hidden_ = false;
   cached_heights_.resize(kCachedSizeLimit);
-  ResetCachedSize();
+  ResetLayoutCache();
   is_first_paint_text_ = true;
 
   SetText(text);
 }
 
 void Label::RecalculateColors() {
   actual_enabled_color_ = auto_color_readability_ ?
       color_utils::GetReadableColor(requested_enabled_color_,
                                     background_color_) :
       requested_enabled_color_;
@@ skipping 76 matching lines @@
 
   return flags;
 }
 
 gfx::Rect Label::GetAvailableRect() const {
   gfx::Rect bounds(size());
   bounds.Inset(GetInsets());
   return bounds;
 }
 
-void Label::CalculateDrawStringParams(base::string16* paint_text,
-                                      gfx::Rect* text_bounds,
-                                      int* flags) const {
-  DCHECK(paint_text && text_bounds && flags);
+const Label::DrawStringParams* Label::CalculateDrawStringParams() const {
+  if (cached_draw_params_.text.empty()) {
+    const bool forbid_ellipsis = elide_behavior_ == gfx::NO_ELIDE ||
+                                 elide_behavior_ == gfx::FADE_TAIL;
+    if (multi_line_ || forbid_ellipsis) {
+      cached_draw_params_.text = layout_text_;
+    } else {
+      cached_draw_params_.text = gfx::ElideText(layout_text_, font_list_,
+          GetAvailableRect().width(), elide_behavior_);
+    }
 
-  const bool forbid_ellipsis = elide_behavior_ == gfx::NO_ELIDE ||
-                               elide_behavior_ == gfx::FADE_TAIL;
-  if (multi_line_ || forbid_ellipsis) {
-    *paint_text = layout_text_;
-  } else {
-    *paint_text = gfx::ElideText(layout_text_, font_list_,
-                                 GetAvailableRect().width(), elide_behavior_);
+    cached_draw_params_.bounds = GetTextBounds();
+    cached_draw_params_.flags = ComputeDrawStringFlags();
+    // TODO(msw): Elide multi-line text with ElideRectangleText instead.
+    if (!multi_line_ || forbid_ellipsis)
+      cached_draw_params_.flags |= gfx::Canvas::NO_ELLIPSIS;
   }
 
-  *text_bounds = GetTextBounds();
-  *flags = ComputeDrawStringFlags();
-  // TODO(msw): Elide multi-line text with ElideRectangleText instead.
-  if (!multi_line_ || forbid_ellipsis)
-    *flags |= gfx::Canvas::NO_ELLIPSIS;
+  return &cached_draw_params_;
 }
 
 void Label::UpdateColorsFromTheme(const ui::NativeTheme* theme) {
   if (!enabled_color_set_) {
     requested_enabled_color_ = theme->GetSystemColor(
         ui::NativeTheme::kColorId_LabelEnabledColor);
   }
   if (!disabled_color_set_) {
     requested_disabled_color_ = theme->GetSystemColor(
         ui::NativeTheme::kColorId_LabelDisabledColor);
   }
   if (!background_color_set_) {
     background_color_ = theme->GetSystemColor(
         ui::NativeTheme::kColorId_LabelBackgroundColor);
   }
   RecalculateColors();
 }
 
-void Label::ResetCachedSize() {
+void Label::ResetLayoutCache() {
+  cached_draw_params_.text.clear();
   text_size_valid_ = false;
   cached_heights_cursor_ = 0;
   for (int i = 0; i < kCachedSizeLimit; ++i)
     cached_heights_[i] = gfx::Size();
 }
 
 bool Label::ShouldShowDefaultTooltip() const {
   const gfx::Size text_size = GetTextSize();
   const gfx::Size size = GetContentsBounds().size();
   return !obscured() && (text_size.width() > size.width() ||
                          (multi_line_ && text_size.height() > size.height()));
 }
 
 }  // namespace views