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();
   const int flags = ComputeDrawStringFlags();

[sky, 2015/01/08 22:54:57]

It seems like there is still a number of places calling ComputeDrawStringFlags.
Shouldn't they all you the cache now?

[ckocagil, 2015/01/09 15:05:14]

There are 2 calls to ComputeDrawStringFlags() other than the one in
CalculateDrawStringParams():

The call in GetHeightForWidth() is needed because the flags returned by
CalculateDrawStringParams() have a different value which changes the behavior
(and the tests fail).

Simply replacing the call in GetTextSize() with ComputeDrawStringFlags() causes
an infinite recursion. Breaking it would require passing an argument, some
complex state juggling, or separating the caches of |flags| and |text|. I don't
think we want these.

[sky, 2015/01/09 17:07:09]

Fair enough. Please add comments to these places as to why they can't use the
cache then.

   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 84 matching lines @@
     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