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 437
