[Android] Add phone progress bar animation behind a flag.

chrome/android/java/src/org/chromium/chrome/browser/widget/ToolbarProgressBar.java

 // Copyright 2015 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.widget;
 
+import android.animation.TimeAnimator;
+import android.animation.TimeAnimator.TimeListener;
 import android.content.Context;
+import android.text.TextUtils;
 import android.util.AttributeSet;
 
+import org.chromium.base.CommandLine;
 import org.chromium.base.VisibleForTesting;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.ui.interpolators.BakedBezierInterpolator;
 
 /**
  * Progress bar for use in the Toolbar view.
  */
 public class ToolbarProgressBar extends ClipDrawableProgressBar {
-    private long mAlphaAnimationDurationMs = 130;
+
+    /**
+     * Interface for progress bar animation interpolation logics.
+     */
+    interface AnimationLogic {
+        /**
+         * Resets internal data. It must be called on every loading start.
+         */
+        void reset();
+
+        /**
+         * Returns interpolated progress for animation.
+         *
+         * @param targetProgress Actual page loading progress.
+         * @param frameTimeSec   Duration since the last call.
+         * @param resolution     Resolution of the displayed progress bar. Mainly for rounding.
+         */
+        float updateProgress(float targetProgress, float frameTimeSec, int resolution);
+    }
+
+    private static final long PROGRESS_FRAME_TIME_CAP_MS = 50;
+    private long mAlphaAnimationDurationMs = 140;
     private long mHidingDelayMs = 100;
 
     private boolean mIsStarted;
+    private float mTargetProgress;
     private float mTargetAlpha = 0.0f;
+    AnimationLogic mAnimationLogic;
+
     private final Runnable mHideRunnable = new Runnable() {
         @Override
         public void run() {
             animateAlphaTo(0.0f);
         }
     };
 
+    private final TimeAnimator mProgressAnimator = new TimeAnimator();
+    {
+        mProgressAnimator.setTimeListener(new TimeListener() {
+            @Override
+            public void onTimeUpdate(TimeAnimator animation, long totalTimeMs, long deltaTimeMs) {
+                // Cap progress bar animation frame time so that it doesn't jump too much even when
+                // the animation is janky.
+                ToolbarProgressBar.super.setProgress(mAnimationLogic.updateProgress(
+                        mTargetProgress,
+                        Math.max(deltaTimeMs, PROGRESS_FRAME_TIME_CAP_MS) * 0.001f,
+                        getWidth()));
+
+                if (getProgress() == mTargetProgress) {
+                    if (mTargetProgress == 1.0f && !mIsStarted) {
+                        postDelayed(mHideRunnable, mHidingDelayMs);
+                    }
+                    mProgressAnimator.end();
+                    return;
+                }
+            }
+        });
+    }
+
     /**
      * Creates a toolbar progress bar.
      *
      * @param context the application environment.
      * @param attrs the xml attributes that should be used to initialize this view.
      */
     public ToolbarProgressBar(Context context, AttributeSet attrs) {
         super(context, attrs);
         setAlpha(mTargetAlpha);
     }
 
     /**
+     * Initializes animation based on command line configuration. This must be called when native
+     * library is ready.
+     */
+    public void initializeAnimation() {
+        assert mAnimationLogic == null;
+
+        String animation = CommandLine.getInstance().getSwitchValue(
+                ChromeSwitches.PROGRESS_BAR_ANIMATION);
+        if (TextUtils.equals(animation, "smooth")) {
+            mAnimationLogic = new ProgressAnimationSmooth();
+        } else if (TextUtils.equals(animation, "fast-start")) {
+            mAnimationLogic = new ProgressAnimationFastStart();
+        }
+    }
+
+    /**
      * Start showing progress bar animation.
      */
     public void start() {
         mIsStarted = true;
+        super.setProgress(0.0f);
+        if (mAnimationLogic != null) mAnimationLogic.reset();
         removeCallbacks(mHideRunnable);
         animateAlphaTo(1.0f);
     }
 
     /**
      * Start hiding progress bar animation.
      * @param delayed Whether a delayed fading out animation should be posted.
      */
     public void finish(boolean delayed) {
         mIsStarted = false;
 
-        removeCallbacks(mHideRunnable);
-
         if (delayed) {
-            postDelayed(mHideRunnable, mHidingDelayMs);
+            updateVisibleProgress();

[jdduke (slow), 2015/08/03 23:35:35]

Silly ignorant question: Is finish() allowed to be called multiple times
redundantly? If so we might get into a scenario where the hide callback is
posted a ton of times. I have no idea if this happens in practice. There are
other places that call setProgress too, basically I'm wondering if there's any
way we can safeguarding against posting a ton of hide runnables? Also, why not
postOnAnimationDelayed?

[Kibeom Kim (inactive), 2015/08/04 02:08:44]

Yeah currently finish() can be called multiple times aftert start(), though
normally it will be called only once. The list of events that calls finish():

- onCrash
- onPageLoadFailed
- onPageLoadFinished
- onPageLoadStarted (if it's native page)
- ToolbarManager#updateCurrentTabDisplayStatus()

So I don't think we're spamming, and actually only onPageLoadFinished will call
finished() with "delayed==true" argument, so definitely we're not spamming
posting tasks at least. I could have just guarded by |if (!mIsStarted) return;|
but didn't feel it's worth when I was writing this.

And yeah I think I should have used postOnAnimationDelayed. Thanks for pointing
out, I'll prepare CL shortly.

         } else {
             mTargetAlpha = 0.0f;
             setAlpha(0.0f);
         }
     }
 
     /**
      * Set alpha show&hide animation duration. This is for faster testing.
      * @param alphaAnimationDurationMs Alpha animation duration in milliseconds.
      */
@@ skipping 16 matching lines @@
         float alphaDiff = targetAlpha - getAlpha();
         if (alphaDiff != 0.0f) {
             animate().alpha(targetAlpha)
                     .setDuration((long) Math.abs(alphaDiff * mAlphaAnimationDurationMs))
                     .setInterpolator(alphaDiff > 0
                             ? BakedBezierInterpolator.FADE_IN_CURVE
                             : BakedBezierInterpolator.FADE_OUT_CURVE);
         }
     }
 
+    private void updateVisibleProgress() {
+        if (mAnimationLogic == null) {
+            super.setProgress(mTargetProgress);
+            if (!mIsStarted) {
+                postDelayed(mHideRunnable, mHidingDelayMs);
+            }
+        } else {
+            if (!mProgressAnimator.isStarted()) mProgressAnimator.start();
+        }
+    }
+
     // ClipDrawableProgressBar implementation.
 
     @Override
     public void setProgress(float progress) {
         assert mIsStarted;
-        super.setProgress(progress);
+        assert getProgress() <= progress;
+
+        mTargetProgress = progress;
+        updateVisibleProgress();
     }
 }