fix know issues in RenderText

ui/gfx/render_text.h

 // 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.
 
 #ifndef UI_GFX_RENDER_TEXT_H_
 #define UI_GFX_RENDER_TEXT_H_
 #pragma once
 
 #include <algorithm>
 #include <vector>
@@ skipping 175 matching lines @@
 
   // Moves the cursor left or right. Cursor movement is visual, meaning that
   // left and right are relative to screen, not the directionality of the text.
   // If |select| is false, the selection start is moved to the same position.
   void MoveCursorLeft(BreakType break_type, bool select);
   void MoveCursorRight(BreakType break_type, bool select);
 
   // Set the selection_model_ to the value of |selection|.
   // The selection model components are modified if invalid.
   // Returns true if the cursor position or selection range changed.
-  // TODO(xji): need to check the cursor is set at grapheme boundary.
+  // If |selectin_start_| or |selection_end_| or |caret_pos_| in
+  // |selection_model| is not a cursorable position (not on grapheme boundary),
+  // it is a NO-OP and returns false.
   bool MoveCursorTo(const SelectionModel& selection_model);

[msw, 2011/09/09 23:03:24]

Is it possible that the text could end with a non-cursorable position? For
example, if the logical text ends with the first half of a surrogate pair? What
happens then?

[xji, 2011/09/12 21:31:48]

We do not allow that.
When I choose whether to use u_strToUTF8 or u_strToUTF8WithSub for utf8 and
utf16 conversion, I talked with Junghsik. And we think since we are dealing with
text field, user either input surrogate pair directly, in which, the IME should
not allow half surrogate pair, or if user paste text, the pasted text would be
garbage character if the source contains half surrogate.
So, I used u_strToUTF8 and assert that there wont be INVALID  character in the
source string.

 
   // Move the cursor to the position associated with the clicked point.
   // If |select| is false, the selection start is moved to the same position.
   // Returns true if the cursor position or selection range changed.
   bool MoveCursorTo(const Point& point, bool select);
 
   size_t GetSelectionStart() const {
       return selection_model_.selection_start();
   }
   size_t MinOfSelection() const {
@@ skipping 39 matching lines @@
   // may be outside the visible region if the text is longer than the textfield.
   // Subsequent text, cursor, or bounds changes may invalidate returned values.
   virtual Rect GetCursorBounds(const SelectionModel& selection,
                                bool insert_mode);
 
   // Compute the current cursor bounds, panning the text to show the cursor in
   // the display rect if necessary. These bounds are in local coordinates.
   // Subsequent text, cursor, or bounds changes may invalidate returned values.
   const Rect& GetUpdatedCursorBounds();
 
+  // Get the logical index of the grapheme following the argument |position|.
+  virtual size_t GetIndexOfNextGrapheme(size_t position);
+
  protected:
   RenderText();
 
   const Point& GetUpdatedDisplayOffset();
 
   void set_cached_bounds_and_offset_valid(bool valid) {
       cached_bounds_and_offset_valid_ = valid;
   }
 
   const StyleRanges& style_ranges() const { return style_ranges_; }
@@ skipping 14 matching lines @@
   virtual size_t GetIndexOfPreviousGrapheme(size_t position);
 
   // Get the visual bounds containing the logical substring within |from| to
   // |to|. These bounds could be visually discontinuous if the substring is
   // split by a LTR/RTL level change. These bounds are in local coordinates, but
   // may be outside the visible region if the text is longer than the textfield.
   // Subsequent text, cursor, or bounds changes may invalidate returned values.
   // TODO(msw) Re-evaluate this function's necessity and signature.
   virtual std::vector<Rect> GetSubstringBounds(size_t from, size_t to);
 
+  // Return true if cursor can appear in front of the character at |position|,
+  // which means it is a grapheme boundary or the first character in the text.
+  virtual bool IsCursorablePosition(size_t position);
+
   // Apply composition style (underline) to composition range and selection
   // style (foreground) to selection range.
   void ApplyCompositionAndSelectionStyles(StyleRanges* style_ranges) const;
 
   // Convert points from the text space to the view space and back.
   // Handles the display area, display offset, and the application LTR/RTL mode.
   Point ToTextPoint(const Point& point);
   Point ToViewPoint(const Point& point);
 
  private:
   friend class RenderTextTest;
 
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, DefaultStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, CustomDefaultStyle);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, ApplyStyleRange);
   FRIEND_TEST_ALL_PREFIXES(RenderTextTest, StyleRangesAdjust);
 
   // Sets the selection model, the argument is assumed to be valid.
   void SetSelectionModel(const SelectionModel& selection_model);
 
   // Set the cursor to |position|, with the caret trailing the previous
   // grapheme, or if there is no previous grapheme, leading the cursor position.
   // If |select| is false, the selection start is moved to the same position.
+  // If the |position| is not a cursorable position (not on grapheme boundary),
+  // it is a NO-OP.
   void MoveCursorTo(size_t position, bool select);
 
-  bool IsPositionAtWordSelectionBoundary(size_t pos);
-
   // Update the cached bounds and display offset to ensure that the current
   // cursor is within the visible display area.
   void UpdateCachedBoundsAndOffset();
 
   // Returns the selection model of selection_start_.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel GetSelectionModelForSelectionStart();
 
   // Logical UTF-16 string data to be drawn.
   string16 text_;
@@ skipping 28 matching lines @@
   // The cached bounds and offset are invalidated by changes to the cursor,
   // selection, font, and other operations that adjust the visible text bounds.
   bool cached_bounds_and_offset_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_