fix know issues in RenderText

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 "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 219 matching lines @@
     return SelectionModel(0, 0, SelectionModel::LEADING);
   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);
 }
 
-size_t RenderTextWin::GetIndexOfPreviousGrapheme(size_t position) {
-  return IndexOfAdjacentGrapheme(position, false);
-}
-
 std::vector<Rect> RenderTextWin::GetSubstringBounds(size_t from, size_t to) {
   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) {
@@ skipping 34 matching lines @@
       if (!bounds.empty() && rect.SharesEdgeWith(bounds.back())) {
         rect = rect.Union(bounds.back());
         bounds.pop_back();
       }
       bounds.push_back(rect);
     }
   }
   return bounds;
 }
 
+bool RenderTextWin::IsCursorablePosition(size_t position) {
+  if (position == 0 || position == text().length())
+    return true;
+
+  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];
+}
+
+size_t RenderTextWin::IndexOfAdjacentGrapheme(size_t index, bool next) {
+  size_t run_index = GetRunContainingPosition(index);
+  internal::TextRun* run = run_index < runs_.size() ? runs_[run_index] : NULL;
+  long start = run ? run->range.start() : 0;
+  long length = run ? run->range.length() : text().length();
+  long 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(static_cast<long>(std::min(ch, length) + start), 0L);
+}
+
 void RenderTextWin::ItemizeLogicalText() {
   text_is_dirty_ = false;
   STLDeleteContainerPointers(runs_.begin(), runs_.end());
   runs_.clear();
   if (text().empty())
     return;
 
   const wchar_t* raw_text = text().c_str();
   const int text_length = text().length();
 
@@ skipping 134 matching lines @@
 size_t RenderTextWin::GetRunContainingPoint(const Point& point) const {
   // 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;
 }
 
-size_t RenderTextWin::IndexOfAdjacentGrapheme(size_t index, bool next) const {
-  size_t run_index = GetRunContainingPosition(index);
-  internal::TextRun* run = run_index < runs_.size() ? runs_[run_index] : NULL;
-  long start = run ? run->range.start() : 0;
-  long length = run ? run->range.length() : text().length();
-  long 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(static_cast<long>(std::min(ch, length) + start), 0L);
-}
 
 SelectionModel RenderTextWin::FirstSelectionModelInsideRun(
-    internal::TextRun* run) const {
+    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) const {
+    internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), false);
   return SelectionModel(caret, caret, SelectionModel::LEADING);
 }
 
 SelectionModel RenderTextWin::LeftSelectionModel(
     const SelectionModel& selection) {
   size_t caret = selection.caret_pos();
   SelectionModel::CaretPlacement caret_placement = selection.caret_placement();
   size_t run_index = GetRunContainingPosition(caret);
   DCHECK(run_index < runs_.size());
@@ skipping 147 matching lines @@
     Rect r(GetUpdatedCursorBounds());
     canvas->DrawRectInt(kCursorColor, r.x(), r.y(), r.width(), r.height());
   }
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx