[Andorid] Migrate to ClipDrawable progress bar.

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.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ObjectAnimator;
+import android.animation.TimeAnimator;
+import android.animation.TimeAnimator.TimeListener;
 import android.content.Context;
-import android.graphics.drawable.Drawable;
-import android.graphics.drawable.LayerDrawable;
 import android.util.AttributeSet;
-import android.view.View;
 
 import org.chromium.base.VisibleForTesting;
-import org.chromium.ui.interpolators.BakedBezierInterpolator;
+import org.chromium.chrome.browser.util.MathUtils;
 
 /**
  * Progress bar for use in the Toolbar view.
  */
-public class ToolbarProgressBar extends SmoothProgressBar {
-    private static final long PROGRESS_CLEARING_DELAY_MS = 200;
-    private static final int SHOW_HIDE_DURATION_MS = 100;
+public class ToolbarProgressBar extends ClipDrawableProgressBar {
+    private static final float ALPHA_CHANGE_SPEED_PER_SECOND = 8.0f;
+    private static final long HIDING_DELAY_MS = 100;
 
-    private final Runnable mClearLoadProgressRunnable;
-    private int mDesiredVisibility;
-    private Animator mShowAnimator;
-    private Animator mHideAnimator;
+    // Public duration constants are for testing.
+    public static final long SHOWING_DURATION_MS =
+            (long) Math.ceil(1.0f / ALPHA_CHANGE_SPEED_PER_SECOND * 1000);
+    public static final long HIDING_DURATION_MS = HIDING_DELAY_MS
+            + (long) Math.ceil(1.0f / ALPHA_CHANGE_SPEED_PER_SECOND * 1000);
+
+    private boolean mIsStarted;
+    private float mTargetAlpha;
+    private boolean mIsHideRunnablePosted;
+    private TimeAnimator mAlphaAnimator = new TimeAnimator();
+    private final Runnable mHideRunnable = new Runnable() {
+        @Override
+        public void run() {
+            animateAlphaTo(0.0f);
+            mIsHideRunnablePosted = false;
+        }
+    };
 
     /**
      * 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);
-        // The base constructor will trigger a progress change and alter the expected
-        // visibility, so force a visibility change to reset the state.
-        setVisibility(VISIBLE);
 
-        mClearLoadProgressRunnable = new Runnable() {
+        setAlpha(mTargetAlpha);
+
+        mAlphaAnimator.setTimeListener(new TimeListener() {

[Ted C, 2015/07/15 02:41:12]

What is the benefit of the alpha animator?

Doesn't that lose us the ability to set an interpolator?

Wondering why this animation is different than other places?  Is it with the
goal that a total animation from 0 -> 1 should take X seconds?  And if you only
need to animate from 0.5 -> 1 then it should take 1/2X?

[Kibeom Kim (inactive), 2015/07/15 11:22:46]

I like TimeAnimator in general, I don't know why I did that here, I must be
drunk. Done.

Though, I think interpolation doesn't matter as the animation is too short to
notice the difference. Set it back anyways.

             @Override
-            public void run() {
-                setProgress(0);
-            }
-        };
+            public void onTimeUpdate(TimeAnimator animation, long totalTimeMs, long deltaTimeMs) {
+                float alpha = getAlpha();
 
-        // Hide the background portion of the system progress bar.
-        Drawable progressDrawable = getProgressDrawable();
-        if (progressDrawable instanceof LayerDrawable) {
-            Drawable progressBackgroundDrawable =
-                    ((LayerDrawable) progressDrawable)
-                            .findDrawableByLayerId(android.R.id.background);
-            if (progressBackgroundDrawable != null) {
-                progressBackgroundDrawable.setVisible(false, false);
-                progressBackgroundDrawable.setAlpha(0);
-            }
-        }
-    }
+                if (alpha == mTargetAlpha) {
+                    mAlphaAnimator.end();
+                    return;
+                }
 
-    @Override
-    public void setSecondaryProgress(int secondaryProgress) {
-        super.setSecondaryProgress(secondaryProgress);
-        setVisibilityForProgress();
-    }
-
-    @Override
-    protected void setProgressInternal(int progress) {
-        super.setProgressInternal(progress);
-
-        if (progress == getMax()) {
-            postDelayed(mClearLoadProgressRunnable, PROGRESS_CLEARING_DELAY_MS);
-        }
-
-        setVisibilityForProgress();
-    }
-
-    @Override
-    public void setVisibility(int v) {
-        mDesiredVisibility = v;
-        setVisibilityForProgress();
-    }
-
-    private void setVisibilityForProgress() {
-        if (mDesiredVisibility != VISIBLE) {
-            super.setVisibility(mDesiredVisibility);
-            return;
-        }
-
-        int progress = Math.max(getProgress(), getSecondaryProgress());
-        super.setVisibility(progress == 0 ? INVISIBLE : VISIBLE);
-    }
-
-    @Override
-    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-        super.onSizeChanged(w, h, oldw, oldh);
-
-        // Some versions of Android have a bug where they don't properly update the drawables with
-        // the correct bounds.  setProgressDrawable has been overridden to properly push the bounds
-        // but on rotation they weren't always being set.  Forcing a bounds update on size changes
-        // fixes the problem.
-        setProgressDrawable(getProgressDrawable());
-    }
-
-    @Override
-    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
-        super.onLayout(changed, left, top, right, bottom);
-        buildAnimators();
-        setPivotY(getHeight());
-    }
-
-    @Override
-    public void setProgressDrawable(Drawable d) {
-        Drawable currentDrawable = getProgressDrawable();
-
-        super.setProgressDrawable(d);
-
-        if (currentDrawable != null && d instanceof LayerDrawable) {
-            LayerDrawable ld = (LayerDrawable) d;
-            for (int i = 0; i < ld.getNumberOfLayers(); i++) {
-                ld.getDrawable(i).setBounds(currentDrawable.getBounds());
-            }
-        }
-    }
-
-    /**
-     * @return Whether or not this progress bar has animations running for showing/hiding itself.
-     */
-    @VisibleForTesting
-    boolean isAnimatingForShowOrHide() {
-        return (mShowAnimator != null && mShowAnimator.isStarted())
-                || (mHideAnimator != null && mHideAnimator.isStarted());
-    }
-
-    private void buildAnimators() {
-        if (mShowAnimator != null && mShowAnimator.isRunning()) mShowAnimator.end();
-        if (mHideAnimator != null && mHideAnimator.isRunning()) mHideAnimator.end();
-
-        mShowAnimator = ObjectAnimator.ofFloat(this, View.SCALE_Y, 0.f, 1.f);
-        mShowAnimator.setDuration(SHOW_HIDE_DURATION_MS);
-        mShowAnimator.setInterpolator(BakedBezierInterpolator.FADE_IN_CURVE);
-        mShowAnimator.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationStart(Animator animation) {
-                setSecondaryProgress(getMax());
-            }
-        });
-
-        mHideAnimator = ObjectAnimator.ofFloat(this, View.SCALE_Y, 1.f, 0.f);
-        mHideAnimator.setDuration(SHOW_HIDE_DURATION_MS);
-        mHideAnimator.setInterpolator(BakedBezierInterpolator.FADE_OUT_CURVE);
-        mHideAnimator.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationEnd(Animator animation) {
-                setSecondaryProgress(0);
+                float maxAlphaChange = ALPHA_CHANGE_SPEED_PER_SECOND * deltaTimeMs / 1000.0f;
+                setAlpha(alpha
+                        + MathUtils.clamp(mTargetAlpha - alpha, -maxAlphaChange, maxAlphaChange));
             }
         });
     }
 
