cc/CCLayerTreeHostCommonTest.cpp - Issue 11108020: [cc] Change cc_tests.gyp filenames to Chromium style

Unified Diff: cc/CCLayerTreeHostCommonTest.cpp

Issue 11108020: [cc] Change cc_tests.gyp filenames to Chromium style (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Rebase Created 8 years, 2 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 side-by-side diff with in-line comments

Download patch

Index: cc/CCLayerTreeHostCommonTest.cpp

diff --git a/cc/CCLayerTreeHostCommonTest.cpp b/cc/CCLayerTreeHostCommonTest.cpp

deleted file mode 100644

index af74b1fed513b421d04bb68c99e7859ab6aff162..0000000000000000000000000000000000000000

--- a/cc/CCLayerTreeHostCommonTest.cpp

+++ /dev/null

@@ -1,3586 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "config.h"

-#include "CCLayerTreeHostCommon.h"

-#include "CCAnimationTestCommon.h"

-#include "CCGeometryTestUtils.h"

-#include "CCLayerAnimationController.h"

-#include "CCLayerImpl.h"

-#include "CCLayerSorter.h"

-#include "CCMathUtil.h"

-#include "CCProxy.h"

-#include "CCSingleThreadProxy.h"

-#include "CCThread.h"

-#include "ContentLayerChromium.h"

-#include "ContentLayerChromiumClient.h"

-#include "LayerChromium.h"

-#include "testing/gmock/include/gmock/gmock.h"

-#include "testing/gtest/include/gtest/gtest.h"

-#include <public/WebTransformationMatrix.h>

-using namespace cc;

-using namespace WebKitTests;

-using WebKit::WebTransformationMatrix;

-namespace {

-template<typename LayerType>

-void setLayerPropertiesForTesting(LayerType* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D)

- layer->setTransform(transform);

- layer->setSublayerTransform(sublayerTransform);

- layer->setAnchorPoint(anchor);

- layer->setPosition(position);

- layer->setBounds(bounds);

- layer->setPreserves3D(preserves3D);

-void setLayerPropertiesForTesting(LayerChromium* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D)

- setLayerPropertiesForTesting<LayerChromium>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);

-void setLayerPropertiesForTesting(CCLayerImpl* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D)

- setLayerPropertiesForTesting<CCLayerImpl>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);

- layer->setContentBounds(bounds);

-void executeCalculateDrawTransformsAndVisibility(LayerChromium* rootLayer, float deviceScaleFactor = 1)

- WebTransformationMatrix identityMatrix;

- std::vector<scoped_refptr<LayerChromium> > dummyRenderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- IntSize deviceViewportSize = IntSize(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);

- // We are probably not testing what is intended if the rootLayer bounds are empty.

- ASSERT(!rootLayer->bounds().isEmpty());

- CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);

-void executeCalculateDrawTransformsAndVisibility(CCLayerImpl* rootLayer, float deviceScaleFactor = 1)

- // Note: this version skips layer sorting.

- WebTransformationMatrix identityMatrix;

- std::vector<CCLayerImpl*> dummyRenderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- IntSize deviceViewportSize = IntSize(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);

- // We are probably not testing what is intended if the rootLayer bounds are empty.

- ASSERT(!rootLayer->bounds().isEmpty());

- CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, 0, dummyMaxTextureSize, dummyRenderSurfaceLayerList);

-WebTransformationMatrix remove3DComponentOfMatrix(const WebTransformationMatrix& mat)

- WebTransformationMatrix ret = mat;

- ret.setM13(0);

- ret.setM23(0);

- ret.setM31(0);

- ret.setM32(0);

- ret.setM33(1);

- ret.setM34(0);

- ret.setM43(0);

- return ret;

-scoped_ptr<CCLayerImpl> createTreeForFixedPositionTests()

- scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);

- scoped_ptr<CCLayerImpl> child = CCLayerImpl::create(2);

- scoped_ptr<CCLayerImpl> grandChild = CCLayerImpl::create(3);

- scoped_ptr<CCLayerImpl> greatGrandChild = CCLayerImpl::create(4);

- WebTransformationMatrix IdentityMatrix;

- FloatPoint anchor(0, 0);

- FloatPoint position(0, 0);

- IntSize bounds(100, 100);

- setLayerPropertiesForTesting(root.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);

- setLayerPropertiesForTesting(child.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);

- setLayerPropertiesForTesting(grandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);

- setLayerPropertiesForTesting(greatGrandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);

- grandChild->addChild(greatGrandChild.Pass());

- child->addChild(grandChild.Pass());

- root->addChild(child.Pass());

- return root.Pass();

-class LayerChromiumWithForcedDrawsContent : public LayerChromium {

-public:

- LayerChromiumWithForcedDrawsContent()

- : LayerChromium()

- {

- }

- virtual bool drawsContent() const OVERRIDE { return true; }

-private:

- virtual ~LayerChromiumWithForcedDrawsContent()

- {

- }

-};

-class MockContentLayerChromiumClient : public ContentLayerChromiumClient {

-public:

- MockContentLayerChromiumClient() { }

- virtual ~MockContentLayerChromiumClient() { }

- virtual void paintContents(SkCanvas*, const IntRect& clip, FloatRect& opaque) OVERRIDE { }

-};

-scoped_refptr<ContentLayerChromium> createDrawableContentLayerChromium(ContentLayerChromiumClient* delegate)

- scoped_refptr<ContentLayerChromium> toReturn = ContentLayerChromium::create(delegate);

- toReturn->setIsDrawable(true);

