chrome/android: Push EventFilters into the Layout implementations.

chrome/android/java/src/org/chromium/chrome/browser/compositor/layouts/phone/StackLayout.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.phone;
 
 import android.content.Context;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.os.SystemClock;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.widget.FrameLayout;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.compositor.LayerTitleCache;
 import org.chromium.chrome.browser.compositor.layouts.ChromeAnimation.Animatable;
 import org.chromium.chrome.browser.compositor.layouts.Layout;
+import org.chromium.chrome.browser.compositor.layouts.LayoutManager;
 import org.chromium.chrome.browser.compositor.layouts.LayoutRenderHost;
 import org.chromium.chrome.browser.compositor.layouts.LayoutUpdateHost;
 import org.chromium.chrome.browser.compositor.layouts.components.LayoutTab;
 import org.chromium.chrome.browser.compositor.layouts.content.TabContentManager;
 import org.chromium.chrome.browser.compositor.layouts.eventfilter.EventFilter;
+import org.chromium.chrome.browser.compositor.layouts.eventfilter.GestureEventFilter;
+import org.chromium.chrome.browser.compositor.layouts.eventfilter.GestureHandler;
 import org.chromium.chrome.browser.compositor.layouts.eventfilter.ScrollDirection;
 import org.chromium.chrome.browser.compositor.layouts.phone.stack.Stack;
 import org.chromium.chrome.browser.compositor.layouts.phone.stack.StackTab;
 import org.chromium.chrome.browser.compositor.scene_layer.SceneLayer;
 import org.chromium.chrome.browser.compositor.scene_layer.TabListSceneLayer;
 import org.chromium.chrome.browser.fullscreen.ChromeFullscreenManager;
 import org.chromium.chrome.browser.partnercustomizations.HomepageManager;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
@@ skipping 90 matching lines @@
     private boolean mDelayedLayoutTabInitRequired;
 
     private Boolean mTemporarySelectedStack;
 
     // Orientation Variables
     private PortraitViewport mCachedPortraitViewport;
     private PortraitViewport mCachedLandscapeViewport;
 
     private final ViewGroup mViewContainer;
 
+    private final GestureEventFilter mGestureEventFilter;
     private final TabListSceneLayer mSceneLayer;
 
+    private StackLayoutGestureHandler mGestureHandler;
+
+    private class StackLayoutGestureHandler implements GestureHandler {
+        @Override
+        public void onDown(float x, float y, boolean fromMouse, int buttons) {
+            long time = time();
+            mLastOnDownX = x;
+            mLastOnDownY = y;
+            mLastOnDownTimeStamp = time;
+            mInputMode = computeInputMode(time, x, y, 0, 0);
+            mStacks[getTabStackIndex()].onDown(time);
+        }
+
+        @Override
+        public void onUpOrCancel() {
+            onUpOrCancel(time());
+        }
+
+        @Override
+        public void drag(float x, float y, float dx, float dy, float tx, float ty) {
+            SwipeMode oldInputMode = mInputMode;
+            long time = time();
+            float amountX = dx;
+            float amountY = dy;
+            mInputMode = computeInputMode(time, x, y, amountX, amountY);
+
+            if (oldInputMode == SwipeMode.SEND_TO_STACK && mInputMode == SwipeMode.SWITCH_STACK) {
+                mStacks[getTabStackIndex()].onUpOrCancel(time);
+            } else if (oldInputMode == SwipeMode.SWITCH_STACK
+                    && mInputMode == SwipeMode.SEND_TO_STACK) {
+                onUpOrCancel(time);
+            }
+
+            if (mInputMode == SwipeMode.SEND_TO_STACK) {
+                mStacks[getTabStackIndex()].drag(time, x, y, amountX, amountY);
+            } else if (mInputMode == SwipeMode.SWITCH_STACK) {
+                scrollStacks(getOrientation() == Orientation.PORTRAIT ? amountX : amountY);
+            }
+        }
+
+        @Override
+        public void click(float x, float y, boolean fromMouse, int buttons) {
+            // Click event happens before the up event. mClicked is set to mute the up event.
+            mClicked = true;
+            PortraitViewport viewportParams = getViewportParameters();
+            int stackIndexAt = viewportParams.getStackIndexAt(x, y);
+            if (stackIndexAt == getTabStackIndex()) {
+                mStacks[getTabStackIndex()].click(time(), x, y);
+            } else {
+                flingStacks(getTabStackIndex() == 0);
+            }
+            requestStackUpdate();
+        }
+
+        @Override
+        public void fling(float x, float y, float velocityX, float velocityY) {
+            long time = time();
+            float vx = velocityX;
+            float vy = velocityY;
+
+            if (mInputMode == SwipeMode.NONE) {
+                mInputMode = computeInputMode(
+                        time, x, y, vx * SWITCH_STACK_FLING_DT, vy * SWITCH_STACK_FLING_DT);
+            }
+
+            if (mInputMode == SwipeMode.SEND_TO_STACK) {
+                mStacks[getTabStackIndex()].fling(time, x, y, vx, vy);
+            } else if (mInputMode == SwipeMode.SWITCH_STACK) {
+                final float velocity = getOrientation() == Orientation.PORTRAIT ? vx : vy;
+                final float origin = getOrientation() == Orientation.PORTRAIT ? x : y;
+                final float max =
+                        getOrientation() == Orientation.PORTRAIT ? getWidth() : getHeight();
+                final float predicted = origin + velocity * SWITCH_STACK_FLING_DT;
+                final float delta = MathUtils.clamp(predicted, 0, max) - origin;
+                scrollStacks(delta);
+            }
+            requestStackUpdate();
+        }
+
+        @Override
+        public void onLongPress(float x, float y) {
+            mStacks[getTabStackIndex()].onLongPress(time(), x, y);
+        }
+
+        @Override
+        public void onPinch(float x0, float y0, float x1, float y1, boolean firstEvent) {
+            mStacks[getTabStackIndex()].onPinch(time(), x0, y0, x1, y1, firstEvent);
+        }
+
+        private void onUpOrCancel(long time) {
+            int currentIndex = getTabStackIndex();
+            int nextIndex = 1 - currentIndex;
+            if (!mClicked
+                    && Math.abs(currentIndex + mRenderedScrollOffset) > THRESHOLD_TO_SWITCH_STACK
+                    && mStacks[nextIndex].isDisplayable()) {
+                setActiveStackState(nextIndex == 1);
+            }
+            mClicked = false;
+            finishScrollStacks();
+            mStacks[getTabStackIndex()].onUpOrCancel(time);
+            mInputMode = SwipeMode.NONE;
+        }
+
+        private long time() {
+            return LayoutManager.time();
+        }
+    }
+
     /**
      * @param context     The current Android's context.
      * @param updateHost  The {@link LayoutUpdateHost} view for this layout.
      * @param renderHost  The {@link LayoutRenderHost} view for this layout.
      * @param eventFilter The {@link EventFilter} that is needed for this view.
      */
