Views: Extract text selection code from Textfield.

ui/views/controls/textfield/textfield.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_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 #define UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/touch/touch_editing_controller.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/drag_controller.h"
+#include "ui/views/selection_controller_host.h"
 #include "ui/views/view.h"
 
 namespace views {
 
 class MenuRunner;
 class Painter;
 class TextfieldController;
+class SelectionController;
 
 // A views/skia textfield implementation. No platform-specific code is used.
 class VIEWS_EXPORT Textfield : public View,
                                public TextfieldModel::Delegate,
                                public ContextMenuController,
                                public DragController,
+                               public SelectionControllerHost,
                                public ui::TouchEditable,
                                public ui::TextInputClient {
  public:
   // The textfield's class name.
   static const char kViewClassName[];
 
   // The preferred size of the padding to be used around textfield text.
   static const int kTextPadding;
 
   // Returns the text cursor blink time in milliseconds, or 0 for no blinking.
@@ skipping 31 matching lines @@
   // Appends the given string to the previously-existing text in the field.
   void AppendText(const base::string16& new_text);
 
   // Inserts |new_text| at the cursor position, replacing any selected text.
   void InsertOrReplaceText(const base::string16& new_text);
 
   // Returns the text that is currently selected. Call sites should take care to
   // not reveal the text for a password textfield.
   base::string16 GetSelectedText() const;
 
-  // Select the entire text range. If |reversed| is true, the range will end at
-  // the logical beginning of the text; this generally shows the leading portion
-  // of text that overflows its display area.
-  void SelectAll(bool reversed);
-
-  // A convenience method to select the word closest to |point|.
-  void SelectWordAt(const gfx::Point& point);
-
-  // Clears the selection within the edit field and sets the caret to the end.
-  void ClearSelection();
-
   // Checks if there is any selected text.
   bool HasSelection() const;
 
   // Gets/sets the text color to be used when painting the Textfield.
   // Call UseDefaultTextColor() to restore the default system color.
   SkColor GetTextColor() const;
   void SetTextColor(SkColor color);
   void UseDefaultTextColor();
 
   // Gets/sets the background color to be used when painting the Textfield.
@@ skipping 48 matching lines @@
 
   // Displays a virtual keyboard or alternate input view if enabled.
   void ShowImeIfNeeded();
 
   // Returns whether or not an IME is composing text.
   bool IsIMEComposing() const;
 
   // Gets the selected logical text range.
   const gfx::Range& GetSelectedRange() const;
 
-  // Selects the specified logical text range.
-  void SelectRange(const gfx::Range& range);
-
   // Gets the text selection model.
   const gfx::SelectionModel& GetSelectionModel() const;
 
   // Sets the specified text selection model.
   void SelectSelectionModel(const gfx::SelectionModel& sel);
 
   // Returns the current cursor position.
   size_t GetCursorPosition() const;
 
   // Set the text color over the entire text or a logical character range.
   // Empty and invalid ranges are ignored.
   void SetColor(SkColor value);
   void ApplyColor(SkColor value, const gfx::Range& range);
 
   // Set various text styles over the entire text or a logical character range.
   // The respective |style| is applied if |value| is true, or removed if false.
   // Empty and invalid ranges are ignored.
   void SetStyle(gfx::TextStyle style, bool value);
   void ApplyStyle(gfx::TextStyle style, bool value, const gfx::Range& range);
 
   // Clears Edit history.
   void ClearEditHistory();
 
   // Set the accessible name of the text field.
   void SetAccessibleName(const base::string16& name);
 
-  // Returns whether there is a drag operation originating from the textfield.
-  bool HasTextBeingDragged();
-
   // View overrides:
   gfx::Insets GetInsets() const override;
   int GetBaseline() const override;
   gfx::Size GetPreferredSize() const override;
   const char* GetClassName() const override;
   gfx::NativeCursor GetCursor(const ui::MouseEvent& event) override;
   bool OnMousePressed(const ui::MouseEvent& event) override;
   bool OnMouseDragged(const ui::MouseEvent& event) override;
   void OnMouseReleased(const ui::MouseEvent& event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
@@ skipping 30 matching lines @@
 
   // DragController overrides:
   void WriteDragDataForView(View* sender,
                             const gfx::Point& press_pt,
                             ui::OSExchangeData* data) override;
   int GetDragOperationsForView(View* sender, const gfx::Point& p) override;
   bool CanStartDragForView(View* sender,
                            const gfx::Point& press_pt,
                            const gfx::Point& p) override;
 
+  // SelectionControllerHost overrides:
+  bool HasTextBeingDragged() const override;
+  void SelectAll(bool reversed) override;

[karandeepb, 2016/10/11 03:43:56]

I think it's a bit problematic that these overridden functions are also part of
the public Textfield interface. Since these can be called by external callers,
we can't for example DCHECK(performing_mouse_action_) in them. 

Do you think it's a good idea to have a nested class implement
SelectionControllerHost instead. This way these overridden functions which are
merely an implementation detail of supporting selection, wouldn't be exposed as
part of the public Textfield interface. However, it will lead to some more
boilerplate code.

[tapted, 2016/10/11 04:42:09]

I think it's reasonable for classes outside to be able to consider a TextField
as a thing-that-can-have-a-selection, and for them to manipulate that.

But I also like the idea of encapsulating more things into a nested class. E.g.
something that just wraps a RenderText, plus helpers to manipulate its
selection. Maybe this should be owned by TextfieldModel though. E.g. split out
the selection/non-editing parts from TextfieldModel, or have TextfieldModel
inherit from a `TextSelectionModel` and then extend it with editing
capabilities.

[karandeepb, 2016/10/11 05:01:30]

Yeah we definitely need these on the public interface. I meant having a
SelectionControllerHostImpl inner class. Then Textfield can have a
SelectionControllerHostImpl as a member. This has the advantage that
Textfield::SelectRange will be decoupled from
SelectionControllerHost::SelectRange, and the methods on the
SelectionControllerHost interface wouldn't be exposed through Textfield. But
it'll probably add unnecessary boiler plate code.

+  void SelectRange(const gfx::Range& range) override;
+  void ClearSelection() override;
+
   // ui::TouchEditable overrides:
   void SelectRect(const gfx::Point& start, const gfx::Point& end) override;
   void MoveCaretTo(const gfx::Point& point) override;
   void GetSelectionEndPoints(gfx::SelectionBound* anchor,
                              gfx::SelectionBound* focus) override;
   gfx::Rect GetBounds() override;
   gfx::NativeView GetNativeView() const override;
   void ConvertPointToScreen(gfx::Point* point) override;
   void ConvertPointFromScreen(gfx::Point* point) override;
   bool DrawsHandles() override;
@@ skipping 37 matching lines @@
   bool IsTextEditCommandEnabled(ui::TextEditCommand command) const override;
   void SetTextEditCommandForNextKeyEvent(ui::TextEditCommand command) override;
 
  protected:
   // Inserts or appends a character in response to an IME operation.
   virtual void DoInsertChar(base::char16 ch);
 
   // Returns the TextfieldModel's text/cursor/selection rendering model.
   gfx::RenderText* GetRenderText() const;
 
-  gfx::Point last_click_location() const { return last_click_location_; }
+  gfx::Point last_click_location() const;
 
   // Get the text from the selection clipboard.
   virtual base::string16 GetSelectionClipboardText() const;
 
   // Executes the given |command|.
   virtual void ExecuteTextEditCommand(ui::TextEditCommand command);
 
  private:
   friend class TextfieldTestApi;
 
   // View overrides:
   // Declared final since overriding by subclasses would interfere with the
   // accounting related to the scheduled text edit command. Subclasses should
   // use TextfieldController::HandleKeyEvent, to intercept the key event.
   bool OnKeyPressed(const ui::KeyEvent& event) final;
   bool OnKeyReleased(const ui::KeyEvent& event) final;
 
+  // SelectionControllerHost overrides:
+  gfx::RenderText* GetRenderTextForSelection() override;
+  bool IsReadOnly() const override;
+  void SetTextBeingDragged(bool value) override;
+  int GetViewHeight() const override;
+  int GetViewWidth() const override;
+  int GetDragSelectionDelay() const override;
+  void OnBeforeMouseAction() override;
+  void OnAfterMouseAction(bool text_changed, bool selection_changed) override;
+  void SelectWordAt(const gfx::Point& point) override;
+  void SelectWord() override;
+  void MoveCursorTo(const gfx::Point& point, bool select) override;
+  void SelectTillEdge(gfx::VisualCursorDirection direction) override;
+  void PasteSelectionClipboard() override;
+  void UpdateSelectionClipboard() override;
+
   // Handles a request to change the value of this text field from software
   // using an accessibility API (typically automation software, screen readers
   // don't normally use this). Sets the value and clears the selection.
   void AccessibilitySetValue(const base::string16& new_value);
 
   // Updates the painted background color.
   void UpdateBackgroundColor();
 
-  // Does necessary updates when the text and/or cursor position changes.
+  // Does necessary updates when the text and/or cursor position changes. NO-OP
+  // if |performing_mouse_action_| is true to ensure updates are only made when
+  // the mouse action completes i.e. on the call to OnAfterMouseAction.
   void UpdateAfterChange(bool text_changed, bool cursor_changed);
 
   // A callback function to periodically update the cursor state.
   void UpdateCursor();
 
   // Repaint the cursor.
   void RepaintCursor();
 
   void PaintTextAndCursor(gfx::Canvas* canvas);
 
-  // Helper function to call MoveCursorTo on the TextfieldModel.
-  void MoveCursorTo(const gfx::Point& point, bool select);
-
-  // Helper function to update the selection on a mouse drag.
-  void SelectThroughLastDragLocation();
-
   // Convenience method to notify the InputMethod and TouchSelectionController.
   void OnCaretBoundsChanged();
 
   // Convenience method to call TextfieldController::OnBeforeUserAction();
   void OnBeforeUserAction();
 
   // Convenience method to call TextfieldController::OnAfterUserAction();
   void OnAfterUserAction();
 
   // Calls |model_->Cut()| and notifies TextfieldController on success.
   bool Cut();
 
   // Calls |model_->Copy()| and notifies TextfieldController on success.
   bool Copy();
 
   // Calls |model_->Paste()| and calls TextfieldController::ContentsChanged()
   // explicitly if paste succeeded.
   bool Paste();
 
   // Utility function to prepare the context menu.
   void UpdateContextMenu();
 
-  // Tracks the mouse clicks for single/double/triple clicks.
-  void TrackMouseClicks(const ui::MouseEvent& event);
-
   // Returns true if the current text input type allows access by the IME.
   bool ImeEditingAllowed() const;
 
   // Reveals the password character at |index| for a set duration.
   // If |index| is -1, the existing revealed character will be reset.
   void RevealPasswordChar(int index);
 
   void CreateTouchSelectionControllerAndNotifyIt();
 
-  // Updates the selection clipboard to any non-empty text selection for a non-
-  // password textfield.
-  void UpdateSelectionClipboard() const;
-
-  // Pastes the selection clipboard for the specified mouse event.
-  void PasteSelectionClipboard(const ui::MouseEvent& event);
-
   // Called whenever a keypress is unhandled for any reason, including failing
   // to insert text into a readonly text field.
   void OnKeypressUnhandled();
 
   // Returns true if an insertion cursor should be visible (a vertical bar,
   // placed at the point new text will be inserted).
   bool ShouldShowCursor() const;
 
   // Returns true if an insertion cursor should be visible and blinking.
   bool ShouldBlinkCursor() const;
@@ skipping 54 matching lines @@
   // The input flags of this text field.
   int text_input_flags_;
 
   // The timer to reveal the last typed password character.
   base::OneShotTimer password_reveal_timer_;
 
   // Tracks whether a user action is being performed; i.e. OnBeforeUserAction()
   // has been called, but OnAfterUserAction() has not yet been called.
   bool performing_user_action_;
 
+  // Tracks whether a mouse action is being performed i.e. OnBeforeMouseAction()
+  // has been called, but OnAfterMouseAction() has not yet been called.
+  bool performing_mouse_action_;
+
   // True if InputMethod::CancelComposition() should not be called.
   bool skip_input_method_cancel_composition_;
 
   // Insertion cursor repaint timer and visibility.
   base::RepeatingTimer cursor_blink_timer_;
 
   // The drop cursor is a visual cue for where dragged text will be dropped.
   bool drop_cursor_visible_;
   gfx::SelectionModel drop_cursor_position_;
 
   // Is the user potentially dragging and dropping from this view?
   bool initiating_drag_;
 
-  // A timer and point used to modify the selection when dragging.
-  base::RepeatingTimer drag_selection_timer_;
-  gfx::Point last_drag_location_;
-
-  // State variables used to track double and triple clicks.
-  size_t aggregated_clicks_;
-  base::TimeTicks last_click_time_;
-  gfx::Point last_click_location_;
-  gfx::Range double_click_word_;
-
   std::unique_ptr<ui::TouchEditingControllerDeprecated>
       touch_selection_controller_;
 
+  std::unique_ptr<SelectionController> selection_controller_;
+
   // Used to track touch drag starting location and offset to enable touch
   // scrolling.
   gfx::Point drag_start_location_;
   int drag_start_display_offset_;
 
   // Tracks if touch editing handles are hidden because user has started
   // scrolling. If |true|, handles are shown after scrolling ends.
   bool touch_handles_hidden_due_to_scroll_;
 
   // Context menu related members.
   std::unique_ptr<ui::SimpleMenuModel> context_menu_contents_;
   std::unique_ptr<views::MenuRunner> context_menu_runner_;
 
   // Used to bind callback functions to this object.
   base::WeakPtrFactory<Textfield> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Textfield);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_