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) {

[msw, 2011/11/28 21:15:46]

Init needs_layout_

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

Embarrassing! Done.

   // 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() {

[msw, 2011/11/28 21:15:46]

Do we need EnsureLayout on these protected methods:
LeftEndSelectionModel, RightEndSelectionModel, GetSubstringBounds.
Otherwise, please |DCHECK(!needs_layout_);|

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

Done.

   if (text().empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
   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);
 }
@@ skipping 61 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() {
+  needs_layout_ = true;

[msw, 2011/11/28 21:15:46]

Add a simple comment like "Layout is performed lazily as needed for
drawing/metrics."

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

Done.

+}
+
+void RenderTextWin::EnsureLayout() {

[msw, 2011/11/28 21:15:46]

This should be below IndexOfAdjacentGrapheme to match decl order.

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

Done.

+  if (!needs_layout_)
+    return;
   // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
   ItemizeLogicalText();
   if (!runs_.empty())
     LayoutVisualText();

[msw, 2011/11/28 21:15:46]

I think we actually need to reset |string_width_| here, or you could set
|string_width_ = 0| and then check |if (!runs_.empty())| for early-termination
at the top of LayoutVisualText.

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

Good catch! Done.

+  needs_layout_ = false;
 }
 
 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--;
@@ skipping 153 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(

[msw, 2011/11/28 21:15:46]

Should these private methods |DCHECK(!needs_layout_);|:
[First|Last]SelectionModelInsideRun, [Left|Right]SelectionModel

[Alexei Svitkine (slow), 2011/11/28 21:58:13]

As they currently are, they don't need it. However, I've made
[Left|Right]SelectionModel have the DCHECK() - explanation below.
These shouldn't have it because they don't use any state from layout directly -
only parameters and return values of other functions, specifically
IndexOfAdjacentGrapheme(). That function does need layout, but does call
EnsureLayout().

Since they don't touch layout state (from the class) directly, they shouldn't
need to check it.
These both get called only via entry points that do EnsureLayout(). Furthermore,
both call GetRunContainingPosition() near the start, which has the DCHECK().

But, since they end up using layout state following that call, I've added the
DCHECK()'s to these, to protect against refactoring changes.

     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);
@@ skipping 145 matching lines @@
     Rect r(GetUpdatedCursorBounds());
     canvas->DrawRectInt(kCursorColor, r.x(), r.y(), r.width(), r.height());
   }
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx