From ecc12621a9594424a2ea7347b13e71888fd3c308 Mon Sep 17 00:00:00 2001 From: "shawnsingh@chromium.org" Date: Tue, 30 Oct 2012 20:45:42 +0000 Subject: Remove root layer specialness in calculateDrawTransforms This patch is step 2 in removing root layer specialness. The previous patch removed root layer specialness from code outside of CCLayerTreeHostCommon, this patch removes it from within CCLayerTreeHostCommon. One subtle semantics change occurs with this patch, that only affects tests and not real-world code: The root renderSurface now re-parents the root layer's drawTransform. In practice, the root layer's drawTransform is always an identity matrix, so it does not matter. BUG=154442 Review URL: https://chromiumcodereview.appspot.com/11276061 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@165000 0039d316-1c4b-4281-b951-d872f2087c98 --- cc/layer_tree_host_common.cc | 122 ++++++++++++++++++---------------- cc/layer_tree_host_common_unittest.cc | 94 ++++++++++++++++---------- cc/layer_tree_host_impl_unittest.cc | 45 +++++++------ cc/layer_tree_host_unittest.cc | 102 ++++++++++++++++------------ cc/test/layer_test_common.cc | 25 ++++++- cc/test/layer_tree_test_common.cc | 10 +-- cc/test/layer_tree_test_common.h | 4 +- 7 files changed, 237 insertions(+), 165 deletions(-) (limited to 'cc') diff --git a/cc/layer_tree_host_common.cc b/cc/layer_tree_host_common.cc index 92b44d1..b51fd00 100644 --- a/cc/layer_tree_host_common.cc +++ b/cc/layer_tree_host_common.cc @@ -53,6 +53,12 @@ IntRect LayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRe return layerRect; } +template +static inline bool isRootLayer(LayerType* layer) +{ + return !layer->parent(); +} + template static inline bool layerIsInExisting3DRenderingContext(LayerType* layer) { @@ -62,7 +68,7 @@ static inline bool layerIsInExisting3DRenderingContext(LayerType* layer) } template -static bool layerIsRootOfNewRenderingContext(LayerType* layer) +static bool isRootLayerOfNewRenderingContext(LayerType* layer) { // According to current W3C spec on CSS transforms (Section 6.1), a layer is the // beginning of 3d rendering context if its parent does not have transform-style: @@ -95,7 +101,7 @@ static bool isSurfaceBackFaceVisible(LayerType* layer, const WebTransformationMa if (layerIsInExisting3DRenderingContext(layer)) return drawTransform.isBackFaceVisible(); - if (layerIsRootOfNewRenderingContext(layer)) + if (isRootLayerOfNewRenderingContext(layer)) return layer->transform().isBackFaceVisible(); // If the renderSurface is not part of a new or existing rendering context, then the @@ -218,18 +224,14 @@ static inline bool subtreeShouldBeSkipped(Layer* layer) template static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent) { - // The root layer has a special render surface that is set up externally, so - // it shouldn't be treated as a surface in this code. - if (!layer->parent()) - return false; - - // Cache this value, because otherwise it walks the entire subtree several times. - bool descendantDrawsContent = layer->descendantDrawsContent(); - // // A layer and its descendants should render onto a new RenderSurfaceImpl if any of these rules hold: // + // The root layer should always have a renderSurface. + if (isRootLayer(layer)) + return true; + // If we force it. if (layer->forceRenderSurface()) return true; @@ -246,6 +248,9 @@ static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlig if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty() || layer->filter()) return true; + // Cache this value, because otherwise it walks the entire subtree several times. + bool descendantDrawsContent = layer->descendantDrawsContent(); + // If the layer flattens its subtree (i.e. the layer doesn't preserve-3d), but it is // treated as a 3D object by its parent (i.e. parent does preserve-3d). if (layerIsInExisting3DRenderingContext(layer) && !layer->preserves3D() && descendantDrawsContent) @@ -307,8 +312,8 @@ WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerImpl* la // it is fixed to an ancestor, and is a container for any fixed-position descendants. // - A layer that is a fixed-position container and has a renderSurface should behave the same as a container // without a renderSurface, the renderSurface is irrelevant in that case. - // - A layer that does not have an explicit container is simply fixed to the viewport - // (i.e. the root renderSurface, and it would still compensate for root layer's scrollDelta). + // - A layer that does not have an explicit container is simply fixed to the viewport. + // (i.e. the root renderSurface.) // - If the fixed-position layer has its own renderSurface, then the renderSurface is // the one who gets fixed. // @@ -377,24 +382,10 @@ static inline void updateLayerContentsScale(Layer* layer, const WebTransformatio replicaMaskLayer->setContentsScale(contentsScale); } -// Should be called just before the recursive calculateDrawTransformsInternal(). -template -void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize) -{ - if (!rootLayer->renderSurface()) - rootLayer->createRenderSurface(); - - rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize)); - rootLayer->renderSurface()->clearLayerLists(); - - DCHECK(renderSurfaceLayerList.empty()); - renderSurfaceLayerList.push_back(rootLayer); -} - // Recursively walks the layer tree starting at the given node and computes all the // necessary transformations, clipRects, render surfaces, etc. template -static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix, +static void calculateDrawTransformsInternal(LayerType* layer, const WebTransformationMatrix& parentMatrix, const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix, const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree, RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList, @@ -485,7 +476,8 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty. drawableContentRectOfSubtree = IntRect(); - if (subtreeShouldBeSkipped(layer)) + // The root layer cannot skip calcDrawTransforms. + if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer)) return; IntRect clipRectForSubtree; @@ -642,6 +634,8 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay renderSurfaceLayerList.push_back(layer); } else { + DCHECK(layer->parent()); + layer->setDrawTransform(drawTransform); layer->setDrawTransformIsAnimating(animatingTransformToTarget); layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen); @@ -650,25 +644,15 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay layer->setDrawOpacity(drawOpacity); layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating); - if (layer != rootLayer) { - DCHECK(layer->parent()); - layer->clearRenderSurface(); + layer->clearRenderSurface(); - // Layers without renderSurfaces directly inherit the ancestor's clip status. - subtreeShouldBeClipped = ancestorClipsSubtree; - if (ancestorClipsSubtree) - clipRectForSubtree = clipRectFromAncestor; - - // Layers that are not their own renderTarget will render into the target of their nearest ancestor. - layer->setRenderTarget(layer->parent()->renderTarget()); - } else { - // FIXME: This root layer special case code should eventually go away. https://bugs.webkit.org/show_bug.cgi?id=92290 - DCHECK(!layer->parent()); - DCHECK(layer->renderSurface()); - DCHECK(ancestorClipsSubtree); - layer->renderSurface()->setClipRect(clipRectFromAncestor); - subtreeShouldBeClipped = false; - } + // Layers without renderSurfaces directly inherit the ancestor's clip status. + subtreeShouldBeClipped = ancestorClipsSubtree; + if (ancestorClipsSubtree) + clipRectForSubtree = clipRectFromAncestor; + + // Layers that are not their own renderTarget will render into the target of their nearest ancestor. + layer->setRenderTarget(layer->parent()->renderTarget()); } IntRect rectInTargetSpace = enclosingIntRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect)); @@ -705,7 +689,7 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay for (size_t i = 0; i < layer->children().size(); ++i) { LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i); IntRect drawableContentRectOfChildSubtree; - calculateDrawTransformsInternal(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix, + calculateDrawTransformsInternal(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix, clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels, renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree); if (!drawableContentRectOfChildSubtree.isEmpty()) { @@ -733,7 +717,11 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay layer->setVisibleContentRect(visibleContentRectOfLayer); // Compute the remaining properties for the render surface, if the layer has one. - if (layer->renderSurface() && layer != rootLayer) { + if (isRootLayer(layer)) { + // The root layer's surface's contentRect is always the entire viewport. + DCHECK(layer->renderSurface()); + layer->renderSurface()->setContentRect(clipRectFromAncestor); + } else if (layer->renderSurface() && !isRootLayer(layer)) { RenderSurfaceType* renderSurface = layer->renderSurface(); IntRect clippedContentRect = localDrawableContentRectOfSubtree; @@ -830,14 +818,25 @@ void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const IntSiz WebTransformationMatrix identityMatrix; WebTransformationMatrix deviceScaleTransform; deviceScaleTransform.scale(deviceScaleFactor); + std::vector > dummyLayerList; + + // The root layer's renderSurface should receive the deviceViewport as the initial clipRect. + bool subtreeShouldBeClipped = true; + IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize); - setupRootLayerAndSurfaceForRecursion > >(rootLayer, renderSurfaceLayerList, deviceViewportSize); + // This function should have received a root layer. + DCHECK(isRootLayer(rootLayer)); cc::calculateDrawTransformsInternal >, RenderSurface, void>( - rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, - rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList, - rootLayer->renderSurface()->layerList(), 0, maxTextureSize, + rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, + deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList, + dummyLayerList, 0, maxTextureSize, deviceScaleFactor, pageScaleFactor, totalDrawableContentRect); + + // The dummy layer list should not have been used. + DCHECK(dummyLayerList.size() == 0); + // A root layer renderSurface should always exist after calculateDrawTransforms. + DCHECK(rootLayer->renderSurface()); } void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector& renderSurfaceLayerList) @@ -846,14 +845,25 @@ void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const In WebTransformationMatrix identityMatrix; WebTransformationMatrix deviceScaleTransform; deviceScaleTransform.scale(deviceScaleFactor); + std::vector dummyLayerList; + + // The root layer's renderSurface should receive the deviceViewport as the initial clipRect. + bool subtreeShouldBeClipped = true; + IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize); - setupRootLayerAndSurfaceForRecursion >(rootLayer, renderSurfaceLayerList, deviceViewportSize); + // This function should have received a root layer. + DCHECK(isRootLayer(rootLayer)); cc::calculateDrawTransformsInternal, RenderSurfaceImpl, LayerSorter>( - rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, - rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList, - rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, + rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, + deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList, + dummyLayerList, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, totalDrawableContentRect); + + // The dummy layer list should not have been used. + DCHECK(dummyLayerList.size() == 0); + // A root layer renderSurface should always exist after calculateDrawTransforms. + DCHECK(rootLayer->renderSurface()); } static bool pointHitsRect(const IntPoint& screenSpacePoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect) diff --git a/cc/layer_tree_host_common_unittest.cc b/cc/layer_tree_host_common_unittest.cc index 8e924f6..cf864f9 100644 --- a/cc/layer_tree_host_common_unittest.cc +++ b/cc/layer_tree_host_common_unittest.cc @@ -173,11 +173,15 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) WebTransformationMatrix identityMatrix; scoped_refptr layer = Layer::create(); + scoped_refptr root = Layer::create(); + setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(1, 2), false); + root->addChild(layer); + // Case 1: setting the sublayer transform should not affect this layer's draw transform or screen-space transform. WebTransformationMatrix arbitraryTranslation; arbitraryTranslation.translate(10, 20); setLayerPropertiesForTesting(layer.get(), identityMatrix, arbitraryTranslation, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); WebTransformationMatrix expectedDrawTransform = identityMatrix; EXPECT_TRANSFORMATION_MATRIX_EQ(expectedDrawTransform, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform()); @@ -186,13 +190,13 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) WebTransformationMatrix translationToCenter; translationToCenter.translate(5, 6); setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform()); // Case 3: The anchor point by itself (without a layer transform) should have no effect on the transforms. setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform()); @@ -200,7 +204,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) WebTransformationMatrix positionTransform; positionTransform.translate(0, 1.2); setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 1.2f), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->screenSpaceTransform()); @@ -209,7 +213,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) WebTransformationMatrix layerTransform; layerTransform.scale3d(2, 2, 1); setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->screenSpaceTransform()); @@ -218,7 +222,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) translationToAnchor.translate(5, 0); WebTransformationMatrix expectedResult = translationToAnchor * layerTransform * translationToAnchor.inverse(); setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0.5, 0), FloatPoint(0, 0), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform()); @@ -227,7 +231,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) // still worth testing to detect accidental regressions. expectedResult = positionTransform * translationToAnchor * layerTransform * translationToAnchor.inverse(); setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, FloatPoint(0.5, 0), FloatPoint(0, 1.2f), IntSize(10, 12), false); - executeCalculateDrawTransformsAndVisibility(layer.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform()); } @@ -235,17 +239,22 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer) TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) { WebTransformationMatrix identityMatrix; + scoped_refptr root = Layer::create(); scoped_refptr parent = Layer::create(); scoped_refptr child = Layer::create(); scoped_refptr grandChild = Layer::create(); + root->addChild(parent); parent->addChild(child); child->addChild(grandChild); + // One-time setup of root layer + setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(1, 2), false); + // Case 1: parent's anchorPoint should not affect child or grandChild. setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(76, 78), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->screenSpaceTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform()); @@ -257,7 +266,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 1.2f), IntSize(10, 12), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(76, 78), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->screenSpaceTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, grandChild->drawTransform()); @@ -272,7 +281,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) setLayerPropertiesForTesting(parent.get(), parentLayerTransform, identityMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(76, 78), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->drawTransform()); @@ -293,7 +302,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(76, 78), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->drawTransform()); @@ -304,7 +313,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), true); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(76, 78), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->drawTransform()); @@ -313,16 +322,21 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy) TEST(LayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface) { + scoped_refptr root = Layer::create(); scoped_refptr parent = Layer::create(); scoped_refptr child = Layer::create(); scoped_refptr grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent()); + root->addChild(parent); parent->addChild(child); child->addChild(grandChild); + // One-time setup of root layer + WebTransformationMatrix identityMatrix; + setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(1, 2), false); + // Child is set up so that a new render surface should be created. child->setOpacity(0.5); - WebTransformationMatrix identityMatrix; WebTransformationMatrix parentLayerTransform; parentLayerTransform.scale3d(1, 0.9, 1); WebTransformationMatrix parentTranslationToAnchor; @@ -344,7 +358,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface) setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(100, 120), false); setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(8, 10), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); // Render surface should have been created now. ASSERT_TRUE(child->renderSurface()); @@ -365,18 +379,23 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface) TEST(LayerTreeHostCommonTest, verifyTransformsForReplica) { + scoped_refptr root = Layer::create(); scoped_refptr parent = Layer::create(); scoped_refptr child = Layer::create(); scoped_refptr childReplica = Layer::create(); scoped_refptr grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent()); + root->addChild(parent); parent->addChild(child); child->addChild(grandChild); child->setReplicaLayer(childReplica.get()); + // One-time setup of root layer + WebTransformationMatrix identityMatrix; + setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(1, 2), false); + // Child is set up so that a new render surface should be created. child->setOpacity(0.5); - WebTransformationMatrix identityMatrix; WebTransformationMatrix parentLayerTransform; parentLayerTransform.scale3d(2, 2, 1); WebTransformationMatrix parentTranslationToAnchor; @@ -403,7 +422,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForReplica) setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false); setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-0.5, -0.5), IntSize(1, 1), false); setLayerPropertiesForTesting(childReplica.get(), replicaLayerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(0, 0), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); // Render surface should have been created now. ASSERT_TRUE(child->renderSurface()); @@ -422,6 +441,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) // - Sanity check on recursion: verify transforms of layers described w.r.t. a render surface that is described w.r.t. an ancestor render surface. // - verifying that each layer has a reference to the correct renderSurface and renderTarget values. + scoped_refptr root = Layer::create(); scoped_refptr parent = Layer::create(); scoped_refptr renderSurface1 = Layer::create(); scoped_refptr renderSurface2 = Layer::create(); @@ -433,6 +453,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) scoped_refptr grandChildOfRoot = Layer::create(); scoped_refptr grandChildOfRS1 = make_scoped_refptr(new LayerWithForcedDrawsContent()); scoped_refptr grandChildOfRS2 = make_scoped_refptr(new LayerWithForcedDrawsContent()); + root->addChild(parent); parent->addChild(renderSurface1); parent->addChild(childOfRoot); renderSurface1->addChild(childOfRS1); @@ -448,6 +469,10 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) renderSurface1->setOpacity(0.5); renderSurface2->setOpacity(0.33f); + // One-time setup of root layer + WebTransformationMatrix identityMatrix; + setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(1, 2), false); + // All layers in the tree are initialized with an anchor at .25 and a size of (10,10). // matrix "A" is the composite layer transform used in all layers, centered about the anchor point // matrix "B" is the sublayer transform used in all layers, centered about the center position of the layer. @@ -469,7 +494,6 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) WebTransformationMatrix A = translationToAnchor * layerTransform * translationToAnchor.inverse(); WebTransformationMatrix B = translationToCenter * sublayerTransform * translationToCenter.inverse(); WebTransformationMatrix R = A * translationToAnchor * replicaLayerTransform * translationToAnchor.inverse(); - WebTransformationMatrix identityMatrix; FloatPoint surface1ParentTransformScale = MathUtil::computeTransform2dScaleComponents(A * B); WebTransformationMatrix surface1SublayerTransform; @@ -501,11 +525,11 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) setLayerPropertiesForTesting(replicaOfRS1.get(), replicaLayerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(), false); setLayerPropertiesForTesting(replicaOfRS2.get(), replicaLayerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(), false); - executeCalculateDrawTransformsAndVisibility(parent.get()); + executeCalculateDrawTransformsAndVisibility(root.get()); // Only layers that are associated with render surfaces should have an actual renderSurface() value. // - ASSERT_TRUE(parent->renderSurface()); + ASSERT_TRUE(root->renderSurface()); ASSERT_FALSE(childOfRoot->renderSurface()); ASSERT_FALSE(grandChildOfRoot->renderSurface()); @@ -519,9 +543,9 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy) // Verify all renderTarget accessors // - EXPECT_EQ(parent, parent->renderTarget()); - EXPECT_EQ(parent, childOfRoot->renderTarget()); - EXPECT_EQ(parent, grandChildOfRoot->renderTarget()); + EXPECT_EQ(root, parent->renderTarget()); + EXPECT_EQ(root, childOfRoot->renderTarget()); + EXPECT_EQ(root, grandChildOfRoot->renderTarget()); EXPECT_EQ(renderSurface1, renderSurface1->renderTarget()); EXPECT_EQ(renderSurface1, childOfRS1->renderTarget()); @@ -1297,25 +1321,25 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH root->setScrollDelta(IntSize(0, 0)); executeCalculateDrawTransformsAndVisibility(root.get()); - WebTransformationMatrix expectedChildTransform; - expectedChildTransform.multiply(rotationByZ); - - WebTransformationMatrix expectedGrandChildTransform; - expectedGrandChildTransform.multiply(rotationByZ); + WebTransformationMatrix identityMatrix; - EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform()); - EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform()); + EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform()); + EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform()); // Case 2: root scrollDelta of 10, 10 - root->setScrollDelta(IntSize(10, 10)); + root->setScrollDelta(IntSize(10, 20)); executeCalculateDrawTransformsAndVisibility(root.get()); - // Here the child is affected by scrollDelta, but the fixed position grandChild should not be affected. - expectedChildTransform.makeIdentity(); - expectedChildTransform.translate(-10, -10); // the scrollDelta - expectedChildTransform.multiply(rotationByZ); + // The child is affected by scrollDelta, but it is already implcitly accounted for by + // the child's target surface (i.e. the root renderSurface). The grandChild is not + // affected by the scrollDelta, so its drawTransform needs to explicitly + // inverse-compensate for the scroll that's embedded in the target surface. + WebTransformationMatrix expectedGrandChildTransform; + expectedGrandChildTransform.multiply(rotationByZ.inverse()); + expectedGrandChildTransform.translate(10, 20); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface. + expectedGrandChildTransform.multiply(rotationByZ); - EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform()); + EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform()); EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform()); } diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc index 2d50654..e2ecdce 100644 --- a/cc/layer_tree_host_impl_unittest.cc +++ b/cc/layer_tree_host_impl_unittest.cc @@ -1791,19 +1791,20 @@ TEST_P(LayerTreeHostImplTest, viewportCovered) IntSize viewportSize(1000, 1000); m_hostImpl->setViewportSize(viewportSize, viewportSize); - m_hostImpl->setRootLayer(BlendStateCheckLayer::create(1, m_hostImpl->resourceProvider())); - BlendStateCheckLayer* root = static_cast(m_hostImpl->rootLayer()); - root->setExpectation(false, true); - root->setContentsOpaque(true); + m_hostImpl->setRootLayer(LayerImpl::create(1)); + m_hostImpl->rootLayer()->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider())); + BlendStateCheckLayer* child = static_cast(m_hostImpl->rootLayer()->children()[0]); + child->setExpectation(false, false); + child->setContentsOpaque(true); // No gutter rects { IntRect layerRect(0, 0, 1000, 1000); - root->setPosition(layerRect.location()); - root->setBounds(layerRect.size()); - root->setContentBounds(layerRect.size()); - root->setQuadRect(IntRect(IntPoint(), layerRect.size())); - root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); + child->setPosition(layerRect.location()); + child->setBounds(layerRect.size()); + child->setContentBounds(layerRect.size()); + child->setQuadRect(IntRect(IntPoint(), layerRect.size())); + child->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); LayerTreeHostImpl::FrameData frame; EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); @@ -1815,18 +1816,18 @@ TEST_P(LayerTreeHostImplTest, viewportCovered) EXPECT_EQ(0u, numGutterQuads); EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size()); - verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize)); + verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(IntPoint::zero(), viewportSize)); m_hostImpl->didDrawAllLayers(frame); } // Empty visible content area (fullscreen gutter rect) { IntRect layerRect(0, 0, 0, 0); - root->setPosition(layerRect.location()); - root->setBounds(layerRect.size()); - root->setContentBounds(layerRect.size()); - root->setQuadRect(IntRect(IntPoint(), layerRect.size())); - root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); + child->setPosition(layerRect.location()); + child->setBounds(layerRect.size()); + child->setContentBounds(layerRect.size()); + child->setQuadRect(IntRect(IntPoint(), layerRect.size())); + child->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); LayerTreeHostImpl::FrameData frame; EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); @@ -1839,18 +1840,18 @@ TEST_P(LayerTreeHostImplTest, viewportCovered) EXPECT_EQ(1u, numGutterQuads); EXPECT_EQ(1u, frame.renderPasses[0]->quadList().size()); - verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize)); + verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(IntPoint::zero(), viewportSize)); m_hostImpl->didDrawAllLayers(frame); } // Content area in middle of clip rect (four surrounding gutter rects) { IntRect layerRect(500, 500, 200, 200); - root->setPosition(layerRect.location()); - root->setBounds(layerRect.size()); - root->setContentBounds(layerRect.size()); - root->setQuadRect(IntRect(IntPoint(), layerRect.size())); - root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); + child->setPosition(layerRect.location()); + child->setBounds(layerRect.size()); + child->setContentBounds(layerRect.size()); + child->setQuadRect(IntRect(IntPoint(), layerRect.size())); + child->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size())); LayerTreeHostImpl::FrameData frame; EXPECT_TRUE(m_hostImpl->prepareToDraw(frame)); @@ -1862,7 +1863,7 @@ TEST_P(LayerTreeHostImplTest, viewportCovered) EXPECT_EQ(4u, numGutterQuads); EXPECT_EQ(5u, frame.renderPasses[0]->quadList().size()); - verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(-layerRect.location(), viewportSize)); + verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quadList(), IntRect(IntPoint::zero(), viewportSize)); m_hostImpl->didDrawAllLayers(frame); } diff --git a/cc/layer_tree_host_unittest.cc b/cc/layer_tree_host_unittest.cc index 030ee97..f91cec6 100644 --- a/cc/layer_tree_host_unittest.cc +++ b/cc/layer_tree_host_unittest.cc @@ -651,7 +651,7 @@ public: virtual void beginTest() OVERRIDE { - postAddAnimationToMainThread(); + postAddAnimationToMainThread(m_layerTreeHost->rootLayer()); } virtual void afterTest() OVERRIDE @@ -694,7 +694,7 @@ public: virtual void beginTest() OVERRIDE { - postAddAnimationToMainThread(); + postAddAnimationToMainThread(m_layerTreeHost->rootLayer()); } // Use willAnimateLayers to set visible false before the animation runs and @@ -732,7 +732,7 @@ public: virtual void beginTest() OVERRIDE { - postAddAnimationToMainThread(); + postAddAnimationToMainThread(m_layerTreeHost->rootLayer()); } virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE @@ -761,40 +761,6 @@ private: SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAddAnimationWithTimingFunction) -// Ensures that when opacity is being animated, this value does not cause the subtree to be skipped. -class LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity : public LayerTreeHostTest { -public: - LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity() - { - } - - virtual void beginTest() OVERRIDE - { - m_layerTreeHost->rootLayer()->setDrawOpacity(1); - m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10)); - m_layerTreeHost->rootLayer()->setOpacity(0); - postAddAnimationToMainThread(); - } - - virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE - { - // If the subtree was skipped when preparing to draw, the layer's draw opacity - // will not have been updated. It should be set to 0 due to the animation. - // Without the animation, the layer will be skipped since it has zero opacity. - EXPECT_EQ(0, m_layerTreeHost->rootLayer()->drawOpacity()); - endTest(); - } - - virtual void afterTest() OVERRIDE - { - } -}; - -TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread) -{ - runTest(true); -} - // Ensures that main thread animations have their start times synchronized with impl thread animations. class LayerTreeHostTestSynchronizeAnimationStartTimes : public LayerTreeHostTest { public: @@ -805,7 +771,7 @@ public: virtual void beginTest() OVERRIDE { - postAddAnimationToMainThread(); + postAddAnimationToMainThread(m_layerTreeHost->rootLayer()); } // This is guaranteed to be called before CCLayerTreeHostImpl::animateLayers. @@ -1155,19 +1121,25 @@ TEST_F(LayerTreeHostTestSetVisible, runMultiThread) class TestOpacityChangeLayerDelegate : public ContentLayerClient { public: - TestOpacityChangeLayerDelegate(LayerTreeHostTest* test) - : m_test(test) + TestOpacityChangeLayerDelegate() + : m_testLayer(0) + { + } + + void setTestLayer(Layer* testLayer) { + m_testLayer = testLayer; } virtual void paintContents(SkCanvas*, const IntRect&, FloatRect&) OVERRIDE { // Set layer opacity to 0. - m_test->layerTreeHost()->rootLayer()->setOpacity(0); + if (m_testLayer) + m_testLayer->setOpacity(0); } private: - LayerTreeHostTest* m_test; + Layer* m_testLayer; }; class ContentLayerWithUpdateTracking : public ContentLayer { @@ -1203,15 +1175,16 @@ private: class LayerTreeHostTestOpacityChange : public LayerTreeHostTest { public: LayerTreeHostTestOpacityChange() - : m_testOpacityChangeDelegate(this) + : m_testOpacityChangeDelegate() , m_updateCheckLayer(ContentLayerWithUpdateTracking::create(&m_testOpacityChangeDelegate)) { + m_testOpacityChangeDelegate.setTestLayer(m_updateCheckLayer.get()); } virtual void beginTest() OVERRIDE { - m_layerTreeHost->setRootLayer(m_updateCheckLayer); m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10)); + m_layerTreeHost->rootLayer()->addChild(m_updateCheckLayer); postSetNeedsCommitToMainThread(); } @@ -1260,6 +1233,47 @@ private: virtual ~NoScaleContentLayer() { } }; +// Ensures that when opacity is being animated, this value does not cause the subtree to be skipped. +class LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity : public LayerTreeHostTest { +public: + LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity() + : m_updateCheckLayer(ContentLayerWithUpdateTracking::create(&m_client)) + { + } + + virtual void beginTest() OVERRIDE + { + m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10)); + m_layerTreeHost->rootLayer()->addChild(m_updateCheckLayer); + m_updateCheckLayer->setOpacity(0); + m_updateCheckLayer->setDrawOpacity(0); + postAddAnimationToMainThread(m_updateCheckLayer.get()); + } + + virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE + { + endTest(); + } + + virtual void afterTest() OVERRIDE + { + // update() should have been called once, proving that the layer was not skipped. + EXPECT_EQ(1, m_updateCheckLayer->paintContentsCount()); + + // clear m_updateCheckLayer so LayerTreeHost dies. + m_updateCheckLayer = NULL; + } + +private: + MockContentLayerClient m_client; + scoped_refptr m_updateCheckLayer; +}; + +TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread) +{ + runTest(true); +} + class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public LayerTreeHostTest { public: diff --git a/cc/test/layer_test_common.cc b/cc/test/layer_test_common.cc index 1a41eec..72546dd 100644 --- a/cc/test/layer_test_common.cc +++ b/cc/test/layer_test_common.cc @@ -7,6 +7,7 @@ #include "cc/test/layer_test_common.h" #include "cc/draw_quad.h" +#include "cc/math_util.h" #include "testing/gtest/include/gtest/gtest.h" namespace LayerTestCommon { @@ -14,13 +15,35 @@ namespace LayerTestCommon { // Align with expected and actual output const char* quadString = " Quad: "; +bool floatRectCanBeSafelyRoundedToIntRect(const cc::FloatRect& r) +{ + // Ensure that range of float values is not beyond integer range. + if (!r.isExpressibleAsIntRect()) + return false; + + // Ensure that the values are actually integers. + if (floorf(r.x()) == r.x() + && floorf(r.y()) == r.y() + && floorf(r.width()) == r.width() + && floorf(r.height()) == r.height()) + return true; + + return false; +} + void verifyQuadsExactlyCoverRect(const cc::QuadList& quads, const cc::IntRect& rect) { cc::Region remaining(rect); for (size_t i = 0; i < quads.size(); ++i) { cc::DrawQuad* quad = quads[i]; - cc::IntRect quadRect = cc::IntRect(quad->quadRect()); + cc::FloatRect floatQuadRect = cc::MathUtil::mapClippedRect(quad->sharedQuadState()->quadTransform, cc::FloatRect(quad->quadRect())); + + // Before testing for exact coverage in the integer world, assert that rounding + // will not round the rect incorrectly. + ASSERT_TRUE(floatRectCanBeSafelyRoundedToIntRect(floatQuadRect)); + + cc::IntRect quadRect = enclosingIntRect(floatQuadRect); EXPECT_TRUE(rect.contains(quadRect)) << quadString << i; EXPECT_TRUE(remaining.contains(quadRect)) << quadString << i; diff --git a/cc/test/layer_tree_test_common.cc b/cc/test/layer_tree_test_common.cc index 2bb5d41..0d77c67 100644 --- a/cc/test/layer_tree_test_common.cc +++ b/cc/test/layer_tree_test_common.cc @@ -350,9 +350,9 @@ void ThreadedTest::postSetNeedsAnimateToMainThread() m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchSetNeedsAnimate)); } -void ThreadedTest::postAddAnimationToMainThread() +void ThreadedTest::postAddAnimationToMainThread(Layer* layerToReceiveAnimation) { - m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchAddAnimation)); + m_mainThreadProxy->postTask(createThreadTask(this, &ThreadedTest::dispatchAddAnimation, layerToReceiveAnimation)); } void ThreadedTest::postAddInstantAnimationToMainThread() @@ -456,15 +456,15 @@ void ThreadedTest::dispatchAddInstantAnimation() addOpacityTransitionToLayer(*m_layerTreeHost->rootLayer(), 0, 0, 0.5, false); } -void ThreadedTest::dispatchAddAnimation() +void ThreadedTest::dispatchAddAnimation(Layer* layerToReceiveAnimation) { DCHECK(Proxy::isMainThread()); if (m_finished) return; - if (m_layerTreeHost.get() && m_layerTreeHost->rootLayer()) - addOpacityTransitionToLayer(*m_layerTreeHost->rootLayer(), 10, 0, 0.5, true); + if (layerToReceiveAnimation) + addOpacityTransitionToLayer(*layerToReceiveAnimation, 10, 0, 0.5, true); } void ThreadedTest::dispatchSetNeedsAnimateAndCommit() diff --git a/cc/test/layer_tree_test_common.h b/cc/test/layer_tree_test_common.h index 10f35ca..c8d1c36 100644 --- a/cc/test/layer_tree_test_common.h +++ b/cc/test/layer_tree_test_common.h @@ -77,7 +77,7 @@ public: void endTestAfterDelay(int delayMilliseconds); void postSetNeedsAnimateToMainThread(); - void postAddAnimationToMainThread(); + void postAddAnimationToMainThread(cc::Layer*); void postAddInstantAnimationToMainThread(); void postSetNeedsCommitToMainThread(); void postAcquireLayerTextures(); @@ -104,7 +104,7 @@ protected: void dispatchSetNeedsAnimate(); void dispatchAddInstantAnimation(); - void dispatchAddAnimation(); + void dispatchAddAnimation(cc::Layer*); void dispatchSetNeedsAnimateAndCommit(); void dispatchSetNeedsCommit(); void dispatchAcquireLayerTextures(); -- cgit v1.1