Thread ui opacity animations

ui/compositor/layer_animator_unittest.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/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/compositor/test/layer_animator_test_controller.h"
 #include "ui/compositor/test/test_layer_animation_delegate.h"
 #include "ui/compositor/test/test_layer_animation_observer.h"
 #include "ui/compositor/test/test_utils.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 121 matching lines @@
 // Checks that setting a property on an implicit animator causes an animation to
 // happen.
 TEST(LayerAnimatorTest, ImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(
       LayerAnimator::CreateImplicitAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = base::TimeTicks::Now();
-  animator->SetOpacity(0.5);
+  animator->SetBrightness(0.5);
   EXPECT_TRUE(animator->is_animating());
   element->Step(now + base::TimeDelta::FromSeconds(1));
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that if the animator is a default animator, that implicit animations
 // are not started.
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
-  animator->SetOpacity(0.5);
+  animator->SetBrightness(0.5);
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), 0.5);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that StopAnimatingProperty stops animation for that property, and also
 // skips the stopped animation to the end.
 TEST(LayerAnimatorTest, StopAnimatingProperty) {
   scoped_refptr<LayerAnimator> animator(
       LayerAnimator::CreateImplicitAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 44 matching lines @@
   gfx::Rect target_bounds(0, 0, 50, 50);
   animator->SetOpacity(target_opacity);
   animator->SetBounds(target_bounds);
   EXPECT_TRUE(animator->is_animating());
   animator->AbortAllAnimations();
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(initial_opacity, delegate.GetOpacityForAnimation());
   CheckApproximatelyEqual(initial_bounds, delegate.GetBoundsForAnimation());
 }
 
-// Schedule an animation that can run immediately. This is the trivial case and
-// should result in the animation being started immediately.
+// Schedule a non-threaded animation that can run immediately. This is the
+// trivial case and should result in the animation being started immediately.
 TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetBrightnessFromAnimation(start_brightness);
+
+  animator->ScheduleAnimation(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
+
+  EXPECT_TRUE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
+
+  base::TimeTicks start_time = animator->last_step_time();
+
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+
+  EXPECT_TRUE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
+
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+
+  EXPECT_FALSE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
+}
+
+// Schedule a threaded animation that can run immediately.
+TEST(LayerAnimatorTest, ScheduleThreadedAnimationThatCanRunImmediately) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
   double start_opacity(0.0);
-  double middle_opacity(0.5);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
-  animator->ScheduleAnimation(
+  test_controller.animator()->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
-  EXPECT_TRUE(animator->is_animating());
+  EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
-  base::TimeTicks start_time = animator->last_step_time();
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
 
-  EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  element->Step(effective_start + delta/2);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(
+      0.5,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          last_progressed_fraction());
 
-  EXPECT_FALSE(animator->is_animating());
+  element->Step(effective_start + delta);
+
+  EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
-// Schedule two animations on separate properties. Both animations should
-// start immediately and should progress in lock step.
+// Schedule two non-threaded animations on separate properties. Both animations
+// should start immediately and should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
   delegate.SetBoundsFromAnimation(start_bounds);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
+  CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
+}
+
+// Schedule a threaded and a non-threaded animation on separate properties. Both
+// animations should progress in lock step.
+TEST(LayerAnimatorTest, ScheduleThreadedAndNonThreadedAnimations) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
+  double start_opacity(0.0);
+  double target_opacity(1.0);
+
+  gfx::Rect start_bounds, target_bounds, middle_bounds;
+  start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
+  start_bounds.set_x(-90);
+  target_bounds.set_x(90);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBoundsFromAnimation(start_bounds);
+
+  std::vector<LayerAnimationSequence*> animations;
+  animations.push_back(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+
+  animations.push_back(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
+
+  test_controller.animator()->ScheduleTogether(animations);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
+
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(effective_start + delta/2);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(
+      0.5,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          last_progressed_fraction());
+  CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
+
+  element->Step(effective_start + delta);
+
+  EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Schedule two animations on the same property. In this case, the two
 // animations should run one after another.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsOnSameProperty) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
-// Schedule [{o}, {o,b}, {b}] and ensure that {b} doesn't run right away. That
+// Schedule [{g}, {g,b}, {b}] and ensure that {b} doesn't run right away. That
 // is, ensure that all animations targetting a particular property are run in
 // order.
 TEST(LayerAnimatorTest, ScheduleBlockedAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double middle_grayscale(0.5);
+  double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBoundsFromAnimation(start_bounds);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta)));
 
-  scoped_ptr<LayerAnimationSequence> bounds_and_opacity(
+  scoped_ptr<LayerAnimationSequence> bounds_and_grayscale(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateGrayscaleElement(start_grayscale,
+                                                        delta)));
 
-  bounds_and_opacity->AddElement(
+  bounds_and_grayscale->AddElement(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
 
-  animator->ScheduleAnimation(bounds_and_opacity.release());
+  animator->ScheduleAnimation(bounds_and_grayscale.release());
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(start_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(4000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 }
 
-// Schedule {o} and then schedule {o} and {b} together. In this case, since
+// Schedule {g} and then schedule {g} and {b} together. In this case, since
 // ScheduleTogether is being used, the bounds animation should not start until
-// the second opacity animation starts.
+// the second grayscale animation starts.
 TEST(LayerAnimatorTest, ScheduleTogether) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
   target_bounds.set_x(90);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBoundsFromAnimation(start_bounds);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta)));
 
   std::vector<LayerAnimationSequence*> sequences;
   sequences.push_back(new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+      LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta)));
   sequences.push_back(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   animator->ScheduleTogether(sequences);
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
-// Start animation (that can run immediately). This is the trivial case (see
-// the trival case for ScheduleAnimation).
+// Start non-threaded animation (that can run immediately). This is the trivial
+// case (see the trival case for ScheduleAnimation).
 TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetBrightnessFromAnimation(start_brightness);
+
+  animator->StartAnimation(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
+
+  EXPECT_TRUE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
+
+  base::TimeTicks start_time = animator->last_step_time();
+
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+
+  EXPECT_TRUE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
+
+  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+
+  EXPECT_FALSE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
+}
+
+// Start threaded animation (that can run immediately).
+TEST(LayerAnimatorTest, StartThreadedAnimationThatCanRunImmediately) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
   double start_opacity(0.0);
-  double middle_opacity(0.5);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
-  animator->StartAnimation(
+  test_controller.animator()->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
-  EXPECT_TRUE(animator->is_animating());
+  EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
-  base::TimeTicks start_time = animator->last_step_time();
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
 
-  EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  element->Step(effective_start + delta/2);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(
+      0.5,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          last_progressed_fraction());
 
-  EXPECT_FALSE(animator->is_animating());
+  element->Step(effective_start + delta);
+  EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
@@ skipping 11 matching lines @@
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
-// Preempt by animating to new target.
+// Preempt by animating to new target, with a non-threaded animation.
 TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
 
   EXPECT_TRUE(animator->is_animating());
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(),
-                  0.5 * (start_opacity + middle_opacity));
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
+                  0.5 * (start_brightness + middle_brightness));
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
+}
+
+// Preempt by animating to new target, with a threaded animation.
+TEST(LayerAnimatorTest, PreemptThreadedByImmediatelyAnimatingToNewTarget) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
+  double start_opacity(0.0);
+  double middle_opacity(0.5);
+  double target_opacity(1.0);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetOpacityFromAnimation(start_opacity);
+
+  test_controller.animator()->set_preemption_strategy(
+      LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
+  test_controller.animator()->StartAnimation(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(effective_start + delta/2);
+
+  test_controller.animator()->StartAnimation(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+
+  test_controller.animator()->StartAnimation(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+
+  base::TimeTicks second_effective_start = effective_start + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (second_effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(second_effective_start + delta/2);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(
+      0.5,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          last_progressed_fraction());
+
+  element->Step(second_effective_start + delta);
+
+  EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   EXPECT_TRUE(animator->is_animating());
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, PreemptyByReplacingQueuedAnimations) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double middle_brightness(0.5);
+  double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(middle_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(middle_brightness,
+                                                         delta)));
 
   // Queue should now have two animations. Starting a third should replace the
   // second.
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 TEST(LayerAnimatorTest, StartTogetherSetsLastStepTime) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double target_grayscale(1.0);
   double start_brightness(0.1);
   double target_brightness(0.9);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->set_last_step_time(base::TimeTicks());
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)
       ));
 
   // If last step time was not set correctly, the resulting delta should be
   // miniscule (fractions of a millisecond). If set correctly, then the delta
   // should be enormous. Arbitrarily choosing 1 minute as the threshold,
   // though a much smaller value would probably have sufficed.
   delta = base::TimeTicks::Now() - animator->last_step_time();
   EXPECT_GT(60.0, delta.InSecondsF());
