Revert of Disabled ink drop animations based on gfx::Animation::ShouldRenderRichAnimation().

ui/views/animation/ink_drop_highlight.cc

 // 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.
 
 #include "ui/views/animation/ink_drop_highlight.h"
 
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/compositor/callback_layer_animation_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/animation/animation.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/animation/ink_drop_highlight_observer.h"
 #include "ui/views/animation/ink_drop_painted_layer_delegates.h"
 
 namespace views {
 
 namespace {
 
 // The opacity of the highlight when it is not visible.
 const float kHiddenOpacity = 0.0f;
@@ skipping 65 matching lines @@
 }
 
 test::InkDropHighlightTestApi* InkDropHighlight::GetTestApi() {
   return nullptr;
 }
 
 void InkDropHighlight::AnimateFade(AnimationType animation_type,
                                    const base::TimeDelta& duration,
                                    const gfx::Size& initial_size,
                                    const gfx::Size& target_size) {
-  // Ink drop animations are controlled by the system animation settings for
-  // accessibility reasons."See https://crbug.com/658384.
-  const base::TimeDelta effective_duration =
-      gfx::Animation::ShouldRenderRichAnimation() ? duration
-                                                  : base::TimeDelta();
   last_animation_initiated_was_fade_in_ = animation_type == FADE_IN;
 
   layer_->SetTransform(CalculateTransform(initial_size));
 
   // The |animation_observer| will be destroyed when the
   // AnimationStartedCallback() returns true.
   ui::CallbackLayerAnimationObserver* animation_observer =
       new ui::CallbackLayerAnimationObserver(
           base::Bind(&InkDropHighlight::AnimationStartedCallback,
                      base::Unretained(this), animation_type),
           base::Bind(&InkDropHighlight::AnimationEndedCallback,
                      base::Unretained(this), animation_type));
 
   ui::LayerAnimator* animator = layer_->GetAnimator();
   ui::ScopedLayerAnimationSettings animation(animator);
   animation.SetTweenType(gfx::Tween::EASE_IN_OUT);
   animation.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   ui::LayerAnimationElement* opacity_element =
       ui::LayerAnimationElement::CreateOpacityElement(
           animation_type == FADE_IN ? visible_opacity_ : kHiddenOpacity,
-          effective_duration);
+          duration);
   ui::LayerAnimationSequence* opacity_sequence =
       new ui::LayerAnimationSequence(opacity_element);
   opacity_sequence->AddObserver(animation_observer);
   animator->StartAnimation(opacity_sequence);
 
   if (initial_size != target_size) {
     ui::LayerAnimationElement* transform_element =
         ui::LayerAnimationElement::CreateTransformElement(
-            CalculateTransform(target_size), effective_duration);
+            CalculateTransform(target_size), duration);
     ui::LayerAnimationSequence* transform_sequence =
         new ui::LayerAnimationSequence(transform_element);
     transform_sequence->AddObserver(animation_observer);
     animator->StartAnimation(transform_sequence);
   }
 
   animation_observer->SetActive();
 }
 
 gfx::Transform InkDropHighlight::CalculateTransform(
@@ skipping 27 matching lines @@
   if (observer_) {
     observer_->AnimationEnded(animation_type,
                               observer.aborted_count()
                                   ? InkDropAnimationEndedReason::PRE_EMPTED
                                   : InkDropAnimationEndedReason::SUCCESS);
   }
   return true;
 }
 
 }  // namespace views