ui/compositor/layer_animation_element_unittest.cc - chromium/src - Git at Google

 // 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_animation_element.h"

 #include <memory>

 #include "base/compiler_specific.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/test/test_layer_animation_delegate.h"
 #include "ui/compositor/test/test_utils.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/transform.h"

 namespace ui {

 namespace {

 // Verify that the TargetValue(TestLayerAnimationDelegate*) constructor
 // correctly assigns values. See www.crbug.com/483134.
 TEST(TargetValueTest, VerifyLayerAnimationDelegateConstructor) {
   const gfx::Rect kBounds(1, 2, 3, 5);
   const gfx::Transform kTransform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f);
   const float kOpacity = 1.235f;
   const bool kVisibility = false;
   const float kBrightness = 2.358f;
   const float kGrayscale = 2.5813f;
   const SkColor kColor = SK_ColorCYAN;

   TestLayerAnimationDelegate delegate;
   delegate.SetBoundsFromAnimation(kBounds);
   delegate.SetTransformFromAnimation(kTransform);
   delegate.SetOpacityFromAnimation(kOpacity);
   delegate.SetVisibilityFromAnimation(kVisibility);
   delegate.SetBrightnessFromAnimation(kBrightness);
   delegate.SetGrayscaleFromAnimation(kGrayscale);
   delegate.SetColorFromAnimation(kColor);

   LayerAnimationElement::TargetValue target_value(&delegate);

   EXPECT_EQ(kBounds, target_value.bounds);
   EXPECT_EQ(kTransform, target_value.transform);
   EXPECT_FLOAT_EQ(kOpacity, target_value.opacity);
   EXPECT_EQ(kVisibility, target_value.visibility);
   EXPECT_FLOAT_EQ(kBrightness, target_value.brightness);
   EXPECT_FLOAT_EQ(kGrayscale, target_value.grayscale);
   EXPECT_EQ(SK_ColorCYAN, target_value.color);
 }

 // Check that the transformation element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, TransformElement) {
   TestLayerAnimationDelegate delegate;
   gfx::Transform start_transform, target_transform;
   start_transform.Rotate(-30.0);
   target_transform.Rotate(30.0);
   base::TimeTicks start_time;
   base::TimeTicks effective_start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateTransformElement(target_transform, delta);
   element->set_animation_group_id(1);

   for (int i = 0; i < 2; ++i) {
     start_time = effective_start_time + delta;
     element->set_requested_start_time(start_time);
     delegate.SetTransformFromAnimation(start_transform);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     CheckApproximatelyEqual(start_transform,
                             delegate.GetTransformForAnimation());
     effective_start_time = start_time + delta;
     element->set_effective_start_time(effective_start_time);
     element->Progress(effective_start_time, &delegate);
     EXPECT_FLOAT_EQ(0.0, element->last_progressed_fraction());
     element->Progress(effective_start_time + delta/2, &delegate);
     EXPECT_FLOAT_EQ(0.5, element->last_progressed_fraction());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(effective_start_time + delta,
                                     &element_duration));
     EXPECT_EQ(2 * delta, element_duration);

     element->Progress(effective_start_time + delta, &delegate);
     EXPECT_FLOAT_EQ(1.0, element->last_progressed_fraction());
     CheckApproximatelyEqual(target_transform,
                             delegate.GetTransformForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   CheckApproximatelyEqual(target_transform, target_value.transform);
 }

 // Check that the bounds element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, BoundsElement) {
   TestLayerAnimationDelegate delegate;
   gfx::Rect start, target, middle;
   start = target = middle = gfx::Rect(0, 0, 50, 50);
   start.set_x(-90);
   target.set_x(90);
   base::TimeTicks start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateBoundsElement(target, delta);

   for (int i = 0; i < 2; ++i) {
     start_time += delta;
     element->set_requested_start_time(start_time);
     delegate.SetBoundsFromAnimation(start);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     CheckApproximatelyEqual(start, delegate.GetBoundsForAnimation());
     element->Progress(start_time + delta/2, &delegate);
     CheckApproximatelyEqual(middle, delegate.GetBoundsForAnimation());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
     EXPECT_EQ(delta, element_duration);

     element->Progress(start_time + delta, &delegate);
     CheckApproximatelyEqual(target, delegate.GetBoundsForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   CheckApproximatelyEqual(target, target_value.bounds);
 }

 // Check that the opacity element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, OpacityElement) {
   TestLayerAnimationDelegate delegate;
   float start = 0.0;
   float middle = 0.5;
   float target = 1.0;
   base::TimeTicks start_time;
   base::TimeTicks effective_start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateOpacityElement(target, delta);

   for (int i = 0; i < 2; ++i) {
     start_time = effective_start_time + delta;
     element->set_requested_start_time(start_time);
     delegate.SetOpacityFromAnimation(start);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     EXPECT_FLOAT_EQ(start, element->last_progressed_fraction());
     effective_start_time = start_time + delta;
     element->set_effective_start_time(effective_start_time);
     element->Progress(effective_start_time, &delegate);
     EXPECT_FLOAT_EQ(start, element->last_progressed_fraction());
     element->Progress(effective_start_time + delta/2, &delegate);
     EXPECT_FLOAT_EQ(middle, element->last_progressed_fraction());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(effective_start_time + delta,
                                     &element_duration));
     EXPECT_EQ(2 * delta, element_duration);

     element->Progress(effective_start_time + delta, &delegate);
     EXPECT_FLOAT_EQ(target, element->last_progressed_fraction());
     EXPECT_FLOAT_EQ(target, delegate.GetOpacityForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   EXPECT_FLOAT_EQ(target, target_value.opacity);
 }

 // Check that the visibility element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, VisibilityElement) {
   TestLayerAnimationDelegate delegate;
   bool start = true;
   bool target = false;
   base::TimeTicks start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateVisibilityElement(target, delta);

   for (int i = 0; i < 2; ++i) {
     start_time += delta;
     element->set_requested_start_time(start_time);
     delegate.SetVisibilityFromAnimation(start);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     EXPECT_TRUE(delegate.GetVisibilityForAnimation());
     element->Progress(start_time + delta/2, &delegate);
     EXPECT_TRUE(delegate.GetVisibilityForAnimation());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
     EXPECT_EQ(delta, element_duration);

     element->Progress(start_time + delta, &delegate);
     EXPECT_FALSE(delegate.GetVisibilityForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   EXPECT_FALSE(target_value.visibility);
 }

 // Check that the Brightness element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, BrightnessElement) {
   TestLayerAnimationDelegate delegate;
   float start = 0.0;
   float middle = 0.5;
   float target = 1.0;
   base::TimeTicks start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateBrightnessElement(target, delta);

   for (int i = 0; i < 2; ++i) {
     start_time += delta;
     element->set_requested_start_time(start_time);
     delegate.SetBrightnessFromAnimation(start);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     EXPECT_FLOAT_EQ(start, delegate.GetBrightnessForAnimation());
     element->Progress(start_time + delta/2, &delegate);
     EXPECT_FLOAT_EQ(middle, delegate.GetBrightnessForAnimation());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
     EXPECT_EQ(delta, element_duration);

     element->Progress(start_time + delta, &delegate);
     EXPECT_FLOAT_EQ(target, delegate.GetBrightnessForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   EXPECT_FLOAT_EQ(target, target_value.brightness);
 }

 // Check that the Grayscale element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, GrayscaleElement) {
   TestLayerAnimationDelegate delegate;
   float start = 0.0;
   float middle = 0.5;
   float target = 1.0;
   base::TimeTicks start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateGrayscaleElement(target, delta);

   for (int i = 0; i < 2; ++i) {
     start_time += delta;
     element->set_requested_start_time(start_time);
     delegate.SetGrayscaleFromAnimation(start);
     element->Start(&delegate, 1);
     element->Progress(start_time, &delegate);
     EXPECT_FLOAT_EQ(start, delegate.GetGrayscaleForAnimation());
     element->Progress(start_time + delta/2, &delegate);
     EXPECT_FLOAT_EQ(middle, delegate.GetGrayscaleForAnimation());

     base::TimeDelta element_duration;
     EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
     EXPECT_EQ(delta, element_duration);

     element->Progress(start_time + delta, &delegate);
     EXPECT_FLOAT_EQ(target, delegate.GetGrayscaleForAnimation());
   }

   LayerAnimationElement::TargetValue target_value(&delegate);
   element->GetTargetValue(&target_value);
   EXPECT_FLOAT_EQ(target, target_value.grayscale);
 }

 // Check that the pause element progresses the delegate as expected and
 // that the element can be reused after it completes.
 TEST(LayerAnimationElementTest, PauseElement) {
   LayerAnimationElement::AnimatableProperties properties =
       LayerAnimationElement::TRANSFORM | LayerAnimationElement::BOUNDS |
       LayerAnimationElement::OPACITY | LayerAnimationElement::BRIGHTNESS |
       LayerAnimationElement::GRAYSCALE;

   base::TimeTicks start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreatePauseElement(properties, delta);

   TestLayerAnimationDelegate delegate;
   TestLayerAnimationDelegate copy = delegate;

   start_time += delta;
   element->set_requested_start_time(start_time);
   element->Start(&delegate, 1);

   // Pause should last for |delta|.
   base::TimeDelta element_duration;
   EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
   EXPECT_EQ(delta, element_duration);

   element->Progress(start_time + delta, &delegate);

   // Nothing should have changed.
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(),
                           copy.GetBoundsForAnimation());
   CheckApproximatelyEqual(delegate.GetTransformForAnimation(),
                           copy.GetTransformForAnimation());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(),
                   copy.GetOpacityForAnimation());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
                   copy.GetBrightnessForAnimation());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(),
                   copy.GetGrayscaleForAnimation());
 }

 // Check that a threaded opacity element updates the delegate as expected when
 // aborted.
 TEST(LayerAnimationElementTest, AbortOpacityElement) {
   TestLayerAnimationDelegate delegate;
   float start = 0.0;
   float target = 1.0;
   base::TimeTicks start_time;
   base::TimeTicks effective_start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateOpacityElement(target, delta);

   // Choose a non-linear Tween type.
   gfx::Tween::Type tween_type = gfx::Tween::EASE_IN;
   element->set_tween_type(tween_type);

   delegate.SetOpacityFromAnimation(start);

   // Aborting the element before it has started should not update the delegate.
   element->Abort(&delegate);
   EXPECT_FLOAT_EQ(start, delegate.GetOpacityForAnimation());

   start_time += delta;
   element->set_requested_start_time(start_time);
   element->Start(&delegate, 1);
   element->Progress(start_time, &delegate);
   effective_start_time = start_time + delta;
   element->set_effective_start_time(effective_start_time);
   element->Progress(effective_start_time, &delegate);
   element->Progress(effective_start_time + delta/2, &delegate);

   // Since the element has started, it should update the delegate when
   // aborted.
   element->Abort(&delegate);
   EXPECT_FLOAT_EQ(gfx::Tween::CalculateValue(tween_type, 0.5),
                   delegate.GetOpacityForAnimation());
 }

 // Check that a threaded transform element updates the delegate as expected when
 // aborted.
 TEST(LayerAnimationElementTest, AbortTransformElement) {
   TestLayerAnimationDelegate delegate;
   gfx::Transform start_transform, target_transform;
   start_transform.Rotate(-30.0);
   target_transform.Rotate(30.0);
   base::TimeTicks start_time;
   base::TimeTicks effective_start_time;
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   std::unique_ptr<LayerAnimationElement> element =
       LayerAnimationElement::CreateTransformElement(target_transform, delta);

   // Choose a non-linear Tween type.
   gfx::Tween::Type tween_type = gfx::Tween::EASE_IN;
   element->set_tween_type(tween_type);

   delegate.SetTransformFromAnimation(start_transform);

   // Aborting the element before it has started should not update the delegate.
   element->Abort(&delegate);
   CheckApproximatelyEqual(start_transform, delegate.GetTransformForAnimation());

   start_time += delta;
   element->set_requested_start_time(start_time);
   element->Start(&delegate, 1);
   element->Progress(start_time, &delegate);
   effective_start_time = start_time + delta;
   element->set_effective_start_time(effective_start_time);
   element->Progress(effective_start_time, &delegate);
   element->Progress(effective_start_time + delta/2, &delegate);

   // Since the element has started, it should update the delegate when
   // aborted.
   element->Abort(&delegate);
   target_transform.Blend(start_transform,
                          gfx::Tween::CalculateValue(tween_type, 0.5));
   CheckApproximatelyEqual(target_transform,
                           delegate.GetTransformForAnimation());
 }

 } // namespace

 } // namespace ui
	// 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_animation_element.h"

	#include <memory>

	#include "base/compiler_specific.h"
	#include "base/time/time.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/compositor/layer_animation_delegate.h"
	#include "ui/compositor/scoped_animation_duration_scale_mode.h"
	#include "ui/compositor/test/test_layer_animation_delegate.h"
	#include "ui/compositor/test/test_utils.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/transform.h"

	namespace ui {

	namespace {

	// Verify that the TargetValue(TestLayerAnimationDelegate*) constructor
	// correctly assigns values. See www.crbug.com/483134.
	TEST(TargetValueTest, VerifyLayerAnimationDelegateConstructor) {
	const gfx::Rect kBounds(1, 2, 3, 5);
	const gfx::Transform kTransform(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f);
	const float kOpacity = 1.235f;
	const bool kVisibility = false;
	const float kBrightness = 2.358f;
	const float kGrayscale = 2.5813f;
	const SkColor kColor = SK_ColorCYAN;

	TestLayerAnimationDelegate delegate;
	delegate.SetBoundsFromAnimation(kBounds);
	delegate.SetTransformFromAnimation(kTransform);
	delegate.SetOpacityFromAnimation(kOpacity);
	delegate.SetVisibilityFromAnimation(kVisibility);
	delegate.SetBrightnessFromAnimation(kBrightness);
	delegate.SetGrayscaleFromAnimation(kGrayscale);
	delegate.SetColorFromAnimation(kColor);

	LayerAnimationElement::TargetValue target_value(&delegate);

	EXPECT_EQ(kBounds, target_value.bounds);
	EXPECT_EQ(kTransform, target_value.transform);
	EXPECT_FLOAT_EQ(kOpacity, target_value.opacity);
	EXPECT_EQ(kVisibility, target_value.visibility);
	EXPECT_FLOAT_EQ(kBrightness, target_value.brightness);
	EXPECT_FLOAT_EQ(kGrayscale, target_value.grayscale);
	EXPECT_EQ(SK_ColorCYAN, target_value.color);
	}

	// Check that the transformation element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, TransformElement) {
	TestLayerAnimationDelegate delegate;
	gfx::Transform start_transform, target_transform;
	start_transform.Rotate(-30.0);
	target_transform.Rotate(30.0);
	base::TimeTicks start_time;
	base::TimeTicks effective_start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateTransformElement(target_transform, delta);
	element->set_animation_group_id(1);

	for (int i = 0; i < 2; ++i) {
	start_time = effective_start_time + delta;
	element->set_requested_start_time(start_time);
	delegate.SetTransformFromAnimation(start_transform);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	CheckApproximatelyEqual(start_transform,
	delegate.GetTransformForAnimation());
	effective_start_time = start_time + delta;
	element->set_effective_start_time(effective_start_time);
	element->Progress(effective_start_time, &delegate);
	EXPECT_FLOAT_EQ(0.0, element->last_progressed_fraction());
	element->Progress(effective_start_time + delta/2, &delegate);
	EXPECT_FLOAT_EQ(0.5, element->last_progressed_fraction());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(effective_start_time + delta,
	&element_duration));
	EXPECT_EQ(2 * delta, element_duration);

	element->Progress(effective_start_time + delta, &delegate);
	EXPECT_FLOAT_EQ(1.0, element->last_progressed_fraction());
	CheckApproximatelyEqual(target_transform,
	delegate.GetTransformForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	CheckApproximatelyEqual(target_transform, target_value.transform);
	}

	// Check that the bounds element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, BoundsElement) {
	TestLayerAnimationDelegate delegate;
	gfx::Rect start, target, middle;
	start = target = middle = gfx::Rect(0, 0, 50, 50);
	start.set_x(-90);
	target.set_x(90);
	base::TimeTicks start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateBoundsElement(target, delta);

	for (int i = 0; i < 2; ++i) {
	start_time += delta;
	element->set_requested_start_time(start_time);
	delegate.SetBoundsFromAnimation(start);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	CheckApproximatelyEqual(start, delegate.GetBoundsForAnimation());
	element->Progress(start_time + delta/2, &delegate);
	CheckApproximatelyEqual(middle, delegate.GetBoundsForAnimation());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
	EXPECT_EQ(delta, element_duration);

	element->Progress(start_time + delta, &delegate);
	CheckApproximatelyEqual(target, delegate.GetBoundsForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	CheckApproximatelyEqual(target, target_value.bounds);
	}

	// Check that the opacity element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, OpacityElement) {
	TestLayerAnimationDelegate delegate;
	float start = 0.0;
	float middle = 0.5;
	float target = 1.0;
	base::TimeTicks start_time;
	base::TimeTicks effective_start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateOpacityElement(target, delta);

	for (int i = 0; i < 2; ++i) {
	start_time = effective_start_time + delta;
	element->set_requested_start_time(start_time);
	delegate.SetOpacityFromAnimation(start);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	EXPECT_FLOAT_EQ(start, element->last_progressed_fraction());
	effective_start_time = start_time + delta;
	element->set_effective_start_time(effective_start_time);
	element->Progress(effective_start_time, &delegate);
	EXPECT_FLOAT_EQ(start, element->last_progressed_fraction());
	element->Progress(effective_start_time + delta/2, &delegate);
	EXPECT_FLOAT_EQ(middle, element->last_progressed_fraction());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(effective_start_time + delta,
	&element_duration));
	EXPECT_EQ(2 * delta, element_duration);

	element->Progress(effective_start_time + delta, &delegate);
	EXPECT_FLOAT_EQ(target, element->last_progressed_fraction());
	EXPECT_FLOAT_EQ(target, delegate.GetOpacityForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	EXPECT_FLOAT_EQ(target, target_value.opacity);
	}

	// Check that the visibility element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, VisibilityElement) {
	TestLayerAnimationDelegate delegate;
	bool start = true;
	bool target = false;
	base::TimeTicks start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateVisibilityElement(target, delta);

	for (int i = 0; i < 2; ++i) {
	start_time += delta;
	element->set_requested_start_time(start_time);
	delegate.SetVisibilityFromAnimation(start);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	EXPECT_TRUE(delegate.GetVisibilityForAnimation());
	element->Progress(start_time + delta/2, &delegate);
	EXPECT_TRUE(delegate.GetVisibilityForAnimation());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
	EXPECT_EQ(delta, element_duration);

	element->Progress(start_time + delta, &delegate);
	EXPECT_FALSE(delegate.GetVisibilityForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	EXPECT_FALSE(target_value.visibility);
	}

	// Check that the Brightness element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, BrightnessElement) {
	TestLayerAnimationDelegate delegate;
	float start = 0.0;
	float middle = 0.5;
	float target = 1.0;
	base::TimeTicks start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateBrightnessElement(target, delta);

	for (int i = 0; i < 2; ++i) {
	start_time += delta;
	element->set_requested_start_time(start_time);
	delegate.SetBrightnessFromAnimation(start);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	EXPECT_FLOAT_EQ(start, delegate.GetBrightnessForAnimation());
	element->Progress(start_time + delta/2, &delegate);
	EXPECT_FLOAT_EQ(middle, delegate.GetBrightnessForAnimation());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
	EXPECT_EQ(delta, element_duration);

	element->Progress(start_time + delta, &delegate);
	EXPECT_FLOAT_EQ(target, delegate.GetBrightnessForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	EXPECT_FLOAT_EQ(target, target_value.brightness);
	}

	// Check that the Grayscale element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, GrayscaleElement) {
	TestLayerAnimationDelegate delegate;
	float start = 0.0;
	float middle = 0.5;
	float target = 1.0;
	base::TimeTicks start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateGrayscaleElement(target, delta);

	for (int i = 0; i < 2; ++i) {
	start_time += delta;
	element->set_requested_start_time(start_time);
	delegate.SetGrayscaleFromAnimation(start);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	EXPECT_FLOAT_EQ(start, delegate.GetGrayscaleForAnimation());
	element->Progress(start_time + delta/2, &delegate);
	EXPECT_FLOAT_EQ(middle, delegate.GetGrayscaleForAnimation());

	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
	EXPECT_EQ(delta, element_duration);

	element->Progress(start_time + delta, &delegate);
	EXPECT_FLOAT_EQ(target, delegate.GetGrayscaleForAnimation());
	}

	LayerAnimationElement::TargetValue target_value(&delegate);
	element->GetTargetValue(&target_value);
	EXPECT_FLOAT_EQ(target, target_value.grayscale);
	}

	// Check that the pause element progresses the delegate as expected and
	// that the element can be reused after it completes.
	TEST(LayerAnimationElementTest, PauseElement) {
	LayerAnimationElement::AnimatableProperties properties =
	LayerAnimationElement::TRANSFORM \| LayerAnimationElement::BOUNDS \|
	LayerAnimationElement::OPACITY \| LayerAnimationElement::BRIGHTNESS \|
	LayerAnimationElement::GRAYSCALE;

	base::TimeTicks start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);

	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreatePauseElement(properties, delta);

	TestLayerAnimationDelegate delegate;
	TestLayerAnimationDelegate copy = delegate;

	start_time += delta;
	element->set_requested_start_time(start_time);
	element->Start(&delegate, 1);

	// Pause should last for \|delta\|.
	base::TimeDelta element_duration;
	EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration));
	EXPECT_EQ(delta, element_duration);

	element->Progress(start_time + delta, &delegate);

	// Nothing should have changed.
	CheckApproximatelyEqual(delegate.GetBoundsForAnimation(),
	copy.GetBoundsForAnimation());
	CheckApproximatelyEqual(delegate.GetTransformForAnimation(),
	copy.GetTransformForAnimation());
	EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(),
	copy.GetOpacityForAnimation());
	EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
	copy.GetBrightnessForAnimation());
	EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(),
	copy.GetGrayscaleForAnimation());
	}

	// Check that a threaded opacity element updates the delegate as expected when
	// aborted.
	TEST(LayerAnimationElementTest, AbortOpacityElement) {
	TestLayerAnimationDelegate delegate;
	float start = 0.0;
	float target = 1.0;
	base::TimeTicks start_time;
	base::TimeTicks effective_start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateOpacityElement(target, delta);

	// Choose a non-linear Tween type.
	gfx::Tween::Type tween_type = gfx::Tween::EASE_IN;
	element->set_tween_type(tween_type);

	delegate.SetOpacityFromAnimation(start);

	// Aborting the element before it has started should not update the delegate.
	element->Abort(&delegate);
	EXPECT_FLOAT_EQ(start, delegate.GetOpacityForAnimation());

	start_time += delta;
	element->set_requested_start_time(start_time);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	effective_start_time = start_time + delta;
	element->set_effective_start_time(effective_start_time);
	element->Progress(effective_start_time, &delegate);
	element->Progress(effective_start_time + delta/2, &delegate);

	// Since the element has started, it should update the delegate when
	// aborted.
	element->Abort(&delegate);
	EXPECT_FLOAT_EQ(gfx::Tween::CalculateValue(tween_type, 0.5),
	delegate.GetOpacityForAnimation());
	}

	// Check that a threaded transform element updates the delegate as expected when
	// aborted.
	TEST(LayerAnimationElementTest, AbortTransformElement) {
	TestLayerAnimationDelegate delegate;
	gfx::Transform start_transform, target_transform;
	start_transform.Rotate(-30.0);
	target_transform.Rotate(30.0);
	base::TimeTicks start_time;
	base::TimeTicks effective_start_time;
	base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
	std::unique_ptr<LayerAnimationElement> element =
	LayerAnimationElement::CreateTransformElement(target_transform, delta);

	// Choose a non-linear Tween type.
	gfx::Tween::Type tween_type = gfx::Tween::EASE_IN;
	element->set_tween_type(tween_type);

	delegate.SetTransformFromAnimation(start_transform);

	// Aborting the element before it has started should not update the delegate.
	element->Abort(&delegate);
	CheckApproximatelyEqual(start_transform, delegate.GetTransformForAnimation());

	start_time += delta;
	element->set_requested_start_time(start_time);
	element->Start(&delegate, 1);
	element->Progress(start_time, &delegate);
	effective_start_time = start_time + delta;
	element->set_effective_start_time(effective_start_time);
	element->Progress(effective_start_time, &delegate);
	element->Progress(effective_start_time + delta/2, &delegate);

	// Since the element has started, it should update the delegate when
	// aborted.
	element->Abort(&delegate);
	target_transform.Blend(start_transform,
	gfx::Tween::CalculateValue(tween_type, 0.5));
	CheckApproximatelyEqual(target_transform,
	delegate.GetTransformForAnimation());
	}

	} // namespace

	} // namespace ui