- return toReturn;

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForNoOpLayer)

- // Sanity check: For layers positioned at zero, with zero size,

- // and with identity transforms, then the drawTransform,

- // screenSpaceTransform, and the hierarchy passed on to children

- // layers should also be identity transforms.

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild = LayerChromium::create();

- parent->addChild(child);

- child->addChild(grandChild);

- WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(0, 0), false);

- setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(0, 0), false);

- executeCalculateDrawTransformsAndVisibility(parent.get());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->screenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForSingleLayer)

- WebTransformationMatrix identityMatrix;

- scoped_refptr<LayerChromium> layer = LayerChromium::create();

- // 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());

- WebTransformationMatrix expectedDrawTransform = identityMatrix;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedDrawTransform, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform());

- // Case 2: Setting the bounds of the layer should not affect either the draw transform or the screenspace transform.

- WebTransformationMatrix translationToCenter;

- translationToCenter.translate(5, 6);

- setLayerPropertiesForTesting(layer.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 12), false);

- executeCalculateDrawTransformsAndVisibility(layer.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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, layer->screenSpaceTransform());

- // Case 4: A change in actual position affects both the draw transform and screen space transform.

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(positionTransform, layer->screenSpaceTransform());

- // Case 5: In the correct sequence of transforms, the layer transform should pre-multiply the translationToCenter. This is easily tested by

- // using a scale transform, because scale and translation are not commutative.

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(layerTransform, layer->screenSpaceTransform());

- // Case 6: The layer transform should occur with respect to the anchor point.

- WebTransformationMatrix translationToAnchor;

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform());

- // Case 7: Verify that position pre-multiplies the layer transform.

- // The current implementation of calculateDrawTransforms does this implicitly, but it is

- // 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->screenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)

- WebTransformationMatrix identityMatrix;

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild = LayerChromium::create();

- parent->addChild(child);

- child->addChild(grandChild);

- // 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->screenSpaceTransform());

- // Case 2: parent's position affects child and grandChild.

- WebTransformationMatrix parentPositionTransform;

- parentPositionTransform.translate(0, 1.2);

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentPositionTransform, grandChild->screenSpaceTransform());

- // Case 3: parent's local transform affects child and grandchild

- WebTransformationMatrix parentLayerTransform;

- parentLayerTransform.scale3d(2, 2, 1);

- WebTransformationMatrix parentTranslationToAnchor;

- parentTranslationToAnchor.translate(2.5, 3);

- WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse();

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->screenSpaceTransform());

- // Case 4: parent's sublayerMatrix affects child and grandchild

- // scaling is used here again so that the correct sequence of transforms is properly tested.

- // Note that preserves3D is false, but the sublayer matrix should retain its 3D properties when given to child.

- // But then, the child also does not preserve3D. When it gives its hierarchy to the grandChild, it should be flattened to 2D.

- WebTransformationMatrix parentSublayerMatrix;

- parentSublayerMatrix.scale3d(10, 10, 3.3);

- WebTransformationMatrix parentTranslationToCenter;

- parentTranslationToCenter.translate(5, 6);

- // Sublayer matrix is applied to the center of the parent layer.

- parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()

- * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();

- WebTransformationMatrix flattenedCompositeTransform = remove3DComponentOfMatrix(parentCompositeTransform);

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->screenSpaceTransform());

- // Case 5: same as Case 4, except that child does preserve 3D, so the grandChild should receive the non-flattened composite transform.

- //

- 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());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, grandChild->screenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface)

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- parent->addChild(child);

- child->addChild(grandChild);

- // 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;

- parentTranslationToAnchor.translate(25, 30);

- WebTransformationMatrix parentSublayerMatrix;

- parentSublayerMatrix.scale3d(0.9, 1, 3.3);

- WebTransformationMatrix parentTranslationToCenter;

- parentTranslationToCenter.translate(50, 60);

- WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()

- * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();

- // Child's render surface should not exist yet.

- ASSERT_FALSE(child->renderSurface());

- 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());

- // Render surface should have been created now.

- ASSERT_TRUE(child->renderSurface());

- ASSERT_EQ(child, child->renderTarget());

- // The child layer's draw transform should refer to its new render surface.

- // The screen-space transform, however, should still refer to the root.

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());

- // Because the grandChild is the only drawable content, the child's renderSurface will tighten its bounds to the grandChild.

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->renderTarget()->renderSurface()->drawTransform());

- // The screen space is the same as the target since the child surface draws into the root.

- EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->renderTarget()->renderSurface()->screenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForReplica)

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> childReplica = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- parent->addChild(child);

- child->addChild(grandChild);

- child->setReplicaLayer(childReplica.get());

- // 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;

- parentTranslationToAnchor.translate(2.5, 3);

- WebTransformationMatrix parentSublayerMatrix;

- parentSublayerMatrix.scale3d(10, 10, 3.3);

- WebTransformationMatrix parentTranslationToCenter;

- parentTranslationToCenter.translate(5, 6);

- WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()

- * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();

- WebTransformationMatrix childTranslationToCenter;

- childTranslationToCenter.translate(8, 9);

- WebTransformationMatrix replicaLayerTransform;

- replicaLayerTransform.scale3d(3, 3, 1);

- WebTransformationMatrix replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform;

- // Child's render surface should not exist yet.

- ASSERT_FALSE(child->renderSurface());

- 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.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());

- // Render surface should have been created now.

- ASSERT_TRUE(child->renderSurface());

- ASSERT_EQ(child, child->renderTarget());

