[android_webview] Use a fraction to calculate scroll offset.

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 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.
 
@@ skipping 21 matching lines @@
 
         void invalidate();
     }
 
     private final Delegate mDelegate;
 
     // Scroll offset as seen by the native side.
     private int mNativeScrollX;
     private int mNativeScrollY;
 
-    // Content size.
-    private int mContentWidth;
-    private int mContentHeight;
+    // How many pixels can we scroll in a given direction.
+    private int mMaxHorizontalScrollOffset;
+    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;
 
     // Whether (and to what value) to update the native side scroll offset after we've finished
-    // provessing a touch event.
+    // processing a touch event.
     private boolean mApplyDeferredNativeScroll;
     private int mDeferredNativeScrollX;
     private int mDeferredNativeScrollY;
 
-    // Whether (and to what value) to update the container view scroll offset after we've received
-    // a valid content size.
-    private boolean mApplyDeferredContainerScrollOnValidContentSize;
-    private int mDeferredContainerScrollX;
-    private int mDeferredContainerScrollY;
-
     // The velocity of the last recorded fling,
     private int mLastFlingVelocityX;
     private int mLastFlingVelocityY;
 
     private OverScroller mScroller;
 
     public AwScrollOffsetManager(Delegate delegate, OverScroller overScroller) {
         mDelegate = delegate;
         mScroller = overScroller;
     }
 
     //----- Scroll range and extent calculation methods -------------------------------------------
 
     public int computeHorizontalScrollRange() {
-        return Math.max(mContainerViewWidth, mContentWidth);
+        return mContainerViewWidth + mMaxHorizontalScrollOffset;
     }
 
     public int computeMaximumHorizontalScrollOffset() {
-        return computeHorizontalScrollRange() - mContainerViewWidth;
+        return mMaxHorizontalScrollOffset;
     }
 
     public int computeHorizontalScrollOffset() {
         return mDelegate.getContainerViewScrollX();
     }
 
     public int computeVerticalScrollRange() {
-        return Math.max(mContainerViewHeight, mContentHeight);
+        return mContainerViewHeight + mMaxVerticalScrollOffset;
     }
 
     public int computeMaximumVerticalScrollOffset() {
-        return computeVerticalScrollRange() - mContainerViewHeight;
+        return mMaxVerticalScrollOffset;
     }
 
     public int computeVerticalScrollOffset() {
         return mDelegate.getContainerViewScrollY();
     }
 
     public int computeVerticalScrollExtent() {
         return mContainerViewHeight;
     }
 
     //---------------------------------------------------------------------------------------------
