cc/animation/layer_animation_controller_unittest.cc - Issue 231133002: CC::Animations should use TimeTicks & TimeDelta to represent time

Unified Diff: cc/animation/layer_animation_controller_unittest.cc

Issue 231133002: CC::Animations should use TimeTicks & TimeDelta to represent time (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Self review changes. Created 6 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: cc/animation/layer_animation_controller_unittest.cc

diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc

index a6a5363a6a8ec0d4f26712eeb119f5eb78f79a5b..9f64c06eb9899c37402e89e754371d6cf0273e81 100644

--- a/cc/animation/layer_animation_controller_unittest.cc

+++ b/cc/animation/layer_animation_controller_unittest.cc

@@ -11,6 +11,7 @@

#include "cc/animation/keyframed_animation_curve.h"

#include "cc/animation/scroll_offset_animation_curve.h"

#include "cc/animation/transform_operations.h"

+#include "cc/base/time_util.h"

#include "cc/test/animation_test_common.h"

#include "testing/gmock/include/gmock/gmock.h"

#include "testing/gtest/include/gtest/gtest.h"

@@ -20,10 +21,13 @@

namespace cc {

namespace {

+using base::TimeDelta;

+using base::TimeTicks;

// A LayerAnimationController cannot be ticked at 0.0, since an animation

// with start time 0.0 is treated as an animation whose start time has

// not yet been set.

-const double kInitialTickTime = 1.0;

+const TimeTicks kInitialTickTime = TimeUtil::TicksFromSecondsF(1.0);

scoped_ptr<Animation> CreateAnimation(scoped_ptr<AnimationCurve> curve,

int id,

@@ -93,7 +97,7 @@ TEST(LayerAnimationControllerTest, DoNotClobberStartTimes) {

Animation::Opacity)->start_time());

// Start the animation on the main thread. Should not affect the start time.

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, NULL);

EXPECT_EQ(controller->GetAnimation(group_id,

Animation::Opacity)->start_time(),

@@ -114,7 +118,7 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {

AddOpacityTransitionToController(controller.get(), 1, 0, 1, false);

int group_id = controller->GetAnimation(Animation::Opacity)->group();

- const double start_time = 123;

+ const TimeTicks start_time = TimeUtil::TicksFromSecondsF(123);

controller->GetAnimation(Animation::Opacity)->set_start_time(start_time);

controller->PushAnimationUpdatesTo(controller_impl.get());

@@ -142,7 +146,7 @@ TEST(LayerAnimationControllerTest, UseSpecifiedStartTimes) {

Animation::Opacity)->start_time());

// Start the animation on the main thread. Should not affect the start time.

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, NULL);

EXPECT_EQ(start_time,

controller->GetAnimation(group_id,

@@ -196,18 +200,19 @@ TEST(LayerAnimationControllerTest, Activation) {

EXPECT_EQ(1u, registrar->active_animation_controllers().size());

EXPECT_EQ(1u, registrar_impl->active_animation_controllers().size());

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, NULL);

EXPECT_EQ(1u, registrar->active_animation_controllers().size());

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, NULL);

EXPECT_EQ(Animation::Finished,

controller->GetAnimation(Animation::Opacity)->run_state());

EXPECT_EQ(1u, registrar->active_animation_controllers().size());

events.reset(new AnimationEventsVector);

- controller_impl->Animate(kInitialTickTime + 1.5);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1500));

controller_impl->UpdateState(true, events.get());

EXPECT_EQ(Animation::WaitingForDeletion,

@@ -217,7 +222,7 @@ TEST(LayerAnimationControllerTest, Activation) {

EXPECT_EQ(1u, events->size());

controller->NotifyAnimationFinished((*events)[0]);

- controller->Animate(kInitialTickTime + 1.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));

controller->UpdateState(true, NULL);

EXPECT_EQ(Animation::WaitingForDeletion,

@@ -274,7 +279,9 @@ TEST(LayerAnimationControllerTest, SyncPause) {

Animation::Opacity)->run_state());

// Pause the main-thread animation.

- controller->PauseAnimation(animation_id, kInitialTickTime + 1.0);

+ controller->PauseAnimation(

+ animation_id,

+ TimeDelta::FromMilliseconds(1000) + TimeDelta::FromMilliseconds(1000));

EXPECT_EQ(Animation::Paused,

controller->GetAnimation(group_id,

Animation::Opacity)->run_state());

@@ -352,7 +359,7 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {

controller->PushAnimationUpdatesTo(controller_impl.get());

controller_impl->ActivateAnimations();

- controller_impl->Animate(kInitialTickTime + 0.5);

+ controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller_impl->UpdateState(true, events.get());

// There should be a Started event for the animation.

@@ -360,14 +367,15 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {

EXPECT_EQ(AnimationEvent::Started, (*events)[0].type);

controller->NotifyAnimationStarted((*events)[0]);

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, NULL);

EXPECT_FALSE(dummy.animation_waiting_for_deletion());

EXPECT_FALSE(dummy_impl.animation_waiting_for_deletion());

events.reset(new AnimationEventsVector);

- controller_impl->Animate(kInitialTickTime + 2.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(2000));

controller_impl->UpdateState(true, events.get());

EXPECT_TRUE(dummy_impl.animation_waiting_for_deletion());

@@ -382,7 +390,7 @@ TEST(LayerAnimationControllerTest, AnimationsAreDeleted) {

controller->NotifyAnimationFinished((*events)[0]);

- controller->Animate(kInitialTickTime + 3.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));

controller->UpdateState(true, NULL);

EXPECT_TRUE(dummy.animation_waiting_for_deletion());

@@ -429,7 +437,7 @@ TEST(LayerAnimationControllerTest, TrivialTransition) {

// A non-impl-only animation should not generate property updates.

const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_EQ(1.f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -461,7 +469,8 @@ TEST(LayerAnimationControllerTest, TrivialTransitionOnImpl) {

GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_EQ(0.f, start_opacity_event->opacity);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

EXPECT_EQ(1.f, dummy_impl.opacity());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

@@ -515,7 +524,8 @@ TEST(LayerAnimationControllerTest, TrivialTransformOnImpl) {

gfx::Transform expected_transform;

expected_transform.Translate(delta_x, delta_y);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

EXPECT_EQ(expected_transform, dummy_impl.transform());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

@@ -558,7 +568,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {

const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, events.get());

EXPECT_EQ(1u, dummy.filters().size());

EXPECT_EQ(FilterOperation::CreateBrightnessFilter(1.5f),

@@ -566,7 +576,7 @@ TEST(LayerAnimationControllerTest, FilterTransition) {

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_EQ(end_filters, dummy.filters());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -612,7 +622,8 @@ TEST(LayerAnimationControllerTest, FilterTransitionOnImplOnly) {

EXPECT_EQ(start_filters, start_filter_event->filters);

EXPECT_TRUE(start_filter_event->is_impl_only);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

EXPECT_EQ(end_filters, dummy_impl.filters());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

@@ -656,13 +667,14 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {

controller->PushAnimationUpdatesTo(controller_impl.get());

controller_impl->ActivateAnimations();

EXPECT_TRUE(controller_impl->GetAnimation(Animation::ScrollOffset));

- double duration = controller_impl->GetAnimation(

- Animation::ScrollOffset)->curve()->Duration();

+ double duration = controller_impl->GetAnimation(Animation::ScrollOffset)

+ ->curve()

+ ->Duration();

+ TimeDelta time_delta = TimeDelta::FromMicroseconds(

ajuma 2014/05/05 15:13:32 It would make the rest of the test easier to read

Sikugu_ 2014/05/07 14:49:07 Done.

+ duration * base::Time::kMicrosecondsPerSecond);

EXPECT_EQ(

duration,

controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());

controller->Animate(kInitialTickTime);

controller->UpdateState(true, NULL);

EXPECT_TRUE(controller->HasActiveAnimation());

@@ -675,28 +687,27 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransition) {

// Scroll offset animations should not generate property updates.

const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

controller->NotifyAnimationStarted((*events)[0]);

- controller->Animate(kInitialTickTime + duration/2.0);

+ controller->Animate(kInitialTickTime + time_delta / 2);

controller->UpdateState(true, NULL);

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f), dummy.scroll_offset());

- controller_impl->Animate(kInitialTickTime + duration/2.0);

+ controller_impl->Animate(kInitialTickTime + time_delta / 2);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),

dummy_impl.scroll_offset());

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller_impl->Animate(kInitialTickTime + duration);

+ controller_impl->Animate(kInitialTickTime + time_delta);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller->Animate(kInitialTickTime + duration);

+ controller->Animate(kInitialTickTime + time_delta);

controller->UpdateState(true, NULL);

EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -737,7 +748,6 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {

EXPECT_TRUE(controller_impl->GetAnimation(Animation::ScrollOffset));

double duration = controller_impl->GetAnimation(

Animation::ScrollOffset)->curve()->Duration();

EXPECT_EQ(

duration,

controller->GetAnimation(Animation::ScrollOffset)->curve()->Duration());

@@ -755,27 +765,30 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionNoImplProvider) {

const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

+ TimeDelta time_delta = TimeDelta::FromMicroseconds(

ajuma 2014/05/05 15:13:32 Same comment, please rename this to duration.

Sikugu_ 2014/05/07 14:49:07 Done.

+ duration * base::Time::kMicrosecondsPerSecond);

controller->NotifyAnimationStarted((*events)[0]);

- controller->Animate(kInitialTickTime + duration/2.0);

+ controller->Animate(kInitialTickTime + time_delta / 2);

controller->UpdateState(true, NULL);

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f), dummy.scroll_offset());

- controller_impl->Animate(kInitialTickTime + duration/2.0);

+ controller_impl->Animate(kInitialTickTime + time_delta / 2);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(400.f, 150.f),

dummy_impl.scroll_offset());

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller_impl->Animate(kInitialTickTime + duration);

+ controller_impl->Animate(kInitialTickTime + time_delta);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller->Animate(kInitialTickTime + duration);

+ controller->Animate(kInitialTickTime + time_delta);

controller->UpdateState(true, NULL);

EXPECT_VECTOR2DF_EQ(target_value, dummy.scroll_offset());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -811,14 +824,17 @@ TEST(LayerAnimationControllerTest, ScrollOffsetTransitionOnImplOnly) {

const AnimationEvent* event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller_impl->Animate(kInitialTickTime + duration/2.0);

+ TimeDelta time_delta = TimeDelta::FromMicroseconds(

ajuma 2014/05/05 15:13:32 Here too.

Sikugu_ 2014/05/07 14:49:07 Done.

+ duration * base::Time::kMicrosecondsPerSecond);

+ controller_impl->Animate(kInitialTickTime + time_delta / 2);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(200.f, 250.f),

dummy_impl.scroll_offset());

event = GetMostRecentPropertyUpdateEvent(events.get());

EXPECT_FALSE(event);

- controller_impl->Animate(kInitialTickTime + duration);

+ controller_impl->Animate(kInitialTickTime + time_delta);

controller_impl->UpdateState(true, events.get());

EXPECT_VECTOR2DF_EQ(target_value, dummy_impl.scroll_offset());

EXPECT_FALSE(controller_impl->HasActiveAnimation());

@@ -833,13 +849,13 @@ class FakeAnimationDelegate : public AnimationDelegate {

finished_(false) {}

virtual void NotifyAnimationStarted(

- base::TimeTicks monotonic_time,

+ TimeTicks monotonic_time,

Animation::TargetProperty target_property) OVERRIDE {

started_ = true;

}

virtual void NotifyAnimationFinished(

- base::TimeTicks monotonic_time,

+ TimeTicks monotonic_time,

Animation::TargetProperty target_property) OVERRIDE {

finished_ = true;

}

@@ -894,7 +910,8 @@ TEST(LayerAnimationControllerTest,

EXPECT_TRUE(delegate.started());

events.reset(new AnimationEventsVector);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

// We should receive 2 events (a finished notification and a property update).

@@ -935,19 +952,23 @@ TEST(LayerAnimationControllerTest,

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

// Send the synchronized start time.

- controller->NotifyAnimationStarted(AnimationEvent(

- AnimationEvent::Started, 0, 1, Animation::Opacity, kInitialTickTime + 2));

- controller->Animate(kInitialTickTime + 5.0);

+ controller->NotifyAnimationStarted(

+ AnimationEvent(AnimationEvent::Started,

+ 0,

+ 1,

+ Animation::Opacity,

+ kInitialTickTime + TimeDelta::FromMilliseconds(2000)));

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(5000));

controller->UpdateState(true, events.get());

EXPECT_EQ(1.f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -976,11 +997,11 @@ TEST(LayerAnimationControllerTest, TrivialQueuing) {

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(1.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -1013,11 +1034,11 @@ TEST(LayerAnimationControllerTest, Interrupt) {

// Since the previous animation was aborted, the new animation should start

// right in this call to animate.

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(1.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1500));

controller->UpdateState(true, events.get());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -1050,13 +1071,13 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) {

controller->UpdateState(true, events.get());

EXPECT_EQ(0.f, dummy.opacity());

EXPECT_TRUE(controller->HasActiveAnimation());

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

// Should not have started the float transition yet.

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

// The float animation should have started at time 1 and should be done.

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

EXPECT_EQ(1.f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -1095,7 +1116,7 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {

// The opacity animation should have finished at time 1, but the group

// of animations with id 1 don't finish until time 2 because of the length

// of the transform animation.

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

// Should not have started the float transition yet.

EXPECT_TRUE(controller->HasActiveAnimation());

@@ -1103,7 +1124,7 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {

// The second opacity animation should start at time 2 and should be done by

// time 3.

- controller->Animate(kInitialTickTime + 3.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));

controller->UpdateState(true, events.get());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_FALSE(controller->HasActiveAnimation());

@@ -1129,29 +1150,29 @@ TEST(LayerAnimationControllerTest, TrivialLooping) {

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.25);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.25f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.75);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

- controller->Animate(kInitialTickTime + 2.25);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2250));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.25f, dummy.opacity());

- controller->Animate(kInitialTickTime + 2.75);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2750));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

- controller->Animate(kInitialTickTime + 3.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));

controller->UpdateState(true, events.get());

EXPECT_FALSE(controller->HasActiveAnimation());

EXPECT_EQ(1.f, dummy.opacity());

// Just be extra sure.

- controller->Animate(kInitialTickTime + 4.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(4000));

controller->UpdateState(true, events.get());

EXPECT_EQ(1.f, dummy.opacity());

}

@@ -1177,27 +1198,29 @@ TEST(LayerAnimationControllerTest, InfiniteLooping) {

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.25);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1250));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.25f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.75);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1750));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1073741824.25);

