[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.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;
 
 /**
  * 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 long ALPHA_ANIMATION_DURATION_MS = 150;
+    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 = ALPHA_ANIMATION_DURATION_MS;
+    public static final long HIDING_DURATION_MS = ALPHA_ANIMATION_DURATION_MS + HIDING_DELAY_MS;
+
+    private boolean mIsStarted;
+    private float mTargetAlpha = 0.0f;
+    private final Runnable mHideRunnable = new Runnable() {
+        @Override
+        public void run() {
+            animateAlphaTo(0.0f);
+        }
+    };
 
     /**
      * 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);
+        setAlpha(mTargetAlpha);
+    }
 
-        mClearLoadProgressRunnable = new Runnable() {
-            @Override
-            public void run() {
-                setProgress(0);
-            }
-        };
+    /**
+     * Start showing progress bar animation.
+     */
+    public void start() {
+        mIsStarted = true;
+        removeCallbacks(mHideRunnable);
+        animateAlphaTo(1.0f);
+    }
 
-        // 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);
-            }
+    /**
+     * Start hiding progress bar animation.
+     * @param fadeOut Whether a delayed fading out animation should be posted.
+     */
+    public void finish(boolean fadeOut) {
+        mIsStarted = false;
+
+        removeCallbacks(mHideRunnable);
+
+        if (fadeOut) {
+            postDelayed(mHideRunnable, HIDING_DELAY_MS);
+        } else {
+            mTargetAlpha = 0.0f;
+            setAlpha(0.0f);
         }
     }
 
-    @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());
-            }
+    private void animateAlphaTo(float targetAlpha) {
+        mTargetAlpha = targetAlpha;
+        float alphaDiff = targetAlpha - getAlpha();
+        if (alphaDiff != 0.0f) {
+            animate().alpha(targetAlpha)
+                    .setDuration((long) Math.abs(alphaDiff * ALPHA_ANIMATION_DURATION_MS))
+                    .setInterpolator(alphaDiff > 0
+                            ? BakedBezierInterpolator.FADE_IN_CURVE
+                            : BakedBezierInterpolator.FADE_OUT_CURVE);
         }
     }
 
-    /**
-     * @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);
-            }
-        });
-    }
+    // 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();
-            }
-        }
     }
 }