- EXPECT_TRANSFORMATION_MATRIX_EQ(replicaCompositeTransform, child->renderTarget()->renderSurface()->replicaDrawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(replicaCompositeTransform, child->renderTarget()->renderSurface()->replicaScreenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)

- // This test creates a more complex tree and verifies it all at once. This covers the following cases:

- // - layers that are described w.r.t. a render surface: should have draw transforms described w.r.t. that surface

- // - A render surface described w.r.t. an ancestor render surface: should have a draw transform described w.r.t. that ancestor surface

- // - Replicas of a render surface are described w.r.t. the replica's transform around its anchor, along with the surface itself.

- // - 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<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> renderSurface1 = LayerChromium::create();

- scoped_refptr<LayerChromium> renderSurface2 = LayerChromium::create();

- scoped_refptr<LayerChromium> childOfRoot = LayerChromium::create();

- scoped_refptr<LayerChromium> childOfRS1 = LayerChromium::create();

- scoped_refptr<LayerChromium> childOfRS2 = LayerChromium::create();

- scoped_refptr<LayerChromium> replicaOfRS1 = LayerChromium::create();

- scoped_refptr<LayerChromium> replicaOfRS2 = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChildOfRoot = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChildOfRS1 = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChildOfRS2 = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- parent->addChild(renderSurface1);

- parent->addChild(childOfRoot);

- renderSurface1->addChild(childOfRS1);

- renderSurface1->addChild(renderSurface2);

- renderSurface2->addChild(childOfRS2);

- childOfRoot->addChild(grandChildOfRoot);

- childOfRS1->addChild(grandChildOfRS1);

- childOfRS2->addChild(grandChildOfRS2);

- renderSurface1->setReplicaLayer(replicaOfRS1.get());

- renderSurface2->setReplicaLayer(replicaOfRS2.get());

- // In combination with descendantDrawsContent, opacity != 1 forces the layer to have a new renderSurface.

- renderSurface1->setOpacity(0.5);

- renderSurface2->setOpacity(0.33f);

- // 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.

- // matrix "R" is the composite replica transform used in all replica layers.

- //

- // x component tests that layerTransform and sublayerTransform are done in the right order (translation and scale are noncommutative).

- // y component has a translation by 1 for every ancestor, which indicates the "depth" of the layer in the hierarchy.

- WebTransformationMatrix translationToAnchor;

- translationToAnchor.translate(2.5, 0);

- WebTransformationMatrix translationToCenter;

- translationToCenter.translate(5, 5);

- WebTransformationMatrix layerTransform;

- layerTransform.translate(1, 1);

- WebTransformationMatrix sublayerTransform;

- sublayerTransform.scale3d(10, 1, 1);

- WebTransformationMatrix replicaLayerTransform;

- replicaLayerTransform.scale3d(-2, 5, 1);

- WebTransformationMatrix A = translationToAnchor * layerTransform * translationToAnchor.inverse();

- WebTransformationMatrix B = translationToCenter * sublayerTransform * translationToCenter.inverse();

- WebTransformationMatrix R = A * translationToAnchor * replicaLayerTransform * translationToAnchor.inverse();

- WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(parent.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(renderSurface2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(childOfRoot.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(childOfRS1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(childOfRS2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChildOfRoot.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChildOfRS1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChildOfRS2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- 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());

- // Only layers that are associated with render surfaces should have an actual renderSurface() value.

- //

- ASSERT_TRUE(parent->renderSurface());

- ASSERT_FALSE(childOfRoot->renderSurface());

- ASSERT_FALSE(grandChildOfRoot->renderSurface());

- ASSERT_TRUE(renderSurface1->renderSurface());

- ASSERT_FALSE(childOfRS1->renderSurface());

- ASSERT_FALSE(grandChildOfRS1->renderSurface());

- ASSERT_TRUE(renderSurface2->renderSurface());

- ASSERT_FALSE(childOfRS2->renderSurface());

- ASSERT_FALSE(grandChildOfRS2->renderSurface());

- // Verify all renderTarget accessors

- //

- EXPECT_EQ(parent, parent->renderTarget());

- EXPECT_EQ(parent, childOfRoot->renderTarget());

- EXPECT_EQ(parent, grandChildOfRoot->renderTarget());

- EXPECT_EQ(renderSurface1, renderSurface1->renderTarget());

- EXPECT_EQ(renderSurface1, childOfRS1->renderTarget());

- EXPECT_EQ(renderSurface1, grandChildOfRS1->renderTarget());

- EXPECT_EQ(renderSurface2, renderSurface2->renderTarget());

- EXPECT_EQ(renderSurface2, childOfRS2->renderTarget());

- EXPECT_EQ(renderSurface2, grandChildOfRS2->renderTarget());

- // Verify layer draw transforms

- // note that draw transforms are described with respect to the nearest ancestor render surface

- // but screen space transforms are described with respect to the root.

- //

- EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, childOfRoot->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, grandChildOfRoot->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, renderSurface1->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, childOfRS1->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * A * B * A, grandChildOfRS1->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, renderSurface2->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, childOfRS2->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * A * B * A, grandChildOfRS2->drawTransform());

- // Verify layer screen-space transforms

- //

- EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, childOfRoot->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, grandChildOfRoot->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, childOfRS1->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A, grandChildOfRS1->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, renderSurface2->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A, childOfRS2->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A * B * A, grandChildOfRS2->screenSpaceTransform());

- // Verify render surface transforms.

- //

- // Draw transform of render surface 1 is described with respect to root.

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R, renderSurface1->renderSurface()->replicaDrawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->renderSurface()->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R, renderSurface1->renderSurface()->replicaScreenSpaceTransform());

- // Draw transform of render surface 2 is described with respect to render surface 2.

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, renderSurface2->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(B * R, renderSurface2->renderSurface()->replicaDrawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, renderSurface2->renderSurface()->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * R, renderSurface2->renderSurface()->replicaScreenSpaceTransform());

- // Sanity check. If these fail there is probably a bug in the test itself.

- // It is expected that we correctly set up transforms so that the y-component of the screen-space transform

- // encodes the "depth" of the layer in the tree.

- EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(4, grandChildOfRS1->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(3, renderSurface2->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(4, childOfRS2->screenSpaceTransform().m42());

- EXPECT_FLOAT_EQ(5, grandChildOfRS2->screenSpaceTransform().m42());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForFlatteningLayer)

- // For layers that flatten their subtree, there should be an orthographic projection

- // (for x and y values) in the middle of the transform sequence. Note that the way the

- // code is currently implemented, it is not expected to use a canonical orthographic

- // projection.

- scoped_refptr<LayerChromium> root = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- WebTransformationMatrix rotationAboutYAxis;

- rotationAboutYAxis.rotate3d(0, 30, 0);

- const WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(100, 100), false);

- setLayerPropertiesForTesting(child.get(), rotationAboutYAxis, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChild.get(), rotationAboutYAxis, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- root->addChild(child);

- child->addChild(grandChild);

- child->setForceRenderSurface(true);

- // No layers in this test should preserve 3d.

- ASSERT_FALSE(root->preserves3D());

- ASSERT_FALSE(child->preserves3D());

- ASSERT_FALSE(grandChild->preserves3D());

- WebTransformationMatrix expectedChildDrawTransform = rotationAboutYAxis;

- WebTransformationMatrix expectedChildScreenSpaceTransform = rotationAboutYAxis;

- WebTransformationMatrix expectedGrandChildDrawTransform = rotationAboutYAxis; // draws onto child's renderSurface

- WebTransformationMatrix expectedGrandChildScreenSpaceTransform = rotationAboutYAxis.to2dTransform() * rotationAboutYAxis;

- executeCalculateDrawTransformsAndVisibility(root.get());

- // The child's drawTransform should have been taken by its surface.

- ASSERT_TRUE(child->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildDrawTransform, child->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->renderSurface()->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->screenSpaceTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildDrawTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildScreenSpaceTransform, grandChild->screenSpaceTransform());

-TEST(CCLayerTreeHostCommonTest, verifyTransformsForDegenerateIntermediateLayer)

- // A layer that is empty in one axis, but not the other, was accidentally skipping a necessary translation.

- // Without that translation, the coordinate space of the layer's drawTransform is incorrect.

- //

- // Normally this isn't a problem, because the layer wouldn't be drawn anyway, but if that layer becomes a renderSurface, then

- // its drawTransform is implicitly inherited by the rest of the subtree, which then is positioned incorrectly as a result.

- scoped_refptr<LayerChromium> root = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- // The child height is zero, but has non-zero width that should be accounted for while computing drawTransforms.

- const WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(100, 100), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 0), false);

- setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- root->addChild(child);

- child->addChild(grandChild);

- child->setForceRenderSurface(true);

- executeCalculateDrawTransformsAndVisibility(root.get());

- ASSERT_TRUE(child->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->renderSurface()->drawTransform()); // This is the real test, the rest are sanity checks.

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyRenderSurfaceListForRenderSurfaceWithClippedLayer)

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> renderSurface1 = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> child = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- const WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint(30, 30), IntSize(10, 10), false);

