[ash-md] Remove the number of animators used for the Shelf animations.

ui/gfx/animation/slide_animation.cc

 // Copyright (c) 2012 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.
 
 #include "ui/gfx/animation/slide_animation.h"
 
 #include <math.h>
 
+#include "base/auto_reset.h"
+#include "ui/gfx/animation/animation_delegate.h"
+
 namespace gfx {
 
 // How long animations should take by default.
 static const int kDefaultDurationMs = 120;
 
 SlideAnimation::SlideAnimation(AnimationDelegate* target)
     : LinearAnimation(target),
       target_(target),
       tween_type_(Tween::EASE_OUT),
       showing_(false),
@@ skipping 20 matching lines @@
   if (showing_)
     return;
 
   showing_ = true;
   value_start_ = value_current_;
   value_end_ = 1.0;
 
   // Make sure we actually have something to do.
   if (slide_duration_ == 0) {
     AnimateToState(1.0);  // Skip to the end of the animation.
+    if (delegate())
+      delegate()->AnimationProgressed(this);

[James Cook, 2017/02/08 00:31:28]

Do you know offhand if any of Chrome's other users of SlideAnimation depend on
duration 0?

[bruthig, 2017/02/10 18:49:10]

I did a quick audit and it appears there might be 3 cases where a slide duration
of 0 may be used:
- ImmersiveFullscreenController
- ScrollAnimator
- OmniboxResultView::OnBoundsChanged()

Oddly enough there is a BoundsAnimatorDisabler in shelf_view.cc that uses a
duration of 1.  Seems like a work around for some undesirable behaviour when the
duration is 0.

IMO the SlideAnimation doesn't support this case well and it should probably be
fixed or removed.

     return;
   } else if (value_current_ == value_end_)  {
     return;
   }
 
   // This will also reset the currently-occurring animation.
   SetDuration(static_cast<int>(slide_duration_ * (1 - value_current_)));
   Start();
 }
 
+void SlideAnimation::ShowImmediately() {
+  base::AutoReset<int> auto_reset_duration(&slide_duration_, 0);
+  Show();
+}
+
 void SlideAnimation::Hide() {
   // If we're already hiding (or hidden), we have nothing to do.
   if (!showing_)
     return;
 
   showing_ = false;
   value_start_ = value_current_;
   value_end_ = 0.0;
 
   // Make sure we actually have something to do.
   if (slide_duration_ == 0) {
-    AnimateToState(0.0);  // Skip to the end of the animation.
+    AnimateToState(1.0);  // Skip to the end of the animation.
+    if (delegate())
+      delegate()->AnimationProgressed(this);
     return;
   } else if (value_current_ == value_end_) {
     return;
   }
 
   // This will also reset the currently-occurring animation.
   SetDuration(static_cast<int>(slide_duration_ * value_current_));
   Start();
 }
 
+void SlideAnimation::HideImmediately() {
+  base::AutoReset<int> auto_reset_duration(&slide_duration_, 0);
+  Hide();
+}
+
 void SlideAnimation::SetSlideDuration(int duration) {
   slide_duration_ = duration;
 }
 
 double SlideAnimation::GetCurrentValue() const {
   return value_current_;
 }
 
 void SlideAnimation::AnimateToState(double state) {
   if (state > 1.0)
@@ skipping 10 matching lines @@
 
   // Correct for any overshoot (while state may be capped at 1.0, let's not
   // take any rounding error chances.
   if ((value_end_ >= value_start_ && value_current_ > value_end_) ||
       (value_end_ < value_start_ && value_current_ < value_end_)) {
     value_current_ = value_end_;
   }
 }
 
 }  // namespace gfx