[Android] Respect animation multiplier from Developer Options.

chrome/android/java/src/org/chromium/chrome/browser/compositor/layouts/ChromeAnimation.java

 // Copyright 2010 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.compositor.layouts;
 
+import android.annotation.TargetApi;
+import android.os.Build;
 import android.os.SystemClock;
+import android.provider.Settings;
 import android.view.animation.AccelerateInterpolator;
 import android.view.animation.DecelerateInterpolator;
 import android.view.animation.Interpolator;
 import android.view.animation.LinearInterpolator;
 
+import org.chromium.base.ContextUtils;
+
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * A class to handle simple animation sets.  This can animate any object passed in by overriding
  * the ChromeAnimation.Animation object.
  *
  * @param <T> The type of Object being animated by this ChromeAnimation set.
  */
 @SuppressWarnings("unchecked")
 public class ChromeAnimation<T> {
     /**
      * The amount we jump into the animation for the first frame.  We do this as we assume
      * the object be animated is already resting in the initial value specified.  To avoid wasting
      * a frame of animation on something that will look exactly the same, we jump into the
      * animation by this frame offset (calculated by the desired time required to draw one frame
      * at 60 FPS).
      */
     private static final int FIRST_FRAME_OFFSET_MS = 1000 / 60;
 
     /**
-     * Can be used to slow down created animations for debugging purposes.
+     * Multiplier for animation durations for debugging. Can be set in Developer Options and cached
+     * here.
      */
-    private static final int ANIMATION_MULTIPLIER = 1;
+    private static Float sAnimationMultiplier;

[mdjones, 2017/03/15 20:50:38]

I'm guessing this can't be final because it is set in a function called by the
constructor rather than directly by the constructor, right?

[Bernhard Bauer, 2017/03/15 21:21:58]

It's static, so it would have to be set when the class is loaded, and I don't
really want to have to rely on ContextUtils being initialized at that point.
What I could do is use the initialization-on-demand holder idiom?

[mdjones, 2017/03/15 22:13:12]

Ah right. I think what you have is fine.

 
     private final AtomicBoolean mFinishCalled = new AtomicBoolean();
     private final ArrayList<Animation<T>> mAnimations = new ArrayList<Animation<T>>();
     private long mCurrentTime;
 
     // Keep a reference to one of each standard interpolator to avoid allocations.
     private static AccelerateInterpolator sAccelerateInterpolator;
     private static LinearInterpolator sLinearInterpolator;
     private static DecelerateInterpolator sDecelerateInterpolator;
     private static final Object sLock = new Object();
@@ skipping 202 matching lines @@
          * @param duration The duration of the animation.  This does not include the startTime.
          *                 The duration must be strictly positive.
          * @param startTime The time at which this animation should start.
          */
         public Animation(T t, float start, float end, long duration,
                 long startTime) {
             assert duration > 0;
             mAnimatedObject = t;
             mStart = start;
             mEnd = end;
-            mDuration = duration * ANIMATION_MULTIPLIER;
-            mStartDelay = startTime * ANIMATION_MULTIPLIER;
+            float animationMultiplier = getAnimationMultiplier();
+            mDuration = (long) (duration * animationMultiplier);
+            mStartDelay = (long) (startTime * animationMultiplier);
             mCurrentTime = 0;
         }
 
+        @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
+        private float getAnimationMultiplier() {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) return 1f;
+
+            synchronized (sLock) {
+                if (sAnimationMultiplier == null) {
+                    sAnimationMultiplier = Settings.Global.getFloat(
+                            ContextUtils.getApplicationContext().getContentResolver(),
+                            Settings.Global.ANIMATOR_DURATION_SCALE, 1f);
+                }
+                return sAnimationMultiplier;
+            }
+        }
+
         /**
          * Returns the object being animated.
          */
         protected T getAnimatedObject() {
             return mAnimatedObject;
         }
 
         /**
          * @param delayStartValue Whether to delay setting the animation's initial value until
          *        after the specified start delay (Default = false).
@@ skipping 228 matching lines @@
 
         /**
          * Checks if the given property is being animated.
          */
         @Override
         public <V extends Enum<?>> boolean checkProperty(V prop) {
             return mProperty == prop;
         }
     }
 }