Itemize and layout text lazily in RenderTextWin.

ui/gfx/render_text_win.cc

 // Copyright (c) 2011 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_win.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 127 matching lines @@
 TextRun::~TextRun() {
   ScriptFreeCache(&script_cache);
 }
 
 }  // namespace internal
 
 RenderTextWin::RenderTextWin()
     : RenderText(),
       script_control_(),
       script_state_(),
-      string_width_(0) {
+      string_width_(0),
+      needs_layout_(false) {
   // Omitting default constructors for script_* would leave POD uninitialized.
   HRESULT hr = 0;
 
   // TODO(msw): Call ScriptRecordDigitSubstitution on WM_SETTINGCHANGE message.
   // TODO(msw): Use Chrome/profile locale/language settings?
   hr = ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &digit_substitute_);
   DCHECK(SUCCEEDED(hr));
 
   hr = ScriptApplyDigitSubstitution(&digit_substitute_,
                                     &script_control_,
                                     &script_state_);
   DCHECK(SUCCEEDED(hr));
   script_control_.fMergeNeutralItems = true;
 
   MoveCursorTo(LeftEndSelectionModel());
 }
 
 RenderTextWin::~RenderTextWin() {
   STLDeleteContainerPointers(runs_.begin(), runs_.end());
 }
 
 int RenderTextWin::GetStringWidth() {
+  EnsureLayout();
   return string_width_;
 }
 
 void RenderTextWin::Draw(Canvas* canvas) {
+  EnsureLayout();
   DrawSelection(canvas);
   DrawVisualText(canvas);
   DrawCursor(canvas);
 }
 
 SelectionModel RenderTextWin::FindCursorPosition(const Point& point) {
   if (text().empty())
     return SelectionModel();
 
+  EnsureLayout();
   // Find the run that contains the point and adjust the argument location.
   Point p(ToTextPoint(point));
   size_t run_index = GetRunContainingPoint(p);
   if (run_index == runs_.size())
     return (p.x() < 0) ? LeftEndSelectionModel() : RightEndSelectionModel();
   internal::TextRun* run = runs_[run_index];
 
   int position = 0, trailing = 0;
   HRESULT hr = ScriptXtoCP(p.x() - run->preceding_run_widths,
                            run->range.length(),
                            run->glyph_count,
                            run->logical_clusters.get(),
                            run->visible_attributes.get(),
                            run->advance_widths.get(),
                            &(run->script_analysis),
                            &position,
                            &trailing);
   DCHECK(SUCCEEDED(hr));
   position += run->range.start();
 
   size_t cursor = position + trailing;
   DCHECK_GE(cursor, 0U);
   DCHECK_LE(cursor, text().length());
   return SelectionModel(cursor, position,
       (trailing > 0) ? SelectionModel::TRAILING : SelectionModel::LEADING);
 }
 
 Rect RenderTextWin::GetCursorBounds(const SelectionModel& selection,
                                     bool insert_mode) {
+  EnsureLayout();
+
   // Highlight the logical cursor (selection end) when not in insert mode.
   size_t pos = insert_mode ? selection.caret_pos() : selection.selection_end();
   size_t run_index = GetRunContainingPosition(pos);
   internal::TextRun* run = run_index == runs_.size() ? NULL : runs_[run_index];
 
   int start_x = 0, end_x = 0;
   if (run) {
     HRESULT hr = 0;
     hr = ScriptCPtoX(pos - run->range.start(),
                      false,
@@ skipping 32 matching lines @@
       rect.set_x(rect.right());
     rect.set_width(0);
   }
   rect.set_origin(ToViewPoint(rect.origin()));
   return rect;
 }
 
 SelectionModel RenderTextWin::GetLeftSelectionModel(
     const SelectionModel& selection,
     BreakType break_type) {
+  EnsureLayout();
+
   if (break_type == LINE_BREAK || text().empty())
     return LeftEndSelectionModel();
   if (break_type == CHARACTER_BREAK)
     return LeftSelectionModel(selection);
   // TODO(msw): Implement word breaking.
   return RenderText::GetLeftSelectionModel(selection, break_type);
 }
 
 SelectionModel RenderTextWin::GetRightSelectionModel(
     const SelectionModel& selection,
     BreakType break_type) {
+  EnsureLayout();
+
   if (break_type == LINE_BREAK || text().empty())
     return RightEndSelectionModel();
   if (break_type == CHARACTER_BREAK)
     return RightSelectionModel(selection);
   // TODO(msw): Implement word breaking.
   return RenderText::GetRightSelectionModel(selection, break_type);
 }
 
 SelectionModel RenderTextWin::LeftEndSelectionModel() {
   if (text().empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
+
+  EnsureLayout();
   size_t cursor = base::i18n::IsRTL() ? text().length() : 0;
   internal::TextRun* run = runs_[visual_to_logical_[0]];
   bool rtl = run->script_analysis.fRTL;
   size_t caret = rtl ? run->range.end() - 1 : run->range.start();
   SelectionModel::CaretPlacement placement =
       rtl ? SelectionModel::TRAILING : SelectionModel::LEADING;
   return SelectionModel(cursor, caret, placement);
 }
 
 SelectionModel RenderTextWin::RightEndSelectionModel() {
   if (text().empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
+
+  EnsureLayout();
   size_t cursor = base::i18n::IsRTL() ? 0 : text().length();
   internal::TextRun* run = runs_[visual_to_logical_[runs_.size() - 1]];
   bool rtl = run->script_analysis.fRTL;
   size_t caret = rtl ? run->range.start() : run->range.end() - 1;
   SelectionModel::CaretPlacement placement =
       rtl ? SelectionModel::LEADING : SelectionModel::TRAILING;
   return SelectionModel(cursor, caret, placement);
 }
 
 std::vector<Rect> RenderTextWin::GetSubstringBounds(size_t from, size_t to) {
+  DCHECK(!needs_layout_);
   ui::Range range(from, to);
   DCHECK(ui::Range(0, text().length()).Contains(range));
   Point display_offset(GetUpdatedDisplayOffset());
   std::vector<Rect> bounds;
   HRESULT hr = 0;
 
   // Add a Rect for each run/selection intersection.
   // TODO(msw): The bounds should probably not always be leading the range ends.
   for (size_t i = 0; i < runs_.size(); ++i) {
     internal::TextRun* run = runs_[visual_to_logical_[i]];
@@ skipping 37 matching lines @@
       bounds.push_back(rect);
     }
   }
   return bounds;
 }
 
 bool RenderTextWin::IsCursorablePosition(size_t position) {
   if (position == 0 || position == text().length())
     return true;
 
+  EnsureLayout();
   size_t run_index = GetRunContainingPosition(position);
   if (run_index >= runs_.size())
     return false;
 
   internal::TextRun* run = runs_[run_index];
   size_t start = run->range.start();
   if (position == start)
     return true;
   return run->logical_clusters[position - start] !=
          run->logical_clusters[position - start - 1];
 }
 
 void RenderTextWin::UpdateLayout() {
-  // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
-  ItemizeLogicalText();
-  if (!runs_.empty())
-    LayoutVisualText();
+  // Layout is performed lazily as needed for drawing/metrics.
+  needs_layout_ = true;
 }
 
 size_t RenderTextWin::IndexOfAdjacentGrapheme(size_t index, bool next) {
+  EnsureLayout();
   size_t run_index = GetRunContainingPosition(index);
   internal::TextRun* run = run_index < runs_.size() ? runs_[run_index] : NULL;
   int start = run ? run->range.start() : 0;
   int length = run ? run->range.length() : text().length();
   int ch = index - start;
   WORD cluster = run ? run->logical_clusters[ch] : 0;
 
   if (!next) {
     do {
       ch--;
     } while (ch >= 0 && run && run->logical_clusters[ch] == cluster);
   } else {
     while (ch < length && run && run->logical_clusters[ch] == cluster)
       ch++;
   }
   return std::max(std::min(ch, length) + start, 0);
 }
 
+void RenderTextWin::EnsureLayout() {
+  if (!needs_layout_)
+    return;
+  // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
+  ItemizeLogicalText();
+  if (!runs_.empty())
+    LayoutVisualText();
+  needs_layout_ = false;
+}
+
 void RenderTextWin::ItemizeLogicalText() {
   STLDeleteContainerPointers(runs_.begin(), runs_.end());
   runs_.clear();
+  string_width_ = 0;
   if (text().empty())
     return;
 
   const wchar_t* raw_text = text().c_str();
   const int text_length = text().length();
 
   HRESULT hr = E_OUTOFMEMORY;
   int script_items_count = 0;
   std::vector<SCRIPT_ITEM> script_items;
   for (size_t n = kGuessItems; hr == E_OUTOFMEMORY && n < kMaxItems; n *= 2) {
@@ skipping 132 matching lines @@
     internal::TextRun* run = runs_[visual_to_logical_[i]];
     run->preceding_run_widths = preceding_run_widths;
     const ABC& abc = run->abc_widths;
     run->width = abc.abcA + abc.abcB + abc.abcC;
     preceding_run_widths += run->width;
   }
   string_width_ = preceding_run_widths;
 }
 
 size_t RenderTextWin::GetRunContainingPosition(size_t position) const {
+  DCHECK(!needs_layout_);
   // Find the text run containing the argument position.
   size_t run = 0;
   for (; run < runs_.size(); ++run)
     if (runs_[run]->range.start() <= position &&
         runs_[run]->range.end() > position)
       break;
   return run;
 }
 
 size_t RenderTextWin::GetRunContainingPoint(const Point& point) const {
+  DCHECK(!needs_layout_);
   // Find the text run containing the argument point (assumed already offset).
   size_t run = 0;
   for (; run < runs_.size(); ++run)
     if (runs_[run]->preceding_run_widths <= point.x() &&
         runs_[run]->preceding_run_widths + runs_[run]->width > point.x())
       break;
   return run;
 }
 
 SelectionModel RenderTextWin::FirstSelectionModelInsideRun(
     internal::TextRun* run) {
   size_t caret = run->range.start();
   size_t cursor = IndexOfAdjacentGrapheme(caret, true);
   return SelectionModel(cursor, caret, SelectionModel::TRAILING);
 }
 
 SelectionModel RenderTextWin::LastSelectionModelInsideRun(
     internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), false);
   return SelectionModel(caret, caret, SelectionModel::LEADING);
 }
 
 SelectionModel RenderTextWin::LeftSelectionModel(
     const SelectionModel& selection) {
+  DCHECK(!needs_layout_);
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   size_t run_index = GetRunContainingPosition(caret);
   DCHECK(run_index < runs_.size());
   internal::TextRun* run = runs_[run_index];
 
   // If the caret's associated character is in a LTR run.
   if (!run->script_analysis.fRTL) {
     if (caret_placement == SelectionModel::TRAILING)
       return SelectionModel(caret, caret, SelectionModel::LEADING);
@@ skipping 16 matching lines @@
   size_t visual_index = logical_to_visual_[run_index];
   if (visual_index == 0)
     return LeftEndSelectionModel();
   internal::TextRun* prev = runs_[visual_to_logical_[visual_index - 1]];
   return prev->script_analysis.fRTL ? FirstSelectionModelInsideRun(prev) :
                                       LastSelectionModelInsideRun(prev);
 }
 
 SelectionModel RenderTextWin::RightSelectionModel(
     const SelectionModel& selection) {
+  DCHECK(!needs_layout_);
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   size_t run_index = GetRunContainingPosition(caret);
   DCHECK(run_index < runs_.size());
   internal::TextRun* run = runs_[run_index];
 
   // If the caret's associated character is in a LTR run.
   if (!run->script_analysis.fRTL) {
     if (caret_placement == SelectionModel::LEADING) {
       size_t cursor = IndexOfAdjacentGrapheme(caret, true);
@@ skipping 95 matching lines @@
     Rect r(GetUpdatedCursorBounds());
     canvas->DrawRectInt(kCursorColor, r.x(), r.y(), r.width(), r.height());
   }
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx