Reland: Implement Aura side of unified touch text selection for contents

ui/touch_selection/touch_handle_drawable_aura.cc

+// Copyright 2015 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 "ui/touch_selection/touch_handle_drawable_aura.h"
+
+#include "ui/aura/window.h"
+#include "ui/aura/window_targeter.h"
+#include "ui/base/cursor/cursor.h"
+#include "ui/base/hit_test.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/events/event.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/resources/grit/ui_resources.h"
+
+namespace ui {
+namespace {
+
+// The distance by which a handle image is offset from the focal point (i.e.
+// text baseline) downwards.
+const int kSelectionHandleVerticalVisualOffset = 2;
+
+// The padding around the selection handle image can be used to extend the
+// handle window so that touch events near the selection handle image are
+// targeted to the selection handle window.
+const int kSelectionHandlePadding = 0;
+
+// Epsilon value used to compare float values to zero.
+const float kEpsilon = 1e-8f;
+
+// Returns the appropriate handle image based on the handle orientation.
+gfx::Image* GetHandleImage(TouchHandleOrientation orientation) {
+  int resource_id;
+  switch(orientation) {
+    case TouchHandleOrientation::LEFT:
+      resource_id = IDR_TEXT_SELECTION_HANDLE_LEFT;
+      break;
+    case TouchHandleOrientation::CENTER:
+      resource_id = IDR_TEXT_SELECTION_HANDLE_CENTER;
+      break;
+    case TouchHandleOrientation::RIGHT:
+      resource_id = IDR_TEXT_SELECTION_HANDLE_RIGHT;
+      break;
+    default:

[sadrul, 2015/03/05 12:37:03]

Remove default, explicitly list UNDEFINED

[mohsen, 2015/03/06 23:10:08]

Done.

+      NOTREACHED() << "Invalid touch handle bound type.";
+      return nullptr;
+  };
+  return &ResourceBundle::GetSharedInstance().GetImageNamed(resource_id);
+}
+
+bool IsNearlyZero(float value) {
+  return std::abs(value) < kEpsilon;
+}
+
+// A window targeter for touch handles that will let every touch event pass
+// through handles to the underlying window.

[sadrul, 2015/03/05 12:37:03]

Can you set Window::set_ignore_events() instead?

Why ignore events though? Shouldn't the user be able to drag the handle to
change selection?

[mfomitchev, 2015/03/05 16:07:54]

So this is a bit awkward because at this point we are trying to share the
targeting code with Android. The targeting flow for Android is as follows:
RenderWidgetHostViewAndroid::OnTouchEvent ->
TouchSelectionController::WillHandleTouchEvent -> TouchHandle::SetOrientation
The last method in the chain is where the targeting logic is actually
implemented. Android doesn't have Windows, WindowTargeters, etc, so this is what
it does. So we are trying to use a similar flow Aura. So we don't do any
targeting in the handle's window - we let it fall through to RWHVA, then to
TouchSelectionControllerAura::HandleTouchEvent, and then - the same flow as on
Android.

Now, I think we could've just used a Layer instead of |window_| for the handle
drawable, but for native Aura selection we actually will want the targeting to
be done by the WindowTargeter rather than TouchHandle. Perhaps at that point we
should also switch the content targeting over to use the same mechanism - it's
probably more important for Aura handles to be consistent across native/web than
for handles to be consistent from Aura to Clank. 

[sadrul, 2015/03/05 16:56:22]

We shouldn't do this in a roundabout way to fit into the same flow as Android.
Being consistent with the rest of aura is as important as being consistent with
Android code. It would be better to do any necessary refactor here so that the
default window-targeting can be used here.
I am not sure what you mean by 'native/web'; do you mean native == views (e.g.
omnibox) and web == content (i.e. content/RWHVA)?

[mfomitchev, 2015/03/05 18:03:24]

Yes, that's what I meant. Thus we'd have to switch to using window-based
targeting for content/RWHVA for Aura eventually in any case. So I agree we might
as well do it now.

[mohsen, 2015/03/06 23:10:08]

This is how ui::TouchSelectionController is implemented and I tried to change it
as little as possible for this patch. It gets the touch events and has its own
handle targeting and even gesture recognition logic. Probably, jdduke@ can
explain better why this was needed. Our plan is to remove the pass-through
targeter when adding support for Views textfields. But, even in that case the
handle would receive events and just forward them to selection controller for
targeting/gesture recognition (see ui::TouchHandleDrawableAura and
ui::TouchHandleDrawableAuraDelegate sections in the design doc).

(For now, I replaced targeter with set_ignore_events())

+class TouchHandleDrawableAuraTargeter : public aura::WindowTargeter {
+ protected:
+  bool EventLocationInsideBounds(EventTarget* target,
+                                 const LocatedEvent& event) const override;
+};
+
+bool TouchHandleDrawableAuraTargeter::EventLocationInsideBounds(
+    EventTarget* target,
+    const LocatedEvent& event) const {
+  return false;
+}
+
+}
+
+TouchHandleDrawableAura::TouchHandleDrawableAura(aura::Window* parent)
+    : window_(new aura::Window(this)),
+      enabled_(false),
+      alpha_(0),
+      orientation_(TouchHandleOrientation::UNDEFINED) {
+  set_image_offset(gfx::Vector2d(kSelectionHandlePadding,
+                                 kSelectionHandlePadding));
+  set_background_color(SK_ColorTRANSPARENT);
+  window_->SetTransparent(true);
+  window_->Init(aura::WINDOW_LAYER_TEXTURED);
+  window_->set_owned_by_parent(false);
+  window_->SetEventTargeter(
+      scoped_ptr<EventTargeter>(new TouchHandleDrawableAuraTargeter));
+  parent->AddChild(window_.get());
+}
+
+TouchHandleDrawableAura::~TouchHandleDrawableAura() {
+}
+
+// static
+gfx::Size TouchHandleDrawableAura::GetMaxHandleImageSize() {
+  gfx::Size max_size(GetHandleImage(TouchHandleOrientation::CENTER)->Size());
+  max_size.SetToMax(GetHandleImage(TouchHandleOrientation::LEFT)->Size());
+  max_size.SetToMax(GetHandleImage(TouchHandleOrientation::RIGHT)->Size());
+  return max_size;
+}
+
+void TouchHandleDrawableAura::OnWindowDestroyed(aura::Window* window) {
+  // Overriding ImageWindowDelegate's implementation, which calls |delete this|
+  // when the window is destroyed - in our case the delegate owns the window,
+  // and not vice versa.
+}
+
+void TouchHandleDrawableAura::UpdateBounds() {
+  gfx::RectF new_bounds = relative_bounds_;
+  new_bounds.Offset(focal_position_.x(), focal_position_.y());
+  window_->SetBounds(gfx::ToNearestRect(new_bounds));
+}
+
+void TouchHandleDrawableAura::SetEnabled(bool enabled) {
+  if (enabled == enabled_)
+    return;
+
+  enabled_ = enabled;
+  bool visible = !IsNearlyZero(alpha_);
+  if (enabled_ && visible)
+    window_->Show();
+  else
+    window_->Hide();
+}
+
+void TouchHandleDrawableAura::SetOrientation(
+    TouchHandleOrientation orientation) {
+  if (orientation_ == orientation)
+    return;
+  orientation_ = orientation;
+  gfx::Image* image = GetHandleImage(orientation);
+  SetImage(*image);
+
+  // Calculate the relative bounds.
+  gfx::Size image_size = image->Size();
+  int window_width = image_size.width() + 2 * kSelectionHandlePadding;
+  int window_height = image_size.height() + 2 * kSelectionHandlePadding;
+  // Due to the shape of the handle images, the window is aligned differently to
+  // the selection bound depending on the orientation.
+  int window_left = 0;
+  switch (orientation) {
+    case TouchHandleOrientation::LEFT:
+      window_left = -image_size.width() - kSelectionHandlePadding;
+      break;
+    case TouchHandleOrientation::RIGHT:
+      window_left = -kSelectionHandlePadding;
+      break;
+    case TouchHandleOrientation::CENTER:
+      window_left = -window_width / 2;
+      break;
+    default:

[sadrul, 2015/03/05 12:37:03]

case UNDEFINED: instead of default:

[mohsen, 2015/03/06 23:10:08]

Done.

+      NOTREACHED() << "Undefined handle orientation.";
+      break;
+  };
+  relative_bounds_ = gfx::RectF(
+      window_left,
+      kSelectionHandleVerticalVisualOffset - kSelectionHandlePadding,
+      window_width,
+      window_height);
+  UpdateBounds();
+}
+
+void TouchHandleDrawableAura::SetAlpha(float alpha) {
+  if (alpha == alpha_)
+    return;
+
+  alpha_ = alpha;
+  window_->layer()->SetOpacity(alpha_);
+  bool visible = !IsNearlyZero(alpha_);
+  if (enabled_ && visible)
+    window_->Show();
+  else
+    window_->Hide();
+}
+
+void TouchHandleDrawableAura::SetFocus(const gfx::PointF& position) {
+  focal_position_ = position;
+  UpdateBounds();
+}
+
+gfx::RectF TouchHandleDrawableAura::GetVisibleBounds() const {
+  gfx::RectF bounds(window_->bounds());
+  bounds.Inset(kSelectionHandlePadding,
+               kSelectionHandlePadding + kSelectionHandleVerticalVisualOffset,
+               kSelectionHandlePadding,
+               kSelectionHandlePadding);
+  return bounds;
+}
+
+}  // namespace ui