[Android] Composited selection handle rendering

content/browser/renderer_host/input/touch_handle.cc

Index: content/browser/renderer_host/input/touch_handle.cc
diff --git a/content/browser/renderer_host/input/touch_handle.cc b/content/browser/renderer_host/input/touch_handle.cc
new file mode 100644
index 0000000000000000000000000000000000000000..193812b36f73d317a482aed0072dbbde868520c2
--- /dev/null
+++ b/content/browser/renderer_host/input/touch_handle.cc
@@ -0,0 +1,217 @@
+// 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.
+
+#include "content/browser/renderer_host/input/touch_handle.h"
+
+namespace content {
+
+namespace {
+
+// Maximum duration of a fade sequence.
+const double kFadeDurationMs = 200;
+
+// Maximum amount of travel for a fade sequence. This avoids handle "ghosting"
+// when the handle is moving rapidly while the fade is active.
+const double kFadeDistanceSquared = 20.f * 20.f;
+
+}  // namespace
+
+// Responsible for rendering a selection or insertion handle for text editing.
+TouchHandle::TouchHandle(TouchHandleClient* client,
+                         TouchHandleOrientation orientation)
+    : drawable_(client->CreateDrawable()),
+      client_(client),
+      orientation_(orientation),
+      deferred_orientation_(TOUCH_HANDLE_ORIENTATION_UNDEFINED),
+      alpha_(0.f),
+      animate_deferred_fade_(false),
+      enabled_(true),
+      is_visible_(false),
+      is_dragging_(false) {
+  DCHECK_NE(orientation, TOUCH_HANDLE_ORIENTATION_UNDEFINED);
+  drawable_->SetEnabled(enabled_);
+  drawable_->SetOrientation(orientation_);
+  drawable_->SetAlpha(alpha_);
+  drawable_->SetVisible(is_visible_);
+  drawable_->SetFocus(position_);
+}
+
+TouchHandle::~TouchHandle() {
+}
+
+void TouchHandle::SetEnabled(bool enabled) {
+  if (enabled_ == enabled)
+    return;
+  if (!enabled) {
+    EndDrag();
+    EndFade();
+  }
+  enabled_ = enabled;
+  drawable_->SetEnabled(enabled);
+}
+
+void TouchHandle::SetVisible(bool visible, AnimationStyle animation_style) {
+  if (is_visible_ == visible)
+    return;
+
+  is_visible_ = visible;
+
+  // Handle repositioning may have been deferred while previously invisible.
+  if (visible)
+    drawable_->SetFocus(position_);
+
+  bool animate = animation_style != ANIMATION_NONE;
+  if (is_dragging_) {
+    animate_deferred_fade_ = animate;
+    return;
+  }
+
+  if (enabled_ && animate)
+    BeginFade();
+  else
+    EndFade();
+}
+
+void TouchHandle::SetPosition(const gfx::PointF& position) {
+  if (position_ == position)
+    return;
+  position_ = position;
+  // Suppress repositioning a handle while invisible or fading out to prevent it
+  // from "ghosting" outside the visible bounds. The position will be pushed to
+  // the drawable when the handle regains visibility (see |SetVisible()|).
+  if (is_visible_)
+    drawable_->SetFocus(position_);
+}
+
+void TouchHandle::SetOrientation(TouchHandleOrientation orientation) {
+  DCHECK_NE(orientation, TOUCH_HANDLE_ORIENTATION_UNDEFINED);
+  if (is_dragging_) {
+    deferred_orientation_ = orientation;
+    return;
+  }
+  deferred_orientation_ = TOUCH_HANDLE_ORIENTATION_UNDEFINED;

[cjhopman, 2014/07/15 18:40:28]

If you reset deferred_orientation in whatever calls SetOrientation() for that
case instead of here, you can assert here that there is no deferred orientation.
I don't know if that's easier to reason about or not.

[jdduke (slow), 2014/07/15 21:51:56]

Done.

+  if (orientation_ == orientation)
+    return;
+
+  orientation_ = orientation;
+  drawable_->SetOrientation(orientation);
+}
+
+bool TouchHandle::WillHandleTouchEvent(const ui::MotionEvent& event) {
+  if (!enabled_)
+    return false;
+
+  if (!is_dragging_ && event.GetAction() != ui::MotionEvent::ACTION_DOWN)
+    return false;
+
+  switch (event.GetAction()) {
+    case ui::MotionEvent::ACTION_DOWN: {
+      gfx::PointF touch_position = gfx::PointF(event.GetX(), event.GetY());
+      if (!is_visible_ || !drawable_->ContainsPoint(touch_position))
+        return false;
+      touch_down_position_ = touch_position;
+      touch_to_focus_offset_ = position_ - touch_down_position_;
+      touch_down_time_ = event.GetEventTime();
+      BeginDrag();

[cjhopman, 2014/07/15 18:40:28]

The handle could be fading in at this point. It's probably easiest to reason
about stuff if that fade is ended when dragging starts (so that this is never
dragging and fading at the same time).

If we don't make that change, then if the drag ends before the animate, the
EndFade() call in EndDrag() will end the fade early. If while fading and
dragging, we do another setvisible something bad happens (I think it would
continue fading to the new visibility).

[jdduke (slow), 2014/07/15 21:51:56]

Done.

+    } break;
+
+    case ui::MotionEvent::ACTION_MOVE: {
+      gfx::PointF new_position =
+          gfx::PointF(event.GetX(), event.GetY()) + touch_to_focus_offset_;
+      client_->OnHandleDragUpdate(*this, new_position);
+    } break;
+
+    case ui::MotionEvent::ACTION_UP: {
+      base::TimeDelta delay = event.GetEventTime() - touch_down_time_;
+      if (delay < base::TimeDelta::FromMilliseconds(180))

[cjhopman, 2014/07/15 18:40:28]

Should we delay dragging during this period? Delay dragging within some distance
during this period? (I don't really know what Android does for that case) This
can probably be done in a followup.

[jdduke (slow), 2014/07/15 21:51:56]

Well, we really ought to be using a proper touch slop suppression distance. I've
considered adding a GestureDetector instance here, although I think that's
overkill. What I had planned was pulling in the platform slop distance and tap
duration, and if an ACTION_MOVE exceeds that distance we prevent a tap from
being triggered.  I'll do that as a follow-up, and make a note of it.

+        client_->OnHandleTapped(*this);
+
+      EndDrag();
+    } break;
+
+    case ui::MotionEvent::ACTION_CANCEL:
+      EndDrag();
+      break;
+
+    default:
+      break;
+  };
+  return true;
+}
+
+bool TouchHandle::Animate(base::TimeTicks frame_time) {
+  if (fade_end_time_ == base::TimeTicks())
+    return false;
+
+  float time_u =
+      1.f - (fade_end_time_ - frame_time).InMillisecondsF() / kFadeDurationMs;
+  float position_u =
+      (position_ - fade_start_position_).LengthSquared() / kFadeDistanceSquared;
+  float u = std::max(time_u, position_u);
+  SetAlpha(is_visible_ ? u : 1.f - u);
+
+  if (u >= 1.f) {
+    EndFade();
+    return false;
+  }
+
+  return true;
+}
+
+void TouchHandle::BeginDrag() {
+  DCHECK(enabled_);
+  if (is_dragging_)
+    return;
+  is_dragging_ = true;
+  client_->OnHandleDragBegin(*this);
+}
+
+void TouchHandle::EndDrag() {
+  if (!is_dragging_)
+    return;
+
+  is_dragging_ = false;
+  client_->OnHandleDragEnd(*this);
+
+  if (deferred_orientation_ != TOUCH_HANDLE_ORIENTATION_UNDEFINED)
+    SetOrientation(deferred_orientation_);
+
+  // As a fade may have been deferred while dragging, trigger now if necessary.
+  if (enabled_ && animate_deferred_fade_)
+    BeginFade();
+  else
+    EndFade();
+}
+
+void TouchHandle::BeginFade() {
+  DCHECK(enabled_);
+  animate_deferred_fade_ = false;
+  const float target_alpha = is_visible_ ? 1.f : 0.f;
+  if (target_alpha == alpha_)

[cjhopman, 2014/07/15 18:40:28]

If the handle is visible and I do fade out immediately followed by fade in, the
handle will go to 0 alpha and fade in. It looks like otherwise switching between
fade in and out works.

[jdduke (slow), 2014/07/15 21:51:56]

I'll terminate the fade here if (target_alpha == alpha_) for good measure.

+    return;
+
+  drawable_->SetVisible(true);
+  fade_end_time_ = base::TimeTicks::Now() +
+                   base::TimeDelta::FromMillisecondsD(
+                       kFadeDurationMs * std::abs(target_alpha - alpha_));

[cjhopman, 2014/07/15 18:40:28]

If i fade out a handle, then reposition it, then fade it in (before the fade out
finishes), it will start the fade at whatever alpha it was at during the fade
out. Due to the repositioning, it feels like maybe should fade from 0? I'm not
really sure about what should happen in this case (and don't think it really
matters). 

[jdduke (slow), 2014/07/15 21:51:56]

Hmm, preserving the fade alpha is somewhat desirable if the handle is along a
visibility boundary and transitioning back and forth but moving slightly (e.g.,
scroll subdiv up, hiding the handle, then immediately back down). I think the
duration is short enough that most other scenarios should be OK.

+  fade_start_position_ = position_;
+  client_->SetNeedsAnimate();
+}
+
+void TouchHandle::EndFade() {
+  animate_deferred_fade_ = false;
+  fade_end_time_ = base::TimeTicks();
+  SetAlpha(is_visible_ ? 1.f : 0.f);
+  drawable_->SetVisible(is_visible_);
+}
+
+void TouchHandle::SetAlpha(float alpha) {
+  alpha = std::max(0.f, std::min(1.f, alpha));
+  if (alpha_ == alpha)
+    return;
+  alpha_ = alpha;
+  drawable_->SetAlpha(alpha);
+}
+
+}  // namespace content