-
-    // Called when the content size changes. This needs to be the size of the on-screen content and
-    // therefore we can't use the WebContentsDelegate preferred size.
-    public void setContentSize(int width, int height) {
-        mContentWidth = width;
-        mContentHeight = height;
-
-        if (mApplyDeferredContainerScrollOnValidContentSize &&
-                mContentWidth != 0 && mContentHeight != 0) {
-            mApplyDeferredContainerScrollOnValidContentSize = false;
-            scrollContainerViewTo(mDeferredContainerScrollX, mDeferredContainerScrollY);
-        }
+    // Called when the scroll range changes. This needs to be the size of the on-screen content.
+    public void setMaxScrollOffset(int width, int height) {
+        mMaxHorizontalScrollOffset = width;
+        mMaxVerticalScrollOffset = height;
     }
 
     // Called when the physical size of the view changes.
     public void setContainerViewSize(int width, int height) {
         mContainerViewWidth = width;
         mContainerViewHeight = height;
     }
 
     public void syncScrollOffsetFromOnDraw() {
         // Unfortunately apps override onScrollChanged without calling super which is why we need
         // to sync the scroll offset on every onDraw.
         onContainerViewScrollChanged(mDelegate.getContainerViewScrollX(),
                 mDelegate.getContainerViewScrollY());
     }
 
     public void setProcessingTouchEvent(boolean processingTouchEvent) {
         assert mProcessingTouchEvent != processingTouchEvent;
         mProcessingTouchEvent = processingTouchEvent;
 
         if (!mProcessingTouchEvent && mApplyDeferredNativeScroll) {
             mApplyDeferredNativeScroll = false;
             scrollNativeTo(mDeferredNativeScrollX, mDeferredNativeScrollY);
         }
     }
 
-    // Called by the native side to attempt to scroll the container view.
+    // Called by the native side to scroll the container view.
     public void scrollContainerViewTo(int x, int y) {
-        if (mContentWidth == 0 && mContentHeight == 0) {
-            mApplyDeferredContainerScrollOnValidContentSize = true;
-            mDeferredContainerScrollX = x;
-            mDeferredContainerScrollY = y;
-            return;
-        }
-        mApplyDeferredContainerScrollOnValidContentSize = false;
-
         mNativeScrollX = x;
         mNativeScrollY = y;
 
         final int scrollX = mDelegate.getContainerViewScrollX();
         final int scrollY = mDelegate.getContainerViewScrollY();
         final int deltaX = x - scrollX;
         final int deltaY = y - scrollY;
         final int scrollRangeX = computeMaximumHorizontalScrollOffset();
         final int scrollRangeY = computeMaximumVerticalScrollOffset();
 
@@ skipping 71 matching lines @@
         if (mProcessingTouchEvent) {
             mDeferredNativeScrollX = x;
             mDeferredNativeScrollY = y;
             mApplyDeferredNativeScroll = true;
             return;
         }
 
         if (x == mNativeScrollX && y == mNativeScrollY)
             return;
 
-        // Updating the native scroll will override any pending scroll originally sent from native.
-        mApplyDeferredContainerScrollOnValidContentSize = false;
-
         // The scrollNativeTo call should be a simple store, so it's OK to assume it always
         // succeeds.
         mNativeScrollX = x;
         mNativeScrollY = y;
 
         mDelegate.scrollNativeTo(x, y);
     }
 
     // Called at the beginning of every fling gesture.
     public void onFlingStartGesture(int velocityX, int velocityY) {
@@ skipping 13 matching lines @@
     // scroll layer.
     public void onUnhandledFlingStartEvent() {
         flingScroll(-mLastFlingVelocityX, -mLastFlingVelocityY);
     }
 
     // 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 rangeX = computeMaximumHorizontalScrollOffset();
-        final int rangeY = computeMaximumVerticalScrollOffset();
+        final int scrollRangeX = computeMaximumHorizontalScrollOffset();
+        final int scrollRangeY = computeMaximumVerticalScrollOffset();
 
         mScroller.fling(scrollX, scrollY, velocityX, velocityY,
-                0, rangeX, 0, rangeY);
+                0, scrollRangeX, 0, scrollRangeY);
         mDelegate.invalidate();
     }
 
     // Called immediately before the draw to update the scroll offset.
     public void computeScrollAndAbsorbGlow(OverScrollGlow overScrollGlow) {
         final boolean stillAnimating = mScroller.computeScrollOffset();
         if (!stillAnimating) return;
 
         final int oldX = mDelegate.getContainerViewScrollX();
         final int oldY = mDelegate.getContainerViewScrollY();
         int x = mScroller.getCurrX();
         int y = mScroller.getCurrY();
 
-        int rangeX = computeMaximumHorizontalScrollOffset();
-        int rangeY = computeMaximumVerticalScrollOffset();
+        final int scrollRangeX = computeMaximumHorizontalScrollOffset();
+        final int scrollRangeY = computeMaximumVerticalScrollOffset();
 
         if (overScrollGlow != null) {
-            overScrollGlow.absorbGlow(x, y, oldX, oldY, rangeX, rangeY,
+            overScrollGlow.absorbGlow(x, y, oldX, oldY, scrollRangeX, scrollRangeY,
                     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();
     }
 
@@ skipping 116 matching lines @@
         }
 
         if (immediate) {
             scrollBy(scrollXDelta, scrollYDelta);
             return true;
         } else {
             return animateScrollTo(scrollX + scrollXDelta, scrollY + scrollYDelta);
         }
     }
 }