+    /**
+     * Start showing progress bar animation.
+     */
+    public void start() {
+        mIsStarted = true;
+
+        removeCallbacks(mHideRunnable);
+        mIsHideRunnablePosted = false;
+
+        animateAlphaTo(1.0f);
+    }
+
+    /**
+     * Start hiding progress bar animation.
+     */
+    public void finish() {
+        mIsStarted = false;

[Ted C, 2015/07/15 02:41:12]

Is page load finished always going to happen right after progress hits 100%?  We
aren't delaying the hiding more by having this be driven by something other than
set progress are we?

[Kibeom Kim (inactive), 2015/07/15 11:22:46]

I think, regardless of happening right after 100% or not, page load finished
event is the correct place to finish progress. At least it seems desktop spinner
has done in that way.
https://code.google.com/p/chromium/codesearch#chromium/src/content/public/bro...

And for the question, I don't know for sure :/ though it doesn't seem guaranteed
to me.
https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/fr...

[Ted C, 2015/07/15 17:42:59]

Not sure I agree with the "correctness" assertion.

The desktop spinner don't have a finished state while the progress bar does.  If
they rotate a bit extra than the user won't really notice.  If our blue bar
stays on the screen for a couple extra seconds then it will be much more
noticeable to the user.

[Kibeom Kim (inactive), 2015/07/16 04:45:48]

Investigation so far:

In general, progress can be updated from these two functions.
1.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
2.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

1 is coupled with DidFinishLoad event
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
. But for 2, seems like it only tracks total downloaded bytes % per estimation.
My impression is that it's not a sufficient condition for DidFinishLoad event to
be fired as DidFinishLoad has to pass these additional checks.

-
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
-
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...


Notes:
- If 100% progress is happened by 2, not 1, Frame#m_isLoading variable will be
still true.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
setIsLoading(false); is only called in 1. 
- Though, I tried many pages locally, but couldn't find an example that the
progress bar reaches 100% independent from DidFinishLoad event. 

+
+        removeCallbacks(mHideRunnable);
+        postDelayed(mHideRunnable, HIDING_DELAY_MS);
+        mIsHideRunnablePosted = true;
+    }
+
+    /**
+     * @return Whether or not this progress bar has animations running or scheduled for
+     *         showing/hiding itself.
+     */
+    @VisibleForTesting
+    public boolean isAnimatingForShowOrHide() {
+        return mAlphaAnimator.isStarted() || mIsHideRunnablePosted;
+    }
+
+    private void animateAlphaTo(float targetAlpha) {
+        mTargetAlpha = targetAlpha;
+        if (getAlpha() != targetAlpha) mAlphaAnimator.start();
+    }
+
+    // ClipDrawableProgressBar implementation.
+
     @Override
-    public void setProgress(int progress) {
-        // If the show animator has started, the progress bar needs to be tracked as if it is
-        // currently showing.  This makes sure we trigger the proper hide animation and cancel the
-        // show animation if we show/hide the bar very fast.  See crbug.com/453360.
-        boolean isShowing =
-                getProgress() > 0 || (mShowAnimator != null && mShowAnimator.isStarted());
-        boolean willShow = progress > 0;
-
-        removeCallbacks(mClearLoadProgressRunnable);
+    public void setProgress(float progress) {
+        assert mIsStarted;
         super.setProgress(progress);
-
-        if (isShowing != willShow) {
-            if (mShowAnimator == null || mHideAnimator == null) buildAnimators();
-
-            if (mShowAnimator.isRunning()) mShowAnimator.end();
-            if (mHideAnimator.isRunning()) mHideAnimator.end();
-
-            if (willShow) {
-                mShowAnimator.start();
-            } else {
-                mHideAnimator.start();
-            }
-        }
     }
 }