@@ skipping 39 matching lines @@
 }
 
 // Preempt by animating to new target.
 TEST(LayerAnimatorTest, MultiPreemptByImmediatelyAnimatingToNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double middle_grayscale(0.5);
+  double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)
       ));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(),
-                  0.5 * (start_opacity + middle_opacity));
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(),
+                  0.5 * (start_grayscale + middle_grayscale));
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
                   0.5 * (start_brightness + middle_brightness));
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
+}
+
+// Preempt a threaded animation by animating to new target.
+TEST(LayerAnimatorTest, MultiPreemptThreadedByImmediatelyAnimatingToNewTarget) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
+  double start_opacity(0.0);
+  double middle_opacity(0.5);
+  double target_opacity(1.0);
+
+  double start_brightness(0.1);
+  double middle_brightness(0.2);
+  double target_brightness(0.3);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
+
+  test_controller.animator()->set_preemption_strategy(
+      LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+
+  test_controller.animator()->StartTogether(
+      CreateMultiSequence(
+          LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)
+      ));
+
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(effective_start + delta/2);
+
+  test_controller.animator()->StartTogether(
+      CreateMultiSequence(
+          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
+
+  test_controller.animator()->StartTogether(
+      CreateMultiSequence(
+          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateBrightnessElement(start_brightness,
+                                                         delta)));
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+
+  base::TimeTicks second_effective_start = effective_start + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (second_effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(second_effective_start + delta/2);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(
+      0.5,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          last_progressed_fraction());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
+                  0.5 * (start_brightness + middle_brightness));
+
+  element->Step(second_effective_start + delta);
+
+  EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, MultiPreemptEnqueueNewAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double middle_grayscale(0.5);
+  double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   EXPECT_TRUE(animator->is_animating());
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, MultiPreemptByReplacingQueuedAnimations) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double middle_opacity(0.5);
-  double target_opacity(1.0);
+  double start_grayscale(0.0);
+  double middle_grayscale(0.5);
+  double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
+                                                        delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(middle_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(middle_grayscale,
+                                                        delta),
           LayerAnimationElement::CreateBrightnessElement(middle_brightness,
                                                          delta)));
 
   // Queue should now have two animations. Starting a third should replace the
   // second.
   animator->StartTogether(
       CreateMultiSequence(
-          LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
+          LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 //-------------------------------------------------------
-// Test that cyclic sequences continue to animate.
+// Test that non-threaded cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, CyclicSequences) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+          LayerAnimationElement::CreateBrightnessElement(target_brightness,
+                                                         delta)));
 
   sequence->AddElement(
-      LayerAnimationElement::CreateOpacityElement(start_opacity, delta));
+      LayerAnimationElement::CreateBrightnessElement(start_brightness, delta));
 
   sequence->set_is_cyclic(true);
 
   animator->StartAnimation(sequence.release());
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   // Skip ahead by a lot.
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000000000));
 
   EXPECT_TRUE(animator->is_animating());
-  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   // Skip ahead by a lot.
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000001000));
 
   EXPECT_TRUE(animator->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
+
+  animator->StopAnimatingProperty(LayerAnimationElement::BRIGHTNESS);
+
+  EXPECT_FALSE(animator->is_animating());
+}
+
+// Test that threaded cyclic sequences continue to animate.
+TEST(LayerAnimatorTest, ThreadedCyclicSequences) {
+  LayerAnimatorTestController test_controller(
+      LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = test_controller.animator();
+  test_controller.animator()->set_disable_timer_for_test(true);
+  TestLayerAnimationDelegate delegate;
+  test_controller.animator()->SetDelegate(&delegate);
+
+  double start_opacity(0.0);
+  double target_opacity(1.0);
+
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+
+  delegate.SetOpacityFromAnimation(start_opacity);
+
+  scoped_ptr<LayerAnimationSequence> sequence(
+      new LayerAnimationSequence(
+          LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
+
+  sequence->AddElement(
+      LayerAnimationElement::CreateOpacityElement(start_opacity, delta));
+
+  sequence->set_is_cyclic(true);
+
+  test_controller.animator()->StartAnimation(sequence.release());
+
+  base::TimeTicks start_time = test_controller.animator()->last_step_time();
+  base::TimeTicks effective_start = start_time + delta;
+
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(effective_start + delta);
+  EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
-  animator->StopAnimatingProperty(LayerAnimationElement::OPACITY);
+  base::TimeTicks second_effective_start = effective_start + 2 * delta;
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (second_effective_start - base::TimeTicks()).InSecondsF()));
 
-  EXPECT_FALSE(animator->is_animating());
+  element->Step(second_effective_start + delta);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+
+  base::TimeTicks third_effective_start = second_effective_start + 2 * delta;
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (third_effective_start - base::TimeTicks()).InSecondsF()));
+
+  element->Step(third_effective_start + delta);
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+
+  base::TimeTicks fourth_effective_start = third_effective_start + 2 * delta;
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (fourth_effective_start - base::TimeTicks()).InSecondsF()));
+
+  // Skip ahead by a lot.
+  element->Step(fourth_effective_start + 1000 * delta);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
+
+  base::TimeTicks fifth_effective_start = fourth_effective_start + 1001 * delta;
+  test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
+      cc::AnimationEvent::Started,
+      0,
+      test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
+          animation_group_id(),
+      cc::Animation::Opacity,
+      (fifth_effective_start - base::TimeTicks()).InSecondsF()));
+
+  // Skip ahead by a lot.
+  element->Step(fifth_effective_start + 999 * delta);
+
+  EXPECT_TRUE(test_controller.animator()->is_animating());
+  EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
+
+  test_controller.animator()->StopAnimatingProperty(
+      LayerAnimationElement::OPACITY);
+
+  EXPECT_FALSE(test_controller.animator()->is_animating());
 }
 
 TEST(LayerAnimatorTest, AddObserverExplicit) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->AddObserver(&observer);
   observer.set_requires_notification_when_animator_destroyed(true);
 
   EXPECT_TRUE(!observer.last_ended_sequence());
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
-  delegate.SetOpacityFromAnimation(0.0f);
+  delegate.SetBrightnessFromAnimation(0.0f);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+      LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
 
   // |sequence| has been destroyed. Recreate it to test abort.
   sequence = new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+      LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   animator = NULL;
 
   EXPECT_EQ(observer.last_aborted_sequence(), sequence);
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope.
 TEST(LayerAnimatorTest, ImplicitAnimationObservers) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
