Improve RenderTextWin font fallback.

ui/gfx/render_text.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.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 49 matching lines @@
       split_style.range.set_end(new_range.start());
       i = style_ranges->insert(i, split_style) + 1;
       i->range.set_start(new_range.end());
       break;
     } else if (i->range.start() < new_range.start()) {
       i->range.set_end(new_range.start());
       i++;
     } else if (i->range.end() > new_range.end()) {
       i->range.set_start(new_range.end());
       break;
-    } else
+    } else {
       NOTREACHED();
+    }
   }
   // Add the new range in its sorted location.
   style_ranges->insert(i, style_range);
 }
 
 }  // namespace
 
 namespace gfx {
 
 StyleRange::StyleRange()
@@ skipping 97 matching lines @@
     if (break_type == WORD_BREAK)
       position = GetRightSelectionModel(position, break_type);
   } else {
     position = GetRightSelectionModel(position, break_type);
   }
   if (select)
     position.set_selection_start(GetSelectionStart());
   MoveCursorTo(position);
 }
 
-bool RenderText::MoveCursorTo(const SelectionModel& selection_model) {
-  SelectionModel sel(selection_model);
+bool RenderText::MoveCursorTo(const SelectionModel& model) {
+  SelectionModel sel(model);
   size_t text_length = text().length();
   // Enforce valid selection model components.
   if (sel.selection_start() > text_length)
     sel.set_selection_start(text_length);
   if (sel.selection_end() > text_length)
     sel.set_selection_end(text_length);
   // The current model only supports caret positions at valid character indices.
   if (text_length == 0) {
     sel.set_caret_pos(0);
     sel.set_caret_placement(SelectionModel::LEADING);
   } else if (sel.caret_pos() >= text_length) {
     SelectionModel end = GetTextDirection() == base::i18n::RIGHT_TO_LEFT ?
         LeftEndSelectionModel() : RightEndSelectionModel();
     sel.set_caret_pos(end.caret_pos());
     sel.set_caret_placement(end.caret_placement());
   }
 
-  if (!IsCursorablePosition(sel.selection_start()) ||
-      !IsCursorablePosition(sel.selection_end()) ||
-      !IsCursorablePosition(sel.caret_pos()))
+  if (!IsCursorablePosition(sel.selection_start(), false) ||
+      !IsCursorablePosition(sel.selection_end(), false) ||
+      !IsCursorablePosition(sel.caret_pos(),
+          (sel.caret_placement() == SelectionModel::TRAILING))) {

[xji, 2011/11/29 21:15:48]

I did not quite get the reason of introducing "bool is_trailing" to
IsCursorablePosition.

As to this call site, it originally means caret_pos() itself should also be a
cursorable position regardless whether it is the leading edge or trailing edge.

For example:
ABC,  "BC" belongs to one grapheme, 
cursorable positions are |ABC, A|BC, and ABC|.
If selection model is (2, trailing, 3), which means caret_pos is 2, it is the
trailing edge of 2nd character, and the logical index is 3, it is not a correct
selection_model because 2nd character is not the start of a grapheme.

After this change, if caret_placement() is trailing, does 
IsCursorPosition(sel.caret_pos(), true)
check the same position as
IsCursorPosition(sel.selection_end(), false)?

will it be treated as a valid selection model in Win?

     return false;
+  }
 
   bool changed = !sel.Equals(selection_model_);
   SetSelectionModel(sel);
   return changed;
 }
 
 bool RenderText::MoveCursorTo(const Point& point, bool select) {
   SelectionModel selection = FindCursorPosition(point);
   if (select)
     selection.set_selection_start(GetSelectionStart());
   return MoveCursorTo(selection);
 }
 
 bool RenderText::SelectRange(const ui::Range& range) {
   size_t text_length = text().length();
   size_t start = std::min(range.start(), text_length);
   size_t end = std::min(range.end(), text_length);
 
-  if (!IsCursorablePosition(start) || !IsCursorablePosition(end))
+  if (!IsCursorablePosition(start, false) || !IsCursorablePosition(end, false))
     return false;
 
   size_t pos = end;
   SelectionModel::CaretPlacement placement = SelectionModel::LEADING;
   if (start < end) {
     pos = GetIndexOfPreviousGrapheme(end);
     DCHECK_LT(pos, end);
     placement = SelectionModel::TRAILING;
   } else if (end == text_length) {
     SelectionModel boundary = GetTextDirection() == base::i18n::RIGHT_TO_LEFT ?
@@ skipping 162 matching lines @@
   int left_pos = 0;
   int right = font.GetStringWidth(text());
   int right_pos = text().length();
 
   int x = point.x() - (display_rect_.x() + GetUpdatedDisplayOffset().x());
   if (x <= left) return SelectionModel(left_pos);
   if (x >= right) return SelectionModel(right_pos);
   // binary searching the cursor position.
   // TODO(oshima): use the center of character instead of edge.
   // Binary search may not work for language like Arabic.
-  while (std::abs(static_cast<long>(right_pos - left_pos)) > 1) {
+  while (std::abs(right_pos - left_pos) > 1) {
     int pivot_pos = left_pos + (right_pos - left_pos) / 2;
     int pivot = font.GetStringWidth(text().substr(0, pivot_pos));
     if (pivot < x) {
       left = pivot;
       left_pos = pivot_pos;
     } else if (pivot == x) {
       return SelectionModel(pivot_pos);
     } else {
       right = pivot;
       right_pos = pivot_pos;
@@ skipping 48 matching lines @@
 
 const Point& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetLeftSelectionModel(const SelectionModel& current,
                                                  BreakType break_type) {
   if (break_type == LINE_BREAK)
     return LeftEndSelectionModel();
-  size_t pos = std::max(static_cast<long>(current.selection_end() - 1),
-                        static_cast<long>(0));
+  size_t pos = std::max<int>(current.selection_end() - 1, 0);
   if (break_type == CHARACTER_BREAK)
     return SelectionModel(pos, pos, SelectionModel::LEADING);
 
   // Notes: We always iterate words from the beginning.
   // This is probably fast enough for our usage, but we may
   // want to modify WordIterator so that it can start from the
   // middle of string and advance backwards.
   base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
@@ skipping 109 matching lines @@
   if (base::i18n::IsRTL())
     p.Offset(display_rect().width() - GetStringWidth() - 1, 0);
   return p;
 }
 
 void RenderText::SetSelectionModel(const SelectionModel& selection_model) {
   DCHECK_LE(selection_model.selection_start(), text().length());
   selection_model_.set_selection_start(selection_model.selection_start());
   DCHECK_LE(selection_model.selection_end(), text().length());
   selection_model_.set_selection_end(selection_model.selection_end());
-  DCHECK_LT(selection_model.caret_pos(),
-            std::max(text().length(), static_cast<size_t>(1)));
+  DCHECK_LT(selection_model.caret_pos(), std::max<size_t>(text().length(), 1));
   selection_model_.set_caret_pos(selection_model.caret_pos());
   selection_model_.set_caret_placement(selection_model.caret_placement());
 
   cached_bounds_and_offset_valid_ = false;
   UpdateLayout();
 }
 
 void RenderText::MoveCursorTo(size_t position, bool select) {
   size_t cursor = std::min(position, text().length());
   size_t caret_pos = GetIndexOfPreviousGrapheme(cursor);
   SelectionModel::CaretPlacement placement = (caret_pos == cursor) ?
       SelectionModel::LEADING : SelectionModel::TRAILING;
   size_t selection_start = select ? GetSelectionStart() : cursor;
-  if (IsCursorablePosition(cursor)) {
+  if (IsCursorablePosition(cursor, false)) {
     SelectionModel sel(selection_start, cursor, caret_pos, placement);
     SetSelectionModel(sel);
   }
 }
 
 void RenderText::UpdateCachedBoundsAndOffset() {
   if (cached_bounds_and_offset_valid_)
     return;
   // First, set the valid flag true to calculate the current cursor bounds using
   // the stale |display_offset_|. Applying |delta_offset| at the end of this
@@ skipping 19 matching lines @@
     // LTR character.
     //
     // Pan to show the cursor when it overflows to the left.
     delta_offset = display_rect_.x() - cursor_bounds_.x();
   }
   display_offset_.Offset(delta_offset, 0);
   cursor_bounds_.Offset(delta_offset, 0);
 }
 
 }  // namespace gfx