Add EventForwarder for routing touch events

ui/android/view_android.cc

 // Copyright 2016 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/android/view_android.h"
 
 #include <algorithm>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
+#include "base/containers/adapters.h"
 #include "cc/layers/layer.h"
 #include "jni/ViewAndroidDelegate_jni.h"
+#include "ui/android/event_handler.h"
+#include "ui/android/view_client.h"
 #include "ui/android/window_android.h"
-#include "ui/display/display.h"
-#include "ui/display/screen.h"
+#include "ui/base/layout.h"
+#include "ui/events/android/motion_event_android.h"
 #include "url/gurl.h"
 
 namespace ui {
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
+namespace {
+
+struct TouchEventSender : ViewAndroid::EventSender {
+  TouchEventSender(bool for_touch_handle)
+      : for_touch_handle_(for_touch_handle) {}
+  bool SendToView(ViewAndroid* view,
+                  const MotionEventAndroid& e) const override {
+    return view->OnTouchEvent(e, for_touch_handle_);
+  }
+
+  bool SendToClient(ViewClient* client,
+                    const MotionEventAndroid& e) const override {
+    return client->OnTouchEvent(e, for_touch_handle_);
+  }
+
+ private:
+  bool for_touch_handle_;
+};
+
+struct MouseEventSender : ViewAndroid::EventSender {
+  MouseEventSender() {}
+  bool SendToView(ViewAndroid* view,
+                  const MotionEventAndroid& e) const override {
+    return view->OnMouseEvent(e);
+  }
+
+  bool SendToClient(ViewClient* client,
+                    const MotionEventAndroid& e) const override {
+    return client->OnMouseEvent(e);
+  }
+};
+
+}  // namespace
+
 ViewAndroid::ScopedAnchorView::ScopedAnchorView(
     JNIEnv* env,
     const JavaRef<jobject>& jview,
     const JavaRef<jobject>& jdelegate)
     : view_(env, jview.obj()), delegate_(env, jdelegate.obj()) {
   // If there's a view, then we need a delegate to remove it.
   DCHECK(!jdelegate.is_null() || jview.is_null());
 }
 
 ViewAndroid::ScopedAnchorView::ScopedAnchorView() { }
@@ skipping 30 matching lines @@
   view_.reset();
   delegate_.reset();
 }
 
 const base::android::ScopedJavaLocalRef<jobject>
 ViewAndroid::ScopedAnchorView::view() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   return view_.get(env);
 }
 
-ViewAndroid::ViewAndroid(const JavaRef<jobject>& delegate)
-    : parent_(nullptr),
-      delegate_(base::android::AttachCurrentThread(), delegate.obj()) {}
+ViewAndroid::ViewAndroid(ViewClient* view_client)
+    : parent_(nullptr), client_(view_client) {}
 
-ViewAndroid::ViewAndroid() : parent_(nullptr) {}
+ViewAndroid::ViewAndroid() : ViewAndroid(nullptr) {}
 
 ViewAndroid::~ViewAndroid() {
   RemoveFromParent();
 
   for (std::list<ViewAndroid*>::iterator it = children_.begin();
        it != children_.end(); it++) {
     DCHECK_EQ((*it)->parent_, this);
     (*it)->parent_ = nullptr;
   }
 }
 
 void ViewAndroid::SetDelegate(const JavaRef<jobject>& delegate) {
+  // A ViewAndroid may have its own delegate or otherwise will use the next
+  // available parent's delegate.
   JNIEnv* env = base::android::AttachCurrentThread();
   delegate_ = JavaObjectWeakGlobalRef(env, delegate);
 }
 
+float ViewAndroid::GetDipScale() {
+  return ui::GetScaleFactorForNativeView(this);
+}
+
+ScopedJavaLocalRef<jobject> ViewAndroid::GetEventHandler() {
+  if (!event_handler_) {
+    DCHECK(!ViewTreeHasEventHandler(this))
+        << "Root of the ViewAndroid can have at most one handler.";
+    event_handler_.reset(new EventHandler(this));
+  }
+  return event_handler_->GetJavaObject();
+}
+
 void ViewAndroid::AddChild(ViewAndroid* child) {
   DCHECK(child);
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
          children_.end());