-  animator->SetOpacity(1.0f);
+  animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
-    animator->SetOpacity(0.0f);
+    animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(observer.animations_completed());
-  EXPECT_FLOAT_EQ(0.0f, delegate.GetOpacityForAnimation());
+  EXPECT_FLOAT_EQ(0.0f, delegate.GetBrightnessForAnimation());
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope due to the animation being interrupted.
 TEST(LayerAnimatorTest, InterruptedImplicitAnimationObservers) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
-  animator->SetOpacity(1.0f);
+  animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
-    animator->SetOpacity(0.0f);
+    animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   // This should interrupt the implicit animation causing the observer to be
   // notified immediately.
-  animator->SetOpacity(1.0f);
+  animator->SetBrightness(1.0f);
   EXPECT_TRUE(observer.animations_completed());
-  EXPECT_FLOAT_EQ(1.0f, delegate.GetOpacityForAnimation());
+  EXPECT_FLOAT_EQ(1.0f, delegate.GetBrightnessForAnimation());
 }
 
 // Tests that an observer added to a scoped settings object is not notified
 // when the animator is destroyed unless explicitly requested.
 TEST(LayerAnimatorTest, ImplicitObserversAtAnimatorDestruction) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer_notify(true);
   TestImplicitAnimationObserver observer_do_not_notify(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
 
-  animator->SetOpacity(1.0f);
+  animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer_notify);
     settings.AddObserver(&observer_do_not_notify);
