RenderTextHarfBuzz: Add support for multi line text selection.

ui/gfx/render_text.h

 // Copyright (c) 2012 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_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 141 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StyleIterator);
 };
 
 // Line segments are slices of the display text to be rendered on a single line.
 struct LineSegment {
   LineSegment();
   ~LineSegment();
 
   // X coordinates of this line segment in text space.
   RangeF x_range;

[karandeepb, 2016/12/07 03:57:47]

I'd like to point out some issues I found with the way the code behaves. There
is this concept of text space bounds [which are the coordinates along the x axis
for some block of text, computed assuming the text was rendered on a single
line]. These text space bounds can be computed using either-

- LineSegment's x_range parameter. This is used for example in
RenderText::TextBoundsToViewBounds for the multiline case (this case is not hit
currently)
- TextRunHarfBuzz's preceding_run_widths and positions[]. This is used
directly/indirectly for example in RenderTextHarfBuzz::GetGraphemeBounds,
RenderTextHarfBuzz::GetSubstringBounds, RenderTextHarfBuzz::GetGlyphBounds,
RenderText::GetCursorBounds and an omnibox function).

The way GetSubstringBounds is currently implemented, it computes the
intersection of text space bounds computed using LineSegment and
TextRunHarfBuzz. However, the text space bounds computed using TextRunHarfBuzz
may not be correct if there is newline in text (we don't render newline -
https://cs.chromium.org/chromium/src/ui/gfx/render_text_harfbuzz.cc?sq=packag...)
or if we truncate the text. Hence in these cases, any code using TextRunHarfBuzz
to compute the text space bounds would be incorrect. This is not an issue
currently, since only Textfields use GetCursorBounds etc. and they don't have
newlines and they don't truncate text.

I'll add some comments in the code pointing this out, if this makes sense to
you.

Also, I have removed the only usage of LineSegment's x_range parameter. I think
it can be removed in a subsequent CL. The way it is computed currently is quite
complex. See for example UpdateRTLSegmentRanges(). Even if it's needed, I think
it may be easier to compute it in a post processing step.

[msw, 2016/12/13 03:04:55]

I'm afraid I can't offer much useful insight here. Perhaps we can actually
include the newlines in the display text, so long as common fonts don't actually
render a glyph for it, or add significant width. Removing x_range sgtm if we can
actually rely on the rthb's preceding_run_widths and positions[] instead, and it
sounds like those are more accurate anyway. (lines and segments were added after
I really worked on RenderText, and though I did review them, I can't claim to
know them as well as some of my own earlier work)

[karandeepb, 2016/12/16 02:58:38]

Yeah I think if this goes through, xrange can be removed and replaced with width
since it is not being used anymore. That should simplify the code somewhat. I
pinged xdai@ regarding not rendering the newline glyph, but she couldn't
remember why it was so. The newline glyph does take up some space. Since we
won't like to mess with the layout of already existing multiline strings, this
may be fine (only rendering newline when it's the only character in its' line). 

 
   // The character range this segment corresponds to.
   Range char_range;
 
   // Index of the text run that generated this segment.
   size_t run;
 
   // Returns the width of this line segment in text space.
   float width() const { return x_range.length(); }
 };