- parent->addChild(renderSurface1);

- parent->setMasksToBounds(true);

- renderSurface1->addChild(child);

- renderSurface1->setForceRenderSurface(true);

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- // The child layer's content is entirely outside the parent's clip rect, so the intermediate

- // render surface should not be listed here, even if it was forced to be created. Render surfaces without children or visible

- // content are unexpected at draw time (e.g. we might try to create a content texture of size 0).

- ASSERT_TRUE(parent->renderSurface());

- ASSERT_FALSE(renderSurface1->renderSurface());

- EXPECT_EQ(1U, renderSurfaceLayerList.size());

-TEST(CCLayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild)

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> renderSurface1 = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> child = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- const WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- parent->addChild(renderSurface1);

- renderSurface1->addChild(child);

- renderSurface1->setForceRenderSurface(true);

- renderSurface1->setOpacity(0);

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- // Since the layer is transparent, renderSurface1->renderSurface() should not have gotten added anywhere.

- // Also, the drawable content rect should not have been extended by the children.

- ASSERT_TRUE(parent->renderSurface());

- EXPECT_EQ(0U, parent->renderSurface()->layerList().size());

- EXPECT_EQ(1U, renderSurfaceLayerList.size());

- EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());

- EXPECT_EQ(IntRect(), parent->drawableContentRect());

-TEST(CCLayerTreeHostCommonTest, verifyForceRenderSurface)

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> renderSurface1 = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> child = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- renderSurface1->setForceRenderSurface(true);

- const WebTransformationMatrix identityMatrix;

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);

- parent->addChild(renderSurface1);

- renderSurface1->addChild(child);

- // Sanity check before the actual test

- EXPECT_FALSE(parent->renderSurface());

- EXPECT_FALSE(renderSurface1->renderSurface());

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- // The root layer always creates a renderSurface