+  DCHECK(!ChildrenHaveEventHandler(child) || !ViewTreeHasEventHandler(this))

[Khushal, 2017/03/03 23:36:07]

nit: this is a bit confusing. How about:
DCHECK(!child->has_event_handler() || !ViewTreeHasEventHandler(this));

[Jinsuk Kim, 2017/03/06 04:07:34]

has_event_handler() won't be enough since it only check direct children. The
checking needs to do against all the way down. Renamed the method to
|SubtreeHasEventHandler| which I hope makes it look a bit nicer.

[Khushal, 2017/03/07 04:17:08]

Sorry I missed that. Much clearer now. Thanks.

+      << "Only one event handler is allowed.";
 
+  // The new child goes to the top, which is the end of the list.
   children_.push_back(child);
   if (child->parent_)
     child->RemoveFromParent();
   child->parent_ = this;
 }
 
+// static
+bool ViewAndroid::ViewTreeHasEventHandler(ViewAndroid* view) {
+  ViewAndroid* v = view;
+  do {
+    if (v->has_event_handler())
+      return true;
+    v = v->parent_;
+  } while (v);
+  return ChildrenHaveEventHandler(view);
+}
+
+// static
+bool ViewAndroid::ChildrenHaveEventHandler(ViewAndroid* view) {
+  if (view->has_event_handler())
+    return true;
+  for (auto* child : view->children_) {
+    if (child->ChildrenHaveEventHandler(child))

[Khushal, 2017/03/03 23:36:08]

You're calling a static method on child?
And these 2 private static methods can be in anonymous namespace.

[Jinsuk Kim, 2017/03/06 04:07:34]

They access non-public member/method which I'd rather keep them as is now.

[Khushal, 2017/03/07 04:17:07]

That should still be possible if you put it in the anonymous namespace of this
cc file.

[Jinsuk Kim, 2017/03/07 05:02:23]

Sorry I still don't get it - |view->children_|, |view->parent_|, and 
|view->has_event_handler()| all fail if these methods are put in anonymous
namespace.

[Khushal, 2017/03/07 06:32:05]

Sorry for being unclear. I meant |ChildrenHaveEventHandler| and
|ViewTreeHasEventHandler| can be moved to anonymous namespace.

[Khushal, 2017/03/07 06:43:13]

I see it now. :l Please ignore me here.

[Jinsuk Kim, 2017/03/08 02:16:16]

Acknowledged.

+      return true;
+  }
+  return false;
+}
+
+void ViewAndroid::MoveToTop(ViewAndroid* child) {
+  DCHECK(child);
+  auto it = std::find(children_.begin(), children_.end(), child);
+  DCHECK(it != children_.end());
+
+  // Top element is placed at the end of the list.
+  if (*it != children_.back())
+    children_.splice(children_.end(), children_, it);
+}
+
 void ViewAndroid::RemoveFromParent() {
   if (parent_)
     parent_->RemoveChild(this);
 }
 
 ViewAndroid::ScopedAnchorView ViewAndroid::AcquireAnchorView() {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return ViewAndroid::ScopedAnchorView();
 
   JNIEnv* env = base::android::AttachCurrentThread();
   return ViewAndroid::ScopedAnchorView(
       env, Java_ViewAndroidDelegate_acquireView(env, delegate), delegate);
 }
 
 void ViewAndroid::SetAnchorRect(const JavaRef<jobject>& anchor,
                                 const gfx::RectF& bounds) {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return;
 
-  float scale = display::Screen::GetScreen()
-                    ->GetDisplayNearestWindow(this)
-                    .device_scale_factor();
-  int left_margin = std::round(bounds.x() * scale);
-  int top_margin = std::round((content_offset().y() + bounds.y()) * scale);
+  float dip_scale = GetDipScale();
+  int left_margin = std::round(bounds.x() * dip_scale);
+  int top_margin = std::round((content_offset().y() + bounds.y()) * dip_scale);
   JNIEnv* env = base::android::AttachCurrentThread();
   Java_ViewAndroidDelegate_setViewPosition(
       env, delegate, anchor, bounds.x(), bounds.y(), bounds.width(),
-      bounds.height(), scale, left_margin, top_margin);
+      bounds.height(), dip_scale, left_margin, top_margin);
 }
 
 ScopedJavaLocalRef<jobject> ViewAndroid::GetContainerView() {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return nullptr;
 
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_ViewAndroidDelegate_getContainerView(env, delegate);
 }
