fix know issues in RenderText

ui/gfx/render_text_linux.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_linux.h"
 
 #include <pango/pangocairo.h>
 
 #include <algorithm>
 
@@ skipping 105 matching lines @@
   bounds = GetUpdatedCursorBounds();
   if (cursor_visible() && focused())
       canvas->DrawRectInt(kCursorColor,
                           bounds.x(),
                           bounds.y(),
                           bounds.width(),
                           bounds.height());
 }
 
 SelectionModel RenderTextLinux::FindCursorPosition(const Point& point) {
-  // TODO(xji): when points outside of text, return HOME/END position.
   PangoLayout* layout = EnsureLayout();
 
   if (text().empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
 
   Point p(ToTextPoint(point));
+
+  // When the point is outside of text, return HOME/END position.
+  if (p.x() < 0)
+    return LeftEndSelectionModel();
+  else if (p.x() > GetStringWidth())
+    return RightEndSelectionModel();
+
   int caret_pos, trailing;
   pango_layout_xy_to_index(layout, p.x() * PANGO_SCALE, p.y() * PANGO_SCALE,
                            &caret_pos, &trailing);
 
   size_t selection_end = caret_pos;
   if (trailing > 0) {
     const char* ch = g_utf8_offset_to_pointer(layout_text_ + caret_pos,
                                               trailing);
     DCHECK_GE(ch, layout_text_);
     DCHECK_LE(ch, layout_text_ + layout_text_len_);
@@ skipping 62 matching lines @@
   if (GetTextDirection() == base::i18n::RIGHT_TO_LEFT) {
     if (current_line_->runs) {
       PangoLayoutRun* first_visual_run =
           reinterpret_cast<PangoLayoutRun*>(current_line_->runs->data);
       PangoItem* item = first_visual_run->item;
       if (item->analysis.level % 2 == 0) {  // LTR.
         size_t caret = Utf8IndexToUtf16Index(item->offset);
         return SelectionModel(text().length(), caret, SelectionModel::LEADING);
       } else {  // RTL.
         size_t caret = Utf16IndexOfAdjacentGrapheme(item->offset + item->length,
-                                                    PREVIOUS);
+                                                    false);
         return SelectionModel(text().length(), caret, SelectionModel::TRAILING);
       }
     }
   }
   return SelectionModel(0, 0, SelectionModel::LEADING);
 }
 
 SelectionModel RenderTextLinux::RightEndSelectionModel() {
   if (GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
     PangoLayoutRun* last_visual_run = GetLastRun();
     if (last_visual_run) {
       PangoItem* item = last_visual_run->item;
       if (item->analysis.level % 2 == 0) {  // LTR.
         size_t caret = Utf16IndexOfAdjacentGrapheme(item->offset + item->length,
-                                                    PREVIOUS);
+                                                    false);
         return SelectionModel(text().length(), caret, SelectionModel::TRAILING);
       } else {  // RTL.
         size_t caret = Utf8IndexToUtf16Index(item->offset);
         return SelectionModel(text().length(), caret, SelectionModel::LEADING);
       }
     }
   }
   return SelectionModel(0, 0, SelectionModel::LEADING);
 }
 