-    public StackLayout(Context context, LayoutUpdateHost updateHost, LayoutRenderHost renderHost,
-            EventFilter eventFilter) {
-        super(context, updateHost, renderHost, eventFilter);
+    public StackLayout(Context context, LayoutUpdateHost updateHost, LayoutRenderHost renderHost) {
+        super(context, updateHost, renderHost);
 
+        mGestureHandler = new StackLayoutGestureHandler();
+        mGestureEventFilter = new GestureEventFilter(context, mGestureHandler);
         final ViewConfiguration configuration = ViewConfiguration.get(context);
         mMinDirectionThreshold = configuration.getScaledTouchSlop();
         mMinShortPressThresholdSqr =
                 configuration.getScaledPagingTouchSlop() * configuration.getScaledPagingTouchSlop();
 
         mMinMaxInnerMargin = (int) (MIN_INNER_MARGIN_PERCENT_DP + 0.5);
         mFlingSpeed = FLING_SPEED_DP;
         mStacks = new Stack[2];
         mStacks[0] = new Stack(context, this);
         mStacks[1] = new Stack(context, this);
         mStackRects = new RectF[2];
         mStackRects[0] = new RectF();
         mStackRects[1] = new RectF();
 
         mViewContainer = new FrameLayout(getContext());
         mSceneLayer = new TabListSceneLayer();
     }
 
     @Override
     public boolean forceShowBrowserControlsAndroidView() {
         return true;
     }
 
+    /**
+     * Simulates a click on the view at the specified pixel offset
+     * from the top left of the view.
+     * This is used by UI tests.
+     * @param x Coordinate of the click in dp.
+     * @param y Coordinate of the click in dp.
+     */
+    @VisibleForTesting
+    public void simulateClick(float x, float y) {
+        mGestureHandler.click(x, y, false, -1);
+    }
+
+    /**
+     * Simulates a drag and issues Up-event to commit the drag.
+     * @param x  Coordinate to start the Drag from in dp.
+     * @param y  Coordinate to start the Drag from in dp.
+     * @param dX Amount of drag in X direction in dp.
+     * @param dY Amount of drag in Y direction in dp.
+     */
+    @VisibleForTesting
+    public void simulateDrag(float x, float y, float dX, float dY) {
+        mGestureHandler.onDown(x, y, false, -1);
+        mGestureHandler.drag(x, y, dX, dY, -1, -1);
+        mGestureHandler.onUpOrCancel();
+    }
+
     @Override
     public ViewportMode getViewportMode() {
         return ViewportMode.ALWAYS_FULLSCREEN;
     }
 
     @Override
     public void setTabModelSelector(TabModelSelector modelSelector, TabContentManager manager) {
         super.setTabModelSelector(modelSelector, manager);
         mStacks[0].setTabModel(modelSelector.getModel(false));
         mStacks[1].setTabModel(modelSelector.getModel(true));
@@ skipping 411 matching lines @@
 
     @Override
     public void contextChanged(Context context) {
         super.contextChanged(context);
         StackTab.resetDimensionConstants(context);
         mStacks[0].contextChanged(context);
         mStacks[1].contextChanged(context);
         requestStackUpdate();
     }
 
-    @Override
-    public void drag(long time, float x, float y, float amountX, float amountY) {
-        SwipeMode oldInputMode = mInputMode;
-        mInputMode = computeInputMode(time, x, y, amountX, amountY);
-
-        if (oldInputMode == SwipeMode.SEND_TO_STACK && mInputMode == SwipeMode.SWITCH_STACK) {
-            mStacks[getTabStackIndex()].onUpOrCancel(time);
-        } else if (oldInputMode == SwipeMode.SWITCH_STACK
-                && mInputMode == SwipeMode.SEND_TO_STACK) {
-            onUpOrCancel(time);
-        }
-
-        if (mInputMode == SwipeMode.SEND_TO_STACK) {
-            mStacks[getTabStackIndex()].drag(time, x, y, amountX, amountY);
-        } else if (mInputMode == SwipeMode.SWITCH_STACK) {
-            scrollStacks(getOrientation() == Orientation.PORTRAIT ? amountX : amountY);
-        }
-    }
-
     /**
      * Computes the input mode for drag and fling based on the first event position.
      * @param time The current time of the app in ms.
      * @param x    The x layout position of the mouse (without the displacement).
      * @param y    The y layout position of the mouse (without the displacement).
      * @param dx   The x displacement happening this frame.
      * @param dy   The y displacement happening this frame.
      * @return     The input mode to select.
      */
     private SwipeMode computeInputMode(long time, float x, float y, float dx, float dy) {
@@ skipping 29 matching lines @@
         if (time - mLastOnDownTimeStamp > THRESHOLD_TIME_TO_SWITCH_STACK_INPUT_MODE) {
             return SwipeMode.SEND_TO_STACK;
         }
         // Dragging fast
         if (distanceToDownSqr > mMinShortPressThresholdSqr) {
             return SwipeMode.SWITCH_STACK;
         }
         return SwipeMode.NONE;
     }
 
-    @Override
-    public void fling(long time, float x, float y, float vx, float vy) {
-        if (mInputMode == SwipeMode.NONE) {
-            mInputMode = computeInputMode(
-                    time, x, y, vx * SWITCH_STACK_FLING_DT, vy * SWITCH_STACK_FLING_DT);
-        }
-
-        if (mInputMode == SwipeMode.SEND_TO_STACK) {
-            mStacks[getTabStackIndex()].fling(time, x, y, vx, vy);
-        } else if (mInputMode == SwipeMode.SWITCH_STACK) {
-            final float velocity = getOrientation() == Orientation.PORTRAIT ? vx : vy;
-            final float origin = getOrientation() == Orientation.PORTRAIT ? x : y;
-            final float max = getOrientation() == Orientation.PORTRAIT ? getWidth() : getHeight();
-            final float predicted = origin + velocity * SWITCH_STACK_FLING_DT;
-            final float delta = MathUtils.clamp(predicted, 0, max) - origin;
-            scrollStacks(delta);
-        }
-        requestStackUpdate();
-    }
-
     class PortraitViewport {
         protected float mWidth, mHeight;
         PortraitViewport() {
             mWidth = StackLayout.this.getWidth();
             mHeight = StackLayout.this.getHeightMinusBrowserControls();
         }
 
         float getClampedRenderedScrollOffset() {
             if (mStacks[1].isDisplayable() || mFlingFromModelChange) {
                 return MathUtils.clamp(mRenderedScrollOffset, 0, -1);
@@ skipping 112 matching lines @@
             }
             return mCachedPortraitViewport;
         } else {
             if (mCachedLandscapeViewport == null) {
                 mCachedLandscapeViewport = new LandscapeViewport();
             }
             return mCachedLandscapeViewport;
         }
     }
 
-    @Override
-    public void click(long time, float x, float y) {
-        // Click event happens before the up event. mClicked is set to mute the up event.
-        mClicked = true;
-        PortraitViewport viewportParams = getViewportParameters();
-        int stackIndexAt = viewportParams.getStackIndexAt(x, y);
-        if (stackIndexAt == getTabStackIndex()) {
-            mStacks[getTabStackIndex()].click(time, x, y);
-        } else {
-            flingStacks(getTabStackIndex() == 0);
-        }
-        requestStackUpdate();
-    }
-
     /**
      * Check if we are dragging stack in a wrong direction.
      *
      * @param downX The X coordinate on the last down event.
      * @param downY The Y coordinate on the last down event.
      * @param x The current X coordinate.
      * @param y The current Y coordinate.
      * @param dx The amount of change in X coordinate.
      * @param dy The amount of change in Y coordinate.
      * @param orientation The device orientation (portrait / landscape).
@@ skipping 52 matching lines @@
             addToAnimation(this, Property.STACK_SNAP, mRenderedScrollOffset, target, duration, 0);
         } else {
             setProperty(Property.STACK_SNAP, target);
             if (mTemporarySelectedStack != null) {
                 mTabModelSelector.selectModel(mTemporarySelectedStack);
                 mTemporarySelectedStack = null;
             }
         }
     }
 
-    @Override
-    public void onDown(long time, float x, float y) {
-        mLastOnDownX = x;
-        mLastOnDownY = y;
-        mLastOnDownTimeStamp = time;
-        mInputMode = computeInputMode(time, x, y, 0, 0);
-        mStacks[getTabStackIndex()].onDown(time);
-    }
-
-    @Override
-    public void onLongPress(long time, float x, float y) {
-        mStacks[getTabStackIndex()].onLongPress(time, x, y);
-    }
-
-    @Override
-    public void onUpOrCancel(long time) {
-        int currentIndex = getTabStackIndex();
-        int nextIndex = 1 - currentIndex;
-        if (!mClicked && Math.abs(currentIndex + mRenderedScrollOffset) > THRESHOLD_TO_SWITCH_STACK
-                && mStacks[nextIndex].isDisplayable()) {
-            setActiveStackState(nextIndex == 1);
-        }
-        mClicked = false;
-        finishScrollStacks();
-        mStacks[getTabStackIndex()].onUpOrCancel(time);
-        mInputMode = SwipeMode.NONE;
-    }
-
     /**
      * Pushes a rectangle to be drawn on the screen on top of everything.
      *
      * @param rect  The rectangle to be drawn on screen
      * @param color The color of the rectangle
      */
     public void pushDebugRect(Rect rect, int color) {
         if (rect.left > rect.right) {
             int tmp = rect.right;
             rect.right = rect.left;
             rect.left = tmp;
         }
         if (rect.top > rect.bottom) {
             int tmp = rect.bottom;
             rect.bottom = rect.top;
             rect.top = tmp;
         }
         mRenderHost.pushDebugRect(rect, color);
     }
 
     @Override
-    public void onPinch(long time, float x0, float y0, float x1, float y1, boolean firstEvent) {
-        mStacks[getTabStackIndex()].onPinch(time, x0, y0, x1, y1, firstEvent);
-    }
-
-    @Override
     protected void updateLayout(long time, long dt) {
         super.updateLayout(time, dt);
         boolean needUpdate = false;
 
         final PortraitViewport viewport = getViewportParameters();
         mStackRects[0].left = viewport.getStack0Left();
         mStackRects[0].right = mStackRects[0].left + viewport.getWidth();
         mStackRects[0].top = viewport.getStack0Top();
         mStackRects[0].bottom = mStackRects[0].top + viewport.getHeight();
         mStackRects[1].left = mStackRects[0].left + viewport.getStack0ToStack1TranslationX();
@@ skipping 249 matching lines @@
 
     /**
      * Called by the stacks whenever they finish their animations.
      */
     public void onStackAnimationFinished() {
         mStackAnimationCount--;
         if (mStackAnimationCount == 0) super.onAnimationFinished();
     }
 
     @Override
+    protected EventFilter getEventFilter() {
+        return mGestureEventFilter;
+    }
+
+    @Override
     protected SceneLayer getSceneLayer() {
         return mSceneLayer;
     }
 
     @Override
     protected void updateSceneLayer(RectF viewport, RectF contentViewport,
             LayerTitleCache layerTitleCache, TabContentManager tabContentManager,
             ResourceManager resourceManager, ChromeFullscreenManager fullscreenManager) {
         super.updateSceneLayer(viewport, contentViewport, layerTitleCache, tabContentManager,
                 resourceManager, fullscreenManager);
         assert mSceneLayer != null;
         mSceneLayer.pushLayers(getContext(), viewport, contentViewport, this, layerTitleCache,
                 tabContentManager, resourceManager, fullscreenManager);
     }
 }