@@ skipping 24 matching lines @@
 }
 
 cc::Layer* ViewAndroid::GetLayer() const {
   return layer_.get();
 }
 
 void ViewAndroid::SetLayer(scoped_refptr<cc::Layer> layer) {
   layer_ = layer;
 }
 
+void ViewAndroid::SetLayout(int x,
+                            int y,
+                            int width,
+                            int height,
+                            bool match_parent) {
+  DCHECK(!match_parent || (x == 0 && y == 0 && width == 0 && height == 0))
+      << "Should give empty dimension when view layout matches its parent. "
+      << "match_parent: " << match_parent << " x: " << x << " y: " << y
+      << " width: " << width << " height: " << height;
+  origin_.SetPoint(x, y);
+  size_.SetSize(width, height);
+  match_parent_ = match_parent;
+}
+
 bool ViewAndroid::StartDragAndDrop(const JavaRef<jstring>& jtext,
                                    const JavaRef<jobject>& jimage) {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return false;
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_ViewAndroidDelegate_startDragAndDrop(env, delegate, jtext,
                                                    jimage);
 }
 
@@ skipping 30 matching lines @@
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return;
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jstring> jcontent_url =
       ConvertUTF8ToJavaString(env, content_url.spec());
   Java_ViewAndroidDelegate_onStartContentIntent(env, delegate, jcontent_url,
                                                 is_main_frame);
 }
 
+bool ViewAndroid::OnTouchEvent(const MotionEventAndroid& event,
+                               bool for_touch_handle) {
+  return HitTest(TouchEventSender(for_touch_handle), event);
+}
+
+bool ViewAndroid::OnMouseEvent(const MotionEventAndroid& event) {
+  return HitTest(MouseEventSender(), event);
+}
+
+bool ViewAndroid::HitTest(const EventSender& es,

[boliu, 2017/03/03 22:01:32]

what you need here is argument binding, which of course is what base::Bind is
for

HitTest can take a callback that just takes a ViewAndroid to do the equivalent
of SendToClient. OnTouchEvent than can bind the for_touch_handle arg into the
callback. Then HitTest can just recurse on itself.

If you want to be fancy, base::Bind can bind lambdas, so you don't even need to
declare methods.


also a note that virtual struct is very unidiomatic c++

[Jinsuk Kim, 2017/03/06 04:07:34]

Maybe I need your help on this. I tried Bind here but not can'get it done to
make it work for both OnTouchEvent and OnMouseEvent. Uploaded patch doesn't
compile - just to show you what I'm doing:

OnMouseEvent has the version that uses Bind + methods (SendToClient,SendToView).
But in this way I need another set of the methods for OnTouchEvent, which is not
good.

OnTouchEvent is to show how I tried to address that by using lambda - but Bind
doesn't like lambda with capture list - it seems to work only for captureless
one.

+                          const MotionEventAndroid& event) {
+  if (!children_.empty()) {
+    MotionEventAndroid e(event, -origin_.x(), -origin_.y());
+
+    // Match from back to front for hit testing.
+    for (auto* child : base::Reversed(children_)) {
+      bool matched = child->match_parent_;
+      if (!matched) {
+        gfx::Rect bound(child->origin_, child->size_);
+        matched = bound.Contains(e.GetX(0), e.GetY(0));
+      }
+      if (matched && es.SendToView(child, e))

[Khushal, 2017/03/03 23:36:08]

Given that we first send the event to the children, and if consumed the event is
never given to the parent. Will the code in WCVA that is relying on seeing the
event work? It will never see the event...

[Jinsuk Kim, 2017/03/06 04:07:34]

You're correct. See my other comment about switching the order.

+        return true;
+    }
+  }
+  return client_ && es.SendToClient(client_, event);
+}
+
 }  // namespace ui