| OLD | NEW |
|---|
| (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 "CCDrawQuad.h" | |
| 8 | |
| 9 #include "CCCheckerboardDrawQuad.h" | |
| 10 #include "CCDebugBorderDrawQuad.h" | |
| 11 #include "CCGeometryTestUtils.h" | |
| 12 #include "CCIOSurfaceDrawQuad.h" | |
| 13 #include "CCRenderPassDrawQuad.h" | |
| 14 #include "CCSolidColorDrawQuad.h" | |
| 15 #include "CCStreamVideoDrawQuad.h" | |
| 16 #include "CCTextureDrawQuad.h" | |
| 17 #include "CCTileDrawQuad.h" | |
| 18 #include "CCYUVVideoDrawQuad.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 #include <public/WebTransformationMatrix.h> | |
| 21 | |
| 22 using WebKit::WebTransformationMatrix; | |
| 23 | |
| 24 using namespace cc; | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 TEST(CCDrawQuadTest, copySharedQuadState) | |
| 29 { | |
| 30 WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0); | |
| 31 IntRect visibleContentRect(10, 12, 14, 16); | |
| 32 IntRect clippedRectInTarget(19, 21, 23, 25); | |
| 33 float opacity = 0.25; | |
| 34 bool opaque = true; | |
| 35 int id = 3; | |
| 36 | |
| 37 scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform,
visibleContentRect, clippedRectInTarget, opacity, opaque)); | |
| 38 state->id = id; | |
| 39 | |
| 40 scoped_ptr<CCSharedQuadState> copy(state->copy()); | |
| 41 EXPECT_EQ(id, copy->id); | |
| 42 EXPECT_EQ(quadTransform, copy->quadTransform); | |
| 43 EXPECT_RECT_EQ(visibleContentRect, copy->visibleContentRect); | |
| 44 EXPECT_RECT_EQ(clippedRectInTarget, copy->clippedRectInTarget); | |
| 45 EXPECT_EQ(opacity, copy->opacity); | |
| 46 EXPECT_EQ(opaque, copy->opaque); | |
| 47 } | |
| 48 | |
| 49 scoped_ptr<CCSharedQuadState> createSharedQuadState() | |
| 50 { | |
| 51 WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0); | |
| 52 IntRect visibleContentRect(10, 12, 14, 16); | |
| 53 IntRect clippedRectInTarget(19, 21, 23, 25); | |
| 54 float opacity = 1; | |
| 55 bool opaque = false; | |
| 56 int id = 3; | |
| 57 | |
| 58 scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform,
visibleContentRect, clippedRectInTarget, opacity, opaque)); | |
| 59 state->id = id; | |
| 60 return state.Pass(); | |
| 61 } | |
| 62 | |
| 63 void compareDrawQuad(CCDrawQuad* quad, CCDrawQuad* copy, CCSharedQuadState* copy
SharedState) | |
| 64 { | |
| 65 EXPECT_EQ(quad->size(), copy->size()); | |
| 66 EXPECT_EQ(quad->material(), copy->material()); | |
| 67 EXPECT_EQ(quad->isDebugQuad(), copy->isDebugQuad()); | |
| 68 EXPECT_RECT_EQ(quad->quadRect(), copy->quadRect()); | |
| 69 EXPECT_RECT_EQ(quad->quadVisibleRect(), copy->quadVisibleRect()); | |
| 70 EXPECT_EQ(quad->opaqueRect(), copy->opaqueRect()); | |
| 71 EXPECT_EQ(quad->needsBlending(), copy->needsBlending()); | |
| 72 | |
| 73 EXPECT_EQ(copySharedState, copy->sharedQuadState()); | |
| 74 EXPECT_EQ(copySharedState->id, copy->sharedQuadStateId()); | |
| 75 | |
| 76 EXPECT_EQ(quad->sharedQuadStateId(), quad->sharedQuadState()->id); | |
| 77 EXPECT_EQ(copy->sharedQuadStateId(), copy->sharedQuadState()->id); | |
| 78 } | |
| 79 | |
| 80 #define CREATE_SHARED_STATE() \ | |
| 81 scoped_ptr<CCSharedQuadState> sharedState(createSharedQuadState()); \ | |
| 82 scoped_ptr<CCSharedQuadState> copySharedState(sharedState->copy()); \ | |
| 83 copySharedState->id = 5; | |
| 84 | |
| 85 #define QUAD_DATA \ | |
| 86 IntRect quadRect(30, 40, 50, 60); \ | |
| 87 IntRect quadVisibleRect(40, 50, 30, 20); \ | |
| 88 | |
| 89 #define SETUP_AND_COPY_QUAD(Type, quad) \ | |
| 90 quad->setQuadVisibleRect(quadVisibleRect); \ | |
| 91 scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get())); \ | |
| 92 compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \ | |
| 93 const Type* copyQuad = Type::materialCast(copy.get()); | |
| 94 | |
| 95 #define SETUP_AND_COPY_QUAD_1(Type, quad, a) \ | |
| 96 quad->setQuadVisibleRect(quadVisibleRect); \ | |
| 97 scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get(), a)); \ | |
| 98 compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \ | |
| 99 const Type* copyQuad = Type::materialCast(copy.get()); | |
| 100 | |
| 101 #define CREATE_QUAD_0(Type) \ | |
| 102 QUAD_DATA \ | |
| 103 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \ | |
| 104 SETUP_AND_COPY_QUAD(Type, quad); \ | |
| 105 UNUSED_PARAM(copyQuad); | |
| 106 | |
| 107 #define CREATE_QUAD_1(Type, a) \ | |
| 108 QUAD_DATA \ | |
| 109 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \ | |
| 110 SETUP_AND_COPY_QUAD(Type, quad); | |
| 111 | |
| 112 #define CREATE_QUAD_2(Type, a, b) \ | |
| 113 QUAD_DATA \ | |
| 114 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \ | |
| 115 SETUP_AND_COPY_QUAD(Type, quad); | |
| 116 | |
| 117 #define CREATE_QUAD_3(Type, a, b, c) \ | |
| 118 QUAD_DATA \ | |
| 119 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \ | |
| 120 SETUP_AND_COPY_QUAD(Type, quad); | |
| 121 | |
| 122 #define CREATE_QUAD_4(Type, a, b, c, d) \ | |
| 123 QUAD_DATA \ | |
| 124 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d))
; \ | |
| 125 SETUP_AND_COPY_QUAD(Type, quad); | |
| 126 | |
| 127 #define CREATE_QUAD_5(Type, a, b, c, d, e) \ | |
| 128 QUAD_DATA \ | |
| 129 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e)); \ | |
| 130 SETUP_AND_COPY_QUAD(Type, quad); | |
| 131 | |
| 132 #define CREATE_QUAD_6(Type, a, b, c, d, e, f) \ | |
| 133 QUAD_DATA \ | |
| 134 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f)); \ | |
| 135 SETUP_AND_COPY_QUAD(Type, quad); | |
| 136 | |
| 137 #define CREATE_QUAD_7(Type, a, b, c, d, e, f, g) \ | |
| 138 QUAD_DATA \ | |
| 139 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f, g)); \ | |
| 140 SETUP_AND_COPY_QUAD(Type, quad); | |
| 141 | |
| 142 #define CREATE_QUAD_8(Type, a, b, c, d, e, f, g, h) \ | |
| 143 QUAD_DATA \ | |
| 144 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f, g, h)); \ | |
| 145 SETUP_AND_COPY_QUAD(Type, quad); | |
| 146 | |
| 147 #define CREATE_QUAD_8_1(Type, a, b, c, d, e, f, g, h, copyA) \ | |
| 148 QUAD_DATA \ | |
| 149 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f, g, h)); \ | |
| 150 SETUP_AND_COPY_QUAD_1(Type, quad, copyA); | |
| 151 | |
| 152 #define CREATE_QUAD_9(Type, a, b, c, d, e, f, g, h, i) \ | |
| 153 QUAD_DATA \ | |
| 154 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f, g, h, i)); \ | |
| 155 SETUP_AND_COPY_QUAD(Type, quad); | |
| 156 | |
| 157 #define CREATE_QUAD_10(Type, a, b, c, d, e, f, g, h, i, j) \ | |
| 158 QUAD_DATA \ | |
| 159 scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d,
e, f, g, h, i, j)); \ | |
| 160 SETUP_AND_COPY_QUAD(Type, quad); | |
| 161 | |
| 162 TEST(CCDrawQuadTest, copyCheckerboardDrawQuad) | |
| 163 { | |
| 164 SkColor color = 0xfabb0011; | |
| 165 CREATE_SHARED_STATE(); | |
| 166 CREATE_QUAD_1(CCCheckerboardDrawQuad, color); | |
| 167 EXPECT_EQ(color, copyQuad->color()); | |
| 168 } | |
| 169 | |
| 170 TEST(CCDrawQuadTest, copyDebugBorderDrawQuad) | |
| 171 { | |
| 172 SkColor color = 0xfabb0011; | |
| 173 int width = 99; | |
| 174 CREATE_SHARED_STATE(); | |
| 175 CREATE_QUAD_2(CCDebugBorderDrawQuad, color, width); | |
| 176 EXPECT_EQ(color, copyQuad->color()); | |
| 177 EXPECT_EQ(width, copyQuad->width()); | |
| 178 } | |
| 179 | |
| 180 TEST(CCDrawQuadTest, copyIOSurfaceDrawQuad) | |
| 181 { | |
| 182 IntSize size(58, 95); | |
| 183 unsigned textureId = 72; | |
| 184 CCIOSurfaceDrawQuad::Orientation orientation = CCIOSurfaceDrawQuad::Unflippe
d; | |
| 185 | |
| 186 CREATE_SHARED_STATE(); | |
| 187 CREATE_QUAD_3(CCIOSurfaceDrawQuad, size, textureId, orientation); | |
| 188 EXPECT_EQ(size, copyQuad->ioSurfaceSize()); | |
| 189 EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId()); | |
| 190 EXPECT_EQ(orientation, copyQuad->orientation()); | |
| 191 } | |
| 192 | |
| 193 TEST(CCDrawQuadTest, copyRenderPassDrawQuad) | |
| 194 { | |
| 195 CCRenderPass::Id renderPassId(22, 64); | |
| 196 bool isReplica = true; | |
| 197 CCResourceProvider::ResourceId maskResourceId = 78; | |
| 198 IntRect contentsChangedSinceLastFrame(42, 11, 74, 24); | |
| 199 float maskTexCoordScaleX = 33; | |
| 200 float maskTexCoordScaleY = 19; | |
| 201 float maskTexCoordOffsetX = -45; | |
| 202 float maskTexCoordOffsetY = -21; | |
| 203 | |
| 204 CCRenderPass::Id copiedRenderPassId(235, 11); | |
| 205 | |
| 206 CREATE_SHARED_STATE(); | |
| 207 CREATE_QUAD_8_1(CCRenderPassDrawQuad, renderPassId, isReplica, maskResourceI
d, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTe
xCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId); | |
| 208 EXPECT_EQ(copiedRenderPassId, copyQuad->renderPassId()); | |
| 209 EXPECT_EQ(isReplica, copyQuad->isReplica()); | |
| 210 EXPECT_EQ(maskResourceId, copyQuad->maskResourceId()); | |
| 211 EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contentsChangedSince
LastFrame()); | |
| 212 EXPECT_EQ(maskTexCoordScaleX, copyQuad->maskTexCoordScaleX()); | |
| 213 EXPECT_EQ(maskTexCoordScaleY, copyQuad->maskTexCoordScaleY()); | |
| 214 EXPECT_EQ(maskTexCoordOffsetX, copyQuad->maskTexCoordOffsetX()); | |
| 215 EXPECT_EQ(maskTexCoordOffsetY, copyQuad->maskTexCoordOffsetY()); | |
| 216 } | |
| 217 | |
| 218 TEST(CCDrawQuadTest, copySolidColorDrawQuad) | |
| 219 { | |
| 220 SkColor color = 0x49494949; | |
| 221 | |
| 222 CREATE_SHARED_STATE(); | |
| 223 CREATE_QUAD_1(CCSolidColorDrawQuad, color); | |
| 224 EXPECT_EQ(color, copyQuad->color()); | |
| 225 } | |
| 226 | |
| 227 TEST(CCDrawQuadTest, copyStreamVideoDrawQuad) | |
| 228 { | |
| 229 unsigned textureId = 64; | |
| 230 WebTransformationMatrix matrix(0.5, 1, 0.25, 0.75, 0, 1); | |
| 231 | |
| 232 CREATE_SHARED_STATE(); | |
| 233 CREATE_QUAD_2(CCStreamVideoDrawQuad, textureId, matrix); | |
| 234 EXPECT_EQ(textureId, copyQuad->textureId()); | |
| 235 EXPECT_EQ(matrix, copyQuad->matrix()); | |
| 236 } | |
| 237 | |
| 238 TEST(CCDrawQuadTest, copyTextureDrawQuad) | |
| 239 { | |
| 240 unsigned resourceId = 82; | |
| 241 bool premultipliedAlpha = true; | |
| 242 FloatRect uvRect(0.5, 224, -51, 36); | |
| 243 bool flipped = true; | |
| 244 | |
| 245 CREATE_SHARED_STATE(); | |
| 246 CREATE_QUAD_4(CCTextureDrawQuad, resourceId, premultipliedAlpha, uvRect, fli
pped); | |
| 247 EXPECT_EQ(resourceId, copyQuad->resourceId()); | |
| 248 EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha()); | |
| 249 EXPECT_EQ(uvRect, copyQuad->uvRect()); | |
| 250 EXPECT_EQ(flipped, copyQuad->flipped()); | |
| 251 } | |
| 252 | |
| 253 TEST(CCDrawQuadTest, copyTileDrawQuad) | |
| 254 { | |
| 255 IntRect opaqueRect(33, 44, 22, 33); | |
| 256 unsigned resourceId = 104; | |
| 257 IntPoint textureOffset(-31, 47); | |
| 258 IntSize textureSize(85, 32); | |
| 259 GC3Dint textureFilter = 82; | |
| 260 bool swizzleContents = true; | |
| 261 bool leftEdgeAA = true; | |
| 262 bool topEdgeAA = true; | |
| 263 bool rightEdgeAA = false; | |
| 264 bool bottomEdgeAA = true; | |
| 265 | |
| 266 CREATE_SHARED_STATE(); | |
| 267 CREATE_QUAD_10(CCTileDrawQuad, opaqueRect, resourceId, textureOffset, textur
eSize, textureFilter, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, botto
mEdgeAA); | |
| 268 EXPECT_RECT_EQ(opaqueRect, copyQuad->opaqueRect()); | |
| 269 EXPECT_EQ(resourceId, copyQuad->resourceId()); | |
| 270 EXPECT_EQ(textureOffset, copyQuad->textureOffset()); | |
| 271 EXPECT_EQ(textureSize, copyQuad->textureSize()); | |
| 272 EXPECT_EQ(textureFilter, copyQuad->textureFilter()); | |
| 273 EXPECT_EQ(swizzleContents, copyQuad->swizzleContents()); | |
| 274 EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA()); | |
| 275 EXPECT_EQ(topEdgeAA, copyQuad->topEdgeAA()); | |
| 276 EXPECT_EQ(rightEdgeAA, copyQuad->rightEdgeAA()); | |
| 277 EXPECT_EQ(bottomEdgeAA, copyQuad->bottomEdgeAA()); | |
| 278 } | |
| 279 | |
| 280 TEST(CCDrawQuadTest, copyYUVVideoDrawQuad) | |
| 281 { | |
| 282 CCVideoLayerImpl::FramePlane yPlane; | |
| 283 yPlane.resourceId = 45; | |
| 284 yPlane.size = IntSize(34, 23); | |
| 285 yPlane.format = 8; | |
| 286 yPlane.visibleSize = IntSize(623, 235); | |
| 287 CCVideoLayerImpl::FramePlane uPlane; | |
| 288 uPlane.resourceId = 532; | |
| 289 uPlane.size = IntSize(134, 16); | |
| 290 uPlane.format = 2; | |
| 291 uPlane.visibleSize = IntSize(126, 27); | |
| 292 CCVideoLayerImpl::FramePlane vPlane; | |
| 293 vPlane.resourceId = 4; | |
| 294 vPlane.size = IntSize(456, 486); | |
| 295 vPlane.format = 46; | |
| 296 vPlane.visibleSize = IntSize(19, 45); | |
| 297 | |
| 298 CREATE_SHARED_STATE(); | |
| 299 CREATE_QUAD_3(CCYUVVideoDrawQuad, yPlane, uPlane, vPlane); | |
| 300 EXPECT_EQ(yPlane.resourceId, copyQuad->yPlane().resourceId); | |
| 301 EXPECT_EQ(yPlane.size, copyQuad->yPlane().size); | |
| 302 EXPECT_EQ(yPlane.format, copyQuad->yPlane().format); | |
| 303 EXPECT_EQ(yPlane.visibleSize, copyQuad->yPlane().visibleSize); | |
| 304 EXPECT_EQ(uPlane.resourceId, copyQuad->uPlane().resourceId); | |
| 305 EXPECT_EQ(uPlane.size, copyQuad->uPlane().size); | |
| 306 EXPECT_EQ(uPlane.format, copyQuad->uPlane().format); | |
| 307 EXPECT_EQ(uPlane.visibleSize, copyQuad->uPlane().visibleSize); | |
| 308 EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId); | |
| 309 EXPECT_EQ(vPlane.size, copyQuad->vPlane().size); | |
| 310 EXPECT_EQ(vPlane.format, copyQuad->vPlane().format); | |
| 311 EXPECT_EQ(vPlane.visibleSize, copyQuad->vPlane().visibleSize); | |
| 312 } | |
| 313 | |
| 314 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 11108020:
[cc] Change cc_tests.gyp filenames to Chromium style (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src