-size_t RenderTextLinux::GetIndexOfPreviousGrapheme(size_t position) {
+bool RenderTextLinux::IsCursorablePosition(size_t position) {
+  if (position == 0 && text().empty())
+    return true;
+
   EnsureLayout();
-  size_t index = Utf16IndexToUtf8Index(position);
-  return Utf16IndexOfAdjacentGrapheme(index, PREVIOUS);
+  return (position < static_cast<size_t>(num_log_attrs_) &&
+          log_attrs_[position].is_cursor_position);
 }
 
-size_t RenderTextLinux::GetIndexOfNextGrapheme(size_t position) {
+size_t RenderTextLinux::IndexOfAdjacentGrapheme(size_t index, bool next) {
   EnsureLayout();
-  size_t index = Utf16IndexToUtf8Index(position);
-  return Utf16IndexOfAdjacentGrapheme(index, NEXT);
+  return Utf16IndexOfAdjacentGrapheme(Utf16IndexToUtf8Index(index), next);
 }
 
 GSList* RenderTextLinux::GetRunContainingPosition(size_t position) const {
   GSList* run = current_line_->runs;
   while (run) {
     PangoItem* item = reinterpret_cast<PangoLayoutRun*>(run->data)->item;
     size_t run_start = Utf8IndexToUtf16Index(item->offset);
     size_t run_end = Utf8IndexToUtf16Index(item->offset + item->length);
 
     if (position >= run_start && position < run_end)
       return run;
     run = run->next;
   }
   return NULL;
 }
 
 size_t RenderTextLinux::Utf8IndexOfAdjacentGrapheme(
     size_t utf8_index_of_current_grapheme,
-    RelativeLogicalPosition pos) const {
+    bool next) const {
   const char* ch = layout_text_ + utf8_index_of_current_grapheme;
   int char_offset = static_cast<int>(g_utf8_pointer_to_offset(layout_text_,
                                                               ch));
   int start_char_offset = char_offset;
-  if (pos == PREVIOUS) {
+  if (!next) {
     if (char_offset > 0) {
       do {
         --char_offset;
       } while (char_offset > 0 && !log_attrs_[char_offset].is_cursor_position);
     }
   } else {
     if (char_offset < num_log_attrs_ - 1) {
       do {
         ++char_offset;
       } while (char_offset < num_log_attrs_ - 1 &&
                !log_attrs_[char_offset].is_cursor_position);
     }
   }
 
   ch = g_utf8_offset_to_pointer(ch, char_offset - start_char_offset);
   return static_cast<size_t>(ch - layout_text_);
 }
 
 size_t RenderTextLinux::Utf16IndexOfAdjacentGrapheme(
     size_t utf8_index_of_current_grapheme,
-    RelativeLogicalPosition pos) const {
+    bool next) const {
   size_t utf8_index = Utf8IndexOfAdjacentGrapheme(
-      utf8_index_of_current_grapheme, pos);
+      utf8_index_of_current_grapheme, next);
   return Utf8IndexToUtf16Index(utf8_index);
 }
 
 SelectionModel RenderTextLinux::FirstSelectionModelInsideRun(
     const PangoItem* item) const {
   size_t caret = Utf8IndexToUtf16Index(item->offset);
-  size_t cursor = Utf16IndexOfAdjacentGrapheme(item->offset, NEXT);
+  size_t cursor = Utf16IndexOfAdjacentGrapheme(item->offset, true);
   return SelectionModel(cursor, caret, SelectionModel::TRAILING);
 }
 
 SelectionModel RenderTextLinux::LastSelectionModelInsideRun(
     const PangoItem* item) const {
   size_t caret = Utf16IndexOfAdjacentGrapheme(item->offset + item->length,
-                                              PREVIOUS);
+                                              false);
   return SelectionModel(caret, caret, SelectionModel::LEADING);
 }
 
 // Assume caret_pos in |current| is n, 'l' represents leading in
 // caret_placement and 't' represents trailing in caret_placement. Following
 // is the calculation from (caret_pos, caret_placement) in |current| to
 // (selection_end, caret_pos, caret_placement) when moving cursor left by
 // one grapheme (for simplicity, assume each grapheme is one character).
 // If n is in LTR run,
 // (n, t) ---> (n, n, l).
@@ skipping 259 matching lines @@
 size_t RenderTextLinux::Utf8IndexToUtf16Index(size_t index) const {
   int32_t utf16_index = 0;
   UErrorCode ec = U_ZERO_ERROR;
   u_strFromUTF8(NULL, 0, &utf16_index, layout_text_, index, &ec);
   DCHECK(ec == U_BUFFER_OVERFLOW_ERROR ||
          ec == U_STRING_NOT_TERMINATED_WARNING);
   return utf16_index;
 }
 
 }  // namespace gfx