@@ skipping 29 matching lines @@
                        SkPaint* paint);
 
 }  // namespace internal
 
 // RenderText represents an abstract model of styled text and its corresponding
 // visual layout. Support is built in for a cursor, a selection, simple styling,
 // complex scripts, and bi-directional text. Implementations provide mechanisms
 // for rendering and translation between logical and visual data.
 class GFX_EXPORT RenderText {
  public:
-// The character used for displaying obscured text.
-// TODO(benrg): GTK uses the first of U+25CF, U+2022, U+2731, U+273A, '*'
-// that's available in the font (find_invisible_char() in gtkentry.c).
-// Use a bullet character on Mac.
 #if defined(OS_MACOSX)
+  // The character used for displaying obscured text.
+  // TODO(benrg): GTK uses the first of U+25CF, U+2022, U+2731, U+273A, '*'
+  // that's available in the font (find_invisible_char() in gtkentry.c).
+  // Use a bullet character on Mac.
   static constexpr base::char16 kPasswordReplacementChar = 0x2022;
+
+  // On Mac, while selecting text if the cursor is outside the vertical text
+  // bounds, drag to the end of the text.
+  static constexpr bool kDragToEndIfOutsideVerticalBounds = true;
 #else
   static constexpr base::char16 kPasswordReplacementChar = '*';
+  static constexpr bool kDragToEndIfOutsideVerticalBounds = false;
 #endif
 
   virtual ~RenderText();
 
   // Creates a platform-specific or cross-platform RenderText instance.
   static RenderText* CreateInstance();
   static RenderText* CreateInstanceForEditing();
 
   // Creates another instance of the same concrete class.
   virtual std::unique_ptr<RenderText> CreateInstanceOfSameType() const = 0;
@@ skipping 175 matching lines @@
   // RenderText.
   bool GetStyle(TextStyle style) const;
 
   // Set or get the text directionality mode and get the text direction yielded.
   void SetDirectionalityMode(DirectionalityMode mode);
   DirectionalityMode directionality_mode() const {
       return directionality_mode_;
   }
   base::i18n::TextDirection GetDisplayTextDirection();
 
-  // Returns the visual movement direction corresponding to the logical end
-  // of the text, considering only the dominant direction returned by
-  // |GetDisplayTextDirection()|, not the direction of a particular run.
+  // Returns the visual movement direction corresponding to the logical
+  // end/beginning of the text, considering only the dominant direction returned
+  // by |GetDisplayTextDirection()|, not the direction of a particular run.
   VisualCursorDirection GetVisualDirectionOfLogicalEnd();
+  VisualCursorDirection GetVisualDirectionOfLogicalBeginning();
 
   // Returns the text used to display, which may be obscured, truncated or
   // elided. The subclass may compute elided text on the fly, or use
   // precomputed the elided text.
   virtual const base::string16& GetDisplayText() = 0;
 
   // Returns the size required to display the current string (which is the
   // wrapped size in multiline mode). The returned size does not include space
   // reserved for the cursor or the offset text shadows.
   virtual Size GetStringSize() = 0;
@@ skipping 37 matching lines @@
   // Returns true if this instance supports text selection.
   virtual bool IsSelectionSupported() const = 0;
 
   // Get the visual bounds of a cursor at |caret|. These bounds typically
   // represent a vertical line if |insert_mode| is true. Pass false for
   // |insert_mode| to retrieve the bounds of the associated glyph. 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. Note that |caret| must be placed at
   // grapheme boundary, i.e. caret.caret_pos() must be a cursorable position.
+  // Note: This function does not support multiline currently.
   Rect GetCursorBounds(const SelectionModel& caret, 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();
 
   // Given an |index| in text(), return the next or previous grapheme boundary
   // in logical order (i.e. the nearest cursorable index). The return value is
   // in the range 0 to text().length() inclusive (the input is clamped if it is
@@ skipping 102 matching lines @@
   // Get the selection model visually left/right of |selection| by one word.
   // The returned value represents a cursor/caret position without a selection.
   virtual SelectionModel AdjacentWordSelectionModel(
       const SelectionModel& selection,
       VisualCursorDirection direction) = 0;
 
   // Get the SelectionModels corresponding to visual text ends.
   // The returned value represents a cursor/caret position without a selection.
   SelectionModel EdgeSelectionModel(VisualCursorDirection direction);
 
+  // Get the selection model corresponding to visual text ends for the given
+  // |line|.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel LineSelectionModel(const internal::Line& line,
+                                    gfx::VisualCursorDirection direction);
+
   // Sets the selection model, the argument is assumed to be valid.
   virtual void SetSelectionModel(const SelectionModel& model);
 
   // Get the visual bounds containing the logical substring within the |range|.
   // If |range| is empty, the result is empty. 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.
   virtual std::vector<Rect> GetSubstringBounds(const Range& range) = 0;
@@ skipping 25 matching lines @@
   // Update the display text.
   void UpdateDisplayText(float text_width);
 
   // Returns display text positions that are suitable for breaking lines.
   const BreakList<size_t>& GetLineBreaks();
 
   // Apply (and undo) temporary composition underlines and selection colors.
   void ApplyCompositionAndSelectionStyles();
   void UndoCompositionAndSelectionStyles();
 
-  // Convert points from the text space to the view space and back. Handles the
-  // display area, display offset, application LTR/RTL mode and multiline.
-  Point ToTextPoint(const Point& point);
+  // Convert points from the text space to the view space. Handles the display
+  // area, display offset, application LTR/RTL mode and multiline.
   Point ToViewPoint(const Point& point);
 
-  // Convert a text space x-coordinate range to rects in view space.
-  std::vector<Rect> TextBoundsToViewBounds(const Range& x);
-
   // Get the alignment, resolving ALIGN_TO_HEAD with the current text direction.
   HorizontalAlignment GetCurrentHorizontalAlignment();
 
   // Returns the line offset from the origin, accounts for text alignment only.
   Vector2d GetAlignmentOffset(size_t line_number);
 
   // Applies fade effects to |renderer|.
   void ApplyFadeEffects(internal::SkiaTextRenderer* renderer);
 
   // Applies text shadows to |renderer|.
@@ skipping 200 matching lines @@
   // Lines computed by EnsureLayout. These should be invalidated upon
   // OnLayoutTextAttributeChanged and OnDisplayTextAttributeChanged calls.
   std::vector<internal::Line> lines_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderText);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RENDER_TEXT_H_