Unify Android Webview and Chrome's fling

android_webview/java/src/org/chromium/android_webview/AwScrollOffsetManager.java

 // 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.
 
 package org.chromium.android_webview;
 
 import android.graphics.Rect;
 import android.widget.OverScroller;
 
 import org.chromium.base.VisibleForTesting;
 
 /**
  * Takes care of syncing the scroll offset between the Android View system and the
  * InProcessViewRenderer.
  *
  * Unless otherwise values (sizes, scroll offsets) are in physical pixels.
  */
 @VisibleForTesting
 public class AwScrollOffsetManager {
     // Values taken from WebViewClassic.
 
     // The amount of content to overlap between two screens when using pageUp/pageDown methiods.
     private static final int PAGE_SCROLL_OVERLAP = 24;
     // Standard animated scroll speed.
     private static final int STD_SCROLL_ANIMATION_SPEED_PIX_PER_SEC = 480;
     // Time for the longest scroll animation.
     private static final int MAX_SCROLL_ANIMATION_DURATION_MILLISEC = 750;
 
+    private boolean mIsAnimatingScroll = false;

[boliu, 2015/05/29 19:42:47]

what's the difference between mIsAnimatingScroll and mWasSmoothScrolling?

[hush (inactive), 2015/06/05 21:47:22]

I was silly there.
mIsAnimatingScroll is equal to mScroller.computeScrollOffset(). I will just
remove this field.

+
     /**
      * The interface that all users of AwScrollOffsetManager should implement.
      *
      * The unit of all the values in this delegate are physical pixels.
      */
     public interface Delegate {
         // Call View#overScrollBy on the containerView.
         void overScrollContainerViewBy(int deltaX, int deltaY, int scrollX, int scrollY,
                 int scrollRangeX, int scrollRangeY, boolean isTouchEvent);
         // Call View#scrollTo on the containerView.
@@ skipping 20 matching lines @@
     private int mMaxVerticalScrollOffset;
 
     // Size of the container view.
     private int mContainerViewWidth;
     private int mContainerViewHeight;
 
     // Whether we're in the middle of processing a touch event.
     private boolean mProcessingTouchEvent;
 
     // Don't skip computeScrollAndAbsorbGlow just because isFling is called in between.
-    private boolean mWasFlinging;
+    private boolean mWasSmoothScrolling;

[hush (inactive), 2015/06/05 21:47:22]

This field is not needed any more. It is used to guard early exit
computeScrollAndAbsorbGlow, which should always be called when
isSmoothScrolling()

 
     // Whether (and to what value) to update the native side scroll offset after we've finished
     // processing a touch event.
     private boolean mApplyDeferredNativeScroll;
     private int mDeferredNativeScrollX;
     private int mDeferredNativeScrollY;
 
     private OverScroller mScroller;
 
     public AwScrollOffsetManager(Delegate delegate, OverScroller overScroller) {
@@ skipping 76 matching lines @@
         final int deltaY = y - scrollY;
         final int scrollRangeX = computeMaximumHorizontalScrollOffset();
         final int scrollRangeY = computeMaximumVerticalScrollOffset();
 
         // We use overScrollContainerViewBy to be compatible with WebViewClassic which used this
         // method for handling both over-scroll as well as in-bounds scroll.
         mDelegate.overScrollContainerViewBy(deltaX, deltaY, scrollX, scrollY,
                 scrollRangeX, scrollRangeY, mProcessingTouchEvent);
     }
 
-    public boolean isFlingActive() {
-        boolean flinging = mScroller.computeScrollOffset();
-        mWasFlinging |= flinging;
-        return flinging;
+    // This is used temporarily until animateScrollTo path of Android WebView (pageUp, pageDown)
+    // is unified with Chrome smooth scrolling.
+    public boolean isSmoothScrollingActive() {
+        boolean smoothScrolling = mScroller.computeScrollOffset();
+        mWasSmoothScrolling |= smoothScrolling;
+        return smoothScrolling;
     }
 
     // Called by the native side to over-scroll the container view.
     public void overScrollBy(int deltaX, int deltaY) {
         // TODO(mkosiba): Once http://crbug.com/260663 and http://crbug.com/261239 are fixed it
         // should be possible to uncomment the following asserts:
         // if (deltaX < 0) assert mDelegate.getContainerViewScrollX() == 0;
         // if (deltaX > 0) assert mDelegate.getContainerViewScrollX() ==
         //          computeMaximumHorizontalScrollOffset();
         scrollBy(deltaX, deltaY);
@@ skipping 71 matching lines @@
         mDelegate.scrollNativeTo(x, y);
     }
 
     // Called whenever some other touch interaction requires the fling gesture to be canceled.
     public void onFlingCancelGesture() {
         // TODO(mkosiba): Support speeding up a fling by flinging again.
         // http://crbug.com/265841
         mScroller.forceFinished(true);
     }
 
-    // Called when a fling gesture is not handled by the renderer.
-    // We explicitly ask the renderer not to handle fling gestures targeted at the root
-    // scroll layer.
-    public void onUnhandledFlingStartEvent(int velocityX, int velocityY) {
-        flingScroll(-velocityX, -velocityY);
-    }
-
-    // Starts the fling animation. Called both as a response to a fling gesture and as via the
-    // public WebView#flingScroll(int, int) API.
-    public void flingScroll(int velocityX, int velocityY) {
-        final int scrollX = mDelegate.getContainerViewScrollX();
-        final int scrollY = mDelegate.getContainerViewScrollY();
-        final int scrollRangeX = computeMaximumHorizontalScrollOffset();
-        final int scrollRangeY = computeMaximumVerticalScrollOffset();
-
-        mScroller.fling(scrollX, scrollY, velocityX, velocityY,
-                0, scrollRangeX, 0, scrollRangeY);
-        mDelegate.invalidate();
+    // This is used temporarily until animateScrollTo path of Android WebView (pageUp, pageDown)
+    // is unified with Chrome smooth scrolling.
+    public boolean willComputeScroll() {
+        if (mScroller.isFinished()) mIsAnimatingScroll = false;

[boliu, 2015/05/29 19:42:47]

not quite the same as mIsAnimatingScroll = mScroller.isFinished(); but is that
what you are going for here?

[hush (inactive), 2015/06/05 21:47:21]

Sorry. Same as I said above. This function should just be
"mScroller.computeScrollOffset()" And it is the same as isSmoothScrollingActive.

+        return mIsAnimatingScroll && !mScroller.isFinished();
     }
 
     // Called immediately before the draw to update the scroll offset.
     public void computeScrollAndAbsorbGlow(OverScrollGlow overScrollGlow) {
-        if (!mScroller.computeScrollOffset() && !mWasFlinging) {
+        if (!mScroller.computeScrollOffset() && !mWasSmoothScrolling) {
             return;
         }
-        mWasFlinging = false;
+        mWasSmoothScrolling = false;
 
         final int oldX = mDelegate.getContainerViewScrollX();
         final int oldY = mDelegate.getContainerViewScrollY();
         int x = mScroller.getCurrX();
         int y = mScroller.getCurrY();
 
         final int scrollRangeX = computeMaximumHorizontalScrollOffset();
         final int scrollRangeY = computeMaximumVerticalScrollOffset();
 
         if (overScrollGlow != null) {
@@ skipping 19 matching lines @@
         final int scrollY = mDelegate.getContainerViewScrollY();
 
         x = clampHorizontalScroll(x);
         y = clampVerticalScroll(y);
 
         int dx = x - scrollX;
         int dy = y - scrollY;
 
         if (dx == 0 && dy == 0) return false;
 
+        mIsAnimatingScroll = true;
+
         mScroller.startScroll(scrollX, scrollY, dx, dy, computeDurationInMilliSec(dx, dy));
         mDelegate.invalidate();
 
         return true;
     }
 
     /**
      * See {@link android.webkit.WebView#pageUp(boolean)}
      */
     public boolean pageUp(boolean top) {
@@ skipping 87 matching lines @@
         }
 
         if (immediate) {
             scrollBy(scrollXDelta, scrollYDelta);
             return true;
         } else {
             return animateScrollTo(scrollX + scrollXDelta, scrollY + scrollYDelta);
         }
     }
 }