-    animator->SetOpacity(0.0f);
+    animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
   animator = NULL;
   EXPECT_TRUE(observer_notify.animations_completed());
   EXPECT_FALSE(observer_do_not_notify.animations_completed());
 }
 
 
 TEST(LayerAnimatorTest, RemoveObserverShouldRemoveFromSequences) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationObserver removed_observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+      LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   sequence->AddObserver(&observer);
   sequence->AddObserver(&removed_observer);
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!observer.last_ended_sequence());
   EXPECT_EQ(removed_observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 
   // This should stop the observer from observing sequence.
   animator->RemoveObserver(&removed_observer);
 
   base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
+  TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
 
   scoped_ptr<TestLayerAnimationObserver> observer(
       new TestLayerAnimationObserver);
-  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->AddObserver(observer.get());
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
@@ skipping 10 matching lines @@
 
 TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  delegate.SetOpacityFromAnimation(0.0f);
+  delegate.SetBrightnessFromAnimation(0.0f);
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
 
     base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
     LayerAnimationSequence* sequence = new LayerAnimationSequence(
-        LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+        LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
     animator->StartAnimation(sequence);
     base::TimeTicks start_time = animator->last_step_time();
     element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
     setter.AddObserver(&observer);
 
     // Start observing an in-flight animation.
     sequence->AddObserver(&observer);
 
     element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   }
 
   EXPECT_TRUE(observer.animations_completed());
 }
 
 TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  delegate.SetOpacityFromAnimation(0.0f);
+  delegate.SetBrightnessFromAnimation(0.0f);
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+      LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
     setter.AddObserver(&observer);
 
     animator->StartAnimation(sequence);
     base::TimeTicks start_time = animator->last_step_time();
     element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
   }
 
