[Android] Composited selection handle rendering

content/browser/renderer_host/input/touch_selection_controller.h

+// Copyright 2014 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 CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_SELECTION_CONTROLLER_H_
+#define CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_SELECTION_CONTROLLER_H_
+
+#include "content/browser/renderer_host/input/selection_event_type.h"
+#include "content/browser/renderer_host/input/touch_handle.h"
+#include "content/common/content_export.h"
+#include "ui/gfx/geometry/point_f.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+namespace ui {
+class MotionEvent;
+}
+
+namespace content {
+
+// Interface through which |TouchSelectionController| issues selection-related
+// commands, notifications and requests.
+class CONTENT_EXPORT TouchSelectionControllerClient {
+ public:
+  virtual ~TouchSelectionControllerClient() {}
+
+  virtual void SetNeedsAnimate() = 0;
+  virtual void MoveCaret(const gfx::PointF& position) = 0;
+  virtual void SelectBetweenCoordinates(const gfx::PointF& start,
+                                        const gfx::PointF& end) = 0;
+  virtual void OnSelectionEvent(SelectionEventType event,
+                                const gfx::PointF& anchor_position) = 0;
+  virtual scoped_ptr<TouchHandleDrawable> CreateDrawable() = 0;
+};
+
+// Controller for manipulating text selection via touch input.
+class CONTENT_EXPORT TouchSelectionController : public TouchHandleClient {
+ public:
+  explicit TouchSelectionController(TouchSelectionControllerClient* client);
+  virtual ~TouchSelectionController();
+
+  void OnSelectionBoundsChanged(const gfx::RectF& anchor_rect,

[cjhopman, 2014/07/07 22:13:41]

based on the naming (all the way into WebView::selectionBounds), this returns
the anchor/focus, but it looks like it actually returns the start/end...

This really confused me, because you were using it (correctly) as though it is
the start/end. The names for these parameters should probably be fixed to
start/end all the way to WebView::selectionBounds (I think it's probably easier
to deal with start/end than anchor/focus).

One thing to note about that, though, is that during a selection drag, the fixed
handle can switch between being the start and being the end (whereas it is
always the 'anchor').

This implementation (and the java one), then have the unintuitive behavior that
the handle receiving move events may not be the handle underneath the finger
(when the end handle is dragged past the start handle, the start handle begins
moving and the end handle stops, even though the end handle is the one handling
the move events). "Fixing" this requires swapping the orientation of the handles
during the drag and I could never get that to actually look good with the
PopupWindows (and I don't know that "fixing" it would be any better).

[jdduke (slow), 2014/07/08 00:54:45]

Sigh, yeah, it took me a while to figure out what was going on, and by then I
already had most of the naming wired up.  I'll go back and change everything to
use start/end for consistency (https://codereview.chromium.org/379473002/).

I played around with doing some swapping when the relative handle positioning
changes , but I never really arrived at anything better than the current
approach other than allowing the "fixed" handle orientation to be updated while
dragging.

+                                TouchHandleOrientation anchor_orientation,
+                                bool anchor_visible,
+                                const gfx::RectF& focus_rect,
+                                TouchHandleOrientation focus_orientation,
+                                bool focus_visible);
+  bool WillHandleTouchEvent(const ui::MotionEvent& event);
+  void AllowAutomaticInsertionShowing();
+  void AllowAutomaticSelectionShowing();
+  void HideAndDisallowAutomaticShowing();
+  void OnSelectionEditable(bool editable);
+  bool Animate(base::TimeTicks animate_time);
+
+ private:
+  // TouchHandleClient implementation.
+  virtual void OnHandleDragBegin(const TouchHandle& handle) OVERRIDE;
+  virtual void OnHandleDragUpdate(const TouchHandle& handle,
+                                  const gfx::PointF& new_position) OVERRIDE;
+  virtual void OnHandleDragEnd(const TouchHandle& handle) OVERRIDE;
+  virtual void OnHandleTapped(const TouchHandle& handle) OVERRIDE;
+  virtual void SetNeedsAnimate() OVERRIDE;
+  virtual scoped_ptr<TouchHandleDrawable> CreateDrawable() OVERRIDE;
+
+  void OnInsertionChanged();
+  void OnSelectionChanged();
+
+  void ActivateInsertion();
+  void DeactivateInsertion();
+  void ActivateSelection();
+  void DeactivateSelection();
+  void ResetCachedValues();
+
+  gfx::PointF GetAnchorPosition() const;
+  gfx::PointF GetFocusPosition() const;
+  float GetAnchorLineHeight() const;
+  float GetFocusLineHeight() const;
+
+  TouchSelectionControllerClient* const client_;
+
+  gfx::RectF anchor_rect_;
+  TouchHandleOrientation anchor_orientation_;
+  bool anchor_visible_;
+  gfx::RectF focus_rect_;
+  TouchHandleOrientation focus_orientation_;
+  bool focus_visible_;
+
+  scoped_ptr<TouchHandle> insertion_handle_;
+  bool is_insertion_active_;
+  bool allow_automatic_insertion_activation_;
+
+  scoped_ptr<TouchHandle> start_selection_handle_;
+  scoped_ptr<TouchHandle> end_selection_handle_;
+  gfx::PointF fixed_handle_position_;
+  bool is_selection_active_;
+  bool allow_automatic_selection_activation_;
+
+  bool selection_editable_;
+  bool selection_editable_for_last_update_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchSelectionController);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_INPUT_TOUCH_SELECTION_CONTROLLER_H_