android: move TouchEventHandler into JavaPanZoomController

Change-Id: I6de3c0cdf3a0ec646fd63c9cc2c5a9a153e3e574

6 files changed, 253 insertions, 184 deletions

diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/GeckoLayerClient.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/GeckoLayerClient.java
index e1a12bdb4594..644ef46f9f2b 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/GeckoLayerClient.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/GeckoLayerClient.java
@@ -61,7 +61,7 @@ public class GeckoLayerClient implements PanZoomTarget, LayerView.Listener {
     /* The new color for the checkerboard. */
     private int mCheckerboardColor;
 
-    private final PanZoomController mPanZoomController;
+    private PanZoomController mPanZoomController;
     private LayerView mView;
 
     public GeckoLayerClient(Context context) {
@@ -75,12 +75,11 @@ public class GeckoLayerClient implements PanZoomTarget, LayerView.Listener {
         DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
         mViewportMetrics = new ImmutableViewportMetrics(displayMetrics);
         mZoomConstraints = new ZoomConstraints(false);
-
-        mPanZoomController = PanZoomController.Factory.create(this);
     }
 
     public void setView(LayerView view) {
         mView = view;
+        mPanZoomController = PanZoomController.Factory.create(this, view);
         mView.connect(this);
     }
 
@@ -347,6 +346,11 @@ public class GeckoLayerClient implements PanZoomTarget, LayerView.Listener {
         return layerPoint;
     }
 
+    @Override
+    public boolean isFullScreen() {
+        return false;
+    }
+
     public void destroy() {
         mPanZoomController.destroy();
     }
diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/JavaPanZoomController.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/JavaPanZoomController.java
index 595657f4ce7c..af3f11c5a70f 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/JavaPanZoomController.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/JavaPanZoomController.java
@@ -7,10 +7,13 @@ package org.mozilla.gecko.gfx;
 
 import android.graphics.PointF;
 import android.graphics.RectF;
+import android.os.Build;
 import android.util.FloatMath;
 import android.util.Log;
 import android.view.GestureDetector;
+import android.view.InputDevice;
 import android.view.MotionEvent;
+import android.view.View;
 
 import org.libreoffice.LOKitShell;
 import org.libreoffice.LibreOfficeMainActivity;
@@ -74,7 +77,7 @@ public class JavaPanZoomController
     private final SubdocumentScrollHelper mSubscroller;
     private final Axis mX;
     private final Axis mY;
-
+    private final TouchEventHandler mTouchEventHandler;
     private Thread mMainThread;
 
     /* The timer that handles flings or bounces. */
@@ -90,11 +93,12 @@ public class JavaPanZoomController
     /* Whether or not to wait for a double-tap before dispatching a single-tap */
     private boolean mWaitForDoubleTap;
 
-    public JavaPanZoomController(PanZoomTarget target) {
+    public JavaPanZoomController(PanZoomTarget target, View view) {
         mTarget = target;
         mSubscroller = new SubdocumentScrollHelper();
         mX = new AxisX(mSubscroller);
         mY = new AxisY(mSubscroller);
+        mTouchEventHandler = new TouchEventHandler(view.getContext(), view, this);
 
         mMainThread = LibreOfficeMainActivity.mAppContext.getMainLooper().getThread();
         checkMainThread();
@@ -104,6 +108,7 @@ public class JavaPanZoomController
 
     public void destroy() {
         mSubscroller.destroy();
+        mTouchEventHandler.destroy();
     }
 
     private final static float easeOut(float t) {
@@ -131,15 +136,40 @@ public class JavaPanZoomController
         }
     }
 
+    /** This function MUST be called on the UI thread */
+    public boolean onMotionEvent(MotionEvent event) {
+        if (Build.VERSION.SDK_INT <= 11) {
+            return false;
+        }
+
+        switch (event.getSource() & InputDevice.SOURCE_CLASS_MASK) {
+        case InputDevice.SOURCE_CLASS_POINTER:
+            switch (event.getAction() & MotionEvent.ACTION_MASK) {
+            case MotionEvent.ACTION_SCROLL: return handlePointerScroll(event);
+            }
+            break;
+        }
+        return false;
+    }
+
+    /** This function MUST be called on the UI thread */
     public boolean onTouchEvent(MotionEvent event) {
+        return mTouchEventHandler.handleEvent(event);
+    }
+
+    boolean handleEvent(MotionEvent event) {
         switch (event.getAction() & MotionEvent.ACTION_MASK) {
-            case MotionEvent.ACTION_DOWN:   return onTouchStart(event);
-            case MotionEvent.ACTION_MOVE:   return onTouchMove(event);
-            case MotionEvent.ACTION_UP:     return onTouchEnd(event);
-            case MotionEvent.ACTION_CANCEL: return onTouchCancel(event);
-            case MotionEvent.ACTION_SCROLL: return onScroll(event);
-            default:                        return false;
+        case MotionEvent.ACTION_DOWN:   return handleTouchStart(event);
+        case MotionEvent.ACTION_MOVE:   return handleTouchMove(event);
+        case MotionEvent.ACTION_UP:     return handleTouchEnd(event);
+        case MotionEvent.ACTION_CANCEL: return handleTouchCancel(event);
         }
+        return false;
+    }
+
+    /** This function MUST be called on the UI thread */
+    public void notifyDefaultActionPrevented(boolean prevented) {
+        mTouchEventHandler.handleEventListenerAction(!prevented);
     }
 
     /** This function must be called from the UI thread. */
@@ -150,24 +180,24 @@ public class JavaPanZoomController
         // snaps to edges. for other cases (where the user's finger(s) are down) don't do
         // anything special.
         switch (mState) {
-            case FLING:
-                mX.stopFling();
-                mY.stopFling();
-                // fall through
-            case BOUNCE:
-            case ANIMATED_ZOOM:
-                // the zoom that's in progress likely makes no sense any more (such as if
-                // the screen orientation changed) so abort it
-                setState(PanZoomState.NOTHING);
-                // fall through
-            case NOTHING:
-                // Don't do animations here; they're distracting and can cause flashes on page
-                // transitions.
-                synchronized (mTarget.getLock()) {
-                    mTarget.setViewportMetrics(getValidViewportMetrics());
-                    mTarget.forceRedraw();
-                }
-                break;
+        case FLING:
+            mX.stopFling();
+            mY.stopFling();
+            // fall through
+        case BOUNCE:
+        case ANIMATED_ZOOM:
+            // the zoom that's in progress likely makes no sense any more (such as if
+            // the screen orientation changed) so abort it
+            setState(PanZoomState.NOTHING);
+            // fall through
+        case NOTHING:
+            // Don't do animations here; they're distracting and can cause flashes on page
+            // transitions.
+            synchronized (mTarget.getLock()) {
+                mTarget.setViewportMetrics(getValidViewportMetrics());
+                mTarget.forceRedraw();
+            }
+            break;
         }
     }
 
@@ -212,122 +242,123 @@ public class JavaPanZoomController
      * Panning/scrolling
      */
 
-    private boolean onTouchStart(MotionEvent event) {
+    private boolean handleTouchStart(MotionEvent event) {
         // user is taking control of movement, so stop
         // any auto-movement we have going
         stopAnimationTimer();
 
         switch (mState) {
-            case ANIMATED_ZOOM:
-                // We just interrupted a double-tap animation, so force a redraw in
-                // case this touchstart is just a tap that doesn't end up triggering
-                // a redraw
-                mTarget.forceRedraw();
-                // fall through
-            case FLING:
-            case BOUNCE:
-            case NOTHING:
-            case WAITING_LISTENERS:
-                startTouch(event.getX(0), event.getY(0), event.getEventTime());
-                return false;
-            case TOUCHING:
-            case PANNING:
-            case PANNING_LOCKED:
-            case PANNING_HOLD:
-            case PANNING_HOLD_LOCKED:
-            case PINCHING:
-                Log.e(LOGTAG, "Received impossible touch down while in " + mState);
-                return false;
+        case ANIMATED_ZOOM:
+            // We just interrupted a double-tap animation, so force a redraw in
+            // case this touchstart is just a tap that doesn't end up triggering
+            // a redraw
+            mTarget.forceRedraw();
+            // fall through
+        case FLING:
+        case BOUNCE:
+        case NOTHING:
+        case WAITING_LISTENERS:
+            startTouch(event.getX(0), event.getY(0), event.getEventTime());
+            return false;
+        case TOUCHING:
+        case PANNING:
+        case PANNING_LOCKED:
+        case PANNING_HOLD:
+        case PANNING_HOLD_LOCKED:
+        case PINCHING:
+            Log.e(LOGTAG, "Received impossible touch down while in " + mState);
+            return false;
         }
-        Log.e(LOGTAG, "Unhandled case " + mState + " in onTouchStart");
+        Log.e(LOGTAG, "Unhandled case " + mState + " in handleTouchStart");
         return false;
     }
 
-    private boolean onTouchMove(MotionEvent event) {
+    private boolean handleTouchMove(MotionEvent event) {
 
         switch (mState) {
-            case FLING:
-            case BOUNCE:
-            case WAITING_LISTENERS:
-                // should never happen
-                Log.e(LOGTAG, "Received impossible touch move while in " + mState);
-                // fall through
-            case ANIMATED_ZOOM:
-            case NOTHING:
-                // may happen if user double-taps and drags without lifting after the
-                // second tap. ignore the move if this happens.
-                return false;
+        case FLING:
+        case BOUNCE:
+        case WAITING_LISTENERS:
+            // should never happen
+            Log.e(LOGTAG, "Received impossible touch move while in " + mState);
+            // fall through
+        case ANIMATED_ZOOM:
+        case NOTHING:
+            // may happen if user double-taps and drags without lifting after the
+            // second tap. ignore the move if this happens.
+            return false;
 
-            case TOUCHING:
-                if (panDistance(event) < PAN_THRESHOLD) {
-                    return false;
-                }
-                cancelTouch();
-                startPanning(event.getX(0), event.getY(0), event.getEventTime());
-                track(event);
-                return true;
+        case TOUCHING:
+            // Don't allow panning if there is an element in full-screen mode. See bug 775511.
+            if (mTarget.isFullScreen() || panDistance(event) < PAN_THRESHOLD) {
+                return false;
+            }
+            cancelTouch();
+            startPanning(event.getX(0), event.getY(0), event.getEventTime());
+            track(event);
+            return true;
 
-            case PANNING_HOLD_LOCKED:
-                setState(PanZoomState.PANNING_LOCKED);
-                // fall through
-            case PANNING_LOCKED:
-                track(event);
-                return true;
+        case PANNING_HOLD_LOCKED:
+            setState(PanZoomState.PANNING_LOCKED);
+            // fall through
+        case PANNING_LOCKED:
+            track(event);
+            return true;
 
-            case PANNING_HOLD:
-                setState(PanZoomState.PANNING);
-                // fall through
-            case PANNING:
-                track(event);
-                return true;
+        case PANNING_HOLD:
+            setState(PanZoomState.PANNING);
+            // fall through
+        case PANNING:
+            track(event);
+            return true;
 
-            case PINCHING:
-                // scale gesture listener will handle this
-                return false;
+        case PINCHING:
+            // scale gesture listener will handle this
+            return false;
         }
-        Log.e(LOGTAG, "Unhandled case " + mState + " in onTouchMove");
+        Log.e(LOGTAG, "Unhandled case " + mState + " in handleTouchMove");
         return false;
     }
 
-    private boolean onTouchEnd(MotionEvent event) {
+    private boolean handleTouchEnd(MotionEvent event) {
 
         switch (mState) {
-            case FLING:
-            case BOUNCE:
-            case WAITING_LISTENERS:
-                // should never happen
-                Log.e(LOGTAG, "Received impossible touch end while in " + mState);
-                // fall through
-            case ANIMATED_ZOOM:
-            case NOTHING:
-                // may happen if user double-taps and drags without lifting after the
-                // second tap. ignore if this happens.
-                return false;
+        case FLING:
+        case BOUNCE:
+        case WAITING_LISTENERS:
+            // should never happen
+            Log.e(LOGTAG, "Received impossible touch end while in " + mState);
+            // fall through
+        case ANIMATED_ZOOM:
+        case NOTHING:
+            // may happen if user double-taps and drags without lifting after the
+            // second tap. ignore if this happens.
+            return false;
 
-            case TOUCHING:
-                // the switch into TOUCHING might have happened while the page was
-                // snapping back after overscroll. we need to finish the snap if that
-                // was the case
-                bounce();
-                return false;
+        case TOUCHING:
+            // the switch into TOUCHING might have happened while the page was
+            // snapping back after overscroll. we need to finish the snap if that
+            // was the case
+            bounce();
+            return false;
 
-            case PANNING:
-            case PANNING_LOCKED:
-            case PANNING_HOLD:
-            case PANNING_HOLD_LOCKED:
-                setState(PanZoomState.FLING);
-                fling();
-                return true;
+        case PANNING:
+        case PANNING_LOCKED:
+        case PANNING_HOLD:
+        case PANNING_HOLD_LOCKED:
+            setState(PanZoomState.FLING);
+            fling();
+            return true;
 
-            case PINCHING:
-                setState(PanZoomState.NOTHING);
-                return true;
+        case PINCHING:
+            setState(PanZoomState.NOTHING);
+            return true;
         }
-        Log.e(LOGTAG, "Unhandled case " + mState + " in onTouchEnd");
+        Log.e(LOGTAG, "Unhandled case " + mState + " in handleTouchEnd");
         return false;
     }
 
-    private boolean onTouchCancel(MotionEvent event) {
+    private boolean handleTouchCancel(MotionEvent event) {
         cancelTouch();
 
         if (mState == PanZoomState.WAITING_LISTENERS) {
@@ -345,7 +376,7 @@ public class JavaPanZoomController
         return false;
     }
 
-    private boolean onScroll(MotionEvent event) {
+    private boolean handlePointerScroll(MotionEvent event) {
         if (mState == PanZoomState.NOTHING || mState == PanZoomState.FLING) {
             float scrollX = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
             float scrollY = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
@@ -414,8 +445,8 @@ public class JavaPanZoomController
 
         for (int i = 0; i < event.getHistorySize(); i++) {
             track(event.getHistoricalX(0, i),
-                    event.getHistoricalY(0, i),
-                    event.getHistoricalEventTime(i));
+                  event.getHistoricalY(0, i),
+                  event.getHistoricalEventTime(i));
         }
         track(event.getX(0), event.getY(0), event.getEventTime());
 
@@ -791,6 +822,9 @@ public class JavaPanZoomController
 
     @Override
     public boolean onScale(SimpleScaleGestureDetector detector) {
+        if (mTarget.isFullScreen())
+            return false;
+
         if (mState != PanZoomState.PINCHING)
             return false;
 
@@ -834,7 +868,7 @@ public class JavaPanZoomController
             }
 
             scrollBy(mLastZoomFocus.x - detector.getFocusX(),
-                    mLastZoomFocus.y - detector.getFocusY());
+                     mLastZoomFocus.y - detector.getFocusY());
             PointF focus = new PointF(detector.getFocusX(), detector.getFocusY());
             scaleWithFocus(newZoomFactor, focus);
         }
@@ -867,7 +901,6 @@ public class JavaPanZoomController
         mTarget.setViewportMetrics(viewportMetrics);
     }
 
-    @Override
     public boolean getRedrawHint() {
         switch (mState) {
             case PINCHING:
@@ -989,19 +1022,16 @@ public class JavaPanZoomController
     }
 
     /** This function must be called from the UI thread. */
-    @Override
     public void abortPanning() {
         checkMainThread();
         bounce();
     }
 
-    @Override
     public void setOverScrollMode(int overscrollMode) {
         mX.setOverScrollMode(overscrollMode);
         mY.setOverScrollMode(overscrollMode);
     }
 
-    @Override
     public int getOverScrollMode() {
         return mX.getOverScrollMode();
     }
diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/LayerView.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/LayerView.java
index c6b4e2e401ba..167da849628e 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/LayerView.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/LayerView.java
@@ -29,6 +29,7 @@ import android.widget.FrameLayout;
 
 import org.libreoffice.LibreOfficeMainActivity;
 import org.libreoffice.R;
+import org.mozilla.gecko.OnInterceptTouchListener;
 
 import java.lang.reflect.Method;
 import java.nio.IntBuffer;
@@ -45,7 +46,7 @@ public class LayerView extends FrameLayout {
     private static String LOGTAG = LayerView.class.getName();
 
     private GeckoLayerClient mLayerClient;
-    private TouchEventHandler mTouchEventHandler;
+    private PanZoomController mPanZoomController;
     private GLController mGLController;
     private InputConnectionHandler mInputConnectionHandler;
     private LayerRenderer mRenderer;
@@ -53,11 +54,13 @@ public class LayerView extends FrameLayout {
     private boolean mRenderTimeReset;
     /* Must be a PAINT_xxx constant */
     private int mPaintState = PAINT_NONE;
+    private boolean mFullScreen = false;
 
     private SurfaceView mSurfaceView;
     private TextureView mTextureView;
 
     private Listener mListener;
+    private OnInterceptTouchListener mTouchIntercepter;
 
     /* Flags used to determine when to show the painted surface. The integer
      * order must correspond to the order in which these states occur. */
@@ -105,7 +108,7 @@ public class LayerView extends FrameLayout {
 
     void connect(GeckoLayerClient layerClient) {
         mLayerClient = layerClient;
-        mTouchEventHandler = new TouchEventHandler(getContext(), this, layerClient);
+        mPanZoomController = mLayerClient.getPanZoomController();
         mRenderer = new LayerRenderer(this);
         mInputConnectionHandler = null;
 
@@ -115,26 +118,81 @@ public class LayerView extends FrameLayout {
         createGLThread();
     }
 
+    public void show() {
+        // Fix this if TextureView support is turned back on above
+        mSurfaceView.setVisibility(View.VISIBLE);
+    }
+
+    public void hide() {
+        // Fix this if TextureView support is turned back on above
+        mSurfaceView.setVisibility(View.INVISIBLE);
+    }
+
+    public void destroy() {
+        if (mLayerClient != null) {
+            mLayerClient.destroy();
+        }
+        if (mRenderer != null) {
+            mRenderer.destroy();
+        }
+    }
+
+    public void setTouchIntercepter(final OnInterceptTouchListener touchIntercepter) {
+        // this gets run on the gecko thread, but for thread safety we want the assignment
+        // on the UI thread.
+        post(new Runnable() {
+            public void run() {
+                mTouchIntercepter = touchIntercepter;
+            }
+        });
+    }
+
     @Override
     public boolean onTouchEvent(MotionEvent event) {
-        if (event.getActionMasked() == MotionEvent.ACTION_DOWN)
+        if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
             requestFocus();
-        return mTouchEventHandler.handleEvent(event);
+        }
+
+        if (mTouchIntercepter != null && mTouchIntercepter.onInterceptTouchEvent(this, event)) {
+            return true;
+        }
+        if (mPanZoomController != null && mPanZoomController.onTouchEvent(event)) {
+            return true;
+        }
+        if (mTouchIntercepter != null && mTouchIntercepter.onTouch(this, event)) {
+            return true;
+        }
+        return false;
     }
 
     @Override
     public boolean onHoverEvent(MotionEvent event) {
-        return mTouchEventHandler.handleEvent(event);
+        if (mTouchIntercepter != null && mTouchIntercepter.onTouch(this, event)) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onGenericMotionEvent(MotionEvent event) {
+        if (mPanZoomController != null && mPanZoomController.onMotionEvent(event)) {
+            return true;
+        }
+        return false;
     }
 
     public GeckoLayerClient getLayerClient() { return mLayerClient; }
-    public TouchEventHandler getTouchEventHandler() { return mTouchEventHandler; }
+    public PanZoomController getPanZoomController() { return mPanZoomController; }
 
     /** The LayerRenderer calls this to indicate that the window has changed size. */
     public void setViewportSize(IntSize size) {
         mLayerClient.setViewportSize(new FloatSize(size));
     }
 
+    public ImmutableViewportMetrics getViewportMetrics() {
+        return mLayerClient.getViewportMetrics();
+    }
+
     @Override
     public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
         if (mInputConnectionHandler != null)
@@ -177,6 +235,13 @@ public class LayerView extends FrameLayout {
         return false;
     }
 
+    public boolean isIMEEnabled() {
+        /*if (mInputConnectionHandler != null) {
+            return mInputConnectionHandler.isIMEEnabled();
+        }*/
+        return false;
+    }
+
     public void requestRender() {
         if (mRenderControllerThread != null) {
             mRenderControllerThread.renderFrame();
@@ -242,7 +307,6 @@ public class LayerView extends FrameLayout {
         return mPaintState;
     }
 
-
     public LayerRenderer getRenderer() {
         return mRenderer;
     }
@@ -422,4 +486,12 @@ public class LayerView extends FrameLayout {
             super(e);
         }
     }
+
+    public void setFullScreen(boolean fullScreen) {
+        mFullScreen = fullScreen;
+    }
+
+    public boolean isFullScreen() {
+        return mFullScreen;
+    }
 }
diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomController.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomController.java
index 86036bbea287..829ffd555feb 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomController.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomController.java
@@ -6,6 +6,8 @@
 package org.mozilla.gecko.gfx;
 
 import android.graphics.PointF;
+import android.view.MotionEvent;
+import android.view.View;
 
 import org.libreoffice.LOKitShell;
 
@@ -15,13 +17,17 @@ public interface PanZoomController {
     public static final float PAN_THRESHOLD = 1/16f * LOKitShell.getDpi();
 
     static class Factory {
-        static PanZoomController create(PanZoomTarget target) {
-            return new JavaPanZoomController(target);
+        static PanZoomController create(PanZoomTarget target, View view) {
+            return new JavaPanZoomController(target, view);
         }
     }
 
     public void destroy();
 
+    public boolean onTouchEvent(MotionEvent event);
+    public boolean onMotionEvent(MotionEvent event);
+    public void notifyDefaultActionPrevented(boolean prevented);
+
     public boolean getRedrawHint();
     public PointF getVelocityVector();
 
diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomTarget.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomTarget.java
index f79819cdd172..88e1b216c61b 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomTarget.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/PanZoomTarget.java
@@ -21,4 +21,6 @@ public interface PanZoomTarget {
     public boolean post(Runnable action);
     public Object getLock();
     public PointF convertViewPointToLayerPoint(PointF viewPoint);
+
+    boolean isFullScreen();
 }
diff --git a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/TouchEventHandler.java b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/TouchEventHandler.java
index cba380236465..4ac51460cfc4 100644
--- a/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/TouchEventHandler.java
+++ b/android/experimental/LOAndroid3/src/java/org/mozilla/gecko/gfx/TouchEventHandler.java
@@ -11,6 +11,7 @@ import android.os.SystemClock;
 import android.util.Log;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
+import android.view.View;
 
 import org.mozilla.gecko.OnInterceptTouchListener;
 
@@ -54,7 +55,7 @@ public final class TouchEventHandler {
     // before we begin panning the page
     private final int EVENT_LISTENER_TIMEOUT = 200;
 
-    private final LayerView mView;
+    private final View mView;
     private final GestureDetector mGestureDetector;
     private final SimpleScaleGestureDetector mScaleGestureDetector;
     private final JavaPanZoomController mPanZoomController;
@@ -64,9 +65,6 @@ public final class TouchEventHandler {
     private final Queue<MotionEvent> mEventQueue;
     private final ListenerTimeoutProcessor mListenerTimeoutProcessor;
 
-    // the listener we use to notify gecko of touch events
-    private OnInterceptTouchListener mOnTouchListener;
-
     // whether or not we should wait for touch listeners to respond (this state is
     // per-tab and is updated when we switch tabs).
     private boolean mWaitForTouchListeners;
@@ -122,11 +120,11 @@ public final class TouchEventHandler {
     //   processed. (n is the absolute value of the balance.)
     private int mProcessingBalance;
 
-    TouchEventHandler(Context context, LayerView view, GeckoLayerClient layerClient) {
+    TouchEventHandler(Context context, View view, JavaPanZoomController panZoomController) {
         mView = view;
 
         mEventQueue = new LinkedList<MotionEvent>();
-        mPanZoomController = (JavaPanZoomController)layerClient.getPanZoomController();
+        mPanZoomController = panZoomController;
         mGestureDetector = new GestureDetector(context, mPanZoomController);
         mScaleGestureDetector = new SimpleScaleGestureDetector(mPanZoomController);
         mListenerTimeoutProcessor = new ListenerTimeoutProcessor();
@@ -140,28 +138,6 @@ public final class TouchEventHandler {
 
     /* This function MUST be called on the UI thread */
     public boolean handleEvent(MotionEvent event) {
-        // if we don't have gecko listeners, just dispatch the event
-        // and be done with it, no extra work needed.
-        if (mOnTouchListener == null) {
-            dispatchEvent(event);
-            return true;
-        }
-
-        if (mOnTouchListener.onInterceptTouchEvent(mView, event)) {
-            return true;
-        }
-
-        // if this is a hover event just notify gecko, we don't have any interest in the java layer.
-        if (isHoverEvent(event)) {
-            mOnTouchListener.onTouch(mView, event);
-            return true;
-        }
-
-        if (isScrollEvent(event)) {
-            dispatchEvent(event);
-            return true;
-        }
-
         if (isDownEvent(event)) {
             // this is the start of a new block of events! whee!
             mHoldInQueue = mWaitForTouchListeners;
@@ -204,9 +180,6 @@ public final class TouchEventHandler {
             mPanZoomController.preventedTouchFinished();
         }
 
-        // notify gecko of the event
-        mOnTouchListener.onTouch(mView, event);
-
         return true;
     }
 
@@ -235,16 +208,6 @@ public final class TouchEventHandler {
         mWaitForTouchListeners = aValue;
     }
 
-    /* This function MUST be called on the UI thread. */
-    public void setOnTouchListener(OnInterceptTouchListener onTouchListener) {
-        mOnTouchListener = onTouchListener;
-    }
-
-    private boolean isHoverEvent(MotionEvent event) {
-        int action = (event.getAction() & MotionEvent.ACTION_MASK);
-        return (action == MotionEvent.ACTION_HOVER_ENTER || action == MotionEvent.ACTION_HOVER_MOVE || action == MotionEvent.ACTION_HOVER_EXIT);
-    }
-
     private boolean isDownEvent(MotionEvent event) {
         int action = (event.getAction() & MotionEvent.ACTION_MASK);
         return (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN);
@@ -255,14 +218,6 @@ public final class TouchEventHandler {
         return (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL);
     }
 
-    private boolean isScrollEvent(MotionEvent event) {
-        if (Build.VERSION.SDK_INT <= 11) {
-            return false;
-        }
-        int action = (event.getAction() & MotionEvent.ACTION_MASK);
-        return (action == MotionEvent.ACTION_SCROLL);
-    }
-
     /**
      * Dispatch the event to the gesture detectors and the pan/zoom controller.
      */
@@ -274,7 +229,7 @@ public final class TouchEventHandler {
         if (mScaleGestureDetector.isInProgress()) {
             return;
         }
-        mPanZoomController.onTouchEvent(event);
+        mPanZoomController.handleEvent(event);
     }
 
     /**