[WIP: not for review] Reduce re-layout

ui/gfx/render_text.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/gfx/render_text.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
@@ skipping 416 matching lines @@
     return new RenderTextMac;
 #endif  // defined(OS_MACOSX)
   return new RenderTextHarfBuzz;
 }
 
 // static
 RenderText* RenderText::CreateInstanceForEditing() {
   return new RenderTextHarfBuzz;
 }
 
+std::unique_ptr<RenderText> RenderText::CreateInstanceOfSameStyle(
+    const base::string16& text) const {
+  std::unique_ptr<RenderText> render_text = CreateInstanceOfSameType();
+  // |SetText()| must be called before styles are set.
+  render_text->directionality_mode_ = directionality_mode_;
+  render_text->cursor_enabled_ = cursor_enabled_;
+  render_text->set_truncate_length(truncate_length_);
+  render_text->font_list_ = font_list_;
+  render_text->text_ = text;
+  render_text->styles_ = styles_;
+  render_text->baselines_ = baselines_;
+  render_text->colors_ = colors_;
+  render_text->multiline_ = multiline_;
+  render_text->SetDisplayRect(display_rect_);
+  render_text->OnTextAttributeChanged();
+  return render_text;
+}
+
 void RenderText::SetText(const base::string16& text) {
   DCHECK(!composition_range_.IsValid());
   if (text_ == text)
     return;
   text_ = text;
   UpdateStyleLengths();
 
   // Clear style ranges as they might break new text graphemes and apply
   // the first style to the whole text instead.
   colors_.SetValue(colors_.breaks().begin()->second);
@@ skipping 71 matching lines @@
 
 void RenderText::SetMultiline(bool multiline) {
   if (multiline != multiline_) {
     multiline_ = multiline;
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
     OnTextAttributeChanged();
   }
 }
 
+void RenderText::SetMaxLines(size_t max_lines) {
+  max_lines_ = max_lines;
+  OnDisplayTextAttributeChanged();
+}
+
+size_t RenderText::GetNumLines() {
+  return lines_.size();
+}
+
 void RenderText::SetWordWrapBehavior(WordWrapBehavior behavior) {
   if (word_wrap_behavior_ == behavior)
     return;
   word_wrap_behavior_ = behavior;
   if (multiline_) {
     cached_bounds_and_offset_valid_ = false;
     lines_.clear();
     OnTextAttributeChanged();
   }
 }
@@ skipping 437 matching lines @@
       baselines_(NORMAL_BASELINE),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       elide_behavior_(NO_ELIDE),
       text_elided_(false),
       min_line_height_(0),
       multiline_(false),
+      max_lines_(0),
       word_wrap_behavior_(IGNORE_LONG_WORDS),
       replace_newline_chars_with_symbols_(true),
       subpixel_rendering_suppressed_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
-      cached_bounds_and_offset_valid_(false) {
-}
+      cached_bounds_and_offset_valid_(false) {}
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
     VisualCursorDirection direction) {
   EnsureLayout();
 
   if (break_type == LINE_BREAK || text().empty())
     return EdgeSelectionModel(direction);
   if (break_type == CHARACTER_BREAK)
@@ skipping 12 matching lines @@
 void RenderText::SetSelectionModel(const SelectionModel& model) {
   DCHECK_LE(model.selection().GetMax(), text().length());
   selection_model_ = model;
   cached_bounds_and_offset_valid_ = false;
 }
 
 void RenderText::OnTextColorChanged() {
 }
 
 void RenderText::UpdateDisplayText(float text_width) {
-  // TODO(oshima): Consider support eliding for multi-line text.
-  // This requires max_line support first.
-  if (multiline_ ||
-      elide_behavior() == NO_ELIDE ||
-      elide_behavior() == FADE_TAIL ||
-      text_width < display_rect_.width() ||
+  // TODO(krb): Consider other elision modes for multiline.
+  if ((multiline_ && (!max_lines_ || elide_behavior() != ELIDE_TAIL)) ||
+      elide_behavior() == NO_ELIDE || elide_behavior() == FADE_TAIL ||
+      (text_width > 0 && text_width < display_rect_.width()) ||
       layout_text_.empty()) {
     text_elided_ = false;
     display_text_.clear();
     return;
   }
 
-  // This doesn't trim styles so ellipsis may get rendered as a different
-  // style than the preceding text. See crbug.com/327850.
-  display_text_.assign(Elide(layout_text_,
-                             text_width,
-                             static_cast<float>(display_rect_.width()),
-                             elide_behavior_));
+  if (!multiline_) {
+    // This doesn't trim styles so ellipsis may get rendered as a different
+    // style than the preceding text. See crbug.com/327850.
+    display_text_.assign(Elide(layout_text_, text_width,
+                               static_cast<float>(display_rect_.width()),
+                               elide_behavior_));
+  } else {
+    bool was_elided = text_elided_;
+    text_elided_ = false;
+    display_text_.clear();
 
+    std::unique_ptr<RenderText> render_text(
+        CreateInstanceOfSameStyle(layout_text_));
+    //render_text->SetMultiline(true);
+    //render_text->SetDisplayRect(display_rect_);
+    // Have it arrange words on |lines_|.
+    //render_text->OnLayoutTextAttributeChanged(false);
+    render_text->EnsureLayout();
+
+    if (render_text->lines_.size() > max_lines_) {
+      size_t start_of_elision = render_text->lines_[max_lines_ - 1]
+                                    .segments.front()
+                                    .char_range.start();
+      base::string16 text_to_elide = layout_text_.substr(start_of_elision);
+      display_text_.assign(layout_text_.substr(0, start_of_elision) +
+                           Elide(text_to_elide, 0,
+                                 static_cast<float>(display_rect_.width()),
+                                 ELIDE_TAIL));
+      // Have GetLineBreaks() re-calculate.
+      line_breaks_.SetMax(0);
+    } else {
+      // If elision changed, re-calculate.
+      if (was_elided)
+        line_breaks_.SetMax(0);
+      // Initial state above is fine.
+      return;
+    }
+  }
   text_elided_ = display_text_ != layout_text_;
   if (!text_elided_)
     display_text_.clear();
 }
 
 const BreakList<size_t>& RenderText::GetLineBreaks() {
   if (line_breaks_.max() != 0)
     return line_breaks_;
 
   const base::string16& layout_text = GetDisplayText();
@@ skipping 291 matching lines @@
   if (available_width <= 0 || text.empty())
     return base::string16();
   if (behavior == ELIDE_EMAIL)
     return ElideEmail(text, available_width);
   if (text_width > 0 && text_width < available_width)
     return text;
 
   TRACE_EVENT0("ui", "RenderText::Elide");
 
   // Create a RenderText copy with attributes that affect the rendering width.
-  std::unique_ptr<RenderText> render_text = CreateInstanceOfSameType();
-  render_text->SetFontList(font_list_);
-  render_text->SetDirectionalityMode(directionality_mode_);
-  render_text->SetCursorEnabled(cursor_enabled_);
-  render_text->set_truncate_length(truncate_length_);
-  render_text->styles_ = styles_;
-  render_text->baselines_ = baselines_;
-  render_text->colors_ = colors_;
+  bool orig_multiline = multiline_;
+  multiline_ = false;
+  std::unique_ptr<RenderText> render_text = CreateInstanceOfSameStyle(text);
+  multiline_ = orig_multiline;
   if (text_width == 0) {
-    render_text->SetText(text);
     text_width = render_text->GetContentWidthF();
   }
   if (text_width <= available_width)
     return text;
 
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
   const bool elide_at_beginning = (behavior == ELIDE_HEAD);
 
@@ skipping 141 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx