Remove unneeded ScopedLayerAnimationSettings::LockTransitionDuration()

ui/compositor/layer_animator.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/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/animation/animation_id_provider.h"
@@ skipping 37 matching lines @@
   return container;
 }
 
 }  // namespace
 
 // LayerAnimator public --------------------------------------------------------
 
 LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
     : delegate_(NULL),
       preemption_strategy_(IMMEDIATELY_SET_NEW_TARGET),
-      is_transition_duration_locked_(false),
       transition_duration_(transition_duration),
       tween_type_(gfx::Tween::LINEAR),
       is_started_(false),
       disable_timer_for_test_(false),
       adding_animations_(false) {
 }
 
 LayerAnimator::~LayerAnimator() {
   for (size_t i = 0; i < running_animations_.size(); ++i) {
     if (running_animations_[i].is_sequence_alive())
@@ skipping 43 matching lines @@
 
 ANIMATED_PROPERTY(
     const gfx::Transform&, TRANSFORM, Transform, gfx::Transform, transform);
 ANIMATED_PROPERTY(const gfx::Rect&, BOUNDS, Bounds, gfx::Rect, bounds);
 ANIMATED_PROPERTY(float, OPACITY, Opacity, float, opacity);
 ANIMATED_PROPERTY(bool, VISIBILITY, Visibility, bool, visibility);
 ANIMATED_PROPERTY(float, BRIGHTNESS, Brightness, float, brightness);
 ANIMATED_PROPERTY(float, GRAYSCALE, Grayscale, float, grayscale);
 ANIMATED_PROPERTY(SkColor, COLOR, Color, SkColor, color);
 
-base::TimeDelta LayerAnimator::GetTransitionDuration() const {
-  return transition_duration_;
-}
-
 void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
   delegate_ = delegate;
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   scoped_refptr<LayerAnimator> retain(this);
   OnScheduled(animation);
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
@@ skipping 660 matching lines @@
   if (observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationObserver>::Iterator it(observers_);
     LayerAnimationObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
       sequence->AddObserver(obs);
     }
   }
   sequence->OnScheduled();
 }
 
-void LayerAnimator::SetTransitionDuration(base::TimeDelta duration) {
-  if (is_transition_duration_locked_)
-    return;
-  transition_duration_ = duration;
+base::TimeDelta LayerAnimator::GetTransitionDuration() const {
+  return transition_duration_;
 }
 
 void LayerAnimator::ClearAnimationsInternal() {
   PurgeDeletedAnimations();
 
   // Abort should never affect the set of running animations, but just in case
   // clients are badly behaved, we will use a copy of the running animations.
   RunningAnimations running_animations_copy = running_animations_;
   for (size_t i = 0; i < running_animations_copy.size(); ++i) {
     if (!SAFE_INVOKE_BOOL(HasAnimation, running_animations_copy[i]))
@@ skipping 21 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui