| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/compositor/layer_animation_element.h" | |
| 6 | |
| 7 #include "base/basictypes.h" | |
| 8 #include "base/compiler_specific.h" | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/time/time.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 #include "ui/compositor/layer_animation_delegate.h" | |
| 13 #include "ui/compositor/scoped_animation_duration_scale_mode.h" | |
| 14 #include "ui/compositor/test/test_layer_animation_delegate.h" | |
| 15 #include "ui/compositor/test/test_utils.h" | |
| 16 #include "ui/gfx/rect.h" | |
| 17 #include "ui/gfx/transform.h" | |
| 18 | |
| 19 namespace ui { | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 // Check that the transformation element progresses the delegate as expected and | |
| 24 // that the element can be reused after it completes. | |
| 25 TEST(LayerAnimationElementTest, TransformElement) { | |
| 26 TestLayerAnimationDelegate delegate; | |
| 27 gfx::Transform start_transform, target_transform; | |
| 28 start_transform.Rotate(-30.0); | |
| 29 target_transform.Rotate(30.0); | |
| 30 base::TimeTicks start_time; | |
| 31 base::TimeTicks effective_start_time; | |
| 32 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 33 | |
| 34 scoped_ptr<LayerAnimationElement> element( | |
| 35 LayerAnimationElement::CreateTransformElement(target_transform, delta)); | |
| 36 element->set_animation_group_id(1); | |
| 37 | |
| 38 for (int i = 0; i < 2; ++i) { | |
| 39 start_time = effective_start_time + delta; | |
| 40 element->set_requested_start_time(start_time); | |
| 41 delegate.SetTransformFromAnimation(start_transform); | |
| 42 element->Start(&delegate, 1); | |
| 43 element->Progress(start_time, &delegate); | |
| 44 CheckApproximatelyEqual(start_transform, | |
| 45 delegate.GetTransformForAnimation()); | |
| 46 effective_start_time = start_time + delta; | |
| 47 element->set_effective_start_time(effective_start_time); | |
| 48 element->Progress(effective_start_time, &delegate); | |
| 49 EXPECT_FLOAT_EQ(0.0, element->last_progressed_fraction()); | |
| 50 element->Progress(effective_start_time + delta/2, &delegate); | |
| 51 EXPECT_FLOAT_EQ(0.5, element->last_progressed_fraction()); | |
| 52 | |
| 53 base::TimeDelta element_duration; | |
| 54 EXPECT_TRUE(element->IsFinished(effective_start_time + delta, | |
| 55 &element_duration)); | |
| 56 EXPECT_EQ(2 * delta, element_duration); | |
| 57 | |
| 58 element->Progress(effective_start_time + delta, &delegate); | |
| 59 EXPECT_FLOAT_EQ(1.0, element->last_progressed_fraction()); | |
| 60 CheckApproximatelyEqual(target_transform, | |
| 61 delegate.GetTransformForAnimation()); | |
| 62 } | |
| 63 | |
| 64 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 65 element->GetTargetValue(&target_value); | |
| 66 CheckApproximatelyEqual(target_transform, target_value.transform); | |
| 67 } | |
| 68 | |
| 69 // Ensures that duration is copied correctly. | |
| 70 TEST(LayerAnimationElementTest, InverseElementDurationNoScale) { | |
| 71 gfx::Transform transform; | |
| 72 base::TimeDelta delta; | |
| 73 | |
| 74 scoped_ptr<LayerAnimationElement> base_element( | |
| 75 LayerAnimationElement::CreateTransformElement(transform, delta)); | |
| 76 | |
| 77 scoped_ptr<LayerAnimationElement> inverse_element( | |
| 78 LayerAnimationElement::CreateInverseTransformElement(transform, | |
| 79 base_element.get())); | |
| 80 EXPECT_EQ(base_element->duration(), inverse_element->duration()); | |
| 81 } | |
| 82 | |
| 83 // Ensures that duration is copied correctly and not double scaled. | |
| 84 TEST(LayerAnimationElementTest, InverseElementDurationScaled) { | |
| 85 gfx::Transform transform; | |
| 86 base::TimeDelta delta; | |
| 87 | |
| 88 ScopedAnimationDurationScaleMode faster_duration( | |
| 89 ScopedAnimationDurationScaleMode::FAST_DURATION); | |
| 90 scoped_ptr<LayerAnimationElement> base_element( | |
| 91 LayerAnimationElement::CreateTransformElement(transform, delta)); | |
| 92 | |
| 93 scoped_ptr<LayerAnimationElement> inverse_element( | |
| 94 LayerAnimationElement::CreateInverseTransformElement(transform, | |
| 95 base_element.get())); | |
| 96 EXPECT_EQ(base_element->duration(), inverse_element->duration()); | |
| 97 } | |
| 98 | |
| 99 // Ensures that the GetTargetTransform() method works as intended. | |
| 100 TEST(LayerAnimationElementTest, InverseElementTargetCalculation) { | |
| 101 base::TimeTicks start_time; | |
| 102 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 103 start_time += delta; | |
| 104 | |
| 105 gfx::Transform identity, transform; | |
| 106 | |
| 107 transform.Scale3d(2.0, 2.0, 2.0); | |
| 108 | |
| 109 scoped_ptr<LayerAnimationElement> base_element( | |
| 110 LayerAnimationElement::CreateTransformElement(transform, delta)); | |
| 111 scoped_ptr<LayerAnimationElement> inverse_element( | |
| 112 LayerAnimationElement::CreateInverseTransformElement(identity, | |
| 113 base_element.get())); | |
| 114 | |
| 115 base_element->set_requested_start_time(start_time); | |
| 116 inverse_element->set_requested_start_time(start_time); | |
| 117 | |
| 118 TestLayerAnimationDelegate delegate; | |
| 119 delegate.SetTransformFromAnimation(transform); | |
| 120 | |
| 121 base_element->Start(&delegate, 1); | |
| 122 inverse_element->Start(&delegate, 1); | |
| 123 LayerAnimationElement::TargetValue target; | |
| 124 inverse_element->GetTargetValue(&target); | |
| 125 | |
| 126 EXPECT_TRUE(target.transform.IsIdentity()) | |
| 127 << "Target should be identity such that the initial 2x scale from the start" | |
| 128 << " carries over at end when parent is doubled."; | |
| 129 } | |
| 130 | |
| 131 // Check that the bounds element progresses the delegate as expected and | |
| 132 // that the element can be reused after it completes. | |
| 133 TEST(LayerAnimationElementTest, BoundsElement) { | |
| 134 TestLayerAnimationDelegate delegate; | |
| 135 gfx::Rect start, target, middle; | |
| 136 start = target = middle = gfx::Rect(0, 0, 50, 50); | |
| 137 start.set_x(-90); | |
| 138 target.set_x(90); | |
| 139 base::TimeTicks start_time; | |
| 140 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 141 | |
| 142 scoped_ptr<LayerAnimationElement> element( | |
| 143 LayerAnimationElement::CreateBoundsElement(target, delta)); | |
| 144 | |
| 145 for (int i = 0; i < 2; ++i) { | |
| 146 start_time += delta; | |
| 147 element->set_requested_start_time(start_time); | |
| 148 delegate.SetBoundsFromAnimation(start); | |
| 149 element->Start(&delegate, 1); | |
| 150 element->Progress(start_time, &delegate); | |
| 151 CheckApproximatelyEqual(start, delegate.GetBoundsForAnimation()); | |
| 152 element->Progress(start_time + delta/2, &delegate); | |
| 153 CheckApproximatelyEqual(middle, delegate.GetBoundsForAnimation()); | |
| 154 | |
| 155 base::TimeDelta element_duration; | |
| 156 EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration)); | |
| 157 EXPECT_EQ(delta, element_duration); | |
| 158 | |
| 159 element->Progress(start_time + delta, &delegate); | |
| 160 CheckApproximatelyEqual(target, delegate.GetBoundsForAnimation()); | |
| 161 } | |
| 162 | |
| 163 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 164 element->GetTargetValue(&target_value); | |
| 165 CheckApproximatelyEqual(target, target_value.bounds); | |
| 166 } | |
| 167 | |
| 168 // Check that the opacity element progresses the delegate as expected and | |
| 169 // that the element can be reused after it completes. | |
| 170 TEST(LayerAnimationElementTest, OpacityElement) { | |
| 171 TestLayerAnimationDelegate delegate; | |
| 172 float start = 0.0; | |
| 173 float middle = 0.5; | |
| 174 float target = 1.0; | |
| 175 base::TimeTicks start_time; | |
| 176 base::TimeTicks effective_start_time; | |
| 177 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 178 scoped_ptr<LayerAnimationElement> element( | |
| 179 LayerAnimationElement::CreateOpacityElement(target, delta)); | |
| 180 | |
| 181 for (int i = 0; i < 2; ++i) { | |
| 182 start_time = effective_start_time + delta; | |
| 183 element->set_requested_start_time(start_time); | |
| 184 delegate.SetOpacityFromAnimation(start); | |
| 185 element->Start(&delegate, 1); | |
| 186 element->Progress(start_time, &delegate); | |
| 187 EXPECT_FLOAT_EQ(start, element->last_progressed_fraction()); | |
| 188 effective_start_time = start_time + delta; | |
| 189 element->set_effective_start_time(effective_start_time); | |
| 190 element->Progress(effective_start_time, &delegate); | |
| 191 EXPECT_FLOAT_EQ(start, element->last_progressed_fraction()); | |
| 192 element->Progress(effective_start_time + delta/2, &delegate); | |
| 193 EXPECT_FLOAT_EQ(middle, element->last_progressed_fraction()); | |
| 194 | |
| 195 base::TimeDelta element_duration; | |
| 196 EXPECT_TRUE(element->IsFinished(effective_start_time + delta, | |
| 197 &element_duration)); | |
| 198 EXPECT_EQ(2 * delta, element_duration); | |
| 199 | |
| 200 element->Progress(effective_start_time + delta, &delegate); | |
| 201 EXPECT_FLOAT_EQ(target, element->last_progressed_fraction()); | |
| 202 EXPECT_FLOAT_EQ(target, delegate.GetOpacityForAnimation()); | |
| 203 } | |
| 204 | |
| 205 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 206 element->GetTargetValue(&target_value); | |
| 207 EXPECT_FLOAT_EQ(target, target_value.opacity); | |
| 208 } | |
| 209 | |
| 210 // Check that the visibility element progresses the delegate as expected and | |
| 211 // that the element can be reused after it completes. | |
| 212 TEST(LayerAnimationElementTest, VisibilityElement) { | |
| 213 TestLayerAnimationDelegate delegate; | |
| 214 bool start = true; | |
| 215 bool target = false; | |
| 216 base::TimeTicks start_time; | |
| 217 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 218 scoped_ptr<LayerAnimationElement> element( | |
| 219 LayerAnimationElement::CreateVisibilityElement(target, delta)); | |
| 220 | |
| 221 for (int i = 0; i < 2; ++i) { | |
| 222 start_time += delta; | |
| 223 element->set_requested_start_time(start_time); | |
| 224 delegate.SetVisibilityFromAnimation(start); | |
| 225 element->Start(&delegate, 1); | |
| 226 element->Progress(start_time, &delegate); | |
| 227 EXPECT_TRUE(delegate.GetVisibilityForAnimation()); | |
| 228 element->Progress(start_time + delta/2, &delegate); | |
| 229 EXPECT_TRUE(delegate.GetVisibilityForAnimation()); | |
| 230 | |
| 231 base::TimeDelta element_duration; | |
| 232 EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration)); | |
| 233 EXPECT_EQ(delta, element_duration); | |
| 234 | |
| 235 element->Progress(start_time + delta, &delegate); | |
| 236 EXPECT_FALSE(delegate.GetVisibilityForAnimation()); | |
| 237 } | |
| 238 | |
| 239 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 240 element->GetTargetValue(&target_value); | |
| 241 EXPECT_FALSE(target_value.visibility); | |
| 242 } | |
| 243 | |
| 244 // Check that the Brightness element progresses the delegate as expected and | |
| 245 // that the element can be reused after it completes. | |
| 246 TEST(LayerAnimationElementTest, BrightnessElement) { | |
| 247 TestLayerAnimationDelegate delegate; | |
| 248 float start = 0.0; | |
| 249 float middle = 0.5; | |
| 250 float target = 1.0; | |
| 251 base::TimeTicks start_time; | |
| 252 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 253 scoped_ptr<LayerAnimationElement> element( | |
| 254 LayerAnimationElement::CreateBrightnessElement(target, delta)); | |
| 255 | |
| 256 for (int i = 0; i < 2; ++i) { | |
| 257 start_time += delta; | |
| 258 element->set_requested_start_time(start_time); | |
| 259 delegate.SetBrightnessFromAnimation(start); | |
| 260 element->Start(&delegate, 1); | |
| 261 element->Progress(start_time, &delegate); | |
| 262 EXPECT_FLOAT_EQ(start, delegate.GetBrightnessForAnimation()); | |
| 263 element->Progress(start_time + delta/2, &delegate); | |
| 264 EXPECT_FLOAT_EQ(middle, delegate.GetBrightnessForAnimation()); | |
| 265 | |
| 266 base::TimeDelta element_duration; | |
| 267 EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration)); | |
| 268 EXPECT_EQ(delta, element_duration); | |
| 269 | |
| 270 element->Progress(start_time + delta, &delegate); | |
| 271 EXPECT_FLOAT_EQ(target, delegate.GetBrightnessForAnimation()); | |
| 272 } | |
| 273 | |
| 274 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 275 element->GetTargetValue(&target_value); | |
| 276 EXPECT_FLOAT_EQ(target, target_value.brightness); | |
| 277 } | |
| 278 | |
| 279 // Check that the Grayscale element progresses the delegate as expected and | |
| 280 // that the element can be reused after it completes. | |
| 281 TEST(LayerAnimationElementTest, GrayscaleElement) { | |
| 282 TestLayerAnimationDelegate delegate; | |
| 283 float start = 0.0; | |
| 284 float middle = 0.5; | |
| 285 float target = 1.0; | |
| 286 base::TimeTicks start_time; | |
| 287 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 288 scoped_ptr<LayerAnimationElement> element( | |
| 289 LayerAnimationElement::CreateGrayscaleElement(target, delta)); | |
| 290 | |
| 291 for (int i = 0; i < 2; ++i) { | |
| 292 start_time += delta; | |
| 293 element->set_requested_start_time(start_time); | |
| 294 delegate.SetGrayscaleFromAnimation(start); | |
| 295 element->Start(&delegate, 1); | |
| 296 element->Progress(start_time, &delegate); | |
| 297 EXPECT_FLOAT_EQ(start, delegate.GetGrayscaleForAnimation()); | |
| 298 element->Progress(start_time + delta/2, &delegate); | |
| 299 EXPECT_FLOAT_EQ(middle, delegate.GetGrayscaleForAnimation()); | |
| 300 | |
| 301 base::TimeDelta element_duration; | |
| 302 EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration)); | |
| 303 EXPECT_EQ(delta, element_duration); | |
| 304 | |
| 305 element->Progress(start_time + delta, &delegate); | |
| 306 EXPECT_FLOAT_EQ(target, delegate.GetGrayscaleForAnimation()); | |
| 307 } | |
| 308 | |
| 309 LayerAnimationElement::TargetValue target_value(&delegate); | |
| 310 element->GetTargetValue(&target_value); | |
| 311 EXPECT_FLOAT_EQ(target, target_value.grayscale); | |
| 312 } | |
| 313 | |
| 314 // Check that the pause element progresses the delegate as expected and | |
| 315 // that the element can be reused after it completes. | |
| 316 TEST(LayerAnimationElementTest, PauseElement) { | |
| 317 LayerAnimationElement::AnimatableProperties properties = | |
| 318 LayerAnimationElement::TRANSFORM | LayerAnimationElement::BOUNDS | | |
| 319 LayerAnimationElement::OPACITY | LayerAnimationElement::BRIGHTNESS | | |
| 320 LayerAnimationElement::GRAYSCALE; | |
| 321 | |
| 322 base::TimeTicks start_time; | |
| 323 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 324 | |
| 325 scoped_ptr<LayerAnimationElement> element( | |
| 326 LayerAnimationElement::CreatePauseElement(properties, delta)); | |
| 327 | |
| 328 TestLayerAnimationDelegate delegate; | |
| 329 TestLayerAnimationDelegate copy = delegate; | |
| 330 | |
| 331 start_time += delta; | |
| 332 element->set_requested_start_time(start_time); | |
| 333 element->Start(&delegate, 1); | |
| 334 | |
| 335 // Pause should last for |delta|. | |
| 336 base::TimeDelta element_duration; | |
| 337 EXPECT_TRUE(element->IsFinished(start_time + delta, &element_duration)); | |
| 338 EXPECT_EQ(delta, element_duration); | |
| 339 | |
| 340 element->Progress(start_time + delta, &delegate); | |
| 341 | |
| 342 // Nothing should have changed. | |
| 343 CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), | |
| 344 copy.GetBoundsForAnimation()); | |
| 345 CheckApproximatelyEqual(delegate.GetTransformForAnimation(), | |
| 346 copy.GetTransformForAnimation()); | |
| 347 EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), | |
| 348 copy.GetOpacityForAnimation()); | |
| 349 EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), | |
| 350 copy.GetBrightnessForAnimation()); | |
| 351 EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), | |
| 352 copy.GetGrayscaleForAnimation()); | |
| 353 } | |
| 354 | |
| 355 // Check that a threaded opacity element updates the delegate as expected when | |
| 356 // aborted. | |
| 357 TEST(LayerAnimationElementTest, AbortOpacityElement) { | |
| 358 TestLayerAnimationDelegate delegate; | |
| 359 float start = 0.0; | |
| 360 float target = 1.0; | |
| 361 base::TimeTicks start_time; | |
| 362 base::TimeTicks effective_start_time; | |
| 363 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 364 scoped_ptr<LayerAnimationElement> element( | |
| 365 LayerAnimationElement::CreateOpacityElement(target, delta)); | |
| 366 | |
| 367 // Choose a non-linear Tween type. | |
| 368 gfx::Tween::Type tween_type = gfx::Tween::EASE_IN; | |
| 369 element->set_tween_type(tween_type); | |
| 370 | |
| 371 delegate.SetOpacityFromAnimation(start); | |
| 372 | |
| 373 // Aborting the element before it has started should not update the delegate. | |
| 374 element->Abort(&delegate); | |
| 375 EXPECT_FLOAT_EQ(start, delegate.GetOpacityForAnimation()); | |
| 376 | |
| 377 start_time += delta; | |
| 378 element->set_requested_start_time(start_time); | |
| 379 element->Start(&delegate, 1); | |
| 380 element->Progress(start_time, &delegate); | |
| 381 effective_start_time = start_time + delta; | |
| 382 element->set_effective_start_time(effective_start_time); | |
| 383 element->Progress(effective_start_time, &delegate); | |
| 384 element->Progress(effective_start_time + delta/2, &delegate); | |
| 385 | |
| 386 // Since the element has started, it should update the delegate when | |
| 387 // aborted. | |
| 388 element->Abort(&delegate); | |
| 389 EXPECT_FLOAT_EQ(gfx::Tween::CalculateValue(tween_type, 0.5), | |
| 390 delegate.GetOpacityForAnimation()); | |
| 391 } | |
| 392 | |
| 393 // Check that a threaded transform element updates the delegate as expected when | |
| 394 // aborted. | |
| 395 TEST(LayerAnimationElementTest, AbortTransformElement) { | |
| 396 TestLayerAnimationDelegate delegate; | |
| 397 gfx::Transform start_transform, target_transform; | |
| 398 start_transform.Rotate(-30.0); | |
| 399 target_transform.Rotate(30.0); | |
| 400 base::TimeTicks start_time; | |
| 401 base::TimeTicks effective_start_time; | |
| 402 base::TimeDelta delta = base::TimeDelta::FromSeconds(1); | |
| 403 scoped_ptr<LayerAnimationElement> element( | |
| 404 LayerAnimationElement::CreateTransformElement(target_transform, delta)); | |
| 405 | |
| 406 // Choose a non-linear Tween type. | |
| 407 gfx::Tween::Type tween_type = gfx::Tween::EASE_IN; | |
| 408 element->set_tween_type(tween_type); | |
| 409 | |
| 410 delegate.SetTransformFromAnimation(start_transform); | |
| 411 | |
| 412 // Aborting the element before it has started should not update the delegate. | |
| 413 element->Abort(&delegate); | |
| 414 CheckApproximatelyEqual(start_transform, delegate.GetTransformForAnimation()); | |
| 415 | |
| 416 start_time += delta; | |
| 417 element->set_requested_start_time(start_time); | |
| 418 element->Start(&delegate, 1); | |
| 419 element->Progress(start_time, &delegate); | |
| 420 effective_start_time = start_time + delta; | |
| 421 element->set_effective_start_time(effective_start_time); | |
| 422 element->Progress(effective_start_time, &delegate); | |
| 423 element->Progress(effective_start_time + delta/2, &delegate); | |
| 424 | |
| 425 // Since the element has started, it should update the delegate when | |
| 426 // aborted. | |
| 427 element->Abort(&delegate); | |
| 428 target_transform.Blend(start_transform, | |
| 429 gfx::Tween::CalculateValue(tween_type, 0.5)); | |
| 430 CheckApproximatelyEqual(target_transform, | |
| 431 delegate.GetTransformForAnimation()); | |
| 432 } | |
| 433 | |
| 434 } // namespace | |
| 435 | |
| 436 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
