| 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 "CCDelegatedRendererLayerImpl.h" | |
| 8 | |
| 9 #include "CCAppendQuadsData.h" | |
| 10 #include "CCGeometryTestUtils.h" | |
| 11 #include "CCLayerTreeHostImpl.h" | |
| 12 #include "CCQuadSink.h" | |
| 13 #include "CCRenderPassDrawQuad.h" | |
| 14 #include "CCRenderPassTestCommon.h" | |
| 15 #include "CCSingleThreadProxy.h" | |
| 16 #include "CCSolidColorDrawQuad.h" | |
| 17 #include "CCSolidColorLayerImpl.h" | |
| 18 #include "FakeWebCompositorOutputSurface.h" | |
| 19 #include "FakeWebGraphicsContext3D.h" | |
| 20 #include "MockCCQuadCuller.h" | |
| 21 #include "cc/scoped_ptr_vector.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 #include <public/WebTransformationMatrix.h> | |
| 24 | |
| 25 using WebKit::FakeWebCompositorOutputSurface; | |
| 26 using WebKit::FakeWebGraphicsContext3D; | |
| 27 using WebKit::WebTransformationMatrix; | |
| 28 | |
| 29 using namespace cc; | |
| 30 using namespace WebKitTests; | |
| 31 | |
| 32 namespace { | |
| 33 | |
| 34 class CCDelegatedRendererLayerImplTest : public testing::Test, public CCLayerTre
eHostImplClient { | |
| 35 public: | |
| 36 CCDelegatedRendererLayerImplTest() | |
| 37 { | |
| 38 CCLayerTreeSettings settings; | |
| 39 settings.minimumOcclusionTrackingSize = IntSize(); | |
| 40 | |
| 41 m_hostImpl = CCLayerTreeHostImpl::create(settings, this); | |
| 42 m_hostImpl->initializeRenderer(createContext()); | |
| 43 m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10)); | |
| 44 } | |
| 45 | |
| 46 // CCLayerTreeHostImplClient implementation. | |
| 47 virtual void didLoseContextOnImplThread() OVERRIDE { } | |
| 48 virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { } | |
| 49 virtual void onVSyncParametersChanged(double, double) OVERRIDE { } | |
| 50 virtual void onCanDrawStateChanged(bool) OVERRIDE { } | |
| 51 virtual void setNeedsRedrawOnImplThread() OVERRIDE { } | |
| 52 virtual void setNeedsCommitOnImplThread() OVERRIDE { } | |
| 53 virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<CCAnimat
ionEventsVector>, double wallClockTime) OVERRIDE { } | |
| 54 virtual void releaseContentsTexturesOnImplThread() OVERRIDE { } | |
| 55 | |
| 56 protected: | |
| 57 scoped_ptr<CCGraphicsContext> createContext() | |
| 58 { | |
| 59 return FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphi
csContext3D)).PassAs<CCGraphicsContext>(); | |
| 60 } | |
| 61 | |
| 62 DebugScopedSetImplThread m_alwaysImplThread; | |
| 63 DebugScopedSetMainThreadBlocked m_alwaysMainThreadBlocked; | |
| 64 | |
| 65 scoped_ptr<CCLayerTreeHostImpl> m_hostImpl; | |
| 66 }; | |
| 67 | |
| 68 static CCTestRenderPass* addRenderPass(ScopedPtrVector<CCRenderPass>& passList,
CCRenderPass::Id id, IntRect outputRect, WebTransformationMatrix rootTransform) | |
| 69 { | |
| 70 scoped_ptr<CCRenderPass> pass(CCRenderPass::create(id, outputRect, rootTrans
form)); | |
| 71 CCTestRenderPass* testPass = static_cast<CCTestRenderPass*>(pass.get()); | |
| 72 passList.append(pass.Pass()); | |
| 73 return testPass; | |
| 74 } | |
| 75 | |
| 76 static CCSolidColorDrawQuad* addQuad(CCTestRenderPass* pass, IntRect rect, SkCol
or color) | |
| 77 { | |
| 78 MockCCQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList()); | |
| 79 CCAppendQuadsData data(pass->id()); | |
| 80 CCSharedQuadState* sharedState = quadSink.useSharedQuadState(CCSharedQuadSta
te::create(WebTransformationMatrix(), rect, rect, 1, false)); | |
| 81 scoped_ptr<CCSolidColorDrawQuad> quad = CCSolidColorDrawQuad::create(sharedS
tate, rect, color); | |
| 82 CCSolidColorDrawQuad* quadPtr = quad.get(); | |
| 83 quadSink.append(quad.PassAs<CCDrawQuad>(), data); | |
| 84 return quadPtr; | |
| 85 } | |
| 86 | |
| 87 static void addRenderPassQuad(CCTestRenderPass* toPass, CCTestRenderPass* contri
butingPass) | |
| 88 { | |
| 89 MockCCQuadCuller quadSink(toPass->quadList(), toPass->sharedQuadStateList())
; | |
| 90 CCAppendQuadsData data(toPass->id()); | |
| 91 IntRect outputRect = contributingPass->outputRect(); | |
| 92 CCSharedQuadState* sharedState = quadSink.useSharedQuadState(CCSharedQuadSta
te::create(WebTransformationMatrix(), outputRect, outputRect, 1, false)); | |
| 93 scoped_ptr<CCRenderPassDrawQuad> quad = CCRenderPassDrawQuad::create(sharedS
tate, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0); | |
| 94 quadSink.append(quad.PassAs<CCDrawQuad>(), data); | |
| 95 } | |
| 96 | |
| 97 class CCDelegatedRendererLayerImplTestSimple : public CCDelegatedRendererLayerIm
plTest { | |
| 98 public: | |
| 99 CCDelegatedRendererLayerImplTestSimple() | |
| 100 : CCDelegatedRendererLayerImplTest() | |
| 101 { | |
| 102 scoped_ptr<CCLayerImpl> rootLayer = CCSolidColorLayerImpl::create(1).Pas
sAs<CCLayerImpl>(); | |
| 103 scoped_ptr<CCLayerImpl> layerBefore = CCSolidColorLayerImpl::create(2).P
assAs<CCLayerImpl>(); | |
| 104 scoped_ptr<CCLayerImpl> layerAfter = CCSolidColorLayerImpl::create(3).Pa
ssAs<CCLayerImpl>(); | |
| 105 scoped_ptr<CCDelegatedRendererLayerImpl> delegatedRendererLayer = CCDele
gatedRendererLayerImpl::create(4); | |
| 106 | |
| 107 m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100)); | |
| 108 rootLayer->setBounds(IntSize(100, 100)); | |
| 109 | |
| 110 layerBefore->setPosition(IntPoint(20, 20)); | |
| 111 layerBefore->setBounds(IntSize(14, 14)); | |
| 112 layerBefore->setContentBounds(IntSize(14, 14)); | |
| 113 layerBefore->setDrawsContent(true); | |
| 114 layerBefore->setForceRenderSurface(true); | |
| 115 | |
| 116 layerAfter->setPosition(IntPoint(5, 5)); | |
| 117 layerAfter->setBounds(IntSize(15, 15)); | |
| 118 layerAfter->setContentBounds(IntSize(15, 15)); | |
| 119 layerAfter->setDrawsContent(true); | |
| 120 layerAfter->setForceRenderSurface(true); | |
| 121 | |
| 122 delegatedRendererLayer->setPosition(IntPoint(3, 3)); | |
| 123 delegatedRendererLayer->setBounds(IntSize(10, 10)); | |
| 124 delegatedRendererLayer->setContentBounds(IntSize(10, 10)); | |
| 125 delegatedRendererLayer->setDrawsContent(true); | |
| 126 WebTransformationMatrix transform; | |
| 127 transform.translate(1, 1); | |
| 128 delegatedRendererLayer->setTransform(transform); | |
| 129 | |
| 130 ScopedPtrVector<CCRenderPass> delegatedRenderPasses; | |
| 131 CCTestRenderPass* pass1 = addRenderPass(delegatedRenderPasses, CCRenderP
ass::Id(9, 6), IntRect(6, 6, 6, 6), WebTransformationMatrix()); | |
| 132 addQuad(pass1, IntRect(0, 0, 6, 6), 33u); | |
| 133 CCTestRenderPass* pass2 = addRenderPass(delegatedRenderPasses, CCRenderP
ass::Id(9, 7), IntRect(7, 7, 7, 7), WebTransformationMatrix()); | |
| 134 addQuad(pass2, IntRect(0, 0, 7, 7), 22u); | |
| 135 addRenderPassQuad(pass2, pass1); | |
| 136 CCTestRenderPass* pass3 = addRenderPass(delegatedRenderPasses, CCRenderP
ass::Id(9, 8), IntRect(8, 8, 8, 8), WebTransformationMatrix()); | |
| 137 addRenderPassQuad(pass3, pass2); | |
| 138 delegatedRendererLayer->setRenderPasses(delegatedRenderPasses); | |
| 139 | |
| 140 // The RenderPasses should be taken by the layer. | |
| 141 EXPECT_EQ(0u, delegatedRenderPasses.size()); | |
| 142 | |
| 143 m_rootLayerPtr = rootLayer.get(); | |
| 144 m_layerBeforePtr = layerBefore.get(); | |
| 145 m_layerAfterPtr = layerAfter.get(); | |
| 146 m_delegatedRendererLayerPtr = delegatedRendererLayer.get(); | |
| 147 | |
| 148 // Force the delegated RenderPasses to come before the RenderPass from l
ayerAfter. | |
| 149 layerAfter->addChild(delegatedRendererLayer.PassAs<CCLayerImpl>()); | |
| 150 rootLayer->addChild(layerAfter.Pass()); | |
| 151 | |
| 152 // Get the RenderPass generated by layerBefore to come before the delega
ted RenderPasses. | |
| 153 rootLayer->addChild(layerBefore.Pass()); | |
| 154 | |
| 155 m_hostImpl->setRootLayer(rootLayer.Pass()); | |
| 156 } | |
| 157 | |
| 158 protected: | |
| 159 CCLayerImpl* m_rootLayerPtr; | |
| 160 CCLayerImpl* m_layerBeforePtr; | |
| 161 CCLayerImpl* m_layerAfterPtr; | |
| 162 CCDelegatedRendererLayerImpl* m_delegatedRendererLayerPtr; | |
| 163 }; | |
| 164 | |
| 165 TEST_F(CCDelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) | |
| 166 { | |
| 167 CCLayerTreeHostImpl::FrameData frame; | |
| 168 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 169 m_hostImpl->drawLayers(frame); | |
| 170 m_hostImpl->didDrawAllLayers(frame); | |
| 171 | |
| 172 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes. | |
| 173 ASSERT_EQ(5u, frame.renderPasses.size()); | |
| 174 | |
| 175 // The DelegatedRendererLayer should have added its contributing RenderPasse
s to the frame. | |
| 176 EXPECT_EQ(4, frame.renderPasses[1]->id().layerId); | |
| 177 EXPECT_EQ(1, frame.renderPasses[1]->id().index); | |
| 178 EXPECT_EQ(4, frame.renderPasses[2]->id().layerId); | |
| 179 EXPECT_EQ(2, frame.renderPasses[2]->id().index); | |
| 180 // And all other RenderPasses should be non-delegated. | |
| 181 EXPECT_NE(4, frame.renderPasses[0]->id().layerId); | |
| 182 EXPECT_EQ(0, frame.renderPasses[0]->id().index); | |
| 183 EXPECT_NE(4, frame.renderPasses[3]->id().layerId); | |
| 184 EXPECT_EQ(0, frame.renderPasses[3]->id().index); | |
| 185 EXPECT_NE(4, frame.renderPasses[4]->id().layerId); | |
| 186 EXPECT_EQ(0, frame.renderPasses[4]->id().index); | |
| 187 | |
| 188 // The DelegatedRendererLayer should have added its RenderPasses to the fram
e in order. | |
| 189 EXPECT_RECT_EQ(IntRect(6, 6, 6, 6), frame.renderPasses[1]->outputRect()); | |
| 190 EXPECT_RECT_EQ(IntRect(7, 7, 7, 7), frame.renderPasses[2]->outputRect()); | |
| 191 } | |
| 192 | |
| 193 TEST_F(CCDelegatedRendererLayerImplTestSimple, AddsQuadsToContributingRenderPass
es) | |
| 194 { | |
| 195 CCLayerTreeHostImpl::FrameData frame; | |
| 196 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 197 m_hostImpl->drawLayers(frame); | |
| 198 m_hostImpl->didDrawAllLayers(frame); | |
| 199 | |
| 200 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes. | |
| 201 ASSERT_EQ(5u, frame.renderPasses.size()); | |
| 202 | |
| 203 // The DelegatedRendererLayer should have added its contributing RenderPasse
s to the frame. | |
| 204 EXPECT_EQ(4, frame.renderPasses[1]->id().layerId); | |
| 205 EXPECT_EQ(1, frame.renderPasses[1]->id().index); | |
| 206 EXPECT_EQ(4, frame.renderPasses[2]->id().layerId); | |
| 207 EXPECT_EQ(2, frame.renderPasses[2]->id().index); | |
| 208 | |
| 209 // The DelegatedRendererLayer should have added copies of its quads to contr
ibuting RenderPasses. | |
| 210 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 211 EXPECT_RECT_EQ(IntRect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->qu
adRect()); | |
| 212 | |
| 213 // Verify it added the right quads. | |
| 214 ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size()); | |
| 215 EXPECT_RECT_EQ(IntRect(0, 0, 7, 7), frame.renderPasses[2]->quadList()[0]->qu
adRect()); | |
| 216 EXPECT_RECT_EQ(IntRect(6, 6, 6, 6), frame.renderPasses[2]->quadList()[1]->qu
adRect()); | |
| 217 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 218 EXPECT_RECT_EQ(IntRect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->qu
adRect()); | |
| 219 } | |
| 220 | |
| 221 TEST_F(CCDelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) | |
| 222 { | |
| 223 CCLayerTreeHostImpl::FrameData frame; | |
| 224 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 225 m_hostImpl->drawLayers(frame); | |
| 226 m_hostImpl->didDrawAllLayers(frame); | |
| 227 | |
| 228 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes. | |
| 229 ASSERT_EQ(5u, frame.renderPasses.size()); | |
| 230 | |
| 231 // The layer's target is the RenderPass from m_layerAfter. | |
| 232 EXPECT_EQ(CCRenderPass::Id(3, 0), frame.renderPasses[3]->id()); | |
| 233 | |
| 234 // The DelegatedRendererLayer should have added copies of quads in its root
RenderPass to its target RenderPass. | |
| 235 // The m_layerAfter also adds one quad. | |
| 236 ASSERT_EQ(2u, frame.renderPasses[3]->quadList().size()); | |
| 237 | |
| 238 // Verify it added the right quads. | |
| 239 EXPECT_RECT_EQ(IntRect(7, 7, 7, 7), frame.renderPasses[3]->quadList()[0]->qu
adRect()); | |
| 240 | |
| 241 // Its target layer should have a quad as well. | |
| 242 EXPECT_RECT_EQ(IntRect(0, 0, 15, 15), frame.renderPasses[3]->quadList()[1]->
quadRect()); | |
| 243 } | |
| 244 | |
| 245 TEST_F(CCDelegatedRendererLayerImplTestSimple, QuadsFromRootRenderPassAreModifie
dForTheTarget) | |
| 246 { | |
| 247 CCLayerTreeHostImpl::FrameData frame; | |
| 248 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 249 m_hostImpl->drawLayers(frame); | |
| 250 m_hostImpl->didDrawAllLayers(frame); | |
| 251 | |
| 252 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes. | |
| 253 ASSERT_EQ(5u, frame.renderPasses.size()); | |
| 254 | |
| 255 // The DelegatedRendererLayer is at position 3,3 compared to its target, and
has a translation transform of 1,1. | |
| 256 // So its root RenderPass' quads should all be transformed by that combined
amount. | |
| 257 WebTransformationMatrix transform; | |
| 258 transform.translate(4, 4); | |
| 259 EXPECT_TRANSFORMATION_MATRIX_EQ(transform, frame.renderPasses[3]->quadList()
[0]->quadTransform()); | |
| 260 | |
| 261 // Quads from non-root RenderPasses should not be shifted though. | |
| 262 ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size()); | |
| 263 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[2]->quadList()[0]->quadTransform()); | |
| 264 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[2]->quadList()[1]->quadTransform()); | |
| 265 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 266 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[1]->quadList()[0]->quadTransform()); | |
| 267 } | |
| 268 | |
| 269 class CCDelegatedRendererLayerImplTestOwnSurface : public CCDelegatedRendererLay
erImplTestSimple { | |
| 270 public: | |
| 271 CCDelegatedRendererLayerImplTestOwnSurface() | |
| 272 : CCDelegatedRendererLayerImplTestSimple() | |
| 273 { | |
| 274 m_delegatedRendererLayerPtr->setForceRenderSurface(true); | |
| 275 } | |
| 276 }; | |
| 277 | |
| 278 TEST_F(CCDelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) | |
| 279 { | |
| 280 CCLayerTreeHostImpl::FrameData frame; | |
| 281 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 282 m_hostImpl->drawLayers(frame); | |
| 283 m_hostImpl->didDrawAllLayers(frame); | |
| 284 | |
| 285 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes and its owned surface added one pass. | |
| 286 ASSERT_EQ(6u, frame.renderPasses.size()); | |
| 287 | |
| 288 // The DelegatedRendererLayer should have added its contributing RenderPasse
s to the frame. | |
| 289 EXPECT_EQ(4, frame.renderPasses[1]->id().layerId); | |
| 290 EXPECT_EQ(1, frame.renderPasses[1]->id().index); | |
| 291 EXPECT_EQ(4, frame.renderPasses[2]->id().layerId); | |
| 292 EXPECT_EQ(2, frame.renderPasses[2]->id().index); | |
| 293 // The DelegatedRendererLayer should have added a RenderPass for its surface
to the frame. | |
| 294 EXPECT_EQ(4, frame.renderPasses[1]->id().layerId); | |
| 295 EXPECT_EQ(0, frame.renderPasses[3]->id().index); | |
| 296 // And all other RenderPasses should be non-delegated. | |
| 297 EXPECT_NE(4, frame.renderPasses[0]->id().layerId); | |
| 298 EXPECT_EQ(0, frame.renderPasses[0]->id().index); | |
| 299 EXPECT_NE(4, frame.renderPasses[4]->id().layerId); | |
| 300 EXPECT_EQ(0, frame.renderPasses[4]->id().index); | |
| 301 EXPECT_NE(4, frame.renderPasses[5]->id().layerId); | |
| 302 EXPECT_EQ(0, frame.renderPasses[5]->id().index); | |
| 303 | |
| 304 // The DelegatedRendererLayer should have added its RenderPasses to the fram
e in order. | |
| 305 EXPECT_RECT_EQ(IntRect(6, 6, 6, 6), frame.renderPasses[1]->outputRect()); | |
| 306 EXPECT_RECT_EQ(IntRect(7, 7, 7, 7), frame.renderPasses[2]->outputRect()); | |
| 307 } | |
| 308 | |
| 309 TEST_F(CCDelegatedRendererLayerImplTestOwnSurface, AddsQuadsToContributingRender
Passes) | |
| 310 { | |
| 311 CCLayerTreeHostImpl::FrameData frame; | |
| 312 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 313 m_hostImpl->drawLayers(frame); | |
| 314 m_hostImpl->didDrawAllLayers(frame); | |
| 315 | |
| 316 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes and its owned surface added one pass. | |
| 317 ASSERT_EQ(6u, frame.renderPasses.size()); | |
| 318 | |
| 319 // The DelegatedRendererLayer should have added its contributing RenderPasse
s to the frame. | |
| 320 EXPECT_EQ(4, frame.renderPasses[1]->id().layerId); | |
| 321 EXPECT_EQ(1, frame.renderPasses[1]->id().index); | |
| 322 EXPECT_EQ(4, frame.renderPasses[2]->id().layerId); | |
| 323 EXPECT_EQ(2, frame.renderPasses[2]->id().index); | |
| 324 | |
| 325 // The DelegatedRendererLayer should have added copies of its quads to contr
ibuting RenderPasses. | |
| 326 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 327 EXPECT_RECT_EQ(IntRect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->qu
adRect()); | |
| 328 | |
| 329 // Verify it added the right quads. | |
| 330 ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size()); | |
| 331 EXPECT_RECT_EQ(IntRect(0, 0, 7, 7), frame.renderPasses[2]->quadList()[0]->qu
adRect()); | |
| 332 EXPECT_RECT_EQ(IntRect(6, 6, 6, 6), frame.renderPasses[2]->quadList()[1]->qu
adRect()); | |
| 333 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 334 EXPECT_RECT_EQ(IntRect(0, 0, 6, 6), frame.renderPasses[1]->quadList()[0]->qu
adRect()); | |
| 335 } | |
| 336 | |
| 337 TEST_F(CCDelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) | |
| 338 { | |
| 339 CCLayerTreeHostImpl::FrameData frame; | |
| 340 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 341 m_hostImpl->drawLayers(frame); | |
| 342 m_hostImpl->didDrawAllLayers(frame); | |
| 343 | |
| 344 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes and its owned surface added one pass. | |
| 345 ASSERT_EQ(6u, frame.renderPasses.size()); | |
| 346 | |
| 347 // The layer's target is the RenderPass owned by itself. | |
| 348 EXPECT_EQ(CCRenderPass::Id(4, 0), frame.renderPasses[3]->id()); | |
| 349 | |
| 350 // The DelegatedRendererLayer should have added copies of quads in its root
RenderPass to its target RenderPass. | |
| 351 // The m_layerAfter also adds one quad. | |
| 352 ASSERT_EQ(1u, frame.renderPasses[3]->quadList().size()); | |
| 353 | |
| 354 // Verify it added the right quads. | |
| 355 EXPECT_RECT_EQ(IntRect(7, 7, 7, 7), frame.renderPasses[3]->quadList()[0]->qu
adRect()); | |
| 356 } | |
| 357 | |
| 358 TEST_F(CCDelegatedRendererLayerImplTestOwnSurface, QuadsFromRootRenderPassAreNot
ModifiedForTheTarget) | |
| 359 { | |
| 360 CCLayerTreeHostImpl::FrameData frame; | |
| 361 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 362 m_hostImpl->drawLayers(frame); | |
| 363 m_hostImpl->didDrawAllLayers(frame); | |
| 364 | |
| 365 // Each non-DelegatedRendererLayer added one RenderPass. The DelegatedRender
erLayer added two contributing passes and its owned surface added one pass. | |
| 366 ASSERT_EQ(6u, frame.renderPasses.size()); | |
| 367 | |
| 368 // Because the DelegatedRendererLayer owns a RenderSurface, its root RenderP
ass' quads do not need to be | |
| 369 // modified at all. | |
| 370 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[3]->quadList()[0]->quadTransform()); | |
| 371 | |
| 372 // Quads from non-root RenderPasses should not be shifted though. | |
| 373 ASSERT_EQ(2u, frame.renderPasses[2]->quadList().size()); | |
| 374 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[2]->quadList()[0]->quadTransform()); | |
| 375 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[2]->quadList()[1]->quadTransform()); | |
| 376 ASSERT_EQ(1u, frame.renderPasses[1]->quadList().size()); | |
| 377 EXPECT_TRANSFORMATION_MATRIX_EQ(WebTransformationMatrix(), frame.renderPasse
s[1]->quadList()[0]->quadTransform()); | |
| 378 } | |
| 379 | |
| 380 class CCDelegatedRendererLayerImplTestSharedData : public CCDelegatedRendererLay
erImplTest { | |
| 381 public: | |
| 382 CCDelegatedRendererLayerImplTestSharedData() | |
| 383 : CCDelegatedRendererLayerImplTest() | |
| 384 { | |
| 385 scoped_ptr<CCLayerImpl> rootLayer = CCLayerImpl::create(1); | |
| 386 scoped_ptr<CCDelegatedRendererLayerImpl> delegatedRendererLayer = CCDele
gatedRendererLayerImpl::create(2); | |
| 387 | |
| 388 m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100)); | |
| 389 rootLayer->setBounds(IntSize(100, 100)); | |
| 390 | |
| 391 delegatedRendererLayer->setPosition(IntPoint(20, 20)); | |
| 392 delegatedRendererLayer->setBounds(IntSize(20, 20)); | |
| 393 delegatedRendererLayer->setContentBounds(IntSize(20, 20)); | |
| 394 delegatedRendererLayer->setDrawsContent(true); | |
| 395 WebTransformationMatrix transform; | |
| 396 transform.translate(10, 10); | |
| 397 delegatedRendererLayer->setTransform(transform); | |
| 398 | |
| 399 ScopedPtrVector<CCRenderPass> delegatedRenderPasses; | |
| 400 IntRect passRect(0, 0, 50, 50); | |
| 401 CCTestRenderPass* pass = addRenderPass(delegatedRenderPasses, CCRenderPa
ss::Id(9, 6), passRect, WebTransformationMatrix()); | |
| 402 MockCCQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList())
; | |
| 403 CCAppendQuadsData data(pass->id()); | |
| 404 CCSharedQuadState* sharedState = quadSink.useSharedQuadState(CCSharedQua
dState::create(WebTransformationMatrix(), passRect, passRect, 1, false)); | |
| 405 quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(0, 0,
10, 10), 1u).PassAs<CCDrawQuad>(), data); | |
| 406 quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(0, 10,
10, 10), 2u).PassAs<CCDrawQuad>(), data); | |
| 407 quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(10, 0,
10, 10), 3u).PassAs<CCDrawQuad>(), data); | |
| 408 quadSink.append(CCSolidColorDrawQuad::create(sharedState, IntRect(10, 10
, 10, 10), 4u).PassAs<CCDrawQuad>(), data); | |
| 409 delegatedRendererLayer->setRenderPasses(delegatedRenderPasses); | |
| 410 | |
| 411 // The RenderPasses should be taken by the layer. | |
| 412 EXPECT_EQ(0u, delegatedRenderPasses.size()); | |
| 413 | |
| 414 m_rootLayerPtr = rootLayer.get(); | |
| 415 m_delegatedRendererLayerPtr = delegatedRendererLayer.get(); | |
| 416 | |
| 417 rootLayer->addChild(delegatedRendererLayer.PassAs<CCLayerImpl>()); | |
| 418 | |
| 419 m_hostImpl->setRootLayer(rootLayer.Pass()); | |
| 420 } | |
| 421 | |
| 422 protected: | |
| 423 CCLayerImpl* m_rootLayerPtr; | |
| 424 CCDelegatedRendererLayerImpl* m_delegatedRendererLayerPtr; | |
| 425 }; | |
| 426 | |
| 427 TEST_F(CCDelegatedRendererLayerImplTestSharedData, SharedData) | |
| 428 { | |
| 429 CCLayerTreeHostImpl::FrameData frame; | |
| 430 EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); | |
| 431 m_hostImpl->drawLayers(frame); | |
| 432 m_hostImpl->didDrawAllLayers(frame); | |
| 433 | |
| 434 ASSERT_EQ(1u, frame.renderPasses.size()); | |
| 435 EXPECT_EQ(1, frame.renderPasses[0]->id().layerId); | |
| 436 EXPECT_EQ(0, frame.renderPasses[0]->id().index); | |
| 437 | |
| 438 const CCQuadList& quadList = frame.renderPasses[0]->quadList(); | |
| 439 ASSERT_EQ(4u, quadList.size()); | |
| 440 | |
| 441 // All quads should share the same state. | |
| 442 const CCSharedQuadState* sharedState = quadList[0]->sharedQuadState(); | |
| 443 EXPECT_EQ(sharedState, quadList[1]->sharedQuadState()); | |
| 444 EXPECT_EQ(sharedState, quadList[2]->sharedQuadState()); | |
| 445 EXPECT_EQ(sharedState, quadList[3]->sharedQuadState()); | |
| 446 | |
| 447 // The state should be transformed only once. | |
| 448 EXPECT_RECT_EQ(IntRect(30, 30, 50, 50), sharedState->clippedRectInTarget); | |
| 449 WebTransformationMatrix expected; | |
| 450 expected.translate(30, 30); | |
| 451 EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->quadTransform); | |
| 452 } | |
| 453 | |
| 454 } // 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