- EXPECT_TRUE(parent->renderSurface());

- EXPECT_TRUE(renderSurface1->renderSurface());

- EXPECT_EQ(2U, renderSurfaceLayerList.size());

- renderSurfaceLayerList.clear();

- renderSurface1->setForceRenderSurface(false);

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- EXPECT_TRUE(parent->renderSurface());

- EXPECT_FALSE(renderSurface1->renderSurface());

- EXPECT_EQ(1U, renderSurfaceLayerList.size());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDirectContainer)

- // This test checks for correct scroll compensation when the fixed-position container

- // is the direct parent of the fixed-position layer.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setFixedToContainerLayer(true);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedGrandChildTransform = expectedChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- // Case 2: scrollDelta of 10, 10

- child->setScrollDelta(IntSize(10, 10));

- 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);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithTransformedDirectContainer)

- // This test checks for correct scroll compensation when the fixed-position container

- // is the direct parent of the fixed-position layer, but that container is transformed.

- // In this case, the fixed position element inherits the container's transform,

- // but the scrollDelta that has to be undone should not be affected by that transform.

- //

- // Transforms are in general non-commutative; using something like a non-uniform scale

- // helps to verify that translations and non-uniform scales are applied in the correct

- // order.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- // This scale will cause child and grandChild to be effectively 200 x 800 with respect to the renderTarget.

- WebTransformationMatrix nonUniformScale;

- nonUniformScale.scaleNonUniform(2, 8);

- child->setTransform(nonUniformScale);

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setFixedToContainerLayer(true);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- expectedChildTransform.multiply(nonUniformScale);

- WebTransformationMatrix expectedGrandChildTransform = expectedChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- // Case 2: scrollDelta of 10, 20

- child->setScrollDelta(IntSize(10, 20));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // The child should be affected by scrollDelta, but the fixed position grandChild should not be affected.

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, -20); // scrollDelta

- expectedChildTransform.multiply(nonUniformScale);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainer)

- // This test checks for correct scroll compensation when the fixed-position container

- // is NOT the direct parent of the fixed-position layer.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- CCLayerImpl* greatGrandChild = grandChild->children()[0];

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setPosition(FloatPoint(8, 6));

- greatGrandChild->setFixedToContainerLayer(true);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedGrandChildTransform;

- expectedGrandChildTransform.translate(8, 6);

- WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- // Case 2: scrollDelta of 10, 10

- child->setScrollDelta(IntSize(10, 10));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, -10);

- expectedGrandChildTransform.makeIdentity();

- expectedGrandChildTransform.translate(-2, -4);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainerAndTransforms)

- // This test checks for correct scroll compensation when the fixed-position container

- // is NOT the direct parent of the fixed-position layer, and the hierarchy has various

- // transforms that have to be processed in the correct order.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- CCLayerImpl* greatGrandChild = grandChild->children()[0];

- WebTransformationMatrix rotationAboutZ;

- rotationAboutZ.rotate3d(0, 0, 90);

- child->setIsContainerForFixedPositionLayers(true);

- child->setTransform(rotationAboutZ);

- grandChild->setPosition(FloatPoint(8, 6));

- grandChild->setTransform(rotationAboutZ);

- greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- expectedChildTransform.multiply(rotationAboutZ);

- WebTransformationMatrix expectedGrandChildTransform;

- expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited

- expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.

- expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform

- WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- // Case 2: scrollDelta of 10, 20

- child->setScrollDelta(IntSize(10, 20));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, -20); // scrollDelta

- expectedChildTransform.multiply(rotationAboutZ);

- expectedGrandChildTransform.makeIdentity();

- expectedGrandChildTransform.translate(-10, -20); // child's scrollDelta is inherited

- expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited

- expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.

- expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas)

- // This test checks for correct scroll compensation when the fixed-position container

- // has multiple ancestors that have nonzero scrollDelta before reaching the space where the layer is fixed.

- // In this test, each scrollDelta occurs in a different space because of each layer's local transform.

- // This test checks for correct scroll compensation when the fixed-position container

- // is NOT the direct parent of the fixed-position layer, and the hierarchy has various

- // transforms that have to be processed in the correct order.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- CCLayerImpl* greatGrandChild = grandChild->children()[0];

- WebTransformationMatrix rotationAboutZ;

- rotationAboutZ.rotate3d(0, 0, 90);

- child->setIsContainerForFixedPositionLayers(true);

- child->setTransform(rotationAboutZ);

- grandChild->setPosition(FloatPoint(8, 6));

- grandChild->setTransform(rotationAboutZ);

- greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- expectedChildTransform.multiply(rotationAboutZ);

- WebTransformationMatrix expectedGrandChildTransform;

- expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited

- expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.

- expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform

- WebTransformationMatrix expectedGreatGrandChildTransform = expectedGrandChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- // Case 2: scrollDelta of 10, 20

- child->setScrollDelta(IntSize(10, 0));

- grandChild->setScrollDelta(IntSize(5, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // Here the child and grandChild are affected by scrollDelta, but the fixed position greatGrandChild should not be affected.

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, 0); // scrollDelta

- expectedChildTransform.multiply(rotationAboutZ);

- expectedGrandChildTransform.makeIdentity();

- expectedGrandChildTransform.translate(-10, 0); // child's scrollDelta is inherited

- expectedGrandChildTransform.multiply(rotationAboutZ); // child's local transform is inherited

- expectedGrandChildTransform.translate(-5, 0); // grandChild's scrollDelta

- expectedGrandChildTransform.translate(8, 6); // translation because of position occurs before layer's local transform.

- expectedGrandChildTransform.multiply(rotationAboutZ); // grandChild's local transform

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithIntermediateSurfaceAndTransforms)

- // This test checks for correct scroll compensation when the fixed-position container

- // contributes to a different renderSurface than the fixed-position layer. In this

- // case, the surface drawTransforms also have to be accounted for when checking the

- // scrollDelta.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- CCLayerImpl* greatGrandChild = grandChild->children()[0];

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setPosition(FloatPoint(8, 6));

- grandChild->setForceRenderSurface(true);

- greatGrandChild->setFixedToContainerLayer(true);

- greatGrandChild->setDrawsContent(true);

- WebTransformationMatrix rotationAboutZ;

- rotationAboutZ.rotate3d(0, 0, 90);

- grandChild->setTransform(rotationAboutZ);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedSurfaceDrawTransform;

- expectedSurfaceDrawTransform.translate(8, 6);

- expectedSurfaceDrawTransform.multiply(rotationAboutZ);

- WebTransformationMatrix expectedGrandChildTransform;

- WebTransformationMatrix expectedGreatGrandChildTransform;

- ASSERT_TRUE(grandChild->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- // Case 2: scrollDelta of 10, 30

- child->setScrollDelta(IntSize(10, 30));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // Here the grandChild remains unchanged, because it scrolls along with the

- // renderSurface, and the translation is actually in the renderSurface. But, the fixed

- // position greatGrandChild is more awkward: its actually being drawn with respect to

- // the renderSurface, but it needs to remain fixed with resepct to a container beyond

- // that surface. So, the net result is that, unlike previous tests where the fixed

- // position layer's transform remains unchanged, here the fixed position layer's

- // transform explicitly contains the translation that cancels out the scroll.

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, -30); // scrollDelta

- expectedSurfaceDrawTransform.makeIdentity();

- expectedSurfaceDrawTransform.translate(-10, -30); // scrollDelta

- expectedSurfaceDrawTransform.translate(8, 6);

- expectedSurfaceDrawTransform.multiply(rotationAboutZ);

- // The rotation and its inverse are needed to place the scrollDelta compensation in

- // the correct space. This test will fail if the rotation/inverse are backwards, too,

- // so it requires perfect order of operations.

- expectedGreatGrandChildTransform.makeIdentity();

- expectedGreatGrandChildTransform.multiply(rotationAboutZ.inverse());

- expectedGreatGrandChildTransform.translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.

- expectedGreatGrandChildTransform.multiply(rotationAboutZ);

- ASSERT_TRUE(grandChild->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces)

- // This test checks for correct scroll compensation when the fixed-position container

- // contributes to a different renderSurface than the fixed-position layer, with

- // additional renderSurfaces in-between. This checks that the conversion to ancestor

- // surfaces is accumulated properly in the final matrix transform.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- CCLayerImpl* greatGrandChild = grandChild->children()[0];

- // Add one more layer to the test tree for this scenario.

- {

- WebTransformationMatrix identity;

- scoped_ptr<CCLayerImpl> fixedPositionChild = CCLayerImpl::create(5);

- setLayerPropertiesForTesting(fixedPositionChild.get(), identity, identity, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);

- greatGrandChild->addChild(fixedPositionChild.Pass());

- }

- CCLayerImpl* fixedPositionChild = greatGrandChild->children()[0];

- // Actually set up the scenario here.

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setPosition(FloatPoint(8, 6));

- grandChild->setForceRenderSurface(true);

- greatGrandChild->setPosition(FloatPoint(40, 60));

- greatGrandChild->setForceRenderSurface(true);

- fixedPositionChild->setFixedToContainerLayer(true);

- fixedPositionChild->setDrawsContent(true);

- // The additional rotations, which are non-commutative with translations, help to

- // verify that we have correct order-of-operations in the final scroll compensation.

- // Note that rotating about the center of the layer ensures we do not accidentally

- // clip away layers that we want to test.

- WebTransformationMatrix rotationAboutZ;

- rotationAboutZ.translate(50, 50);

- rotationAboutZ.rotate3d(0, 0, 90);

- rotationAboutZ.translate(-50, -50);

- grandChild->setTransform(rotationAboutZ);

- greatGrandChild->setTransform(rotationAboutZ);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedGrandChildSurfaceDrawTransform;

- expectedGrandChildSurfaceDrawTransform.translate(8, 6);

- expectedGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);

- WebTransformationMatrix expectedGrandChildTransform;

- WebTransformationMatrix expectedGreatGrandChildSurfaceDrawTransform;

- expectedGreatGrandChildSurfaceDrawTransform.translate(40, 60);

- expectedGreatGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);

- WebTransformationMatrix expectedGreatGrandChildTransform;

- WebTransformationMatrix expectedFixedPositionChildTransform;

- ASSERT_TRUE(grandChild->renderSurface());

- ASSERT_TRUE(greatGrandChild->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildSurfaceDrawTransform, greatGrandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedFixedPositionChildTransform, fixedPositionChild->drawTransform());

- // Case 2: scrollDelta of 10, 30

- child->setScrollDelta(IntSize(10, 30));

- executeCalculateDrawTransformsAndVisibility(root.get());

- expectedChildTransform.makeIdentity();

- expectedChildTransform.translate(-10, -30); // scrollDelta

- expectedGrandChildSurfaceDrawTransform.makeIdentity();

- expectedGrandChildSurfaceDrawTransform.translate(-10, -30); // scrollDelta

