Convert browser controls animation to use ratio

chrome/android/java/src/org/chromium/chrome/browser/fullscreen/ChromeFullscreenManager.java

 // Copyright 2014 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.fullscreen;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.ObjectAnimator;
 import android.app.Activity;
@@ skipping 54 matching lines @@
     private final int mControlContainerHeight;
 
     private final TabModelSelector mTabModelSelector;
     private final TabModelSelectorTabModelObserver mTabModelObserver;
 
     private final ControlContainer mControlContainer;
 
     private long mMinShowNotificationMs = MINIMUM_SHOW_DURATION_MS;
     private long mMaxAnimationDurationMs = MAX_ANIMATION_DURATION_MS;
 
-    private float mBrowserControlOffset = Float.NaN;
+    // The shown ratio for the browser controls animated by this class as opposed to what is
+    // computed by the renderer.
+    private float mBrowserControlShownRatio = Float.NaN;
+
     private float mRendererTopControlOffset = Float.NaN;
     private float mRendererBottomControlOffset = Float.NaN;
     private float mRendererTopContentOffset;
     private float mPreviousContentOffset = Float.NaN;
-    private float mControlOffset;
+    private float mControlOffsetRatio;
     private float mPreviousControlOffset;
     private boolean mIsEnteringPersistentModeState;
 
     private boolean mInGesture;
     private boolean mContentViewScrolling;
 
     private int mPersistentControlsCurrentToken;
     private long mCurrentShowTime;
     private int mActivityShowToken = INVALID_TOKEN;
 
