OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 | 6 |
7 #include "CCLayerAnimationController.h" | 7 #include "CCLayerAnimationController.h" |
8 | 8 |
9 #include "CCActiveAnimation.h" | 9 #include "CCActiveAnimation.h" |
10 #include "CCAnimationCurve.h" | 10 #include "CCAnimationCurve.h" |
11 #include "CCAnimationTestCommon.h" | 11 #include "CCAnimationTestCommon.h" |
12 #include "testing/gmock/include/gmock/gmock.h" | 12 #include "testing/gmock/include/gmock/gmock.h" |
13 #include "testing/gtest/include/gtest/gtest.h" | 13 #include "testing/gtest/include/gtest/gtest.h" |
14 #include <public/WebTransformationMatrix.h> | 14 #include <public/WebTransformationMatrix.h> |
15 | 15 |
16 using namespace cc; | 16 using namespace cc; |
17 using namespace WebKitTests; | 17 using namespace WebKitTests; |
18 using WebKit::WebTransformationMatrix; | 18 using WebKit::WebTransformationMatrix; |
19 | 19 |
20 namespace { | 20 namespace { |
21 | 21 |
22 void expectTranslateX(double translateX, const WebTransformationMatrix& matrix) | 22 void expectTranslateX(double translateX, const WebTransformationMatrix& matrix) |
23 { | 23 { |
24 EXPECT_FLOAT_EQ(translateX, matrix.m41()); | 24 EXPECT_FLOAT_EQ(translateX, matrix.m41()); |
25 } | 25 } |
26 | 26 |
27 PassOwnPtr<CCActiveAnimation> createActiveAnimation(PassOwnPtr<CCAnimationCurve>
curve, int id, CCActiveAnimation::TargetProperty property) | 27 scoped_ptr<CCActiveAnimation> createActiveAnimation(scoped_ptr<CCAnimationCurve>
curve, int id, CCActiveAnimation::TargetProperty property) |
28 { | 28 { |
29 return CCActiveAnimation::create(curve, 0, id, property); | 29 return CCActiveAnimation::create(curve.Pass(), 0, id, property); |
30 } | 30 } |
31 | 31 |
32 TEST(CCLayerAnimationControllerTest, syncNewAnimation) | 32 TEST(CCLayerAnimationControllerTest, syncNewAnimation) |
33 { | 33 { |
34 FakeLayerAnimationControllerClient dummyImpl; | 34 FakeLayerAnimationControllerClient dummyImpl; |
35 OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController
::create(&dummyImpl)); | 35 scoped_ptr<CCLayerAnimationController> controllerImpl(CCLayerAnimationContro
ller::create(&dummyImpl)); |
36 FakeLayerAnimationControllerClient dummy; | 36 FakeLayerAnimationControllerClient dummy; |
37 OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::cr
eate(&dummy)); | 37 scoped_ptr<CCLayerAnimationController> controller(CCLayerAnimationController
::create(&dummy)); |
38 | 38 |
39 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 39 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
40 | 40 |
41 addOpacityTransitionToController(*controller, 1, 0, 1, false); | 41 addOpacityTransitionToController(*controller, 1, 0, 1, false); |
42 | 42 |
43 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 43 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
44 | 44 |
45 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); | 45 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); |
46 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); | 46 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); |
47 } | 47 } |
48 | 48 |
49 // If an animation is started on the impl thread before it is ticked on the main | 49 // If an animation is started on the impl thread before it is ticked on the main |
50 // thread, we must be sure to respect the synchronized start time. | 50 // thread, we must be sure to respect the synchronized start time. |
51 TEST(CCLayerAnimationControllerTest, doNotClobberStartTimes) | 51 TEST(CCLayerAnimationControllerTest, doNotClobberStartTimes) |
52 { | 52 { |
53 FakeLayerAnimationControllerClient dummyImpl; | 53 FakeLayerAnimationControllerClient dummyImpl; |
54 OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController
::create(&dummyImpl)); | 54 scoped_ptr<CCLayerAnimationController> controllerImpl(CCLayerAnimationContro
ller::create(&dummyImpl)); |
55 FakeLayerAnimationControllerClient dummy; | 55 FakeLayerAnimationControllerClient dummy; |
56 OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::cr
eate(&dummy)); | 56 scoped_ptr<CCLayerAnimationController> controller(CCLayerAnimationController
::create(&dummy)); |
57 | 57 |
58 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 58 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
59 | 59 |
60 addOpacityTransitionToController(*controller, 1, 0, 1, false); | 60 addOpacityTransitionToController(*controller, 1, 0, 1, false); |
61 | 61 |
62 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 62 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
63 | 63 |
64 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); | 64 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); |
65 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); | 65 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); |
66 | 66 |
67 CCAnimationEventsVector events; | 67 CCAnimationEventsVector events; |
68 controllerImpl->animate(1, &events); | 68 controllerImpl->animate(1, &events); |
69 | 69 |
70 // Synchronize the start times. | 70 // Synchronize the start times. |
71 EXPECT_EQ(1u, events.size()); | 71 EXPECT_EQ(1u, events.size()); |
72 controller->notifyAnimationStarted(events[0]); | 72 controller->notifyAnimationStarted(events[0]); |
73 EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime()); | 73 EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime()); |
74 | 74 |
75 // Start the animation on the main thread. Should not affect the start time. | 75 // Start the animation on the main thread. Should not affect the start time. |
76 controller->animate(1.5, 0); | 76 controller->animate(1.5, 0); |
77 EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime()); | 77 EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->sta
rtTime()); |
78 } | 78 } |
79 | 79 |
80 TEST(CCLayerAnimationControllerTest, syncPauseAndResume) | 80 TEST(CCLayerAnimationControllerTest, syncPauseAndResume) |
81 { | 81 { |
82 FakeLayerAnimationControllerClient dummyImpl; | 82 FakeLayerAnimationControllerClient dummyImpl; |
83 OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController
::create(&dummyImpl)); | 83 scoped_ptr<CCLayerAnimationController> controllerImpl(CCLayerAnimationContro
ller::create(&dummyImpl)); |
84 FakeLayerAnimationControllerClient dummy; | 84 FakeLayerAnimationControllerClient dummy; |
85 OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::cr
eate(&dummy)); | 85 scoped_ptr<CCLayerAnimationController> controller(CCLayerAnimationController
::create(&dummy)); |
86 | 86 |
87 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 87 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
88 | 88 |
89 addOpacityTransitionToController(*controller, 1, 0, 1, false); | 89 addOpacityTransitionToController(*controller, 1, 0, 1, false); |
90 | 90 |
91 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 91 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
92 | 92 |
93 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); | 93 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); |
94 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); | 94 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); |
95 | 95 |
(...skipping 17 matching lines...) Expand all Loading... |
113 EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCAc
tiveAnimation::Opacity)->runState()); | 113 EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCAc
tiveAnimation::Opacity)->runState()); |
114 | 114 |
115 // The pause run state change should make it to the impl thread controller. | 115 // The pause run state change should make it to the impl thread controller. |
116 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 116 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
117 EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0,
CCActiveAnimation::Opacity)->runState()); | 117 EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0,
CCActiveAnimation::Opacity)->runState()); |
118 } | 118 } |
119 | 119 |
120 TEST(CCLayerAnimationControllerTest, doNotSyncFinishedAnimation) | 120 TEST(CCLayerAnimationControllerTest, doNotSyncFinishedAnimation) |
121 { | 121 { |
122 FakeLayerAnimationControllerClient dummyImpl; | 122 FakeLayerAnimationControllerClient dummyImpl; |
123 OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController
::create(&dummyImpl)); | 123 scoped_ptr<CCLayerAnimationController> controllerImpl(CCLayerAnimationContro
ller::create(&dummyImpl)); |
124 FakeLayerAnimationControllerClient dummy; | 124 FakeLayerAnimationControllerClient dummy; |
125 OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::cr
eate(&dummy)); | 125 scoped_ptr<CCLayerAnimationController> controller(CCLayerAnimationController
::create(&dummy)); |
126 | 126 |
127 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 127 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
128 | 128 |
129 addOpacityTransitionToController(*controller, 1, 0, 1, false); | 129 addOpacityTransitionToController(*controller, 1, 0, 1, false); |
130 | 130 |
131 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 131 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
132 | 132 |
133 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); | 133 EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity
)); |
134 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); | 134 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->g
etActiveAnimation(0, CCActiveAnimation::Opacity)->runState()); |
135 | 135 |
136 // Notify main thread controller that the animation has started. | 136 // Notify main thread controller that the animation has started. |
137 CCAnimationEvent animationStartedEvent(CCAnimationEvent::Started, 0, 0, CCAc
tiveAnimation::Opacity, 0); | 137 CCAnimationEvent animationStartedEvent(CCAnimationEvent::Started, 0, 0, CCAc
tiveAnimation::Opacity, 0); |
138 controller->notifyAnimationStarted(animationStartedEvent); | 138 controller->notifyAnimationStarted(animationStartedEvent); |
139 | 139 |
140 // Force animation to complete on impl thread. | 140 // Force animation to complete on impl thread. |
141 controllerImpl->removeAnimation(0); | 141 controllerImpl->removeAnimation(0); |
142 | 142 |
143 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 143 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
144 | 144 |
145 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 145 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
146 | 146 |
147 // Even though the main thread has a 'new' animation, it should not be pushe
d because the animation has already completed on the impl thread. | 147 // Even though the main thread has a 'new' animation, it should not be pushe
d because the animation has already completed on the impl thread. |
148 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); | 148 EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacit
y)); |
149 } | 149 } |
150 | 150 |
151 // Tests that transitioning opacity from 0 to 1 works as expected. | 151 // Tests that transitioning opacity from 0 to 1 works as expected. |
152 TEST(CCLayerAnimationControllerTest, TrivialTransition) | 152 TEST(CCLayerAnimationControllerTest, TrivialTransition) |
153 { | 153 { |
154 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 154 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
155 FakeLayerAnimationControllerClient dummy; | 155 FakeLayerAnimationControllerClient dummy; |
156 OwnPtr<CCLayerAnimationController> controller( | 156 scoped_ptr<CCLayerAnimationController> controller( |
157 CCLayerAnimationController::create(&dummy)); | 157 CCLayerAnimationController::create(&dummy)); |
158 | 158 |
159 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 159 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation
::Opacity)); |
160 | 160 |
161 controller->addAnimation(toAdd.release()); | 161 controller->addAnimation(toAdd.Pass()); |
162 controller->animate(0, events.get()); | 162 controller->animate(0, events.get()); |
163 EXPECT_TRUE(controller->hasActiveAnimation()); | 163 EXPECT_TRUE(controller->hasActiveAnimation()); |
164 EXPECT_EQ(0, dummy.opacity()); | 164 EXPECT_EQ(0, dummy.opacity()); |
165 controller->animate(1, events.get()); | 165 controller->animate(1, events.get()); |
166 EXPECT_EQ(1, dummy.opacity()); | 166 EXPECT_EQ(1, dummy.opacity()); |
167 EXPECT_FALSE(controller->hasActiveAnimation()); | 167 EXPECT_FALSE(controller->hasActiveAnimation()); |
168 } | 168 } |
169 | 169 |
170 // Tests animations that are waiting for a synchronized start time do not finish
. | 170 // Tests animations that are waiting for a synchronized start time do not finish
. |
171 TEST(CCLayerAnimationControllerTest, AnimationsWaitingForStartTimeDoNotFinishIfT
heyWaitLongerToStartThanTheirDuration) | 171 TEST(CCLayerAnimationControllerTest, AnimationsWaitingForStartTimeDoNotFinishIfT
heyWaitLongerToStartThanTheirDuration) |
172 { | 172 { |
173 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 173 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
174 FakeLayerAnimationControllerClient dummy; | 174 FakeLayerAnimationControllerClient dummy; |
175 OwnPtr<CCLayerAnimationController> controller( | 175 scoped_ptr<CCLayerAnimationController> controller( |
176 CCLayerAnimationController::create(&dummy)); | 176 CCLayerAnimationController::create(&dummy)); |
177 | 177 |
178 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 178 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation
::Opacity)); |
179 toAdd->setNeedsSynchronizedStartTime(true); | 179 toAdd->setNeedsSynchronizedStartTime(true); |
180 | 180 |
181 // We should pause at the first keyframe indefinitely waiting for that anima
tion to start. | 181 // We should pause at the first keyframe indefinitely waiting for that anima
tion to start. |
182 controller->addAnimation(toAdd.release()); | 182 controller->addAnimation(toAdd.Pass()); |
183 controller->animate(0, events.get()); | 183 controller->animate(0, events.get()); |
184 EXPECT_TRUE(controller->hasActiveAnimation()); | 184 EXPECT_TRUE(controller->hasActiveAnimation()); |
185 EXPECT_EQ(0, dummy.opacity()); | 185 EXPECT_EQ(0, dummy.opacity()); |
186 controller->animate(1, events.get()); | 186 controller->animate(1, events.get()); |
187 EXPECT_TRUE(controller->hasActiveAnimation()); | 187 EXPECT_TRUE(controller->hasActiveAnimation()); |
188 EXPECT_EQ(0, dummy.opacity()); | 188 EXPECT_EQ(0, dummy.opacity()); |
189 controller->animate(2, events.get()); | 189 controller->animate(2, events.get()); |
190 EXPECT_TRUE(controller->hasActiveAnimation()); | 190 EXPECT_TRUE(controller->hasActiveAnimation()); |
191 EXPECT_EQ(0, dummy.opacity()); | 191 EXPECT_EQ(0, dummy.opacity()); |
192 | 192 |
193 // Send the synchronized start time. | 193 // Send the synchronized start time. |
194 controller->notifyAnimationStarted(CCAnimationEvent(CCAnimationEvent::Starte
d, 0, 1, CCActiveAnimation::Opacity, 2)); | 194 controller->notifyAnimationStarted(CCAnimationEvent(CCAnimationEvent::Starte
d, 0, 1, CCActiveAnimation::Opacity, 2)); |
195 controller->animate(5, events.get()); | 195 controller->animate(5, events.get()); |
196 EXPECT_EQ(1, dummy.opacity()); | 196 EXPECT_EQ(1, dummy.opacity()); |
197 EXPECT_FALSE(controller->hasActiveAnimation()); | 197 EXPECT_FALSE(controller->hasActiveAnimation()); |
198 } | 198 } |
199 | 199 |
200 // Tests that two queued animations affecting the same property run in sequence. | 200 // Tests that two queued animations affecting the same property run in sequence. |
201 TEST(CCLayerAnimationControllerTest, TrivialQueuing) | 201 TEST(CCLayerAnimationControllerTest, TrivialQueuing) |
202 { | 202 { |
203 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 203 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
204 FakeLayerAnimationControllerClient dummy; | 204 FakeLayerAnimationControllerClient dummy; |
205 OwnPtr<CCLayerAnimationController> controller( | 205 scoped_ptr<CCLayerAnimationController> controller( |
206 CCLayerAnimationController::create(&dummy)); | 206 CCLayerAnimationController::create(&dummy)); |
207 | 207 |
208 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 208 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Opacity))
; |
209 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 1, 0.5)), 2, CCActiveAnimation::Opacity)); | 209 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 1, 0.5)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimation::Opacity
)); |
210 | 210 |
211 controller->animate(0, events.get()); | 211 controller->animate(0, events.get()); |
212 EXPECT_TRUE(controller->hasActiveAnimation()); | 212 EXPECT_TRUE(controller->hasActiveAnimation()); |
213 EXPECT_EQ(0, dummy.opacity()); | 213 EXPECT_EQ(0, dummy.opacity()); |
214 controller->animate(1, events.get()); | 214 controller->animate(1, events.get()); |
215 EXPECT_TRUE(controller->hasActiveAnimation()); | 215 EXPECT_TRUE(controller->hasActiveAnimation()); |
216 EXPECT_EQ(1, dummy.opacity()); | 216 EXPECT_EQ(1, dummy.opacity()); |
217 controller->animate(2, events.get()); | 217 controller->animate(2, events.get()); |
218 EXPECT_EQ(0.5, dummy.opacity()); | 218 EXPECT_EQ(0.5, dummy.opacity()); |
219 EXPECT_FALSE(controller->hasActiveAnimation()); | 219 EXPECT_FALSE(controller->hasActiveAnimation()); |
220 } | 220 } |
221 | 221 |
222 // Tests interrupting a transition with another transition. | 222 // Tests interrupting a transition with another transition. |
223 TEST(CCLayerAnimationControllerTest, Interrupt) | 223 TEST(CCLayerAnimationControllerTest, Interrupt) |
224 { | 224 { |
225 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 225 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
226 FakeLayerAnimationControllerClient dummy; | 226 FakeLayerAnimationControllerClient dummy; |
227 OwnPtr<CCLayerAnimationController> controller( | 227 scoped_ptr<CCLayerAnimationController> controller( |
228 CCLayerAnimationController::create(&dummy)); | 228 CCLayerAnimationController::create(&dummy)); |
229 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 229 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Opacity))
; |
230 controller->animate(0, events.get()); | 230 controller->animate(0, events.get()); |
231 EXPECT_TRUE(controller->hasActiveAnimation()); | 231 EXPECT_TRUE(controller->hasActiveAnimation()); |
232 EXPECT_EQ(0, dummy.opacity()); | 232 EXPECT_EQ(0, dummy.opacity()); |
233 | 233 |
234 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity)); | 234 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 1, 0.5)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimati
on::Opacity)); |
235 toAdd->setRunState(CCActiveAnimation::WaitingForNextTick, 0); | 235 toAdd->setRunState(CCActiveAnimation::WaitingForNextTick, 0); |
236 controller->addAnimation(toAdd.release()); | 236 controller->addAnimation(toAdd.Pass()); |
237 | 237 |
238 // Since the animation was in the WaitingForNextTick state, it should start
right in | 238 // Since the animation was in the WaitingForNextTick state, it should start
right in |
239 // this call to animate. | 239 // this call to animate. |
240 controller->animate(0.5, events.get()); | 240 controller->animate(0.5, events.get()); |
241 EXPECT_TRUE(controller->hasActiveAnimation()); | 241 EXPECT_TRUE(controller->hasActiveAnimation()); |
242 EXPECT_EQ(1, dummy.opacity()); | 242 EXPECT_EQ(1, dummy.opacity()); |
243 controller->animate(1.5, events.get()); | 243 controller->animate(1.5, events.get()); |
244 EXPECT_EQ(0.5, dummy.opacity()); | 244 EXPECT_EQ(0.5, dummy.opacity()); |
245 EXPECT_FALSE(controller->hasActiveAnimation()); | 245 EXPECT_FALSE(controller->hasActiveAnimation()); |
246 } | 246 } |
247 | 247 |
248 // Tests scheduling two animations to run together when only one property is fre
e. | 248 // Tests scheduling two animations to run together when only one property is fre
e. |
249 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) | 249 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked) |
250 { | 250 { |
251 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 251 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
252 FakeLayerAnimationControllerClient dummy; | 252 FakeLayerAnimationControllerClient dummy; |
253 OwnPtr<CCLayerAnimationController> controller( | 253 scoped_ptr<CCLayerAnimationController> controller( |
254 CCLayerAnimationController::create(&dummy)); | 254 CCLayerAnimationController::create(&dummy)); |
255 | 255 |
256 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTra
nsition(1)), 1, CCActiveAnimation::Transform)); | 256 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeTrans
formTransition(1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Transform))
; |
257 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTra
nsition(1)), 2, CCActiveAnimation::Transform)); | 257 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeTrans
formTransition(1)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimation::Transform))
; |
258 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 1)), 2, CCActiveAnimation::Opacity)); | 258 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 1)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimation::Opacity))
; |
259 | 259 |
260 controller->animate(0, events.get()); | 260 controller->animate(0, events.get()); |
261 EXPECT_EQ(0, dummy.opacity()); | 261 EXPECT_EQ(0, dummy.opacity()); |
262 EXPECT_TRUE(controller->hasActiveAnimation()); | 262 EXPECT_TRUE(controller->hasActiveAnimation()); |
263 controller->animate(1, events.get()); | 263 controller->animate(1, events.get()); |
264 // Should not have started the float transition yet. | 264 // Should not have started the float transition yet. |
265 EXPECT_TRUE(controller->hasActiveAnimation()); | 265 EXPECT_TRUE(controller->hasActiveAnimation()); |
266 EXPECT_EQ(0, dummy.opacity()); | 266 EXPECT_EQ(0, dummy.opacity()); |
267 // The float animation should have started at time 1 and should be done. | 267 // The float animation should have started at time 1 and should be done. |
268 controller->animate(2, events.get()); | 268 controller->animate(2, events.get()); |
269 EXPECT_EQ(1, dummy.opacity()); | 269 EXPECT_EQ(1, dummy.opacity()); |
270 EXPECT_FALSE(controller->hasActiveAnimation()); | 270 EXPECT_FALSE(controller->hasActiveAnimation()); |
271 } | 271 } |
272 | 272 |
273 // Tests scheduling two animations to run together with different lengths and an
other | 273 // Tests scheduling two animations to run together with different lengths and an
other |
274 // animation queued to start when the shorter animation finishes (should wait | 274 // animation queued to start when the shorter animation finishes (should wait |
275 // for both to finish). | 275 // for both to finish). |
276 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) | 276 TEST(CCLayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) |
277 { | 277 { |
278 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 278 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
279 FakeLayerAnimationControllerClient dummy; | 279 FakeLayerAnimationControllerClient dummy; |
280 OwnPtr<CCLayerAnimationController> controller( | 280 scoped_ptr<CCLayerAnimationController> controller( |
281 CCLayerAnimationController::create(&dummy)); | 281 CCLayerAnimationController::create(&dummy)); |
282 | 282 |
283 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTra
nsition(2)), 1, CCActiveAnimation::Transform)); | 283 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeTrans
formTransition(2)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Transform))
; |
284 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 284 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Opacity))
; |
285 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 1, 0.5)), 2, CCActiveAnimation::Opacity)); | 285 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 1, 0.5)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimation::Opacity
)); |
286 | 286 |
287 // Animations with id 1 should both start now. | 287 // Animations with id 1 should both start now. |
288 controller->animate(0, events.get()); | 288 controller->animate(0, events.get()); |
289 EXPECT_TRUE(controller->hasActiveAnimation()); | 289 EXPECT_TRUE(controller->hasActiveAnimation()); |
290 EXPECT_EQ(0, dummy.opacity()); | 290 EXPECT_EQ(0, dummy.opacity()); |
291 // The opacity animation should have finished at time 1, but the group | 291 // The opacity animation should have finished at time 1, but the group |
292 // of animations with id 1 don't finish until time 2 because of the length | 292 // of animations with id 1 don't finish until time 2 because of the length |
293 // of the transform animation. | 293 // of the transform animation. |
294 controller->animate(2, events.get()); | 294 controller->animate(2, events.get()); |
295 // Should not have started the float transition yet. | 295 // Should not have started the float transition yet. |
296 EXPECT_TRUE(controller->hasActiveAnimation()); | 296 EXPECT_TRUE(controller->hasActiveAnimation()); |
297 EXPECT_EQ(1, dummy.opacity()); | 297 EXPECT_EQ(1, dummy.opacity()); |
298 | 298 |
299 // The second opacity animation should start at time 2 and should be done by
time 3 | 299 // The second opacity animation should start at time 2 and should be done by
time 3 |
300 controller->animate(3, events.get()); | 300 controller->animate(3, events.get()); |
301 EXPECT_EQ(0.5, dummy.opacity()); | 301 EXPECT_EQ(0.5, dummy.opacity()); |
302 EXPECT_FALSE(controller->hasActiveAnimation()); | 302 EXPECT_FALSE(controller->hasActiveAnimation()); |
303 } | 303 } |
304 | 304 |
305 // Tests scheduling an animation to start in the future. | 305 // Tests scheduling an animation to start in the future. |
306 TEST(CCLayerAnimationControllerTest, ScheduleAnimation) | 306 TEST(CCLayerAnimationControllerTest, ScheduleAnimation) |
307 { | 307 { |
308 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 308 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
309 FakeLayerAnimationControllerClient dummy; | 309 FakeLayerAnimationControllerClient dummy; |
310 OwnPtr<CCLayerAnimationController> controller( | 310 scoped_ptr<CCLayerAnimationController> controller( |
311 CCLayerAnimationController::create(&dummy)); | 311 CCLayerAnimationController::create(&dummy)); |
312 | 312 |
313 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 313 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation
::Opacity)); |
314 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); | 314 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); |
315 toAdd->setStartTime(1); | 315 toAdd->setStartTime(1); |
316 controller->addAnimation(toAdd.release()); | 316 controller->addAnimation(toAdd.Pass()); |
317 | 317 |
318 controller->animate(0, events.get()); | 318 controller->animate(0, events.get()); |
319 EXPECT_TRUE(controller->hasActiveAnimation()); | 319 EXPECT_TRUE(controller->hasActiveAnimation()); |
320 EXPECT_EQ(0, dummy.opacity()); | 320 EXPECT_EQ(0, dummy.opacity()); |
321 controller->animate(1, events.get()); | 321 controller->animate(1, events.get()); |
322 EXPECT_TRUE(controller->hasActiveAnimation()); | 322 EXPECT_TRUE(controller->hasActiveAnimation()); |
323 EXPECT_EQ(0, dummy.opacity()); | 323 EXPECT_EQ(0, dummy.opacity()); |
324 controller->animate(2, events.get()); | 324 controller->animate(2, events.get()); |
325 EXPECT_EQ(1, dummy.opacity()); | 325 EXPECT_EQ(1, dummy.opacity()); |
326 EXPECT_FALSE(controller->hasActiveAnimation()); | 326 EXPECT_FALSE(controller->hasActiveAnimation()); |
327 } | 327 } |
328 | 328 |
329 // Tests scheduling an animation to start in the future that's interrupting a ru
nning animation. | 329 // Tests scheduling an animation to start in the future that's interrupting a ru
nning animation. |
330 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimatio
n) | 330 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimatio
n) |
331 { | 331 { |
332 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 332 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
333 FakeLayerAnimationControllerClient dummy; | 333 FakeLayerAnimationControllerClient dummy; |
334 OwnPtr<CCLayerAnimationController> controller( | 334 scoped_ptr<CCLayerAnimationController> controller( |
335 CCLayerAnimationController::create(&dummy)); | 335 CCLayerAnimationController::create(&dummy)); |
336 | 336 |
337 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(2, 0, 1)), 1, CCActiveAnimation::Opacity)); | 337 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(2, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Opacity))
; |
338 | 338 |
339 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0.5, 0)), 2, CCActiveAnimation::Opacity)); | 339 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0.5, 0)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimati
on::Opacity)); |
340 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); | 340 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); |
341 toAdd->setStartTime(1); | 341 toAdd->setStartTime(1); |
342 controller->addAnimation(toAdd.release()); | 342 controller->addAnimation(toAdd.Pass()); |
343 | 343 |
344 // First 2s opacity transition should start immediately. | 344 // First 2s opacity transition should start immediately. |
345 controller->animate(0, events.get()); | 345 controller->animate(0, events.get()); |
346 EXPECT_TRUE(controller->hasActiveAnimation()); | 346 EXPECT_TRUE(controller->hasActiveAnimation()); |
347 EXPECT_EQ(0, dummy.opacity()); | 347 EXPECT_EQ(0, dummy.opacity()); |
348 controller->animate(0.5, events.get()); | 348 controller->animate(0.5, events.get()); |
349 EXPECT_TRUE(controller->hasActiveAnimation()); | 349 EXPECT_TRUE(controller->hasActiveAnimation()); |
350 EXPECT_EQ(0.25, dummy.opacity()); | 350 EXPECT_EQ(0.25, dummy.opacity()); |
351 controller->animate(1, events.get()); | 351 controller->animate(1, events.get()); |
352 EXPECT_TRUE(controller->hasActiveAnimation()); | 352 EXPECT_TRUE(controller->hasActiveAnimation()); |
353 EXPECT_EQ(0.5, dummy.opacity()); | 353 EXPECT_EQ(0.5, dummy.opacity()); |
354 controller->animate(2, events.get()); | 354 controller->animate(2, events.get()); |
355 EXPECT_EQ(0, dummy.opacity()); | 355 EXPECT_EQ(0, dummy.opacity()); |
356 EXPECT_FALSE(controller->hasActiveAnimation()); | 356 EXPECT_FALSE(controller->hasActiveAnimation()); |
357 } | 357 } |
358 | 358 |
359 // Tests scheduling an animation to start in the future that interrupts a runnin
g animation | 359 // Tests scheduling an animation to start in the future that interrupts a runnin
g animation |
360 // and there is yet another animation queued to start later. | 360 // and there is yet another animation queued to start later. |
361 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimatio
nWithAnimInQueue) | 361 TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimatio
nWithAnimInQueue) |
362 { | 362 { |
363 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 363 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
364 FakeLayerAnimationControllerClient dummy; | 364 FakeLayerAnimationControllerClient dummy; |
365 OwnPtr<CCLayerAnimationController> controller( | 365 scoped_ptr<CCLayerAnimationController> controller( |
366 CCLayerAnimationController::create(&dummy)); | 366 CCLayerAnimationController::create(&dummy)); |
367 | 367 |
368 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(2, 0, 1)), 1, CCActiveAnimation::Opacity)); | 368 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(2, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation::Opacity))
; |
369 | 369 |
370 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(2, 0.5, 0)), 2, CCActiveAnimation::Opacity)); | 370 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(2, 0.5, 0)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimati
on::Opacity)); |
371 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); | 371 toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0); |
372 toAdd->setStartTime(1); | 372 toAdd->setStartTime(1); |
373 controller->addAnimation(toAdd.release()); | 373 controller->addAnimation(toAdd.Pass()); |
374 | 374 |
375 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 0.75)), 3, CCActiveAnimation::Opacity)); | 375 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 0.75)).PassAs<CCAnimationCurve>(), 3, CCActiveAnimation::Opacit
y)); |
376 | 376 |
377 // First 2s opacity transition should start immediately. | 377 // First 2s opacity transition should start immediately. |
378 controller->animate(0, events.get()); | 378 controller->animate(0, events.get()); |
379 EXPECT_TRUE(controller->hasActiveAnimation()); | 379 EXPECT_TRUE(controller->hasActiveAnimation()); |
380 EXPECT_EQ(0, dummy.opacity()); | 380 EXPECT_EQ(0, dummy.opacity()); |
381 controller->animate(0.5, events.get()); | 381 controller->animate(0.5, events.get()); |
382 EXPECT_TRUE(controller->hasActiveAnimation()); | 382 EXPECT_TRUE(controller->hasActiveAnimation()); |
383 EXPECT_EQ(0.25, dummy.opacity()); | 383 EXPECT_EQ(0.25, dummy.opacity()); |
384 EXPECT_TRUE(controller->hasActiveAnimation()); | 384 EXPECT_TRUE(controller->hasActiveAnimation()); |
385 controller->animate(1, events.get()); | 385 controller->animate(1, events.get()); |
386 EXPECT_TRUE(controller->hasActiveAnimation()); | 386 EXPECT_TRUE(controller->hasActiveAnimation()); |
387 EXPECT_EQ(0.5, dummy.opacity()); | 387 EXPECT_EQ(0.5, dummy.opacity()); |
388 controller->animate(3, events.get()); | 388 controller->animate(3, events.get()); |
389 EXPECT_TRUE(controller->hasActiveAnimation()); | 389 EXPECT_TRUE(controller->hasActiveAnimation()); |
390 EXPECT_EQ(0, dummy.opacity()); | 390 EXPECT_EQ(0, dummy.opacity()); |
391 controller->animate(4, events.get()); | 391 controller->animate(4, events.get()); |
392 EXPECT_EQ(0.75, dummy.opacity()); | 392 EXPECT_EQ(0.75, dummy.opacity()); |
393 EXPECT_FALSE(controller->hasActiveAnimation()); | 393 EXPECT_FALSE(controller->hasActiveAnimation()); |
394 } | 394 } |
395 | 395 |
396 // Test that a looping animation loops and for the correct number of iterations. | 396 // Test that a looping animation loops and for the correct number of iterations. |
397 TEST(CCLayerAnimationControllerTest, TrivialLooping) | 397 TEST(CCLayerAnimationControllerTest, TrivialLooping) |
398 { | 398 { |
399 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 399 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
400 FakeLayerAnimationControllerClient dummy; | 400 FakeLayerAnimationControllerClient dummy; |
401 OwnPtr<CCLayerAnimationController> controller( | 401 scoped_ptr<CCLayerAnimationController> controller( |
402 CCLayerAnimationController::create(&dummy)); | 402 CCLayerAnimationController::create(&dummy)); |
403 | 403 |
404 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0, 1)), 1, CCActiveAnimation::Opacity)); | 404 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0, 1)).PassAs<CCAnimationCurve>(), 1, CCActiveAnimation
::Opacity)); |
405 toAdd->setIterations(3); | 405 toAdd->setIterations(3); |
406 controller->addAnimation(toAdd.release()); | 406 controller->addAnimation(toAdd.Pass()); |
407 | 407 |
408 controller->animate(0, events.get()); | 408 controller->animate(0, events.get()); |
409 EXPECT_TRUE(controller->hasActiveAnimation()); | 409 EXPECT_TRUE(controller->hasActiveAnimation()); |
410 EXPECT_EQ(0, dummy.opacity()); | 410 EXPECT_EQ(0, dummy.opacity()); |
411 controller->animate(1.25, events.get()); | 411 controller->animate(1.25, events.get()); |
412 EXPECT_TRUE(controller->hasActiveAnimation()); | 412 EXPECT_TRUE(controller->hasActiveAnimation()); |
413 EXPECT_EQ(0.25, dummy.opacity()); | 413 EXPECT_EQ(0.25, dummy.opacity()); |
414 controller->animate(1.75, events.get()); | 414 controller->animate(1.75, events.get()); |
415 EXPECT_TRUE(controller->hasActiveAnimation()); | 415 EXPECT_TRUE(controller->hasActiveAnimation()); |
416 EXPECT_EQ(0.75, dummy.opacity()); | 416 EXPECT_EQ(0.75, dummy.opacity()); |
417 controller->animate(2.25, events.get()); | 417 controller->animate(2.25, events.get()); |
418 EXPECT_TRUE(controller->hasActiveAnimation()); | 418 EXPECT_TRUE(controller->hasActiveAnimation()); |
419 EXPECT_EQ(0.25, dummy.opacity()); | 419 EXPECT_EQ(0.25, dummy.opacity()); |
420 controller->animate(2.75, events.get()); | 420 controller->animate(2.75, events.get()); |
421 EXPECT_TRUE(controller->hasActiveAnimation()); | 421 EXPECT_TRUE(controller->hasActiveAnimation()); |
422 EXPECT_EQ(0.75, dummy.opacity()); | 422 EXPECT_EQ(0.75, dummy.opacity()); |
423 controller->animate(3, events.get()); | 423 controller->animate(3, events.get()); |
424 EXPECT_FALSE(controller->hasActiveAnimation()); | 424 EXPECT_FALSE(controller->hasActiveAnimation()); |
425 EXPECT_EQ(1, dummy.opacity()); | 425 EXPECT_EQ(1, dummy.opacity()); |
426 | 426 |
427 // Just be extra sure. | 427 // Just be extra sure. |
428 controller->animate(4, events.get()); | 428 controller->animate(4, events.get()); |
429 EXPECT_EQ(1, dummy.opacity()); | 429 EXPECT_EQ(1, dummy.opacity()); |
430 } | 430 } |
431 | 431 |
432 // Test that an infinitely looping animation does indeed go until aborted. | 432 // Test that an infinitely looping animation does indeed go until aborted. |
433 TEST(CCLayerAnimationControllerTest, InfiniteLooping) | 433 TEST(CCLayerAnimationControllerTest, InfiniteLooping) |
434 { | 434 { |
435 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 435 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
436 FakeLayerAnimationControllerClient dummy; | 436 FakeLayerAnimationControllerClient dummy; |
437 OwnPtr<CCLayerAnimationController> controller( | 437 scoped_ptr<CCLayerAnimationController> controller( |
438 CCLayerAnimationController::create(&dummy)); | 438 CCLayerAnimationController::create(&dummy)); |
439 | 439 |
440 const int id = 1; | 440 const int id = 1; |
441 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(1, 0, 1)), id, CCActiveAnimation::Opacity)); | 441 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(1, 0, 1)).PassAs<CCAnimationCurve>(), id, CCActiveAnimatio
n::Opacity)); |
442 toAdd->setIterations(-1); | 442 toAdd->setIterations(-1); |
443 controller->addAnimation(toAdd.release()); | 443 controller->addAnimation(toAdd.Pass()); |
444 | 444 |
445 controller->animate(0, events.get()); | 445 controller->animate(0, events.get()); |
446 EXPECT_TRUE(controller->hasActiveAnimation()); | 446 EXPECT_TRUE(controller->hasActiveAnimation()); |
447 EXPECT_EQ(0, dummy.opacity()); | 447 EXPECT_EQ(0, dummy.opacity()); |
448 controller->animate(1.25, events.get()); | 448 controller->animate(1.25, events.get()); |
449 EXPECT_TRUE(controller->hasActiveAnimation()); | 449 EXPECT_TRUE(controller->hasActiveAnimation()); |
450 EXPECT_EQ(0.25, dummy.opacity()); | 450 EXPECT_EQ(0.25, dummy.opacity()); |
451 controller->animate(1.75, events.get()); | 451 controller->animate(1.75, events.get()); |
452 EXPECT_TRUE(controller->hasActiveAnimation()); | 452 EXPECT_TRUE(controller->hasActiveAnimation()); |
453 EXPECT_EQ(0.75, dummy.opacity()); | 453 EXPECT_EQ(0.75, dummy.opacity()); |
454 | 454 |
455 controller->animate(1073741824.25, events.get()); | 455 controller->animate(1073741824.25, events.get()); |
456 EXPECT_TRUE(controller->hasActiveAnimation()); | 456 EXPECT_TRUE(controller->hasActiveAnimation()); |
457 EXPECT_EQ(0.25, dummy.opacity()); | 457 EXPECT_EQ(0.25, dummy.opacity()); |
458 controller->animate(1073741824.75, events.get()); | 458 controller->animate(1073741824.75, events.get()); |
459 EXPECT_TRUE(controller->hasActiveAnimation()); | 459 EXPECT_TRUE(controller->hasActiveAnimation()); |
460 EXPECT_EQ(0.75, dummy.opacity()); | 460 EXPECT_EQ(0.75, dummy.opacity()); |
461 | 461 |
462 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); | 462 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); |
463 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Aborted, 0.75); | 463 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Aborted, 0.75); |
464 EXPECT_FALSE(controller->hasActiveAnimation()); | 464 EXPECT_FALSE(controller->hasActiveAnimation()); |
465 EXPECT_EQ(0.75, dummy.opacity()); | 465 EXPECT_EQ(0.75, dummy.opacity()); |
466 } | 466 } |
467 | 467 |
468 // Test that pausing and resuming work as expected. | 468 // Test that pausing and resuming work as expected. |
469 TEST(CCLayerAnimationControllerTest, PauseResume) | 469 TEST(CCLayerAnimationControllerTest, PauseResume) |
470 { | 470 { |
471 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 471 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
472 FakeLayerAnimationControllerClient dummy; | 472 FakeLayerAnimationControllerClient dummy; |
473 OwnPtr<CCLayerAnimationController> controller( | 473 scoped_ptr<CCLayerAnimationController> controller( |
474 CCLayerAnimationController::create(&dummy)); | 474 CCLayerAnimationController::create(&dummy)); |
475 | 475 |
476 const int id = 1; | 476 const int id = 1; |
477 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 0, 1)), id, CCActiveAnimation::Opacity)); | 477 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 0, 1)).PassAs<CCAnimationCurve>(), id, CCActiveAnimation::Opacity)
); |
478 | 478 |
479 controller->animate(0, events.get()); | 479 controller->animate(0, events.get()); |
480 EXPECT_TRUE(controller->hasActiveAnimation()); | 480 EXPECT_TRUE(controller->hasActiveAnimation()); |
481 EXPECT_EQ(0, dummy.opacity()); | 481 EXPECT_EQ(0, dummy.opacity()); |
482 controller->animate(0.5, events.get()); | 482 controller->animate(0.5, events.get()); |
483 EXPECT_TRUE(controller->hasActiveAnimation()); | 483 EXPECT_TRUE(controller->hasActiveAnimation()); |
484 EXPECT_EQ(0.5, dummy.opacity()); | 484 EXPECT_EQ(0.5, dummy.opacity()); |
485 | 485 |
486 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); | 486 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); |
487 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Paused, 0.5); | 487 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Paused, 0.5); |
488 | 488 |
489 controller->animate(1024, events.get()); | 489 controller->animate(1024, events.get()); |
490 EXPECT_TRUE(controller->hasActiveAnimation()); | 490 EXPECT_TRUE(controller->hasActiveAnimation()); |
491 EXPECT_EQ(0.5, dummy.opacity()); | 491 EXPECT_EQ(0.5, dummy.opacity()); |
492 | 492 |
493 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); | 493 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); |
494 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Running, 1024); | 494 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Running, 1024); |
495 | 495 |
496 controller->animate(1024.25, events.get()); | 496 controller->animate(1024.25, events.get()); |
497 EXPECT_TRUE(controller->hasActiveAnimation()); | 497 EXPECT_TRUE(controller->hasActiveAnimation()); |
498 EXPECT_EQ(0.75, dummy.opacity()); | 498 EXPECT_EQ(0.75, dummy.opacity()); |
499 controller->animate(1024.5, events.get()); | 499 controller->animate(1024.5, events.get()); |
500 EXPECT_FALSE(controller->hasActiveAnimation()); | 500 EXPECT_FALSE(controller->hasActiveAnimation()); |
501 EXPECT_EQ(1, dummy.opacity()); | 501 EXPECT_EQ(1, dummy.opacity()); |
502 } | 502 } |
503 | 503 |
504 TEST(CCLayerAnimationControllerTest, AbortAGroupedAnimation) | 504 TEST(CCLayerAnimationControllerTest, AbortAGroupedAnimation) |
505 { | 505 { |
506 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 506 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
507 FakeLayerAnimationControllerClient dummy; | 507 FakeLayerAnimationControllerClient dummy; |
508 OwnPtr<CCLayerAnimationController> controller( | 508 scoped_ptr<CCLayerAnimationController> controller( |
509 CCLayerAnimationController::create(&dummy)); | 509 CCLayerAnimationController::create(&dummy)); |
510 | 510 |
511 const int id = 1; | 511 const int id = 1; |
512 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeTransformTra
nsition(1)), id, CCActiveAnimation::Transform)); | 512 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeTrans
formTransition(1)).PassAs<CCAnimationCurve>(), id, CCActiveAnimation::Transform)
); |
513 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(2, 0, 1)), id, CCActiveAnimation::Opacity)); | 513 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(2, 0, 1)).PassAs<CCAnimationCurve>(), id, CCActiveAnimation::Opacity)
); |
514 controller->addAnimation(createActiveAnimation(adoptPtr(new FakeFloatTransit
ion(1, 1, 0.75)), 2, CCActiveAnimation::Opacity)); | 514 controller->addAnimation(createActiveAnimation(make_scoped_ptr(new FakeFloat
Transition(1, 1, 0.75)).PassAs<CCAnimationCurve>(), 2, CCActiveAnimation::Opacit
y)); |
515 | 515 |
516 controller->animate(0, events.get()); | 516 controller->animate(0, events.get()); |
517 EXPECT_TRUE(controller->hasActiveAnimation()); | 517 EXPECT_TRUE(controller->hasActiveAnimation()); |
518 EXPECT_EQ(0, dummy.opacity()); | 518 EXPECT_EQ(0, dummy.opacity()); |
519 controller->animate(1, events.get()); | 519 controller->animate(1, events.get()); |
520 EXPECT_TRUE(controller->hasActiveAnimation()); | 520 EXPECT_TRUE(controller->hasActiveAnimation()); |
521 EXPECT_EQ(0.5, dummy.opacity()); | 521 EXPECT_EQ(0.5, dummy.opacity()); |
522 | 522 |
523 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); | 523 EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity)); |
524 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Aborted, 1); | 524 controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(
CCActiveAnimation::Aborted, 1); |
525 controller->animate(1, events.get()); | 525 controller->animate(1, events.get()); |
526 EXPECT_TRUE(controller->hasActiveAnimation()); | 526 EXPECT_TRUE(controller->hasActiveAnimation()); |
527 EXPECT_EQ(1, dummy.opacity()); | 527 EXPECT_EQ(1, dummy.opacity()); |
528 controller->animate(2, events.get()); | 528 controller->animate(2, events.get()); |
529 EXPECT_TRUE(!controller->hasActiveAnimation()); | 529 EXPECT_TRUE(!controller->hasActiveAnimation()); |
530 EXPECT_EQ(0.75, dummy.opacity()); | 530 EXPECT_EQ(0.75, dummy.opacity()); |
531 } | 531 } |
532 | 532 |
533 TEST(CCLayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) | 533 TEST(CCLayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) |
534 { | 534 { |
535 FakeLayerAnimationControllerClient dummyImpl; | 535 FakeLayerAnimationControllerClient dummyImpl; |
536 OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController
::create(&dummyImpl)); | 536 scoped_ptr<CCLayerAnimationController> controllerImpl(CCLayerAnimationContro
ller::create(&dummyImpl)); |
537 OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)
); | 537 scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEv
entsVector)); |
538 FakeLayerAnimationControllerClient dummy; | 538 FakeLayerAnimationControllerClient dummy; |
539 OwnPtr<CCLayerAnimationController> controller( | 539 scoped_ptr<CCLayerAnimationController> controller( |
540 CCLayerAnimationController::create(&dummy)); | 540 CCLayerAnimationController::create(&dummy)); |
541 | 541 |
542 OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloat
Transition(2, 0, 1)), 0, CCActiveAnimation::Opacity)); | 542 scoped_ptr<CCActiveAnimation> toAdd(createActiveAnimation(make_scoped_ptr(ne
w FakeFloatTransition(2, 0, 1)).PassAs<CCAnimationCurve>(), 0, CCActiveAnimation
::Opacity)); |
543 toAdd->setNeedsSynchronizedStartTime(true); | 543 toAdd->setNeedsSynchronizedStartTime(true); |
544 controller->addAnimation(toAdd.release()); | 544 controller->addAnimation(toAdd.Pass()); |
545 | 545 |
546 controller->animate(0, 0); | 546 controller->animate(0, 0); |
547 EXPECT_TRUE(controller->hasActiveAnimation()); | 547 EXPECT_TRUE(controller->hasActiveAnimation()); |
548 CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCAct
iveAnimation::Opacity); | 548 CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCAct
iveAnimation::Opacity); |
549 EXPECT_TRUE(activeAnimation); | 549 EXPECT_TRUE(activeAnimation); |
550 EXPECT_TRUE(activeAnimation->needsSynchronizedStartTime()); | 550 EXPECT_TRUE(activeAnimation->needsSynchronizedStartTime()); |
551 | 551 |
552 controller->setForceSync(); | 552 controller->setForceSync(); |
553 | 553 |
554 controller->pushAnimationUpdatesTo(controllerImpl.get()); | 554 controller->pushAnimationUpdatesTo(controllerImpl.get()); |
555 | 555 |
556 activeAnimation = controllerImpl->getActiveAnimation(0, CCActiveAnimation::O
pacity); | 556 activeAnimation = controllerImpl->getActiveAnimation(0, CCActiveAnimation::O
pacity); |
557 EXPECT_TRUE(activeAnimation); | 557 EXPECT_TRUE(activeAnimation); |
558 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, activeAnimation->
runState()); | 558 EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, activeAnimation->
runState()); |
559 } | 559 } |
560 | 560 |
561 } // namespace | 561 } // namespace |
OLD | NEW |