+ controller->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1073741824250));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.25f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1073741824.75);

+ controller->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1073741824750));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));

controller->GetAnimation(id, Animation::Opacity)->SetRunState(

- Animation::Aborted, kInitialTickTime + 0.75);

+ Animation::Aborted, kInitialTickTime + TimeDelta::FromMilliseconds(750));

EXPECT_FALSE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

}

@@ -1221,29 +1244,30 @@ TEST(LayerAnimationControllerTest, PauseResume) {

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));

controller->GetAnimation(id, Animation::Opacity)->SetRunState(

- Animation::Paused, kInitialTickTime + 0.5);

+ Animation::Paused, kInitialTickTime + TimeDelta::FromMilliseconds(500));

- controller->Animate(kInitialTickTime + 1024.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));

- controller->GetAnimation(id, Animation::Opacity)->SetRunState(

- Animation::Running, kInitialTickTime + 1024);

- controller->Animate(kInitialTickTime + 1024.25);

+ controller->GetAnimation(id, Animation::Opacity)

+ ->SetRunState(Animation::Running,

+ kInitialTickTime + TimeDelta::FromMilliseconds(1024000));

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024250));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1024.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1024500));

controller->UpdateState(true, events.get());

EXPECT_FALSE(controller->HasActiveAnimation());

EXPECT_EQ(1.f, dummy.opacity());

@@ -1276,19 +1300,19 @@ TEST(LayerAnimationControllerTest, AbortAGroupedAnimation) {

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.5f, dummy.opacity());

EXPECT_TRUE(controller->GetAnimation(id, Animation::Opacity));

controller->GetAnimation(id, Animation::Opacity)->SetRunState(

- Animation::Aborted, kInitialTickTime + 1.0);

- controller->Animate(kInitialTickTime + 1.0);

+ Animation::Aborted, kInitialTickTime + TimeDelta::FromMilliseconds(1000));

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(1.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

EXPECT_TRUE(!controller->HasActiveAnimation());

EXPECT_EQ(0.75f, dummy.opacity());

@@ -1352,9 +1376,9 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {

Animation::Opacity));

// Animate but don't UpdateState.

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

events.reset(new AnimationEventsVector);

controller->UpdateState(true, events.get());

@@ -1366,7 +1390,7 @@ TEST(LayerAnimationControllerTest, SkipUpdateState) {

EXPECT_TRUE(controller->HasActiveAnimation());

EXPECT_EQ(0.f, dummy.opacity());

- controller->Animate(kInitialTickTime + 3.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));

controller->UpdateState(true, events.get());

// The float tranisition should now be done.

