Add EventForwarder for routing touch events

ui/android/view_android.h

 // Copyright 2013 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_ANDROID_VIEW_ANDROID_H_
 #define UI_ANDROID_VIEW_ANDROID_H_
 
 #include <list>
 
 #include "base/android/jni_weak_ref.h"
+#include "base/bind.h"
 #include "base/memory/ref_counted.h"
+#include "ui/android/event_handler.h"
 #include "ui/android/ui_android_export.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 class GURL;
 
 namespace cc {
 class Layer;
 }
 
 namespace ui {
 
+class EventSender;
+class MotionEventAndroid;
+class ViewClient;
 class WindowAndroid;
 
 // A simple container for a UI layer.
 // At the root of the hierarchy is a WindowAndroid, when attached.
 class UI_ANDROID_EXPORT ViewAndroid {

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

May be add a comment about the hit-testing order?

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

Done.

  public:
   // Stores an anchored view to delete itself at the end of its lifetime
   // automatically. This helps manage the lifecyle without the dependency
   // on |ViewAndroid|.
   class ScopedAnchorView {
    public:
     ScopedAnchorView(JNIEnv* env,
                      const base::android::JavaRef<jobject>& jview,
                      const base::android::JavaRef<jobject>& jdelegate);
 
@@ skipping 11 matching lines @@
    private:
     // TODO(jinsukkim): Following weak refs can be cast to strong refs which
     //     cannot be garbage-collected and leak memory. Rewrite not to use them.
     //     see comments in crrev.com/2103243002.
     JavaObjectWeakGlobalRef view_;
     JavaObjectWeakGlobalRef delegate_;
 
     // Default copy/assign disabled by move constructor.
   };
 
-  // A ViewAndroid may have its own delegate or otherwise will
-  // use the next available parent's delegate.
-  ViewAndroid(const base::android::JavaRef<jobject>& delegate);
+  // Abstracts out the dispatcher for various types of events. Used for hit
+  // testing logic.
+  struct EventSender {
+    virtual bool SendToView(ViewAndroid* view,
+                            const MotionEventAndroid& event) const = 0;
+    virtual bool SendToClient(ViewClient* client,
+                              const MotionEventAndroid& event) const = 0;
+  };
+
+  // Layout parameters used to set the view's position and size.
+  class LayoutParams {
+   public:
+    static LayoutParams MatchParent() { return {true, 0, 0, 0, 0}; }

[boliu, 2017/03/06 22:27:45]

curious.. did clang not complain about inlining these?

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

No it didn't... 

+    static LayoutParams Normal(int x, int y, int width, int height) {
+      return {false, x, y, width, height};
+    };
+
+   private:
+    friend class ViewAndroid;
+    LayoutParams(bool match_parent, int x, int y, int width, int height)
+        : match_parent(match_parent),
+          x(x),
+          y(y),
+          width(width),
+          height(height) {}
+
+    const bool match_parent;

[boliu, 2017/03/06 22:27:45]

"_" suffix, or you can keep members public and make this a struct

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

Done.

+    const int x;
+    const int y;
+    const int width;
+    const int height;
+  };
+
+  explicit ViewAndroid(ViewClient* view_client);
 
   ViewAndroid();
   virtual ~ViewAndroid();
 
   // The content offset is in CSS pixels, and is used to translate
   // snapshots to the correct part of the view.
   void set_content_offset(const gfx::Vector2dF& content_offset) {
     content_offset_ = content_offset;
   }
 
   gfx::Vector2dF content_offset() const {
     return content_offset_;
   }
 
   // Returns the window at the root of this hierarchy, or |null|
   // if disconnected.
   virtual WindowAndroid* GetWindowAndroid() const;
 
   // Used to return and set the layer for this view. May be |null|.
   cc::Layer* GetLayer() const;
   void SetLayer(scoped_refptr<cc::Layer> layer);
 
   void SetDelegate(const base::android::JavaRef<jobject>& delegate);
 
-  // Adds this view as a child of another view.
+  // Gets (creates one if not present) Java object of the EventHandler
+  // for a view tree in the view hierarchy including this node.
+  // Only one instance per the view tree is allowed.
+  base::android::ScopedJavaLocalRef<jobject> GetEventHandler();
+
+  // Adds a child to this view.
   void AddChild(ViewAndroid* child);
 
+  // Moves the give child ViewAndroid to the front of the list so that it can be
+  // the first responder of events.
+  void MoveToFront(ViewAndroid* child);
+
   // Detaches this view from its parent.
   void RemoveFromParent();
 
+  // Sets the layout relative to parent. Used to do hit testing against events.
+  void SetLayout(LayoutParams params);

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

Not for this patch but wanted to ask if this is in the works. Should updating
the Layout trickle it down to its descendants to let the ViewClients know they
were resized? I'm assuming that's how we're planning to propagate size changes
in the hierarchy?

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

Ah yes - for now it is not necessary to do that since child VA (WCVA) is always
set to 'match parent' mode. But the layout change should definitely propagate
down to children once that is not true any more.

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

Actually propagating them would be required precisely for the match parent case,
isn't it. Because if a View is set to match its parent, the ViewClient still
needs to know what that size is so it can layout its contents accordingly. I
think on android you get that as an OnSizeChanged event.
And in content, we effectively do this with ContentViewCoreImpl->RWHVA size
updates. RWHVA is also match parent.

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

Sorry I meant say 'child VA (RWHVA) is always set to match parent' as you
pointed out.

The actual view size used for layout is still obtained through CVC. Thanks for
the reminder. Will keep this in the next item for refactoring.   

+
   bool StartDragAndDrop(const base::android::JavaRef<jstring>& jtext,
                         const base::android::JavaRef<jobject>& jimage);
 
   void OnBackgroundColorChanged(unsigned int color);
   void OnTopControlsChanged(float top_controls_offset,
                             float top_content_offset);
   void OnBottomControlsChanged(float bottom_controls_offset,
                                float bottom_content_offset);
   void StartContentIntent(const GURL& content_url, bool is_main_frame);
 
   ScopedAnchorView AcquireAnchorView();
   void SetAnchorRect(const base::android::JavaRef<jobject>& anchor,
                      const gfx::RectF& bounds);
 
   // This may return null.
   base::android::ScopedJavaLocalRef<jobject> GetContainerView();
 
+  // Virtual for testing.
+  virtual float GetDipScale();
+
  protected:
   ViewAndroid* parent_;
 
  private:
+  friend class EventHandler;
+  friend class EventSendler;
+
+  bool OnTouchEvent(const MotionEventAndroid& event, bool for_touch_handle);
+  bool OnMouseEvent(const MotionEventAndroid& event);
+
   void RemoveChild(ViewAndroid* child);
 
+  bool HitTest(
+      const base::Callback<bool(ViewClient*, const MotionEventAndroid&)>
+          send_to_client,
+      const base::Callback<bool(ViewAndroid*, const MotionEventAndroid&)>
+          send_to_view,
+      const MotionEventAndroid& event);
+
+  static bool SendToClient(ViewClient* client, const MotionEventAndroid& event);
+  static bool SendToView(ViewAndroid* view, const MotionEventAndroid& event);
+
+  bool has_event_handler() const { return !!event_handler_; }
+
+  // Returns true if any node of the tree along the hierarchy (view's children
+  // and parents) already has |EventHandler| attached to it.
+  static bool ViewTreeHasEventHandler(ViewAndroid* view);
+
+  // Returns true if any children node (or self) has |EventHandler|.
+  static bool SubtreeHasEventHandler(ViewAndroid* view);
+
   // Returns the Java delegate for this view. This is used to delegate work
   // up to the embedding view (or the embedder that can deal with the
   // implementation details).
   const base::android::ScopedJavaLocalRef<jobject>
       GetViewAndroidDelegate() const;
 
   std::list<ViewAndroid*> children_;
   scoped_refptr<cc::Layer> layer_;
   JavaObjectWeakGlobalRef delegate_;
-  gfx::Vector2dF content_offset_;  // in CSS pixel
+
+  ViewClient* const client_;
+
+  // Basic view layout information. Used to do hit testing deciding whether
+  // the passed events should be processed by the view.
+  gfx::Point origin_;  // In parent's coordinate space.

[boliu, 2017/03/06 22:27:45]

move comments here to LayoutParams

maybe consider just storing a LayoutParam?

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

Done. Add copy ctor to |LayoutParams| for this (used in |SetLayout|)

+  gfx::Size size_;
+  bool match_parent_;  // Bounds matches that of the parent if true.
+
+  gfx::Vector2dF content_offset_;  // in CSS pixel.
+  std::unique_ptr<EventHandler> event_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(ViewAndroid);
 };
 
 }  // namespace ui
 
 #endif  // UI_ANDROID_VIEW_ANDROID_H_