- expectedGrandChildSurfaceDrawTransform.translate(8, 6);

- expectedGrandChildSurfaceDrawTransform.multiply(rotationAboutZ);

- // grandChild, greatGrandChild, and greatGrandChild's surface are not expected to

- // change, since they are all not fixed, and they are all drawn with respect to

- // grandChild's surface that already has the scrollDelta accounted for.

- // But the great-great grandchild, "fixedPositionChild", should have a transform that explicitly cancels out the scrollDelta.

- // The expected transform is:

- // compoundDrawTransform.inverse() * translate(positive scrollDelta) * compoundOriginTransform

- WebTransformationMatrix compoundDrawTransform; // transform from greatGrandChildSurface's origin to the root surface.

- compoundDrawTransform.translate(8, 6); // origin translation of grandChild

- compoundDrawTransform.multiply(rotationAboutZ); // rotation of grandChild

- compoundDrawTransform.translate(40, 60); // origin translation of greatGrandChild

- compoundDrawTransform.multiply(rotationAboutZ); // rotation of greatGrandChild

- expectedFixedPositionChildTransform.makeIdentity();

- expectedFixedPositionChildTransform.multiply(compoundDrawTransform.inverse());

- expectedFixedPositionChildTransform.translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.

- expectedFixedPositionChildTransform.multiply(compoundDrawTransform);

- ASSERT_TRUE(grandChild->renderSurface());

- ASSERT_TRUE(greatGrandChild->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildSurfaceDrawTransform, grandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildSurfaceDrawTransform, greatGrandChild->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedFixedPositionChildTransform, fixedPositionChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface)

- // This test checks for correct scroll compensation when the fixed-position container

- // itself has a renderSurface. In this case, the container layer should be treated

- // like a layer that contributes to a renderTarget, and that renderTarget

- // is completely irrelevant; it should not affect the scroll compensation.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- child->setIsContainerForFixedPositionLayers(true);

- child->setForceRenderSurface(true);

- grandChild->setFixedToContainerLayer(true);

- grandChild->setDrawsContent(true);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedSurfaceDrawTransform;

- expectedSurfaceDrawTransform.translate(0, 0);

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedGrandChildTransform;

- ASSERT_TRUE(child->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- // Case 2: scrollDelta of 10, 10

- child->setScrollDelta(IntSize(10, 10));

- executeCalculateDrawTransformsAndVisibility(root.get());

- // The surface is translated by scrollDelta, the child transform doesn't change

- // because it scrolls along with the surface, but the fixed position grandChild

- // needs to compensate for the scroll translation.

- expectedSurfaceDrawTransform.makeIdentity();

- expectedSurfaceDrawTransform.translate(-10, -10);

- expectedGrandChildTransform.makeIdentity();

- expectedGrandChildTransform.translate(10, 10);

- ASSERT_TRUE(child->renderSurface());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedSurfaceDrawTransform, child->renderSurface()->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer)

- // This test checks the scenario where a fixed-position layer also happens to be a

- // container itself for a descendant fixed position layer. In particular, the layer

- // should not accidentally be fixed to itself.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- child->setIsContainerForFixedPositionLayers(true);

- grandChild->setFixedToContainerLayer(true);

- // This should not confuse the grandChild. If correct, the grandChild would still be considered fixed to its container (i.e. "child").

- grandChild->setIsContainerForFixedPositionLayers(true);

- // Case 1: scrollDelta of 0, 0

- child->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- WebTransformationMatrix expectedGrandChildTransform;

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- // Case 2: scrollDelta of 10, 10

- child->setScrollDelta(IntSize(10, 10));

- 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);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatHasNoContainer)

- // This test checks scroll compensation when a fixed-position layer does not find any

- // ancestor that is a "containerForFixedPositionLayers". In this situation, the layer should

- // be fixed to the viewport -- not the rootLayer, which may have transforms of its own.

- DebugScopedSetImplThread scopedImplThread;

- scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();

- CCLayerImpl* child = root->children()[0];

- CCLayerImpl* grandChild = child->children()[0];

- WebTransformationMatrix rotationByZ;

- rotationByZ.rotate3d(0, 0, 90);

- root->setTransform(rotationByZ);

- grandChild->setFixedToContainerLayer(true);

- // Case 1: root scrollDelta of 0, 0

- root->setScrollDelta(IntSize(0, 0));

- executeCalculateDrawTransformsAndVisibility(root.get());

- WebTransformationMatrix expectedChildTransform;

- expectedChildTransform.multiply(rotationByZ);

- WebTransformationMatrix expectedGrandChildTransform;

- expectedGrandChildTransform.multiply(rotationByZ);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

- // Case 2: root scrollDelta of 10, 10

- root->setScrollDelta(IntSize(10, 10));

- 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);

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());

- EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());

-TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsRenderSurfaces)

- // The entire subtree of layers that are outside the clipRect should be culled away,

- // and should not affect the renderSurfaceLayerList.

- //

- // The test tree is set up as follows:

- // - all layers except the leafNodes are forced to be a new renderSurface that have something to draw.

- // - parent is a large container layer.

- // - child has masksToBounds=true to cause clipping.

- // - grandChild is positioned outside of the child's bounds

- // - greatGrandChild is also kept outside child's bounds.

- //

- // In this configuration, grandChild and greatGrandChild are completely outside the

- // clipRect, and they should never get scheduled on the list of renderSurfaces.

- //

- const WebTransformationMatrix identityMatrix;

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild = LayerChromium::create();

