Revert of chrome/android: Push EventFilters into the Layout implementations.

chrome/android/java/src/org/chromium/chrome/browser/compositor/layouts/Layout.java

 // 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.
 
 package org.chromium.chrome.browser.compositor.layouts;
 
 import static org.chromium.chrome.browser.compositor.layouts.ChromeAnimation.AnimatableAnimation.createAnimation;
 
 import android.content.Context;
 import android.graphics.PointF;
@@ skipping 81 matching lines @@
     protected TabContentManager mTabContentManager;
 
     private ChromeAnimation<Animatable<?>> mLayoutAnimations;
 
     // Tablet tab strip managers.
     private final List<SceneOverlay> mSceneOverlays = new ArrayList<SceneOverlay>();
 
     // Helpers
     private final LayoutUpdateHost mUpdateHost;
     protected final LayoutRenderHost mRenderHost;
+    private EventFilter mEventFilter;
 
     /** The tabs currently being rendered as part of this layout. The tabs are
      * drawn using the same ordering as this array. */
     protected LayoutTab[] mLayoutTabs;
 
     // True means that the layout is going to hide as soon as the animation finishes.
     private boolean mIsHiding;
 
     // The next id to show when the layout is hidden, or TabBase#INVALID_TAB_ID if no change.
     private int mNextTabId = Tab.INVALID_TAB_ID;
 
     // The ratio of dp to px.
     private final float mDpToPx;
 
     /**
      * The {@link Layout} is not usable until sizeChanged is called.
      * This is convenient this way so we can pre-create the layout before the host is fully defined.
      * @param context      The current Android's context.
      * @param updateHost   The parent {@link LayoutUpdateHost}.
      * @param renderHost   The parent {@link LayoutRenderHost}.
+     * @param eventFilter  The {@link EventFilter} this {@link Layout} is listening to.
      */
-    public Layout(Context context, LayoutUpdateHost updateHost, LayoutRenderHost renderHost) {
+    public Layout(Context context, LayoutUpdateHost updateHost, LayoutRenderHost renderHost,
+            EventFilter eventFilter) {
         mContext = context;
         mUpdateHost = updateHost;
         mRenderHost = renderHost;
+        mEventFilter = eventFilter;
 
         // Invalid sizes
         mWidthDp = -1;
         mHeightDp = -1;
         mHeightMinusBrowserControlsDp = -1;
 
         mCurrentOrientation = Orientation.UNSET;
         mDpToPx = context.getResources().getDisplayMetrics().density;
     }
 
@@ skipping 424 matching lines @@
      */
     protected boolean initLayoutTabFromHost(LayoutTab layoutTab) {
         if (layoutTab.isInitFromHostNeeded()) {
             mUpdateHost.initLayoutTabFromHost(layoutTab.getId());
             return true;
         }
         return false;
     }
 
     /**
+     * Called on touch drag event.
+     * @param time      The current time of the app in ms.
+     * @param x         The y coordinate of the end of the drag event.
+     * @param y         The y coordinate of the end of the drag event.
+     * @param deltaX    The number of pixels dragged in the x direction.
+     * @param deltaY    The number of pixels dragged in the y direction.
+     */
+    public void drag(long time, float x, float y, float deltaX, float deltaY) { }
+
+    /**
+     * Called on touch fling event. This is called before the onUpOrCancel event.
+     *
+     * @param time      The current time of the app in ms.
+     * @param x         The y coordinate of the start of the fling event.
+     * @param y         The y coordinate of the start of the fling event.
+     * @param velocityX The amount of velocity in the x direction.
+     * @param velocityY The amount of velocity in the y direction.
+     */
+    public void fling(long time, float x, float y, float velocityX, float velocityY) { }
+
+    /**
+     * Called on onDown event.
+     *
+     * @param time      The time stamp in millisecond of the event.
+     * @param x         The x position of the event.
+     * @param y         The y position of the event.
+     */
+    public void onDown(long time, float x, float y) { }
+
+    /**
+     * Called on long press touch event.
+     * @param time The current time of the app in ms.
+     * @param x    The x coordinate of the position of the press event.
+     * @param y    The y coordinate of the position of the press event.
+     */
+    public void onLongPress(long time, float x, float y) { }
+
+    /**
+     * Called on click. This is called before the onUpOrCancel event.
+     * @param time The current time of the app in ms.
+     * @param x    The x coordinate of the position of the click.
+     * @param y    The y coordinate of the position of the click.
+     */
+    public void click(long time, float x, float y) { }
+
+    /**
+     * Called on up or cancel touch events. This is called after the click and fling event if any.
+     * @param time The current time of the app in ms.
+     */
+    public void onUpOrCancel(long time) { }
+
+    /**
+     * Called when at least 2 touch events are detected.
+     * @param time       The current time of the app in ms.
+     * @param x0         The x coordinate of the first touch event.
+     * @param y0         The y coordinate of the first touch event.
+     * @param x1         The x coordinate of the second touch event.
+     * @param y1         The y coordinate of the second touch event.
+     * @param firstEvent The pinch is the first of a sequence of pinch events.
+     */
+    public void onPinch(long time, float x0, float y0, float x1, float y1, boolean firstEvent) { }
+
+    /**
      * Called by the LayoutManager when an animation should be killed.
      */
     public void unstallImmediately() { }
 
     /**
      * Called by the LayoutManager when an animation should be killed.
      * @param tabId The tab that the kill signal is associated with
      */
     public void unstallImmediately(int tabId) { }
 
@@ skipping 383 matching lines @@
     }
 
     /**
      * @return True if the currently active content view is shown in the normal interactive mode.
      */
     public boolean isTabInteractive() {
         return false;
     }
 
     /**
+     * Setting this will only take effect the next time this layout is shown.  If it is currently
+     * showing the original filter will still be used.
+     * @param filter
+     */
+    public void setEventFilter(EventFilter filter) {
+        mEventFilter = filter;
+    }
+
+    /**
      * @param e                 The {@link MotionEvent} to consider.
      * @param offsets           The current touch offsets that should be applied to the
      *                          {@link EventFilter}s.
      * @param isKeyboardShowing Whether or not the keyboard is showing.
      * @return The {@link EventFilter} the {@link Layout} is listening to.
      */
     public EventFilter findInterceptingEventFilter(
             MotionEvent e, PointF offsets, boolean isKeyboardShowing) {
         // The last added overlay will be drawn on top of everything else, therefore the last
         // filter added should have the first chance to intercept any touch events.
         for (int i = mSceneOverlays.size() - 1; i >= 0; i--) {
             EventFilter eventFilter = mSceneOverlays.get(i).getEventFilter();
             if (eventFilter == null) continue;
             if (offsets != null) eventFilter.setCurrentMotionEventOffsets(offsets.x, offsets.y);
             if (eventFilter.onInterceptTouchEvent(e, isKeyboardShowing)) return eventFilter;
         }
 
-        EventFilter layoutEventFilter = getEventFilter();
-        if (layoutEventFilter != null) {
-            if (offsets != null) {
-                layoutEventFilter.setCurrentMotionEventOffsets(offsets.x, offsets.y);
-            }
-            if (layoutEventFilter.onInterceptTouchEvent(e, isKeyboardShowing)) {
-                return layoutEventFilter;
-            }
+        if (mEventFilter != null) {
+            if (offsets != null) mEventFilter.setCurrentMotionEventOffsets(offsets.x, offsets.y);
+            if (mEventFilter.onInterceptTouchEvent(e, isKeyboardShowing)) return mEventFilter;
         }
         return null;
     }
 
     /**
      * Build a {@link SceneLayer} if it hasn't already been built, and update it and return it.
      *
      * @param viewport          A viewport in which to display content in px.
      * @param visibleViewport   The visible section of the viewport in px.
      * @param layerTitleCache   A layer title cache.
@@ skipping 40 matching lines @@
     }
 
     /**
      * @return Whether or not the layout should permenantly show the browser controls.
      */
     public boolean forceShowBrowserControlsAndroidView() {
         return false;
     }
 
     /**
-     * @return The EventFilter to use for processing events for this Layout.
+     * @return Whether the tabstrip's event filter is enabled.
      */
-    protected abstract EventFilter getEventFilter();
+    public boolean isTabStripEventFilterEnabled() {
+        return true;
+    }
 
     /**
      * Get an instance of {@link SceneLayer}. Any class inheriting {@link Layout}
      * should override this function in order for other functions to work.
      *
      * @return The scene layer for this {@link Layout}.
      */
     protected abstract SceneLayer getSceneLayer();
 
     /**
      * Update {@link SceneLayer} instance this layout holds. Any class inheriting {@link Layout}
      * should override this function in order for other functions to work.
      */
     protected void updateSceneLayer(RectF viewport, RectF contentViewport,
             LayerTitleCache layerTitleCache, TabContentManager tabContentManager,
             ResourceManager resourceManager, ChromeFullscreenManager fullscreenManager) {
     }
 }