Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(424)

Side by Side Diff: webkit/compositor/WebTransformOperationsTest.cpp

Issue 10920056: Make cc_unittests and webkit_compositor_unittests executable always (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rename to webkit_compositor_bindings Created 8 years, 3 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 unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include "config.h"
6
7 #include <public/WebTransformOperations.h>
8
9 #include "CCGeometryTestUtils.h"
10 #include <gtest/gtest.h>
11 #include <public/WebTransformationMatrix.h>
12 #include <wtf/OwnPtr.h>
13 #include <wtf/PassOwnPtr.h>
14 #include <wtf/Vector.h>
15
16 using namespace std;
17 using namespace WebKit;
18
19 TEST(WebTransformOperationTest, transformTypesAreUnique)
20 {
21 Vector<OwnPtr<WebTransformOperations> > transforms;
22
23 WebTransformOperations* toAdd = new WebTransformOperations();
24 toAdd->appendTranslate(1, 0, 0);
25 transforms.append(adoptPtr(toAdd));
26
27 toAdd = new WebTransformOperations();
28 toAdd->appendRotate(0, 0, 1, 2);
29 transforms.append(adoptPtr(toAdd));
30
31 toAdd = new WebTransformOperations();
32 toAdd->appendScale(2, 2, 2);
33 transforms.append(adoptPtr(toAdd));
34
35 toAdd = new WebTransformOperations();
36 toAdd->appendSkew(1, 0);
37 transforms.append(adoptPtr(toAdd));
38
39 toAdd = new WebTransformOperations();
40 toAdd->appendPerspective(800);
41 transforms.append(adoptPtr(toAdd));
42
43 for (size_t i = 0; i < transforms.size(); ++i) {
44 for (size_t j = 0; j < transforms.size(); ++j) {
45 bool matchesType = transforms[i]->matchesTypes(*transforms[j]);
46 EXPECT_TRUE((i == j && matchesType) || !matchesType);
47 }
48 }
49 }
50
51 TEST(WebTransformOperationTest, matchTypesSameLength)
52 {
53 WebTransformOperations translates;
54 translates.appendTranslate(1, 0, 0);
55 translates.appendTranslate(1, 0, 0);
56 translates.appendTranslate(1, 0, 0);
57
58 WebTransformOperations skews;
59 skews.appendSkew(0, 2);
60 skews.appendSkew(0, 2);
61 skews.appendSkew(0, 2);
62
63 WebTransformOperations translates2;
64 translates2.appendTranslate(0, 2, 0);
65 translates2.appendTranslate(0, 2, 0);
66 translates2.appendTranslate(0, 2, 0);
67
68 WebTransformOperations translates3 = translates2;
69
70 EXPECT_FALSE(translates.matchesTypes(skews));
71 EXPECT_TRUE(translates.matchesTypes(translates2));
72 EXPECT_TRUE(translates.matchesTypes(translates3));
73 }
74
75 TEST(WebTransformOperationTest, matchTypesDifferentLength)
76 {
77 WebTransformOperations translates;
78 translates.appendTranslate(1, 0, 0);
79 translates.appendTranslate(1, 0, 0);
80 translates.appendTranslate(1, 0, 0);
81
82 WebTransformOperations skews;
83 skews.appendSkew(2, 0);
84 skews.appendSkew(2, 0);
85
86 WebTransformOperations translates2;
87 translates2.appendTranslate(0, 2, 0);
88 translates2.appendTranslate(0, 2, 0);
89
90 EXPECT_FALSE(translates.matchesTypes(skews));
91 EXPECT_FALSE(translates.matchesTypes(translates2));
92 }
93
94 void getIdentityOperations(Vector<OwnPtr<WebTransformOperations> >* operations)
95 {
96 WebTransformOperations* toAdd = new WebTransformOperations();
97 operations->append(adoptPtr(toAdd));
98
99 toAdd = new WebTransformOperations();
100 toAdd->appendTranslate(0, 0, 0);
101 operations->append(adoptPtr(toAdd));
102
103 toAdd = new WebTransformOperations();
104 toAdd->appendTranslate(0, 0, 0);
105 toAdd->appendTranslate(0, 0, 0);
106 operations->append(adoptPtr(toAdd));
107
108 toAdd = new WebTransformOperations();
109 toAdd->appendScale(1, 1, 1);
110 operations->append(adoptPtr(toAdd));
111
112 toAdd = new WebTransformOperations();
113 toAdd->appendScale(1, 1, 1);
114 toAdd->appendScale(1, 1, 1);
115 operations->append(adoptPtr(toAdd));
116
117 toAdd = new WebTransformOperations();
118 toAdd->appendSkew(0, 0);
119 operations->append(adoptPtr(toAdd));
120
121 toAdd = new WebTransformOperations();
122 toAdd->appendSkew(0, 0);
123 toAdd->appendSkew(0, 0);
124 operations->append(adoptPtr(toAdd));
125
126 toAdd = new WebTransformOperations();
127 toAdd->appendRotate(0, 0, 1, 0);
128 operations->append(adoptPtr(toAdd));
129
130 toAdd = new WebTransformOperations();
131 toAdd->appendRotate(0, 0, 1, 0);
132 toAdd->appendRotate(0, 0, 1, 0);
133 operations->append(adoptPtr(toAdd));
134
135 toAdd = new WebTransformOperations();
136 toAdd->appendMatrix(WebTransformationMatrix());
137 operations->append(adoptPtr(toAdd));
138
139 toAdd = new WebTransformOperations();
140 toAdd->appendMatrix(WebTransformationMatrix());
141 toAdd->appendMatrix(WebTransformationMatrix());
142 operations->append(adoptPtr(toAdd));
143 }
144
145 TEST(WebTransformOperationTest, identityAlwaysMatches)
146 {
147 Vector<OwnPtr<WebTransformOperations> > operations;
148 getIdentityOperations(&operations);
149
150 for (size_t i = 0; i < operations.size(); ++i) {
151 for (size_t j = 0; j < operations.size(); ++j)
152 EXPECT_TRUE(operations[i]->matchesTypes(*operations[j]));
153 }
154 }
155
156 TEST(WebTransformOperationTest, applyTranslate)
157 {
158 double x = 1;
159 double y = 2;
160 double z = 3;
161 WebTransformOperations operations;
162 operations.appendTranslate(x, y, z);
163 WebTransformationMatrix expected;
164 expected.translate3d(x, y, z);
165 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());
166 }
167
168 TEST(WebTransformOperationTest, applyRotate)
169 {
170 double x = 1;
171 double y = 2;
172 double z = 3;
173 double degrees = 80;
174 WebTransformOperations operations;
175 operations.appendRotate(x, y, z, degrees);
176 WebTransformationMatrix expected;
177 expected.rotate3d(x, y, z, degrees);
178 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());
179 }
180
181 TEST(WebTransformOperationTest, applyScale)
182 {
183 double x = 1;
184 double y = 2;
185 double z = 3;
186 WebTransformOperations operations;
187 operations.appendScale(x, y, z);
188 WebTransformationMatrix expected;
189 expected.scale3d(x, y, z);
190 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());
191 }
192
193 TEST(WebTransformOperationTest, applySkew)
194 {
195 double x = 1;
196 double y = 2;
197 WebTransformOperations operations;
198 operations.appendSkew(x, y);
199 WebTransformationMatrix expected;
200 expected.skewX(x);
201 expected.skewY(y);
202 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());
203 }
204
205 TEST(WebTransformOperationTest, applyPerspective)
206 {
207 double depth = 800;
208 WebTransformOperations operations;
209 operations.appendPerspective(depth);
210 WebTransformationMatrix expected;
211 expected.applyPerspective(depth);
212 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.apply());
213 }
214
215 TEST(WebTransformOperationTest, applyMatrix)
216 {
217 double dx = 1;
218 double dy = 2;
219 double dz = 3;
220 WebTransformationMatrix expectedMatrix;
221 expectedMatrix.translate3d(dx, dy, dz);
222 WebTransformOperations matrixTransform;
223 matrixTransform.appendMatrix(expectedMatrix);
224 EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, matrixTransform.apply());
225 }
226
227 TEST(WebTransformOperationTest, applyOrder)
228 {
229 double sx = 2;
230 double sy = 4;
231 double sz = 8;
232
233 double dx = 1;
234 double dy = 2;
235 double dz = 3;
236
237 WebTransformOperations operations;
238 operations.appendScale(sx, sy, sz);
239 operations.appendTranslate(dx, dy, dz);
240
241 WebTransformationMatrix expectedScaleMatrix;
242 expectedScaleMatrix.scale3d(sx, sy, sz);
243
244 WebTransformationMatrix expectedTranslateMatrix;
245 expectedTranslateMatrix.translate3d(dx, dy, dz);
246
247 WebTransformationMatrix expectedCombinedMatrix = expectedScaleMatrix;
248 expectedCombinedMatrix.multiply(expectedTranslateMatrix);
249
250 EXPECT_TRANSFORMATION_MATRIX_EQ(expectedCombinedMatrix, operations.apply());
251 }
252
253 TEST(WebTransformOperationTest, blendOrder)
254 {
255 double sx1 = 2;
256 double sy1 = 4;
257 double sz1 = 8;
258
259 double dx1 = 1;
260 double dy1 = 2;
261 double dz1 = 3;
262
263 double sx2 = 4;
264 double sy2 = 8;
265 double sz2 = 16;
266
267 double dx2 = 10;
268 double dy2 = 20;
269 double dz2 = 30;
270
271 WebTransformOperations operationsFrom;
272 operationsFrom.appendScale(sx1, sy1, sz1);
273 operationsFrom.appendTranslate(dx1, dy1, dz1);
274
275 WebTransformOperations operationsTo;
276 operationsTo.appendScale(sx2, sy2, sz2);
277 operationsTo.appendTranslate(dx2, dy2, dz2);
278
279 WebTransformationMatrix scaleFrom;
280 scaleFrom.scale3d(sx1, sy1, sz1);
281 WebTransformationMatrix translateFrom;
282 translateFrom.translate3d(dx1, dy1, dz1);
283
284 WebTransformationMatrix scaleTo;
285 scaleTo.scale3d(sx2, sy2, sz2);
286 WebTransformationMatrix translateTo;
287 translateTo.translate3d(dx2, dy2, dz2);
288
289 double progress = 0.25;
290
291 WebTransformationMatrix blendedScale = scaleTo;
292 blendedScale.blend(scaleFrom, progress);
293
294 WebTransformationMatrix blendedTranslate = translateTo;
295 blendedTranslate.blend(translateFrom, progress);
296
297 WebTransformationMatrix expected = blendedScale;
298 expected.multiply(blendedTranslate);
299
300 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));
301 }
302
303 static void checkProgress(double progress,
304 const WebTransformationMatrix& fromMatrix,
305 const WebTransformationMatrix& toMatrix,
306 const WebTransformOperations& fromTransform,
307 const WebTransformOperations& toTransform)
308 {
309 WebTransformationMatrix expectedMatrix = toMatrix;
310 expectedMatrix.blend(fromMatrix, progress);
311 EXPECT_TRANSFORMATION_MATRIX_EQ(expectedMatrix, toTransform.blend(fromTransf orm, progress));
312 }
313
314 TEST(WebTransformOperationTest, blendProgress)
315 {
316 double sx = 2;
317 double sy = 4;
318 double sz = 8;
319 WebTransformOperations operationsFrom;
320 operationsFrom.appendScale(sx, sy, sz);
321
322 WebTransformationMatrix matrixFrom;
323 matrixFrom.scale3d(sx, sy, sz);
324
325 sx = 4;
326 sy = 8;
327 sz = 16;
328 WebTransformOperations operationsTo;
329 operationsTo.appendScale(sx, sy, sz);
330
331 WebTransformationMatrix matrixTo;
332 matrixTo.scale3d(sx, sy, sz);
333
334 checkProgress(-1, matrixFrom, matrixTo, operationsFrom, operationsTo);
335 checkProgress(0, matrixFrom, matrixTo, operationsFrom, operationsTo);
336 checkProgress(0.25, matrixFrom, matrixTo, operationsFrom, operationsTo);
337 checkProgress(0.5, matrixFrom, matrixTo, operationsFrom, operationsTo);
338 checkProgress(1, matrixFrom, matrixTo, operationsFrom, operationsTo);
339 checkProgress(2, matrixFrom, matrixTo, operationsFrom, operationsTo);
340 }
341
342 TEST(WebTransformOperationTest, blendWhenTypesDoNotMatch)
343 {
344 double sx1 = 2;
345 double sy1 = 4;
346 double sz1 = 8;
347
348 double dx1 = 1;
349 double dy1 = 2;
350 double dz1 = 3;
351
352 double sx2 = 4;
353 double sy2 = 8;
354 double sz2 = 16;
355
356 double dx2 = 10;
357 double dy2 = 20;
358 double dz2 = 30;
359
360 WebTransformOperations operationsFrom;
361 operationsFrom.appendScale(sx1, sy1, sz1);
362 operationsFrom.appendTranslate(dx1, dy1, dz1);
363
364 WebTransformOperations operationsTo;
365 operationsTo.appendTranslate(dx2, dy2, dz2);
366 operationsTo.appendScale(sx2, sy2, sz2);
367
368 WebTransformationMatrix from;
369 from.scale3d(sx1, sy1, sz1);
370 from.translate3d(dx1, dy1, dz1);
371
372 WebTransformationMatrix to;
373 to.translate3d(dx2, dy2, dz2);
374 to.scale3d(sx2, sy2, sz2);
375
376 double progress = 0.25;
377
378 WebTransformationMatrix expected = to;
379 expected.blend(from, progress);
380
381 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));
382 }
383
384 TEST(WebTransformOperationTest, largeRotationsWithSameAxis)
385 {
386 WebTransformOperations operationsFrom;
387 operationsFrom.appendRotate(0, 0, 1, 0);
388
389 WebTransformOperations operationsTo;
390 operationsTo.appendRotate(0, 0, 2, 360);
391
392 double progress = 0.5;
393
394 WebTransformationMatrix expected;
395 expected.rotate3d(0, 0, 1, 180);
396
397 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));
398 }
399
400 TEST(WebTransformOperationTest, largeRotationsWithSameAxisInDifferentDirection)
401 {
402 WebTransformOperations operationsFrom;
403 operationsFrom.appendRotate(0, 0, 1, 180);
404
405 WebTransformOperations operationsTo;
406 operationsTo.appendRotate(0, 0, -1, 180);
407
408 double progress = 0.5;
409
410 WebTransformationMatrix expected;
411
412 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));
413 }
414
415 TEST(WebTransformOperationTest, largeRotationsWithDifferentAxes)
416 {
417 WebTransformOperations operationsFrom;
418 operationsFrom.appendRotate(0, 0, 1, 180);
419
420 WebTransformOperations operationsTo;
421 operationsTo.appendRotate(0, 1, 0, 180);
422
423 double progress = 0.5;
424 WebTransformationMatrix matrixFrom;
425 matrixFrom.rotate3d(0, 0, 1, 180);
426
427 WebTransformationMatrix matrixTo;
428 matrixTo.rotate3d(0, 1, 0, 180);
429
430 WebTransformationMatrix expected = matrixTo;
431 expected.blend(matrixFrom, progress);
432
433 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operationsTo.blend(operationsFrom, progress));
434 }
435
436 TEST(WebTransformOperationTest, blendRotationFromIdentity)
437 {
438 Vector<OwnPtr<WebTransformOperations> > identityOperations;
439 getIdentityOperations(&identityOperations);
440
441 for (size_t i = 0; i < identityOperations.size(); ++i) {
442 WebTransformOperations operations;
443 operations.appendRotate(0, 0, 1, 360);
444
445 double progress = 0.5;
446
447 WebTransformationMatrix expected;
448 expected.rotate3d(0, 0, 1, 180);
449
450 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOper ations[i], progress));
451 }
452 }
453
454 TEST(WebTransformOperationTest, blendTranslationFromIdentity)
455 {
456 Vector<OwnPtr<WebTransformOperations> > identityOperations;
457 getIdentityOperations(&identityOperations);
458
459 for (size_t i = 0; i < identityOperations.size(); ++i) {
460 WebTransformOperations operations;
461 operations.appendTranslate(2, 2, 2);
462
463 double progress = 0.5;
464
465 WebTransformationMatrix expected;
466 expected.translate3d(1, 1, 1);
467
468 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOper ations[i], progress));
469 }
470 }
471
472 TEST(WebTransformOperationTest, blendScaleFromIdentity)
473 {
474 Vector<OwnPtr<WebTransformOperations> > identityOperations;
475 getIdentityOperations(&identityOperations);
476
477 for (size_t i = 0; i < identityOperations.size(); ++i) {
478 WebTransformOperations operations;
479 operations.appendScale(3, 3, 3);
480
481 double progress = 0.5;
482
483 WebTransformationMatrix expected;
484 expected.scale3d(2, 2, 2);
485
486 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOper ations[i], progress));
487 }
488 }
489
490 TEST(WebTransformOperationTest, blendSkewFromIdentity)
491 {
492 Vector<OwnPtr<WebTransformOperations> > identityOperations;
493 getIdentityOperations(&identityOperations);
494
495 for (size_t i = 0; i < identityOperations.size(); ++i) {
496 WebTransformOperations operations;
497 operations.appendSkew(2, 2);
498
499 double progress = 0.5;
500
501 WebTransformationMatrix expected;
502 expected.skewX(1);
503 expected.skewY(1);
504
505 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOper ations[i], progress));
506 }
507 }
508
509 TEST(WebTransformOperationTest, blendPerspectiveFromIdentity)
510 {
511 Vector<OwnPtr<WebTransformOperations> > identityOperations;
512 getIdentityOperations(&identityOperations);
513
514 for (size_t i = 0; i < identityOperations.size(); ++i) {
515 WebTransformOperations operations;
516 operations.appendPerspective(1000);
517
518 double progress = 0.5;
519
520 WebTransformationMatrix expected;
521 expected.applyPerspective(500 + 0.5 * numeric_limits<double>::max());
522
523 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.blend(*identityOper ations[i], progress));
524 }
525 }
526
527 TEST(WebTransformOperationTest, blendRotationToIdentity)
528 {
529 Vector<OwnPtr<WebTransformOperations> > identityOperations;
530 getIdentityOperations(&identityOperations);
531
532 for (size_t i = 0; i < identityOperations.size(); ++i) {
533 WebTransformOperations operations;
534 operations.appendRotate(0, 0, 1, 360);
535
536 double progress = 0.5;
537
538 WebTransformationMatrix expected;
539 expected.rotate3d(0, 0, 1, 180);
540
541 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(o perations, progress));
542 }
543 }
544
545 TEST(WebTransformOperationTest, blendTranslationToIdentity)
546 {
547 Vector<OwnPtr<WebTransformOperations> > identityOperations;
548 getIdentityOperations(&identityOperations);
549
550 for (size_t i = 0; i < identityOperations.size(); ++i) {
551 WebTransformOperations operations;
552 operations.appendTranslate(2, 2, 2);
553
554 double progress = 0.5;
555
556 WebTransformationMatrix expected;
557 expected.translate3d(1, 1, 1);
558
559 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(o perations, progress));
560 }
561 }
562
563 TEST(WebTransformOperationTest, blendScaleToIdentity)
564 {
565 Vector<OwnPtr<WebTransformOperations> > identityOperations;
566 getIdentityOperations(&identityOperations);
567
568 for (size_t i = 0; i < identityOperations.size(); ++i) {
569 WebTransformOperations operations;
570 operations.appendScale(3, 3, 3);
571
572 double progress = 0.5;
573
574 WebTransformationMatrix expected;
575 expected.scale3d(2, 2, 2);
576
577 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(o perations, progress));
578 }
579 }
580
581 TEST(WebTransformOperationTest, blendSkewToIdentity)
582 {
583 Vector<OwnPtr<WebTransformOperations> > identityOperations;
584 getIdentityOperations(&identityOperations);
585
586 for (size_t i = 0; i < identityOperations.size(); ++i) {
587 WebTransformOperations operations;
588 operations.appendSkew(2, 2);
589
590 double progress = 0.5;
591
592 WebTransformationMatrix expected;
593 expected.skewX(1);
594 expected.skewY(1);
595
596 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(o perations, progress));
597 }
598 }
599
600 TEST(WebTransformOperationTest, blendPerspectiveToIdentity)
601 {
602 Vector<OwnPtr<WebTransformOperations> > identityOperations;
603 getIdentityOperations(&identityOperations);
604
605 for (size_t i = 0; i < identityOperations.size(); ++i) {
606 WebTransformOperations operations;
607 operations.appendPerspective(1000);
608
609 double progress = 0.5;
610
611 WebTransformationMatrix expected;
612 expected.applyPerspective(500 + 0.5 * numeric_limits<double>::max());
613
614 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, identityOperations[i]->blend(o perations, progress));
615 }
616 }
617
OLDNEW
« no previous file with comments | « webkit/compositor/WebTransformAnimationCurveTest.cpp ('k') | webkit/compositor/WebTransformationMatrixTest.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698