- scoped_refptr<LayerChromium> greatGrandChild = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> leafNode1 = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- scoped_refptr<LayerChromiumWithForcedDrawsContent> leafNode2 = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- parent->addChild(child);

- child->addChild(grandChild);

- grandChild->addChild(greatGrandChild);

- // leafNode1 ensures that parent and child are kept on the renderSurfaceLayerList,

- // even though grandChild and greatGrandChild should be clipped.

- child->addChild(leafNode1);

- greatGrandChild->addChild(leafNode2);

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);

- setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(45, 45), IntSize(10, 10), false);

- setLayerPropertiesForTesting(greatGrandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- setLayerPropertiesForTesting(leafNode1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), false);

- setLayerPropertiesForTesting(leafNode2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);

- child->setMasksToBounds(true);

- child->setOpacity(0.4f);

- grandChild->setOpacity(0.5);

- greatGrandChild->setOpacity(0.4f);

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- ASSERT_EQ(2U, renderSurfaceLayerList.size());

- EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());

- EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());

-TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsSurfaceWithoutVisibleContent)

- // When a renderSurface has a clipRect, it is used to clip the contentRect

- // of the surface. When the renderSurface is animating its transforms, then

- // the contentRect's position in the clipRect is not defined on the main

- // thread, and its contentRect should not be clipped.

- // The test tree is set up as follows:

- // - parent is a container layer that masksToBounds=true to cause clipping.

- // - child is a renderSurface, which has a clipRect set to the bounds of the parent.

- // - grandChild is a renderSurface, and the only visible content in child. It is positioned outside of the clipRect from parent.

- // In this configuration, grandChild should be outside the clipped

- // contentRect of the child, making grandChild not appear in the

- // renderSurfaceLayerList. However, when we place an animation on the child,

- // this clipping should be avoided and we should keep the grandChild

- // in the renderSurfaceLayerList.

- const WebTransformationMatrix identityMatrix;

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild = LayerChromium::create();

- scoped_refptr<LayerChromiumWithForcedDrawsContent> leafNode = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());

- parent->addChild(child);

- child->addChild(grandChild);

- grandChild->addChild(leafNode);

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);

- setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(200, 200), IntSize(10, 10), false);

- setLayerPropertiesForTesting(leafNode.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), false);

- parent->setMasksToBounds(true);

- child->setOpacity(0.4f);

- grandChild->setOpacity(0.4f);

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- // Without an animation, we should cull child and grandChild from the renderSurfaceLayerList.

- ASSERT_EQ(1U, renderSurfaceLayerList.size());

- EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());

- // Now put an animating transform on child.

- addAnimatedTransformToController(*child->layerAnimationController(), 10, 30, 0);

- parent->clearRenderSurface();

- child->clearRenderSurface();

- grandChild->clearRenderSurface();

- renderSurfaceLayerList.clear();

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- // With an animating transform, we should keep child and grandChild in the renderSurfaceLayerList.

- ASSERT_EQ(3U, renderSurfaceLayerList.size());

- EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());

- EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());

- EXPECT_EQ(grandChild->id(), renderSurfaceLayerList[2]->id());

-TEST(CCLayerTreeHostCommonTest, verifyDrawableContentRectForLayers)

- // Verify that layers get the appropriate drawableContentRect when their parent masksToBounds is true.

- //

- // grandChild1 - completely inside the region; drawableContentRect should be the layer rect expressed in target space.

- // grandChild2 - partially clipped but NOT masksToBounds; the clipRect will be the intersection of layerBounds and the mask region.

- // grandChild3 - partially clipped and masksToBounds; the drawableContentRect will still be the intersection of layerBounds and the mask region.

- // grandChild4 - outside parent's clipRect; the drawableContentRect should be empty.

- //

- const WebTransformationMatrix identityMatrix;

- scoped_refptr<LayerChromium> parent = LayerChromium::create();

- scoped_refptr<LayerChromium> child = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild1 = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild2 = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild3 = LayerChromium::create();

- scoped_refptr<LayerChromium> grandChild4 = LayerChromium::create();

- parent->addChild(child);

- child->addChild(grandChild1);

- child->addChild(grandChild2);

- child->addChild(grandChild3);

- child->addChild(grandChild4);

- setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), false);

- setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);

- setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(5, 5), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChild2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(15, 15), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChild3.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(15, 15), IntSize(10, 10), false);

- setLayerPropertiesForTesting(grandChild4.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(45, 45), IntSize(10, 10), false);

- child->setMasksToBounds(true);

- grandChild3->setMasksToBounds(true);

- // Force everyone to be a render surface.

- child->setOpacity(0.4f);

- grandChild1->setOpacity(0.5);

- grandChild2->setOpacity(0.5);

- grandChild3->setOpacity(0.5);

- grandChild4->setOpacity(0.5);

- std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;

- int dummyMaxTextureSize = 512;

- CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);

- EXPECT_RECT_EQ(IntRect(IntPoint(5, 5), IntSize(10, 10)), grandChild1->drawableContentRect());

- EXPECT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());

- EXPECT_TRUE(grandChild4->drawableContentRect().isEmpty());

-TEST(CCLayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)

- // Verify that renderSurfaces (and their layers) get the appropriate clipRects when their parent masksToBounds is true.

- //

- // Layers that own renderSurfaces (at least for now) do not inherit any clipping;

- // instead the surface will enforce the clip for the entire subtree. They may still

- // have a clipRect of their own layer bounds, however, if masksToBounds was true.