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 22 matching lines @@
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_constants.h"
 
 class SkCanvas;
 class SkDrawLooper;
 struct SkPoint;
 class SkShader;
 class SkTypeface;
 
+namespace views {

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

Hmm, gfx shouldn't reference views, and I'm not sure if friend tests are
exempted from dependency violations. Can you make it a RenderText test or expose
the needed private functions (or add *ForTest intermediary helper functions)?

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

Would like to have a test testing multiline selection at the Label level as
well. Have added a ForTest* intermediary helper function.

+class LabelSelectionTest;
+}
+
 namespace gfx {
 namespace test {
 class RenderTextTestApi;
 }
 
 class Canvas;
 struct DecoratedText;
 class Font;
 
 namespace internal {
@@ skipping 149 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. 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.
+  // TODO(crbug.com/248597): Add multiline support.
   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 98 matching lines @@
   virtual SelectionModel AdjacentCharSelectionModel(
       const SelectionModel& selection,
       VisualCursorDirection direction) = 0;
 
   // 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.
+  // Get the selection model 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 |line_index|.
+  // The returned value represents a cursor/caret position without a selection.
+  SelectionModel LineSelectionModel(size_t line_index,
+                                    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 13 matching lines @@
   void UpdateStyleLengths();
 
   // A convenience function to check whether the glyph attached to the caret
   // is within the given range.
   static bool RangeContainsCaret(const Range& range,
                                  size_t caret_pos,
                                  LogicalCursorDirection caret_affinity);
 
  private:
   friend class test::RenderTextTestApi;
+  friend class ::views::LabelSelectionTest;
 
   // 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);
 
   // Updates |layout_text_| and |display_text_| as needed (or marks them dirty).
   void OnTextAttributeChanged();
@@ skipping 167 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_