@@ skipping 11 matching lines @@
 // causes the second to be deleted, we should not attempt to animate the second
 // animation.
 TEST(LayerAnimatorTest, ObserverDeletesAnimations) {
   LayerAnimator::set_disable_animations_for_test(false);
   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  double start_opacity(0.0);
-  double target_opacity(1.0);
+  double start_brightness(0.0);
+  double target_brightness(1.0);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(5, 5, 5, 5);
 
-  delegate.SetOpacityFromAnimation(start_opacity);
+  delegate.SetBrightnessFromAnimation(start_brightness);
   delegate.SetBoundsFromAnimation(start_bounds);
 
-  base::TimeDelta opacity_delta = base::TimeDelta::FromSeconds(1);
+  base::TimeDelta brightness_delta = base::TimeDelta::FromSeconds(1);
   base::TimeDelta halfway_delta = base::TimeDelta::FromSeconds(2);
   base::TimeDelta bounds_delta = base::TimeDelta::FromSeconds(3);
 
   LayerAnimationSequence* to_delete = new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, bounds_delta));
 
   scoped_ptr<DeletingLayerAnimationObserver> observer(
       new DeletingLayerAnimationObserver(animator.get(), to_delete));
 
   animator->AddObserver(observer.get());
 
   animator->StartAnimation(
       new LayerAnimationSequence(
-          LayerAnimationElement::CreateOpacityElement(
-              target_opacity, opacity_delta)));
+          LayerAnimationElement::CreateBrightnessElement(
+              target_brightness, brightness_delta)));
 
   animator->StartAnimation(to_delete);
 
   base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + halfway_delta);
 
   animator->RemoveObserver(observer.get());
 }
 
 // Check that setting a property during an animation with a default animator
@@ skipping 59 matching lines @@
   // the target value. The sequence should alse be destructed.
   animator->StartAnimation(sequence.release());
 
   EXPECT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
   EXPECT_EQ(0, num_live_instances);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Verifies GetTargetOpacity() works when multiple sequences are scheduled.
 TEST(LayerAnimatorTest, GetTargetOpacity) {
+  TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
   animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     animator->SetOpacity(0.5);
     EXPECT_EQ(0.5, animator->GetTargetOpacity());
 
     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
@@ skipping 182 matching lines @@
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
   AnimationContainerElement* element = observer->animator();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
-  delegate.SetOpacityFromAnimation(0.0f);
+  delegate.SetBrightnessFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
-  LayerAnimationSequence* opacity_sequence = new LayerAnimationSequence(
-      LayerAnimationElement::CreateOpacityElement(1.0f, delta));
-  animator->StartAnimation(opacity_sequence);
+  LayerAnimationSequence* brightness_sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
+  animator->StartAnimation(brightness_sequence);
 
   delta = base::TimeDelta::FromSeconds(2);
   LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
   animator->StartAnimation(bounds_sequence);
 
   base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(observer_was_deleted);
@@ skipping 26 matching lines @@
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
   animator->StartAnimation(bounds_sequence);
 
   animator->StopAnimating();
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterScheduling) {
   bool observer_was_deleted = false;
+  TestLayerAnimationDelegate delegate;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_scheduled(true);
   LayerAnimator* animator = observer->animator();
   animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   std::vector<LayerAnimationSequence*> to_start;
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   to_start.push_back(new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
 
   delta = base::TimeDelta::FromSeconds(2);
   to_start.push_back(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   animator->ScheduleTogether(to_start);
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterAborted) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
+  TestLayerAnimationDelegate delegate;
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animator->set_disable_timer_for_test(true);
-  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   std::vector<LayerAnimationSequence*> to_start;
@@ skipping 11 matching lines @@
   EXPECT_FALSE(observer_was_deleted);
 
   animator->StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta)));
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 
 TEST(LayerAnimatorTest, TestSetterRespectEnqueueStrategy) {
+  TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
 
-  TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   float start_opacity = 0.0f;
   float target_opacity = 1.0f;
   float magic_opacity = 0.123f;
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   ScopedLayerAnimationSettings settings(animator);
   settings.SetPreemptionStrategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta::FromSeconds(1));
   animator->SetOpacity(target_opacity);
 
   EXPECT_EQ(start_opacity, delegate.GetOpacityForAnimation());
 
   settings.SetPreemptionStrategy(
       LayerAnimator::ENQUEUE_NEW_ANIMATION);
   settings.SetTransitionDuration(base::TimeDelta());
   animator->SetOpacity(magic_opacity);
 
   EXPECT_EQ(start_opacity, delegate.GetOpacityForAnimation());
 }
 
 }  // namespace ui