[android_webivew] Implement flingScroll, pageUp, pageDown

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.widget.OverScroller;
 
 import com.google.common.annotations.VisibleForTesting;
 
 import org.chromium.base.CalledByNative;
 
 /**
  * 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;
+
     // 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.
         void scrollContainerViewTo(int x, int y);
         // Store the scroll offset in the native side. This should really be a simple store
         // operation, the native side shouldn't synchronously alter the scroll offset from within
         // this call.
@@ skipping 252 matching lines @@
             overScrollGlow.absorbGlow(x, y, oldX, oldY, rangeX, rangeY,
                     mScroller.getCurrVelocity());
         }
 
         // The mScroller is configured not to go outside of the scrollable range, so this call
         // should never result in attempting to scroll outside of the scrollable region.
         scrollBy(x - oldX, y - oldY);
 
         mDelegate.invalidate();
     }
+
+    private static int computeDurationInMilliSec(int dx, int dy) {
+        int distance = Math.max(Math.abs(dx), Math.abs(dy));
+        int duration = distance * 1000 / STD_SCROLL_ANIMATION_SPEED_PIX_PER_SEC;
+        return Math.min(duration, MAX_SCROLL_ANIMATION_DURATION_MILLISEC);
+    }
+
+    private boolean animateScrollTo(int x, int y) {
+        final int scrollX = mDelegate.getContainerViewScrollX();
+        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;
+
+        mScroller.startScroll(scrollX, scrollY, dx, dy, computeDurationInMilliSec(dx, dy));
+        mDelegate.invalidate();
+
+        return true;
+    }
+
+    /**
+     * See {@link WebView#pageUp(boolean)}
+     */
+    public boolean pageUp(boolean top) {
+        final int scrollX = mDelegate.getContainerViewScrollX();
+        final int scrollY = mDelegate.getContainerViewScrollY();
+
+        if (top) {
+            // go to the top of the document
+            return animateScrollTo(scrollX, 0);
+        }
+        int dy = -mContainerViewHeight / 2;
+        if (mContainerViewHeight > 2 * PAGE_SCROLL_OVERLAP) {
+            dy = -mContainerViewHeight + PAGE_SCROLL_OVERLAP;
+        }
+        // animateScrollTo clamps the argument to the scrollable range so using (scrollY + dy) is
+        // fine.
+        return animateScrollTo(scrollX, scrollY + dy);
+    }
+
+    /**
+     * See {@link WebView#pageDown(boolean)}
+     */
+    public boolean pageDown(boolean bottom) {
+        final int scrollX = mDelegate.getContainerViewScrollX();
+        final int scrollY = mDelegate.getContainerViewScrollY();
+
+        if (bottom) {
+            return animateScrollTo(scrollX, computeVerticalScrollRange());
+        }
+        int dy = mContainerViewHeight / 2;
+        if (mContainerViewHeight > 2 * PAGE_SCROLL_OVERLAP) {
+            dy = mContainerViewHeight - PAGE_SCROLL_OVERLAP;
+        }
+        // animateScrollTo clamps the argument to the scrollable range so using (scrollY + dy) is
+        // fine.
+        return animateScrollTo(scrollX, scrollY + dy);
+    }
 }