@@ -1403,7 +1427,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {

// With only a pending observer, the animation should progress to the

// Starting state and get ticked at its starting point, but should not

// progress to Running.

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, events.get());

EXPECT_EQ(0u, events->size());

EXPECT_EQ(Animation::Starting,

@@ -1412,7 +1436,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {

// Even when already in the Starting state, the animation should stay

// there, and shouldn't be ticked past its starting point.

- controller->Animate(kInitialTickTime + 2.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(2000));

controller->UpdateState(true, events.get());

EXPECT_EQ(0u, events->size());

EXPECT_EQ(Animation::Starting,

@@ -1423,7 +1447,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {

// Now that an active observer has been added, the animation should still

// initially tick at its starting point, but should now progress to Running.

- controller->Animate(kInitialTickTime + 3.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3000));

controller->UpdateState(true, events.get());

EXPECT_EQ(1u, events->size());

EXPECT_EQ(Animation::Running,

@@ -1432,7 +1456,7 @@ TEST(LayerAnimationControllerTest, InactiveObserverGetsTicked) {

EXPECT_EQ(0.5f, dummy.opacity());

// The animation should now tick past its starting point.

- controller->Animate(kInitialTickTime + 3.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(3500));

EXPECT_NE(0.5f, pending_dummy.opacity());

EXPECT_NE(0.5f, dummy.opacity());

}

@@ -1477,7 +1501,7 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {

bounds.ToString());

controller_impl->GetAnimation(1, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

// Only the unfinished animation should affect the animated bounds.

EXPECT_TRUE(controller_impl->TransformAnimationBoundsForBox(box, &bounds));

@@ -1485,7 +1509,7 @@ TEST(LayerAnimationControllerTest, TransformAnimationBounds) {

bounds.ToString());

controller_impl->GetAnimation(2, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

// There are no longer any running animations.

EXPECT_FALSE(controller_impl->HasTransformAnimationThatInflatesBounds());

@@ -1540,7 +1564,7 @@ TEST(LayerAnimationControllerTest, AbortAnimations) {

controller->Animate(kInitialTickTime);

controller->UpdateState(true, NULL);

- controller->Animate(kInitialTickTime + 1.0);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(1000));

controller->UpdateState(true, NULL);

EXPECT_EQ(Animation::Finished,

@@ -1642,7 +1666,7 @@ TEST(LayerAnimationControllerTest, ImplThreadAbortedAnimationGetsDeleted) {

EXPECT_EQ(Animation::Aborted,

controller->GetAnimation(Animation::Opacity)->run_state());

- controller->Animate(kInitialTickTime + 0.5);

+ controller->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller->UpdateState(true, NULL);

EXPECT_TRUE(dummy.animation_waiting_for_deletion());

EXPECT_EQ(Animation::WaitingForDeletion,

@@ -1683,7 +1707,8 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {

EXPECT_EQ(AnimationEvent::Started, (*events)[1].type);

events.reset(new AnimationEventsVector);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

// The opacity animation should be finished, but should not have generated

@@ -1695,7 +1720,8 @@ TEST(LayerAnimationControllerTest, FinishedEventsForGroup) {

controller_impl->GetAnimation(1,

Animation::Transform)->run_state());

- controller_impl->Animate(kInitialTickTime + 2.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(2000));

controller_impl->UpdateState(true, events.get());

// Both animations should have generated Finished events.

@@ -1736,7 +1762,8 @@ TEST(LayerAnimationControllerTest, FinishedAndAbortedEventsForGroup) {

controller_impl->AbortAnimations(Animation::Opacity);

events.reset(new AnimationEventsVector);

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

// We should have exactly 2 events: a Finished event for the tranform

@@ -1796,7 +1823,7 @@ TEST(LayerAnimationControllerTest, HasAnimationThatAffectsScale) {

EXPECT_TRUE(controller_impl->HasAnimationThatAffectsScale());

controller_impl->GetAnimation(3, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

// Only unfinished animations should be considered by

// HasAnimationThatAffectsScale.

@@ -1852,7 +1879,7 @@ TEST(LayerAnimationControllerTest, HasOnlyTranslationTransforms) {

EXPECT_FALSE(controller_impl->HasOnlyTranslationTransforms());

controller_impl->GetAnimation(3, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

// Only unfinished animations should be considered by

// HasOnlyTranslationTransforms.

@@ -1918,9 +1945,9 @@ TEST(LayerAnimationControllerTest, MaximumScale) {

EXPECT_FALSE(controller_impl->MaximumScale(&max_scale));

controller_impl->GetAnimation(3, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

controller_impl->GetAnimation(2, Animation::Transform)

- ->SetRunState(Animation::Finished, 0.0);

+ ->SetRunState(Animation::Finished, TimeUtil::TicksFromSecondsF(0.0));

// Only unfinished animations should be considered by

// MaximumScale.

@@ -1976,7 +2003,8 @@ TEST(LayerAnimationControllerTest, NewlyPushedAnimationWaitsForActivation) {

EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity)

->affects_active_observers());

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

// Since the animation has been activated, it should have reached the

@@ -2037,7 +2065,7 @@ TEST(LayerAnimationControllerTest, ActivationBetweenAnimateAndUpdateState) {

Animation::Running,

controller_impl->GetAnimation(group_id, Animation::Opacity)->run_state());

- controller_impl->Animate(kInitialTickTime + 0.5);

+ controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

// Both observers should have been ticked.

EXPECT_EQ(0.75f, pending_dummy_impl.opacity());

@@ -2087,7 +2115,7 @@ TEST(LayerAnimationControllerTest, PushedDeletedAnimationWaitsForActivation) {

EXPECT_TRUE(controller_impl->GetAnimation(group_id, Animation::Opacity)

->affects_active_observers());

- controller_impl->Animate(kInitialTickTime + 0.5);

+ controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller_impl->UpdateState(true, events.get());

// Only the active observer should have been ticked.

@@ -2149,7 +2177,7 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {

Animation::Opacity)

->affects_active_observers());

- controller_impl->Animate(kInitialTickTime + 0.5);

+ controller_impl->Animate(kInitialTickTime + TimeDelta::FromMilliseconds(500));

controller_impl->UpdateState(true, events.get());

// The original animation should still be running, and the new animation

@@ -2179,7 +2207,8 @@ TEST(LayerAnimationControllerTest, StartAnimationsAffectingDifferentObservers) {

Animation::Opacity)

->affects_active_observers());

- controller_impl->Animate(kInitialTickTime + 1.0);

+ controller_impl->Animate(kInitialTickTime +

+ TimeDelta::FromMilliseconds(1000));

controller_impl->UpdateState(true, events.get());

// The new animation should be running, and the active observer should have

« cc/animation/layer_animation_controller.cc ('K') | « cc/animation/layer_animation_controller.cc ('k') | cc/animation/scroll_offset_animation_curve.h » ('j') | cc/base/time_util.h » ('J')