@@ skipping 27 matching lines @@
 
         /**
          * Called when a ContentVideoView is created/destroyed.
          * @param enabled Whether to enter or leave overlay video mode.
          */
         public void onToggleOverlayVideoMode(boolean enabled);
     }
 
     private class ControlsOffsetProperty extends Property<ChromeFullscreenManager, Float> {
         public ControlsOffsetProperty() {
-            super(Float.class, "controlsOffset");
+            super(Float.class, "controlsOffsetRatio");
         }
 
         @Override
         public Float get(ChromeFullscreenManager object) {
-            return getControlOffset();
+            return getBrowserControlHiddenRatio();
         }
 
         @Override
-        public void set(ChromeFullscreenManager manager, Float offset) {
+        public void set(ChromeFullscreenManager manager, Float ratio) {
             if (mDisableBrowserOverride) return;
-            float browserOffset = offset.floatValue();
-            if (Float.compare(mBrowserControlOffset, browserOffset) == 0) return;
-            mBrowserControlOffset = browserOffset;
+            float browserRatio = ratio.floatValue();
+            if (Float.compare(mBrowserControlShownRatio, browserRatio) == 0) return;
+            mBrowserControlShownRatio = browserRatio;
             manager.updateControlOffset();
             manager.updateVisuals();
         }
     }
 
     private final Runnable mUpdateVisibilityRunnable = new Runnable() {
         @Override
         public void run() {
             int visibility = shouldShowAndroidControls() ? View.VISIBLE : View.INVISIBLE;
             if (mControlContainer.getView().getVisibility() == visibility) return;
@@ skipping 26 matching lines @@
                     chromeFullscreenManager.update(false);
                     break;
                 default:
                     assert false : "Unexpected message for ID: " + msg.what;
                     break;
             }
         }
     }
 
     /**
+     * @return The ratio that the browser controls are off screen; this will be a number [0,1]
+     *         where 1 is completely hidden and 0 is completely shown.
+     */
+    private float getBrowserControlHiddenRatio() {
+        return mControlOffsetRatio;
+    }
+
+    /**
      * Creates an instance of the fullscreen mode manager.
      * @param activity The activity that supports fullscreen.
      * @param controlContainer Container holding the controls (Toolbar).
      * @param modelSelector The tab model selector that will be monitored for tab changes.
      * @param resControlContainerHeight The dimension resource ID for the control container height.
      * @param supportsBrowserOverride Whether we want to disable the token system used by the
                                       browser.
      */
     public ChromeFullscreenManager(Activity activity, ControlContainer controlContainer,
             TabModelSelector modelSelector, int resControlContainerHeight,
@@ skipping 116 matching lines @@
     public void disableBrowserOverrideForTest() {
         ThreadUtils.assertOnUiThread();
 
         mDisableBrowserOverride = true;
         mPersistentControlTokens.clear();
         mHandler.removeMessages(MSG_ID_HIDE_CONTROLS);
         if (mControlAnimation != null) {
             mControlAnimation.cancel();
             mControlAnimation = null;
         }
-        mBrowserControlOffset = Float.NaN;
+        mBrowserControlShownRatio = Float.NaN;
         updateVisuals();
     }
 
     /**
      * Allows tests to override the animation durations for faster tests.
      * @param minShowDuration The minimum time the controls must be shown.
      * @param maxAnimationDuration The maximum animation time to show/hide the controls.
      */
     @VisibleForTesting
     public void setAnimationDurationsForTest(long minShowDuration, long maxAnimationDuration) {
@@ skipping 44 matching lines @@
      * @return Whether or not the toolbar is forcefully being removed.
      */
     public boolean areBrowserControlsPermanentlyHidden() {
         return mBrowserControlsPermanentlyHidden;
     }
 
     /**
      * @return Whether the browser controls should be drawn as a texture.
      */
     public boolean drawControlsAsTexture() {
-        return getControlOffset() > -mControlContainerHeight;
+        return getBrowserControlHiddenRatio() > 0;
     }
 
     @Override
     public int getBrowserControlsHeight() {
         return mControlContainerHeight;
     }
 
     @Override
     public float getContentOffset() {
         if (mBrowserControlsPermanentlyHidden) return 0;
         return rendererContentOffset();
     }
 
     /**
      * @return The offset of the controls from the top of the screen.
      */
     public float getControlOffset() {
         if (mBrowserControlsPermanentlyHidden) return -getBrowserControlsHeight();
-        return mControlOffset;
+        // This is to avoid a problem with -0f in tests.
+        if (mControlOffsetRatio == 0f) return 0f;
+        return mControlOffsetRatio * -getBrowserControlsHeight();
     }
 
     /**
      * @return The toolbar control container.
      */
     public ControlContainer getControlContainer() {
         return mControlContainer;
     }
 
-    @SuppressWarnings("SelfEquality")
     private void updateControlOffset() {
-        float offset = 0;
+        float topOffsetRatio = 0;
+
         // Inline Float.isNan with "x != x":
-        final boolean isNaNBrowserControlOffset = mBrowserControlOffset != mBrowserControlOffset;
-        final float rendererControlOffset = rendererControlOffset();
-        final boolean isNaNRendererControlOffset = rendererControlOffset != rendererControlOffset;
+        final boolean isNaNBrowserControlOffset = Float.isNaN(mBrowserControlShownRatio);
+        final float rendererControlOffset =
+                Math.abs(rendererControlOffset() / controlContainerHeight());
+        final boolean isNaNRendererControlOffset = Float.isNaN(rendererControlOffset);
         if (!isNaNBrowserControlOffset || !isNaNRendererControlOffset) {
-            offset = Math.max(
-                    isNaNBrowserControlOffset ? -mControlContainerHeight : mBrowserControlOffset,
-                    isNaNRendererControlOffset ? -mControlContainerHeight : rendererControlOffset);
+            topOffsetRatio = Math.min(
+                    isNaNBrowserControlOffset ? 1 : mBrowserControlShownRatio,
+                    isNaNRendererControlOffset ? 1 : rendererControlOffset);
         }
-        mControlOffset = offset;
+        mControlOffsetRatio = topOffsetRatio;
     }
 
     @Override
     public void setOverlayVideoMode(boolean enabled) {
         super.setOverlayVideoMode(enabled);
 
         for (int i = 0; i < mListeners.size(); i++) {
             mListeners.get(i).onToggleOverlayVideoMode(enabled);
         }
     }
 
     /**
      * @return Whether the browser has a control offset override.
      */
     @VisibleForTesting
     public boolean hasBrowserControlOffsetOverride() {
-        return !Float.isNaN(mBrowserControlOffset) || mControlAnimation != null
+        return !Float.isNaN(mBrowserControlShownRatio) || mControlAnimation != null
                 || !mPersistentControlTokens.isEmpty();
     }
 
     /**
      * Returns how tall the opaque portion of the control container is.
      */
     public float controlContainerHeight() {
         return mControlContainerHeight;
     }
 
@@ skipping 113 matching lines @@
      */
     public void setHideBrowserControlsAndroidView(boolean hide) {
         if (mBrowserControlsAndroidViewHidden == hide) return;
         mBrowserControlsAndroidViewHidden = hide;
         scheduleVisibilityUpdate();
     }
 
     private boolean shouldShowAndroidControls() {
         if (mBrowserControlsAndroidViewHidden) return false;
 
-        boolean showControls = getControlOffset() == 0;
+        boolean showControls = !drawControlsAsTexture();
         ContentViewCore contentViewCore = getActiveContentViewCore();
         if (contentViewCore == null) return showControls;
         ViewGroup contentView = contentViewCore.getContainerView();
 
         for (int i = 0; i < contentView.getChildCount(); i++) {
             View child = contentView.getChildAt(i);
             if (!(child.getLayoutParams() instanceof FrameLayout.LayoutParams)) continue;
 
             FrameLayout.LayoutParams layoutParams =
                     (FrameLayout.LayoutParams) child.getLayoutParams();
@@ skipping 148 matching lines @@
     private void animateIfNecessary(final boolean show, long startDelay) {
         if (mControlAnimation != null) {
             if (!mControlAnimation.isRunning() || mCurrentAnimationIsShowing != show) {
                 mControlAnimation.cancel();
                 mControlAnimation = null;
             } else {
                 return;
             }
         }
 
-        float destination = show ? 0 : -mControlContainerHeight;
+        float destination = show ? 0 : 1;
         long duration = (long) (mMaxAnimationDurationMs
-                * Math.abs((destination - getControlOffset()) / mControlContainerHeight));
+                * Math.abs(destination - getBrowserControlHiddenRatio()));
         mControlAnimation = ObjectAnimator.ofFloat(this, new ControlsOffsetProperty(), destination);
         mControlAnimation.addListener(new AnimatorListenerAdapter() {
             private boolean mCanceled = false;
 
             @Override
             public void onAnimationCancel(Animator anim) {
                 mCanceled = true;
             }
 
             @Override
             public void onAnimationEnd(Animator animation) {
-                if (!show && !mCanceled) mBrowserControlOffset = Float.NaN;
+                if (!show && !mCanceled) mBrowserControlShownRatio = Float.NaN;
                 mControlAnimation = null;
             }
         });
         mControlAnimation.setStartDelay(startDelay);
         mControlAnimation.setDuration(duration);
         mControlAnimation.start();
         mCurrentAnimationIsShowing = show;
     }
 
     @Override
     public void onContentViewScrollingStateChanged(boolean scrolling) {
         mContentViewScrolling = scrolling;
         if (!scrolling) updateVisuals();
     }
 }