Fix black background when locking with fullscreen window:

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 "ui/base/animation/animation_container.h"
@@ skipping 68 matching lines @@
 LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
   return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
   return new LayerAnimator(
       base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
 }
 
+// static
+scoped_ptr<test::AnimationContainerTestHelper>
+LayerAnimator::CreateAnimatorHelperForTest() {
+  scoped_ptr<test::AnimationContainerTestHelper> result;
+  result.reset(new test::AnimationContainerTestHelper(GetAnimationContainer()));
+  return result.Pass();
+}
+
 // This macro provides the implementation for the setter and getter (well,
 // the getter of the target value) for an animated property. For example,
 // it is used for the implementations of SetTransform and GetTargetTransform.
 // It is worth noting that SetFoo avoids invoking the usual animation machinery
 // if the transition duration is zero -- in this case we just set the property
 // on the layer animation delegate immediately.
 #define ANIMATED_PROPERTY(type, property, name, member_type, member)  \
 void LayerAnimator::Set##name(type value) {                           \
   base::TimeDelta duration = GetTransitionDuration();                 \
   if (duration == base::TimeDelta() && delegate() &&                  \
@@ skipping 77 matching lines @@
       StartAnimation(*iter);
     }
     return;
   }
 
   adding_animations_ = true;
   if (!is_animating()) {
     if (GetAnimationContainer()->is_running())
       last_step_time_ = GetAnimationContainer()->last_tick_time();
     else
-      last_step_time_ = base::TimeTicks::Now();
+      last_step_time_ = GetAnimationContainer()->GetCurrentTime();
   }
 
   // Collect all the affected properties.
   LayerAnimationElement::AnimatableProperties animated_properties;
   std::vector<LayerAnimationSequence*>::const_iterator iter;
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     animated_properties.insert((*iter)->properties().begin(),
                                (*iter)->properties().end());
   }
 
@@ skipping 474 matching lines @@
   // internally).
   // All LayerAnimators share the same AnimationContainer. Use the
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
   base::TimeTicks start_time;
   if (is_animating() || adding_animations_)
     start_time = last_step_time_;
   else if (GetAnimationContainer()->is_running())
     start_time = GetAnimationContainer()->last_tick_time();
   else
-    start_time = base::TimeTicks::Now();
+    start_time = GetAnimationContainer()->GetCurrentTime();
 
   running_animations_.push_back(
       RunningAnimation(sequence->AsWeakPtr(), start_time));
 
   // Need to keep a reference to the animation.
   AddToQueueIfNotPresent(sequence);
 
   // Ensure that animations get stepped at their start time.
   Step(start_time);
 
@@ skipping 57 matching lines @@
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence,
     base::TimeTicks start_time)
     : sequence_(sequence),
       start_time_(start_time) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui