diff options
Diffstat (limited to 'Source/WebKit/chromium/tests')
21 files changed, 1766 insertions, 137 deletions
diff --git a/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp b/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp index 11a88784b..bbea971dd 100644 --- a/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp +++ b/Source/WebKit/chromium/tests/CCDamageTrackerTest.cpp @@ -33,8 +33,11 @@ #include "cc/CCMathUtil.h" #include "cc/CCSingleThreadProxy.h" #include <gtest/gtest.h> +#include <public/WebFilterOperation.h> +#include <public/WebFilterOperations.h> using namespace WebCore; +using namespace WebKit; using namespace WTF; using namespace WebKitTests; @@ -364,8 +367,8 @@ TEST_F(CCDamageTrackerTest, verifyDamageForBlurredSurface) OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface(); CCLayerImpl* child = root->children()[0].get(); - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(5, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(5)); int outsetTop, outsetRight, outsetBottom, outsetLeft; filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft); root->setFilters(filters); @@ -391,8 +394,11 @@ TEST_F(CCDamageTrackerTest, verifyDamageForBackgroundBlurredChild) CCLayerImpl* child1 = root->children()[0].get(); CCLayerImpl* child2 = root->children()[1].get(); - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(2, WebCore::Fixed), FilterOperation::BLUR)); + // Allow us to set damage on child1 too. + child1->setDrawsContent(true); + + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(2)); int outsetTop, outsetRight, outsetBottom, outsetLeft; filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft); child1->setBackgroundFilters(filters); @@ -432,7 +438,7 @@ TEST_F(CCDamageTrackerTest, verifyDamageForBackgroundBlurredChild) expectedDamageRect.expand(outsetLeft, outsetTop); EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect); - // CASE 3: Setting this update rect outside the contentBounds of the blurred + // CASE 3: Setting this update rect outside the blurred contentBounds of the blurred // child1 will not cause it to be expanded. root->setUpdateRect(FloatRect(30, 30, 2, 2)); @@ -444,7 +450,22 @@ TEST_F(CCDamageTrackerTest, verifyDamageForBackgroundBlurredChild) expectedDamageRect = FloatRect(30, 30, 2, 2); EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect); - // CASE 4: Setting the update rect on child2, which is above child1, will + // CASE 4: Setting this update rect inside the blurred contentBounds but outside the + // original contentBounds of the blurred child1 will cause it to be expanded. + root->setUpdateRect(FloatRect(99, 99, 1, 1)); + + emulateDrawingOneFrame(root.get()); + + rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect(); + // Damage on the root should be: position of updateRect (99, 99), expanded + // by the blurring on child1, but since it is 1 pixel outside the layer, the + // expanding should be reduced by 1. + expectedDamageRect = FloatRect(99, 99, 1, 1); + expectedDamageRect.move(-outsetLeft + 1, -outsetTop + 1); + expectedDamageRect.expand(outsetLeft + outsetRight - 1, outsetTop + outsetBottom - 1); + EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect); + + // CASE 5: Setting the update rect on child2, which is above child1, will // not get blurred by child1, so it does not need to get expanded. child2->setUpdateRect(FloatRect(0, 0, 1, 1)); @@ -454,6 +475,19 @@ TEST_F(CCDamageTrackerTest, verifyDamageForBackgroundBlurredChild) // Damage on child2 should be: position of updateRect offset by the child's position (11, 11), and not expanded by anything. expectedDamageRect = FloatRect(11, 11, 1, 1); EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect); + + // CASE 6: Setting the update rect on child1 will also blur the damage, so + // that any pixels needed for the blur are redrawn in the current frame. + child1->setUpdateRect(FloatRect(0, 0, 1, 1)); + + emulateDrawingOneFrame(root.get()); + + rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect(); + // Damage on child1 should be: position of updateRect offset by the child's position (100, 100), and expanded by the damage. + expectedDamageRect = FloatRect(100, 100, 1, 1); + expectedDamageRect.move(-outsetLeft, -outsetTop); + expectedDamageRect.expand(outsetLeft + outsetRight, outsetTop + outsetBottom); + EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect); } TEST_F(CCDamageTrackerTest, verifyDamageForAddingAndRemovingLayer) @@ -1018,7 +1052,7 @@ TEST_F(CCDamageTrackerTest, verifyDamageForEmptyLayerList) ASSERT_TRUE(root->renderSurface() == root->targetRenderSurface()); CCRenderSurface* targetSurface = root->renderSurface(); targetSurface->clearLayerList(); - targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, FilterOperations()); + targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, IntRect(), 0, WebFilterOperations()); FloatRect damageRect = targetSurface->damageTracker()->currentDamageRect(); EXPECT_TRUE(damageRect.isEmpty()); diff --git a/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp b/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp index 1d5409f98..827194bbc 100644 --- a/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerAnimationControllerTest.cpp @@ -747,4 +747,32 @@ TEST(CCLayerAnimationControllerTest, AbortAGroupedAnimation) EXPECT_EQ(0.75, dummy.opacity()); } +TEST(CCLayerAnimationControllerTest, ForceSyncWhenSynchronizedStartTimeNeeded) +{ + FakeLayerAnimationControllerClient dummyImpl; + OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl)); + OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector)); + FakeLayerAnimationControllerClient dummy; + OwnPtr<CCLayerAnimationController> controller( + CCLayerAnimationController::create(&dummy)); + + OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 0, CCActiveAnimation::Opacity)); + toAdd->setNeedsSynchronizedStartTime(true); + controller->add(toAdd.release()); + + controller->animate(0, 0); + EXPECT_TRUE(controller->hasActiveAnimation()); + CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Opacity); + EXPECT_TRUE(activeAnimation); + EXPECT_TRUE(activeAnimation->needsSynchronizedStartTime()); + + controller->setForceSync(); + + controller->pushAnimationUpdatesTo(controllerImpl.get()); + + activeAnimation = controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity); + EXPECT_TRUE(activeAnimation); + EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, activeAnimation->runState()); +} + } // namespace diff --git a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp index 36c1082b7..f5259e1cf 100644 --- a/Source/WebKit/chromium/tests/CCLayerImplTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerImplTest.cpp @@ -29,7 +29,10 @@ #include "cc/CCSingleThreadProxy.h" #include <gmock/gmock.h> #include <gtest/gtest.h> +#include <public/WebFilterOperation.h> +#include <public/WebFilterOperations.h> +using namespace WebKit; using namespace WebCore; namespace { @@ -85,8 +88,8 @@ TEST(CCLayerImplTest, verifyLayerChangesAreTrackedProperly) Color arbitraryColor = Color(10, 20, 30); TransformationMatrix arbitraryTransform; arbitraryTransform.scale3d(0.1, 0.2, 0.3); - FilterOperations arbitraryFilters; - arbitraryFilters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); + WebFilterOperations arbitraryFilters; + arbitraryFilters.append(WebFilterOperation::createOpacityFilter(0.5)); // Changing these properties affects the entire subtree of layers. EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->setAnchorPoint(arbitraryFloatPoint)); diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp index d243aee4a..17e570199 100644 --- a/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp @@ -581,6 +581,37 @@ TEST(CCLayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild) EXPECT_EQ(parent->drawableContentRect(), IntRect()); } +TEST(CCLayerTreeHostCommonTest, verifyForceRenderSurface) +{ + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> renderSurface1 = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> child = adoptRef(new LayerChromiumWithForcedDrawsContent()); + renderSurface1->setForceRenderSurface(true); + + const TransformationMatrix 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->createRenderSurface(); + parent->setClipRect(IntRect(0, 0, 10, 10)); + parent->addChild(renderSurface1); + renderSurface1->addChild(child); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + EXPECT_TRUE(renderSurface1->renderSurface()); + EXPECT_EQ(renderSurfaceLayerList.size(), 1U); + + renderSurfaceLayerList.clear(); + renderSurface1->setForceRenderSurface(false); + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + EXPECT_FALSE(renderSurface1->renderSurface()); + EXPECT_EQ(renderSurfaceLayerList.size(), 0U); +} + TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsRenderSurfaces) { // The entire subtree of layers that are outside the clipRect should be culled away, @@ -700,6 +731,78 @@ TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsRenderSurfacesCrashRepro) 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 TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromium> child = LayerChromium::create(); + RefPtr<LayerChromium> grandChild = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> leafNode = adoptRef(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); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->createRenderSurface(); + renderSurfaceLayerList.append(parent.get()); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // 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(); + dummyLayerList.clear(); + + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + parent->createRenderSurface(); + renderSurfaceLayerList.append(parent.get()); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // 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, verifyClipRectIsPropagatedCorrectlyToLayers) { // Verify that layers get the appropriate clipRects when their parent masksToBounds is true. @@ -874,8 +977,9 @@ TEST(CCLayerTreeHostCommonTest, verifyAnimationsForRenderSurfaceHierarchy) TransformationMatrix sublayerTransform; sublayerTransform.scale3d(10.0, 1.0, 1.0); - // In combination with descendantDrawsContent, an animated transform forces the layer to have a new renderSurface. + // In combination with descendantDrawsContent and masksToBounds, an animated transform forces the layer to have a new renderSurface. addAnimatedTransformToController(*renderSurface2->layerAnimationController(), 10, 30, 0); + renderSurface2->setMasksToBounds(true); // Also put transform animations on grandChildOfRoot, and grandChildOfRS2 addAnimatedTransformToController(*grandChildOfRoot->layerAnimationController(), 10, 30, 0); @@ -1238,9 +1342,208 @@ TEST(CCLayerTreeHostCommonTest, verifyVisibleRectForPerspectiveUnprojection) EXPECT_INT_RECT_EQ(expected, actual); } -TEST(CCLayerTreeHostCommonTest, verifyBackFaceCulling) +TEST(CCLayerTreeHostCommonTest, verifyBackFaceCullingWithoutPreserves3d) { - // Verify that layers are appropriately culled when their back face is showing and they are not double sided. + // Verify the behavior of back-face culling when there are no preserve-3d layers. Note + // that 3d transforms still apply in this case, but they are "flattened" to each + // parent layer according to current W3C spec. + + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChild = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChild = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChildOfFrontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChildOfFrontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChildOfBackFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChildOfBackFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + + parent->createRenderSurface(); + parent->addChild(frontFacingChild); + parent->addChild(backFacingChild); + parent->addChild(frontFacingSurface); + parent->addChild(backFacingSurface); + frontFacingSurface->addChild(frontFacingChildOfFrontFacingSurface); + frontFacingSurface->addChild(backFacingChildOfFrontFacingSurface); + backFacingSurface->addChild(frontFacingChildOfBackFacingSurface); + backFacingSurface->addChild(backFacingChildOfBackFacingSurface); + + // Nothing is double-sided + frontFacingChild->setDoubleSided(false); + backFacingChild->setDoubleSided(false); + frontFacingSurface->setDoubleSided(false); + backFacingSurface->setDoubleSided(false); + frontFacingChildOfFrontFacingSurface->setDoubleSided(false); + backFacingChildOfFrontFacingSurface->setDoubleSided(false); + frontFacingChildOfBackFacingSurface->setDoubleSided(false); + backFacingChildOfBackFacingSurface->setDoubleSided(false); + + TransformationMatrix backfaceMatrix; + backfaceMatrix.translate(50, 50); + backfaceMatrix.rotate3d(0, 1, 0, 180); + backfaceMatrix.translate(-50, -50); + + // Having a descendant and opacity will force these to have render surfaces. + frontFacingSurface->setOpacity(0.5f); + backFacingSurface->setOpacity(0.5f); + + // Nothing preserves 3d. According to current W3C CSS Transforms spec, these layers + // should blindly use their own local transforms to determine back-face culling. + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + parent->renderSurface()->setContentRect(IntRect(IntPoint(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent.get()); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // Verify which renderSurfaces were created. + EXPECT_FALSE(frontFacingChild->renderSurface()); + EXPECT_FALSE(backFacingChild->renderSurface()); + EXPECT_TRUE(frontFacingSurface->renderSurface()); + EXPECT_TRUE(backFacingSurface->renderSurface()); + EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface()); + EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface()); + + // Verify the renderSurfaceLayerList. + ASSERT_EQ(3u, renderSurfaceLayerList.size()); + EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->id()); + // Even though the back facing surface LAYER gets culled, the other descendants should still be added, so the SURFACE should not be culled. + EXPECT_EQ(backFacingSurface->id(), renderSurfaceLayerList[2]->id()); + + // Verify root surface's layerList. + ASSERT_EQ(3u, renderSurfaceLayerList[0]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingChild->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[1]->id()); + EXPECT_EQ(backFacingSurface->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[2]->id()); + + // Verify frontFacingSurface's layerList. + ASSERT_EQ(2u, renderSurfaceLayerList[1]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id()); + EXPECT_EQ(frontFacingChildOfFrontFacingSurface->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[1]->id()); + + // Verify backFacingSurface's layerList; its own layer should be culled from the surface list. + ASSERT_EQ(1u, renderSurfaceLayerList[2]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingChildOfBackFacingSurface->id(), renderSurfaceLayerList[2]->renderSurface()->layerList()[0]->id()); +} + +TEST(CCLayerTreeHostCommonTest, verifyBackFaceCullingWithPreserves3d) +{ + // Verify the behavior of back-face culling when preserves-3d transform style is used. + + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChild = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChild = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChildOfFrontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChildOfFrontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingChildOfBackFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingChildOfBackFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> dummyReplicaLayer1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> dummyReplicaLayer2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + + parent->createRenderSurface(); + parent->addChild(frontFacingChild); + parent->addChild(backFacingChild); + parent->addChild(frontFacingSurface); + parent->addChild(backFacingSurface); + frontFacingSurface->addChild(frontFacingChildOfFrontFacingSurface); + frontFacingSurface->addChild(backFacingChildOfFrontFacingSurface); + backFacingSurface->addChild(frontFacingChildOfBackFacingSurface); + backFacingSurface->addChild(backFacingChildOfBackFacingSurface); + + // Nothing is double-sided + frontFacingChild->setDoubleSided(false); + backFacingChild->setDoubleSided(false); + frontFacingSurface->setDoubleSided(false); + backFacingSurface->setDoubleSided(false); + frontFacingChildOfFrontFacingSurface->setDoubleSided(false); + backFacingChildOfFrontFacingSurface->setDoubleSided(false); + frontFacingChildOfBackFacingSurface->setDoubleSided(false); + backFacingChildOfBackFacingSurface->setDoubleSided(false); + + TransformationMatrix backfaceMatrix; + backfaceMatrix.translate(50, 50); + backfaceMatrix.rotate3d(0, 1, 0, 180); + backfaceMatrix.translate(-50, -50); + + // Opacity will not force creation of renderSurfaces in this case because of the + // preserve-3d transform style. Instead, an example of when a surface would be + // created with preserve-3d is when there is a replica layer. + frontFacingSurface->setReplicaLayer(dummyReplicaLayer1.get()); + backFacingSurface->setReplicaLayer(dummyReplicaLayer2.get()); + + // Each surface creates its own new 3d rendering context (as defined by W3C spec). + // According to current W3C CSS Transforms spec, layers in a 3d rendering context + // should use the transform with respect to that context. This 3d rendering context + // occurs when (a) parent's transform style is flat and (b) the layer's transform + // style is preserve-3d. + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); // parent transform style is flat. + setLayerPropertiesForTesting(frontFacingChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // surface transform style is preserve-3d. + setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // surface transform style is preserve-3d. + setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + parent->renderSurface()->setContentRect(IntRect(IntPoint(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent.get()); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // Verify which renderSurfaces were created. + EXPECT_FALSE(frontFacingChild->renderSurface()); + EXPECT_FALSE(backFacingChild->renderSurface()); + EXPECT_TRUE(frontFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingSurface->renderSurface()); + EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface()); + EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface()); + + // Verify the renderSurfaceLayerList. The back-facing surface should be culled. + ASSERT_EQ(2u, renderSurfaceLayerList.size()); + EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->id()); + + // Verify root surface's layerList. + ASSERT_EQ(2u, renderSurfaceLayerList[0]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingChild->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[1]->id()); + + // Verify frontFacingSurface's layerList. + ASSERT_EQ(2u, renderSurfaceLayerList[1]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id()); + EXPECT_EQ(frontFacingChildOfFrontFacingSurface->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[1]->id()); +} + +TEST(CCLayerTreeHostCommonTest, verifyBackFaceCullingWithAnimatingTransforms) +{ + // Verify that layers are appropriately culled when their back face is showing and + // they are not double sided, while animations are going on. // // Layers that are animating do not get culled on the main thread, as their transforms should be // treated as "unknown" so we can not be sure that their back face is really showing. @@ -1273,15 +1576,16 @@ TEST(CCLayerTreeHostCommonTest, verifyBackFaceCulling) backfaceMatrix.rotate3d(0, 1, 0, 180); backfaceMatrix.translate(-50, -50); - // Having a descendent, and animating transforms, will make the animatingSurface own a render surface. + // Having a descendant that draws, masksToBounds, and animating transforms, will make the animatingSurface own a render surface. addAnimatedTransformToController(*animatingSurface->layerAnimationController(), 10, 30, 0); + animatingSurface->setMasksToBounds(true); // This is just an animating layer, not a surface. addAnimatedTransformToController(*animatingChild->layerAnimationController(), 10, 30, 0); - setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); setLayerPropertiesForTesting(child.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); setLayerPropertiesForTesting(animatingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); - setLayerPropertiesForTesting(childOfAnimatingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(childOfAnimatingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); setLayerPropertiesForTesting(animatingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); @@ -1318,11 +1622,74 @@ TEST(CCLayerTreeHostCommonTest, verifyBackFaceCulling) EXPECT_FALSE(child2->visibleLayerRect().isEmpty()); - // But if the back face is visible, then the visibleLayerRect should be empty. - EXPECT_TRUE(animatingChild->visibleLayerRect().isEmpty()); - EXPECT_TRUE(animatingSurface->visibleLayerRect().isEmpty()); - // And any layers in the subtree should not be considered visible either. - EXPECT_TRUE(childOfAnimatingSurface->visibleLayerRect().isEmpty()); + // The animating layers should have a visibleLayerRect that represents the area of the front face that is within the viewport. + EXPECT_EQ(animatingChild->visibleLayerRect(), IntRect(IntPoint(), animatingChild->contentBounds())); + EXPECT_EQ(animatingSurface->visibleLayerRect(), IntRect(IntPoint(), animatingSurface->contentBounds())); + // And layers in the subtree of the animating layer should have valid visibleLayerRects also. + EXPECT_EQ(childOfAnimatingSurface->visibleLayerRect(), IntRect(IntPoint(), childOfAnimatingSurface->contentBounds())); +} + +TEST(CCLayerTreeHostCommonTest, verifyBackFaceCullingWithPreserves3dForFlatteningSurface) +{ + // Verify the behavior of back-face culling for a renderSurface that is created + // when it flattens its subtree, and its parent has preserves-3d. + + const TransformationMatrix identityMatrix; + RefPtr<LayerChromium> parent = LayerChromium::create(); + RefPtr<LayerChromiumWithForcedDrawsContent> frontFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> backFacingSurface = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> child1 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + RefPtr<LayerChromiumWithForcedDrawsContent> child2 = adoptRef(new LayerChromiumWithForcedDrawsContent()); + + parent->createRenderSurface(); + parent->addChild(frontFacingSurface); + parent->addChild(backFacingSurface); + frontFacingSurface->addChild(child1); + backFacingSurface->addChild(child2); + + // RenderSurfaces are not double-sided + frontFacingSurface->setDoubleSided(false); + backFacingSurface->setDoubleSided(false); + + TransformationMatrix backfaceMatrix; + backfaceMatrix.translate(50, 50); + backfaceMatrix.rotate3d(0, 1, 0, 180); + backfaceMatrix.translate(-50, -50); + + setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // parent transform style is preserve3d. + setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); // surface transform style is flat. + setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); // surface transform style is flat. + setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); + + Vector<RefPtr<LayerChromium> > renderSurfaceLayerList; + Vector<RefPtr<LayerChromium> > dummyLayerList; + int dummyMaxTextureSize = 512; + parent->renderSurface()->setContentRect(IntRect(IntPoint(), parent->bounds())); + parent->setClipRect(IntRect(IntPoint::zero(), parent->bounds())); + renderSurfaceLayerList.append(parent.get()); + + CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(parent.get(), parent.get(), identityMatrix, identityMatrix, renderSurfaceLayerList, dummyLayerList, dummyMaxTextureSize); + + // Verify which renderSurfaces were created. + EXPECT_TRUE(frontFacingSurface->renderSurface()); + EXPECT_FALSE(backFacingSurface->renderSurface()); // because it should be culled + EXPECT_FALSE(child1->renderSurface()); + EXPECT_FALSE(child2->renderSurface()); + + // Verify the renderSurfaceLayerList. The back-facing surface should be culled. + ASSERT_EQ(2u, renderSurfaceLayerList.size()); + EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->id()); + + // Verify root surface's layerList. + ASSERT_EQ(1u, renderSurfaceLayerList[0]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); + + // Verify frontFacingSurface's layerList. + ASSERT_EQ(2u, renderSurfaceLayerList[1]->renderSurface()->layerList().size()); + EXPECT_EQ(frontFacingSurface->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id()); + EXPECT_EQ(child1->id(), renderSurfaceLayerList[1]->renderSurface()->layerList()[1]->id()); } // FIXME: diff --git a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp index 77a3b8264..9e28a5b82 100644 --- a/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp +++ b/Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp @@ -31,7 +31,6 @@ #include "CCTiledLayerTestCommon.h" #include "CompositorFakeWebGraphicsContext3D.h" #include "ContentLayerChromium.h" -#include "FilterOperations.h" #include "GraphicsContext3DPrivate.h" #include "LayerChromium.h" #include "TextureManager.h" @@ -49,8 +48,12 @@ #include <gmock/gmock.h> #include <gtest/gtest.h> #include <public/Platform.h> +#include <public/WebFilterOperation.h> +#include <public/WebFilterOperations.h> +#include <wtf/Locker.h> #include <wtf/MainThread.h> #include <wtf/PassRefPtr.h> +#include <wtf/ThreadingPrimitives.h> #include <wtf/Vector.h> using namespace WebCore; @@ -79,7 +82,9 @@ public: virtual void updateAnimations(double monotonicTime) { } virtual void layout() { } virtual void didRecreateContext(bool succeded) { } + virtual void didCommit() { } virtual void didCommitAndDrawFrame() { } + virtual void scheduleComposite() { } // Implementation of CCLayerAnimationDelegate virtual void notifyAnimationStarted(double time) { } @@ -131,6 +136,11 @@ protected: m_testHooks->animateLayers(this, monotonicTime); } + virtual double lowFrequencyAnimationInterval() const + { + return 1.0 / 60; + } + private: MockLayerTreeHostImpl(TestHooks* testHooks, const CCSettings& settings, CCLayerTreeHostImplClient* client) : CCLayerTreeHostImpl(settings, client) @@ -239,6 +249,10 @@ public: { } + virtual void didBeginFrame() OVERRIDE + { + } + virtual void updateAnimations(double monotonicTime) OVERRIDE { m_testHooks->updateAnimations(monotonicTime); @@ -264,8 +278,13 @@ public: return GraphicsContext3DPrivate::createGraphicsContextFromWebContext(webContext.release(), GraphicsContext3D::RenderDirectlyToHostWindow); } + virtual void willCommit() OVERRIDE + { + } + virtual void didCommit() OVERRIDE { + m_testHooks->didCommit(); } virtual void didCommitAndDrawFrame() OVERRIDE @@ -284,6 +303,7 @@ public: virtual void scheduleComposite() OVERRIDE { + m_testHooks->scheduleComposite(); } private: @@ -367,10 +387,22 @@ protected: CCLayerTreeHostTest() : m_beginning(false) , m_endWhenBeginReturns(false) - , m_timedOut(false) { } + , m_timedOut(false) + , m_finished(false) + , m_scheduled(false) + , m_started(false) + { } void doBeginTest(); + virtual void scheduleComposite() + { + if (!m_started || m_scheduled || m_finished) + return; + m_scheduled = true; + callOnMainThread(&CCLayerTreeHostTest::dispatchComposite, this); + } + static void onEndTest(void* self) { ASSERT(isMainThread()); @@ -380,8 +412,12 @@ protected: static void dispatchSetNeedsAnimate(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) test->m_layerTreeHost->setNeedsAnimate(); } @@ -389,8 +425,12 @@ protected: static void dispatchAddInstantAnimation(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost && test->m_layerTreeHost->rootLayer()) addOpacityTransitionToLayer(*test->m_layerTreeHost->rootLayer(), 0, 0, 0.5, false); } @@ -398,8 +438,12 @@ protected: static void dispatchAddAnimation(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost && test->m_layerTreeHost->rootLayer()) addOpacityTransitionToLayer(*test->m_layerTreeHost->rootLayer(), 10, 0, 0.5, true); } @@ -407,8 +451,12 @@ protected: static void dispatchSetNeedsAnimateAndCommit(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) { test->m_layerTreeHost->setNeedsAnimate(); test->m_layerTreeHost->setNeedsCommit(); @@ -418,26 +466,38 @@ protected: static void dispatchSetNeedsCommit(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT_TRUE(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) test->m_layerTreeHost->setNeedsCommit(); } static void dispatchAcquireLayerTextures(void* self) { - ASSERT(isMainThread()); - CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); - ASSERT_TRUE(test); - if (test->m_layerTreeHost) - test->m_layerTreeHost->acquireLayerTextures(); + ASSERT(isMainThread()); + + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); + ASSERT_TRUE(test); + if (test->m_finished) + return; + + if (test->m_layerTreeHost) + test->m_layerTreeHost->acquireLayerTextures(); } static void dispatchSetNeedsRedraw(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT_TRUE(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) test->m_layerTreeHost->setNeedsRedraw(); } @@ -445,8 +505,12 @@ protected: static void dispatchSetVisible(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) test->m_layerTreeHost->setVisible(true); } @@ -454,12 +518,26 @@ protected: static void dispatchSetInvisible(void* self) { ASSERT(isMainThread()); + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); ASSERT(test); + if (test->m_finished) + return; + if (test->m_layerTreeHost) test->m_layerTreeHost->setVisible(false); } + static void dispatchComposite(void* self) + { + CCLayerTreeHostTest* test = static_cast<CCLayerTreeHostTest*>(self); + ASSERT(isMainThread()); + ASSERT(test); + test->m_scheduled = false; + if (test->m_layerTreeHost && !test->m_finished) + test->m_layerTreeHost->composite(); + } + class TimeoutTask : public WebThread::Task { public: explicit TimeoutTask(CCLayerTreeHostTest* test) @@ -547,6 +625,9 @@ private: bool m_beginning; bool m_endWhenBeginReturns; bool m_timedOut; + bool m_finished; + bool m_scheduled; + bool m_started; OwnPtr<WebThread> m_webThread; RefPtr<CCScopedThreadProxy> m_mainThreadProxy; @@ -565,6 +646,7 @@ void CCLayerTreeHostTest::doBeginTest() rootLayer->setLayerTreeHost(m_layerTreeHost.get()); m_layerTreeHost->setSurfaceReady(); + m_started = true; m_beginning = true; beginTest(); m_beginning = false; @@ -574,6 +656,8 @@ void CCLayerTreeHostTest::doBeginTest() void CCLayerTreeHostTest::endTest() { + m_finished = true; + // If we are called from the CCThread, re-call endTest on the main thread. if (!isMainThread()) m_mainThreadProxy->postTask(createCCThreadTask(this, &CCLayerTreeHostTest::endTest)); @@ -856,7 +940,6 @@ TEST_F(CCLayerTreeHostTestSetNeedsRedraw, runMultiThread) } // If the layerTreeHost says it can't draw, then we should not try to draw. -// FIXME: Make this run in single threaded mode too. http://crbug.com/127481 class CCLayerTreeHostTestCanDrawBlocksDrawing : public CCLayerTreeHostTestThreadOnly { public: CCLayerTreeHostTestCanDrawBlocksDrawing() @@ -866,6 +949,7 @@ public: virtual void beginTest() { + postSetNeedsCommitToMainThread(); } virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl) @@ -883,7 +967,7 @@ public: } } - virtual void didCommitAndDrawFrame() + virtual void didCommit() { m_numCommits++; if (m_numCommits == 1) { @@ -893,10 +977,10 @@ public: OwnArrayPtr<char> pixels(adoptArrayPtr(new char[4])); m_layerTreeHost->compositeAndReadback(static_cast<void*>(pixels.get()), IntRect(0, 0, 1, 1)); } else if (m_numCommits == 2) { + m_layerTreeHost->setNeedsRedraw(); m_layerTreeHost->setNeedsCommit(); - m_layerTreeHost->finishAllRendering(); + } else endTest(); - } } virtual void afterTest() @@ -907,10 +991,7 @@ private: int m_numCommits; }; -TEST_F(CCLayerTreeHostTestCanDrawBlocksDrawing, runMultiThread) -{ - runTestThreaded(); -} +SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestCanDrawBlocksDrawing) // beginLayerWrite should prevent draws from executing until a commit occurs class CCLayerTreeHostTestWriteLayersRedraw : public CCLayerTreeHostTestThreadOnly { @@ -930,8 +1011,8 @@ public: virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl) { - EXPECT_EQ(1, impl->sourceFrameNumber()); m_numDraws++; + EXPECT_EQ(m_numDraws, m_numCommits); } virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl*) @@ -942,7 +1023,6 @@ public: virtual void afterTest() { - EXPECT_EQ(0, m_numDraws); EXPECT_EQ(1, m_numCommits); } @@ -1148,7 +1228,10 @@ public: postAddAnimationToMainThread(); } - virtual void animateLayers(CCLayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) + // Use willAnimateLayers to set visible false before the animation runs and + // causes a commit, so we block the second visible animate in single-thread + // mode. + virtual void willAnimateLayers(CCLayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) { if (m_numAnimates < 2) { if (!m_numAnimates) { @@ -1185,7 +1268,10 @@ public: virtual void animateLayers(CCLayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) { - const CCFloatAnimationCurve* curve = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, CCActiveAnimation::Opacity)->curve()->toFloatAnimationCurve(); + const CCActiveAnimation* animation = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, CCActiveAnimation::Opacity); + if (!animation) + return; + const CCFloatAnimationCurve* curve = animation->curve()->toFloatAnimationCurve(); float startOpacity = curve->getValue(0); float endOpacity = curve->getValue(curve->duration()); float linearlyInterpolatedOpacity = 0.25 * endOpacity + 0.75 * startOpacity; @@ -1353,11 +1439,11 @@ public: root->setMaxScrollPosition(IntSize(100, 100)); root->scrollBy(m_scrollAmount); - if (impl->frameNumber() == 1) { + if (!impl->sourceFrameNumber()) { EXPECT_EQ(root->scrollPosition(), m_initialScroll); EXPECT_EQ(root->scrollDelta(), m_scrollAmount); postSetNeedsCommitToMainThread(); - } else if (impl->frameNumber() == 2) { + } else if (impl->sourceFrameNumber() == 1) { EXPECT_EQ(root->scrollPosition(), m_secondScroll); EXPECT_EQ(root->scrollDelta(), m_scrollAmount); endTest(); @@ -1420,21 +1506,25 @@ public: root->setScrollable(true); root->setMaxScrollPosition(IntSize(100, 100)); - if (impl->frameNumber() == 1) { + if (!impl->sourceFrameNumber() && impl->frameNumber() == 1) { + // First draw after first commit. EXPECT_EQ(root->scrollDelta(), IntSize()); root->scrollBy(m_scrollAmount); EXPECT_EQ(root->scrollDelta(), m_scrollAmount); EXPECT_EQ(root->scrollPosition(), m_initialScroll); postSetNeedsRedrawToMainThread(); - } else if (impl->frameNumber() == 2) { + } else if (!impl->sourceFrameNumber() && impl->frameNumber() == 2) { + // Second draw after first commit. EXPECT_EQ(root->scrollDelta(), m_scrollAmount); root->scrollBy(m_scrollAmount); EXPECT_EQ(root->scrollDelta(), m_scrollAmount + m_scrollAmount); EXPECT_EQ(root->scrollPosition(), m_initialScroll); postSetNeedsCommitToMainThread(); - } else if (impl->frameNumber() == 3) { + } else if (impl->sourceFrameNumber() == 1) { + // Third or later draw after second commit. + EXPECT_GE(impl->frameNumber(), 3); EXPECT_EQ(root->scrollDelta(), IntSize()); EXPECT_EQ(root->scrollPosition(), m_initialScroll + m_scrollAmount + m_scrollAmount); endTest(); @@ -1495,6 +1585,113 @@ TEST_F(CCLayerTreeHostTestCommit, runTest) runTest(true); } +class CCLayerTreeHostTestVisibilityAndAllocationControlDrawing : public CCLayerTreeHostTest { +public: + + CCLayerTreeHostTestVisibilityAndAllocationControlDrawing() { } + + virtual void beginTest() + { + postSetNeedsCommitToMainThread(); + } + + virtual void didCommitAndDrawFrame() + { + int lastFrame = m_layerTreeHost->frameNumber() - 1; + + // These frames should draw. + switch (lastFrame) { + case 0: + // Set the tree invisible, this should not draw. + m_layerTreeHost->setVisible(false); + break; + case 2: + // Set the tree invisible and give a non-visible allocation, this + // should not draw. + m_layerTreeHost->setVisible(false); + m_layerTreeHost->setContentsMemoryAllocationLimitBytes(0); + break; + case 5: + // Give a memory allocation not for display, but while we are + // visible. This should not be used and we should remain + // ready for display and it should draw. + m_layerTreeHost->setContentsMemoryAllocationLimitBytes(0); + break; + case 6: + endTest(); + break; + + default: + ASSERT_NOT_REACHED(); + } + } + + virtual void didCommit() + { + int lastFrame = m_layerTreeHost->frameNumber() - 1; + + // These frames should not draw. + switch (lastFrame) { + case 1: + // Set the tree visible, this should draw. + m_layerTreeHost->setVisible(true); + break; + case 3: + // Set visible without giving a visible memory allocation, this + // shouldn't make the impl side ready for display, so it should + // not draw. + m_layerTreeHost->setVisible(true); + break; + case 4: + // Now give a memory allocation for display, this should draw. + m_layerTreeHost->setContentsMemoryAllocationLimitBytes(1); + break; + } + } + + virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl) + { + switch (impl->sourceFrameNumber()) { + case 0: + // The host starts out visible and able to display before we do any commit. + EXPECT_TRUE(impl->visible()); + EXPECT_TRUE(impl->sourceFrameCanBeDrawn()); + break; + case 1: + // We still have a memory allocation for display. + EXPECT_FALSE(impl->visible()); + EXPECT_TRUE(impl->sourceFrameCanBeDrawn()); + break; + case 2: + EXPECT_TRUE(impl->visible()); + EXPECT_TRUE(impl->sourceFrameCanBeDrawn()); + break; + case 3: + EXPECT_FALSE(impl->visible()); + EXPECT_FALSE(impl->sourceFrameCanBeDrawn()); + break; + case 4: + EXPECT_TRUE(impl->visible()); + EXPECT_FALSE(impl->sourceFrameCanBeDrawn()); + break; + case 5: + EXPECT_TRUE(impl->visible()); + EXPECT_TRUE(impl->sourceFrameCanBeDrawn()); + break; + case 6: + EXPECT_TRUE(impl->visible()); + EXPECT_TRUE(impl->sourceFrameCanBeDrawn()); + break; + } + } + + virtual void afterTest() + { + } +}; + +SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestVisibilityAndAllocationControlDrawing) + // Verifies that startPageScaleAnimation events propagate correctly from CCLayerTreeHost to // CCLayerTreeHostImpl in the MT compositor. class CCLayerTreeHostTestStartPageScaleAnimation : public CCLayerTreeHostTest { @@ -1542,9 +1739,8 @@ public: virtual void commitCompleteOnCCThread(CCLayerTreeHostImpl* impl) { impl->processScrollDeltas(); - // We get one commit before the first draw, and the animation doesn't happen until the second draw, - // so results available on the third commit. - if (impl->frameNumber() == 2) { + // We get one commit before the first draw, and the animation doesn't happen until the second draw. + if (impl->sourceFrameNumber() == 1) { EXPECT_EQ(1.25, impl->pageScale()); endTest(); } else @@ -1699,53 +1895,6 @@ TEST_F(CCLayerTreeHostTestOpacityChange, runMultiThread) runTest(true); } -class CCLayerTreeHostTestSetViewportSize : public CCLayerTreeHostTest { -public: - - CCLayerTreeHostTestSetViewportSize() - : m_numCommits(0) - , m_numDraws(0) - { - } - - virtual void beginTest() - { - IntSize viewportSize(10, 10); - layerTreeHost()->setViewportSize(viewportSize); - - CCTextureUpdater updater; - layerTreeHost()->updateLayers(updater); - - EXPECT_EQ(viewportSize, layerTreeHost()->viewportSize()); - EXPECT_EQ(TextureManager::highLimitBytes(viewportSize), layerTreeHost()->contentsTextureManager()->maxMemoryLimitBytes()); - EXPECT_EQ(TextureManager::reclaimLimitBytes(viewportSize), layerTreeHost()->contentsTextureManager()->preferredMemoryLimitBytes()); - - // setViewportSize() should not call TextureManager::setMaxMemoryLimitBytes() or TextureManager::setPreferredMemoryLimitBytes() - // if the viewport size is not changed. - IntSize fakeSize(5, 5); - layerTreeHost()->contentsTextureManager()->setMaxMemoryLimitBytes(TextureManager::highLimitBytes(fakeSize)); - layerTreeHost()->contentsTextureManager()->setPreferredMemoryLimitBytes(TextureManager::reclaimLimitBytes(fakeSize)); - layerTreeHost()->setViewportSize(viewportSize); - EXPECT_EQ(TextureManager::highLimitBytes(fakeSize), layerTreeHost()->contentsTextureManager()->maxMemoryLimitBytes()); - EXPECT_EQ(TextureManager::reclaimLimitBytes(fakeSize), layerTreeHost()->contentsTextureManager()->preferredMemoryLimitBytes()); - - endTest(); - } - - virtual void afterTest() - { - } - -private: - int m_numCommits; - int m_numDraws; -}; - -TEST_F(CCLayerTreeHostTestSetViewportSize, runSingleThread) -{ - runTest(false); -} - class MockContentLayerDelegate : public ContentLayerDelegate { public: bool drawsContent() const { return true; } @@ -2373,8 +2522,8 @@ public: setTestLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 70), IntSize(500, 500), true); { - FilterOperations filters; - filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createOpacityFilter(0.5)); child->setFilters(filters); } @@ -2401,8 +2550,8 @@ public: setTestLayerPropertiesForTesting(child2.get(), rootLayer.get(), identityMatrix, FloatPoint(0, 0), FloatPoint(10, 70), IntSize(500, 500), true); { - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(10)); child->setFilters(filters); } @@ -2580,15 +2729,15 @@ public: root->setMaxScrollPosition(IntSize(100, 100)); // Check that a fractional scroll delta is correctly accumulated over multiple commits. - if (impl->frameNumber() == 1) { + if (!impl->sourceFrameNumber()) { EXPECT_EQ(root->scrollPosition(), IntPoint(0, 0)); EXPECT_EQ(root->scrollDelta(), FloatSize(0, 0)); postSetNeedsCommitToMainThread(); - } else if (impl->frameNumber() == 2) { + } else if (impl->sourceFrameNumber() == 1) { EXPECT_EQ(root->scrollPosition(), flooredIntPoint(m_scrollAmount)); EXPECT_EQ(root->scrollDelta(), FloatSize(fmod(m_scrollAmount.width(), 1), 0)); postSetNeedsCommitToMainThread(); - } else if (impl->frameNumber() == 3) { + } else if (impl->sourceFrameNumber() == 2) { EXPECT_EQ(root->scrollPosition(), flooredIntPoint(m_scrollAmount + m_scrollAmount)); EXPECT_EQ(root->scrollDelta(), FloatSize(fmod(2 * m_scrollAmount.width(), 1), 0)); endTest(); @@ -2614,4 +2763,55 @@ TEST_F(CCLayerTreeHostTestFractionalScroll, runMultiThread) runTestThreaded(); } +class CCLayerTreeHostTestFinishAllRendering : public CCLayerTreeHostTest { +public: + CCLayerTreeHostTestFinishAllRendering() + : m_once(false) + , m_mutex() + , m_drawCount(0) + { + } + + virtual void beginTest() + { + m_layerTreeHost->setNeedsRedraw(); + } + + virtual void didCommitAndDrawFrame() + { + if (m_once) + return; + m_once = true; + m_layerTreeHost->setNeedsRedraw(); + m_layerTreeHost->acquireLayerTextures(); + { + Locker<Mutex> lock(m_mutex); + m_drawCount = 0; + } + m_layerTreeHost->finishAllRendering(); + { + Locker<Mutex> lock(m_mutex); + EXPECT_EQ(0, m_drawCount); + } + endTest(); + } + + virtual void drawLayersOnCCThread(CCLayerTreeHostImpl* impl) + { + Locker<Mutex> lock(m_mutex); + ++m_drawCount; + } + + virtual void afterTest() + { + } +private: + + bool m_once; + Mutex m_mutex; + int m_drawCount; +}; + +SINGLE_AND_MULTI_THREAD_TEST_F(CCLayerTreeHostTestFinishAllRendering) + } // namespace diff --git a/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp b/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp index 891c305b0..976dc3f29 100644 --- a/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp +++ b/Source/WebKit/chromium/tests/CCOcclusionTrackerTest.cpp @@ -28,7 +28,6 @@ #include "CCAnimationTestCommon.h" #include "CCOcclusionTrackerTestCommon.h" -#include "FilterOperations.h" #include "LayerChromium.h" #include "Region.h" #include "TransformationMatrix.h" @@ -37,11 +36,13 @@ #include "cc/CCLayerImpl.h" #include "cc/CCLayerTreeHostCommon.h" #include "cc/CCSingleThreadProxy.h" - #include <gmock/gmock.h> #include <gtest/gtest.h> +#include <public/WebFilterOperation.h> +#include <public/WebFilterOperations.h> using namespace WebCore; +using namespace WebKit; using namespace WebKitTests; #define EXPECT_EQ_RECT(a, b) \ @@ -199,8 +200,8 @@ protected: typename Types::LayerType* createSurface(typename Types::LayerType* parent, const TransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds) { typename Types::LayerType* layer = createLayer(parent, transform, position, bounds); - FilterOperations filters; - filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createGrayscaleFilter(0.5)); layer->setFilters(filters); return layer; } @@ -246,8 +247,8 @@ protected: typename Types::ContentLayerType* createDrawingSurface(typename Types::LayerType* parent, const TransformationMatrix& transform, const FloatPoint& position, const IntSize& bounds, bool opaque) { typename Types::ContentLayerType* layer = createDrawingLayer(parent, transform, position, bounds, opaque); - FilterOperations filters; - filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createGrayscaleFilter(0.5)); layer->setFilters(filters); return layer; } @@ -1221,16 +1222,16 @@ protected: typename Types::ContentLayerType* opaqueLayer = this->createDrawingLayer(parent, layerTransform, FloatPoint(30, 30), IntSize(500, 500), true); typename Types::ContentLayerType* opacityLayer = this->createDrawingLayer(parent, layerTransform, FloatPoint(30, 30), IntSize(500, 500), true); - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Percent), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(10)); blurLayer->setFilters(filters); - filters.operations().clear(); - filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::GRAYSCALE)); + filters.clear(); + filters.append(WebFilterOperation::createGrayscaleFilter(0.5)); opaqueLayer->setFilters(filters); - filters.operations().clear(); - filters.operations().append(BasicComponentTransferFilterOperation::create(0.5, FilterOperation::OPACITY)); + filters.clear(); + filters.append(WebFilterOperation::createOpacityFilter(0.5)); opacityLayer->setFilters(filters); this->calcDrawEtc(parent); @@ -2495,8 +2496,8 @@ protected: typename Types::LayerType* occludingLayer5 = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(250, 50), IntSize(50, 50), true); // Filters make the layer own a surface. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(10, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(10)); filteredSurface->setBackgroundFilters(filters); // Save the distance of influence for the blur effect. @@ -2616,8 +2617,8 @@ protected: typename Types::LayerType* occludingLayerAbove = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(100, 100), IntSize(50, 50), true); // Filters make the layers own surfaces. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(3)); filteredSurface1->setBackgroundFilters(filters); filteredSurface2->setBackgroundFilters(filters); @@ -2681,8 +2682,8 @@ protected: typename Types::LayerType* occludingLayer5 = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(250, 50), IntSize(50, 50), true); // Filters make the layer own a surface. This filter is large enough that it goes outside the bottom of the clippingSurface. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(12, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(12)); filteredSurface->setBackgroundFilters(filters); // Save the distance of influence for the blur effect. @@ -2804,8 +2805,8 @@ protected: this->createReplicaLayer(filteredSurface, this->identityMatrix, FloatPoint(300, 0), IntSize()); // Filters make the layer own a surface. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(3)); filteredSurface->setBackgroundFilters(filters); this->calcDrawEtc(parent); @@ -2853,8 +2854,8 @@ protected: typename Types::LayerType* aboveReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(200, 50), IntSize(50, 50), true); // Filters make the layer own a surface. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(3)); filteredSurface->setBackgroundFilters(filters); this->calcDrawEtc(parent); @@ -2903,8 +2904,8 @@ protected: typename Types::LayerType* besideReplicaLayer = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(200, 40), IntSize(10, 10), true); // Filters make the layer own a surface. - FilterOperations filters; - filters.operations().append(BlurFilterOperation::create(Length(3, WebCore::Fixed), FilterOperation::BLUR)); + WebFilterOperations filters; + filters.append(WebFilterOperation::createBlurFilter(3)); filteredSurface->setBackgroundFilters(filters); // Save the distance of influence for the blur effect. diff --git a/Source/WebKit/chromium/tests/FakeCCLayerTreeHostClient.h b/Source/WebKit/chromium/tests/FakeCCLayerTreeHostClient.h index 513fd0cbc..992509c4f 100755 --- a/Source/WebKit/chromium/tests/FakeCCLayerTreeHostClient.h +++ b/Source/WebKit/chromium/tests/FakeCCLayerTreeHostClient.h @@ -35,6 +35,7 @@ namespace WebCore { class FakeCCLayerTreeHostClient : public CCLayerTreeHostClient { public: virtual void willBeginFrame() OVERRIDE { } + virtual void didBeginFrame() OVERRIDE { } virtual void updateAnimations(double monotonicFrameBeginTime) OVERRIDE { } virtual void layout() OVERRIDE { } virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) OVERRIDE { } @@ -44,6 +45,7 @@ public: return createCompositorMockGraphicsContext3D(attrs); } virtual void didRecreateContext(bool success) OVERRIDE { } + virtual void willCommit() OVERRIDE { } virtual void didCommit() OVERRIDE { } virtual void didCommitAndDrawFrame() OVERRIDE { } virtual void didCompleteSwapBuffers() OVERRIDE { } diff --git a/Source/WebKit/chromium/tests/FilterOperationsTest.cpp b/Source/WebKit/chromium/tests/FilterOperationsTest.cpp new file mode 100644 index 000000000..8a3c5d8a1 --- /dev/null +++ b/Source/WebKit/chromium/tests/FilterOperationsTest.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "FilterOperations.h" + +#include <gtest/gtest.h> +#include <public/WebFilterOperation.h> +#include <public/WebFilterOperations.h> + +using namespace WebCore; +using namespace WebKit; + +namespace { + +TEST(FilterOperationsTest, getOutsetsBlur) +{ + FilterOperations ops; + ops.operations().append(BlurFilterOperation::create(Length(20.0, WebCore::Fixed), FilterOperation::BLUR)); + EXPECT_TRUE(ops.hasOutsets()); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.getOutsets(top, right, bottom, left); + EXPECT_EQ(57, top); + EXPECT_EQ(57, right); + EXPECT_EQ(57, bottom); + EXPECT_EQ(57, left); +} + +TEST(FilterOperationsTest, getOutsetsDropShadow) +{ + FilterOperations ops; + ops.operations().append(DropShadowFilterOperation::create(IntPoint(3, 8), 20, Color(1, 2, 3), FilterOperation::DROP_SHADOW)); + EXPECT_TRUE(ops.hasOutsets()); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.getOutsets(top, right, bottom, left); + EXPECT_EQ(49, top); + EXPECT_EQ(60, right); + EXPECT_EQ(65, bottom); + EXPECT_EQ(54, left); +} + +TEST(WebFilterOperationsTest, getOutsetsBlur) +{ + WebFilterOperations ops; + ops.append(WebFilterOperation::createBlurFilter(20)); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.getOutsets(top, right, bottom, left); + EXPECT_EQ(57, top); + EXPECT_EQ(57, right); + EXPECT_EQ(57, bottom); + EXPECT_EQ(57, left); +} + +TEST(WebFilterOperationsTest, getOutsetsDropShadow) +{ + WebFilterOperations ops; + ops.append(WebFilterOperation::createDropShadowFilter(WebPoint(3, 8), 20, 0)); + int top, right, bottom, left; + top = right = bottom = left = 0; + ops.getOutsets(top, right, bottom, left); + EXPECT_EQ(49, top); + EXPECT_EQ(60, right); + EXPECT_EQ(65, bottom); + EXPECT_EQ(54, left); +} + +} + diff --git a/Source/WebKit/chromium/tests/GraphicsLayerChromiumTest.cpp b/Source/WebKit/chromium/tests/GraphicsLayerChromiumTest.cpp index 39ad32621..b7aa85746 100644 --- a/Source/WebKit/chromium/tests/GraphicsLayerChromiumTest.cpp +++ b/Source/WebKit/chromium/tests/GraphicsLayerChromiumTest.cpp @@ -28,6 +28,7 @@ #include "CCAnimationTestCommon.h" #include "GraphicsLayer.h" +#include "LayerChromium.h" #include <gtest/gtest.h> #include <wtf/PassOwnPtr.h> diff --git a/Source/WebKit/chromium/tests/IDBAbortOnCorruptTest.cpp b/Source/WebKit/chromium/tests/IDBAbortOnCorruptTest.cpp new file mode 100644 index 000000000..6c78aa53c --- /dev/null +++ b/Source/WebKit/chromium/tests/IDBAbortOnCorruptTest.cpp @@ -0,0 +1,107 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "IDBFactoryBackendImpl.h" +#include "IDBFakeBackingStore.h" +#include "SecurityOrigin.h" +#include <gtest/gtest.h> +#include <wtf/Vector.h> + +#if ENABLE(INDEXED_DATABASE) + +using namespace WebCore; + +namespace { + +class MockIDBCallbacks : public IDBCallbacks { +public: + MockIDBCallbacks() : m_wasErrorCalled(false) { } + + virtual ~MockIDBCallbacks() + { + EXPECT_TRUE(m_wasErrorCalled); + } + virtual void onError(PassRefPtr<IDBDatabaseError>) + { + m_wasErrorCalled = true; + } + virtual void onSuccess(PassRefPtr<DOMStringList>) { } + virtual void onSuccess(PassRefPtr<IDBCursorBackendInterface>) { } + virtual void onSuccess(PassRefPtr<IDBDatabaseBackendInterface>) + { + EXPECT_TRUE(false); + } + virtual void onSuccess(PassRefPtr<IDBKey>) { } + virtual void onSuccess(PassRefPtr<IDBTransactionBackendInterface>) { } + virtual void onSuccess(PassRefPtr<SerializedScriptValue>) { } + virtual void onSuccessWithContinuation() { } + virtual void onSuccessWithPrefetch(const Vector<RefPtr<IDBKey> >&, const Vector<RefPtr<IDBKey> >&, const Vector<RefPtr<SerializedScriptValue> >&) { } + virtual void onBlocked() { } +private: + bool m_wasErrorCalled; +}; + +class FailingBackingStore : public IDBFakeBackingStore { +public: + virtual ~FailingBackingStore() { } + static PassRefPtr<IDBBackingStore> open() + { + return adoptRef(new FailingBackingStore); + } + virtual bool createIDBDatabaseMetaData(const String&, const String&, int64_t&) + { + return false; + } +}; + +class FailingIDBFactoryBackendImpl : public IDBFactoryBackendImpl { +public: + virtual ~FailingIDBFactoryBackendImpl() { } + static PassRefPtr<FailingIDBFactoryBackendImpl> create() + { + return adoptRef(new FailingIDBFactoryBackendImpl); + } + virtual void removeIDBDatabaseBackend(const WTF::String &) { } + +protected: + virtual PassRefPtr<IDBBackingStore> openBackingStore(PassRefPtr<SecurityOrigin> prpOrigin, const String& dataDir) + { + return FailingBackingStore::open(); + } +}; + +TEST(IDBAbortTest, TheTest) +{ + RefPtr<IDBFactoryBackendImpl> factory = FailingIDBFactoryBackendImpl::create(); + const String& name = "db name"; + MockIDBCallbacks callbacks; + RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "localhost", 81); + factory->open(name, &callbacks, origin, 0 /*Frame*/, String() /*path*/); +} + +} // namespace + +#endif // ENABLE(INDEXED_DATABASE) diff --git a/Source/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp b/Source/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp index d60295a5f..c1351850d 100644 --- a/Source/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp +++ b/Source/WebKit/chromium/tests/IDBBindingUtilitiesTest.cpp @@ -41,10 +41,8 @@ namespace { PassRefPtr<IDBKey> checkKeyFromValueAndKeyPathInternal(SerializedScriptValue* value, const String& keyPath) { - Vector<String> idbKeyPath; - IDBKeyPathParseError parseError; - IDBParseKeyPath(keyPath, idbKeyPath, parseError); - EXPECT_EQ(IDBKeyPathParseErrorNone, parseError); + IDBKeyPath idbKeyPath(keyPath); + EXPECT_TRUE(idbKeyPath.isValid()); return createIDBKeyFromSerializedValueAndKeyPath(value, idbKeyPath); } @@ -56,10 +54,8 @@ void checkKeyPathNullValue(SerializedScriptValue* value, const String& keyPath) PassRefPtr<SerializedScriptValue> injectKey(PassRefPtr<IDBKey> key, PassRefPtr<SerializedScriptValue> value, const String& keyPath) { - Vector<String> idbKeyPath; - IDBKeyPathParseError parseError; - IDBParseKeyPath(keyPath, idbKeyPath, parseError); - EXPECT_EQ(IDBKeyPathParseErrorNone, parseError); + IDBKeyPath idbKeyPath(keyPath); + EXPECT_TRUE(idbKeyPath.isValid()); return injectIDBKeyIntoSerializedValue(key, value, idbKeyPath); } diff --git a/Source/WebKit/chromium/tests/IDBFakeBackingStore.h b/Source/WebKit/chromium/tests/IDBFakeBackingStore.h new file mode 100644 index 000000000..ed894cb19 --- /dev/null +++ b/Source/WebKit/chromium/tests/IDBFakeBackingStore.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef IDBFakeBackingStore_h +#define IDBFakeBackingStore_h + +#include "IDBBackingStore.h" + +namespace WebCore { + +class IDBFakeBackingStore : public IDBBackingStore { +public: + virtual void getDatabaseNames(Vector<String>& foundNames) OVERRIDE { } + virtual bool getIDBDatabaseMetaData(const String& name, String& foundVersion, int64_t& foundId) OVERRIDE { return false; } + virtual bool createIDBDatabaseMetaData(const String& name, const String& version, int64_t& rowId) OVERRIDE { return true; } + virtual bool updateIDBDatabaseMetaData(int64_t rowId, const String& version) OVERRIDE { return false; } + virtual bool deleteDatabase(const String& name) OVERRIDE { return false; } + + virtual void getObjectStores(int64_t databaseId, Vector<int64_t>& foundIds, Vector<String>& foundNames, Vector<IDBKeyPath>& foundKeyPaths, Vector<bool>& foundAutoIncrementFlags) OVERRIDE { } + virtual bool createObjectStore(int64_t databaseId, const String& name, const IDBKeyPath& keyPath, bool autoIncrement, int64_t& assignedObjectStoreId) OVERRIDE { return false; } + virtual void deleteObjectStore(int64_t databaseId, int64_t objectStoreId) OVERRIDE { } + + virtual PassRefPtr<ObjectStoreRecordIdentifier> createInvalidRecordIdentifier() OVERRIDE { return PassRefPtr<ObjectStoreRecordIdentifier>(); } + + virtual String getObjectStoreRecord(int64_t databaseId, int64_t objectStoreId, const IDBKey&) OVERRIDE { return String(); } + virtual bool putObjectStoreRecord(int64_t databaseId, int64_t objectStoreId, const IDBKey&, const String& value, ObjectStoreRecordIdentifier*) OVERRIDE { return false; } + virtual void clearObjectStore(int64_t databaseId, int64_t objectStoreId) OVERRIDE { } + virtual void deleteObjectStoreRecord(int64_t databaseId, int64_t objectStoreId, const ObjectStoreRecordIdentifier*) OVERRIDE { } + virtual int64_t nextAutoIncrementNumber(int64_t databaseId, int64_t objectStoreId) OVERRIDE { return 0.0; } + virtual bool keyExistsInObjectStore(int64_t databaseId, int64_t objectStoreId, const IDBKey&, ObjectStoreRecordIdentifier* foundRecordIdentifier) OVERRIDE { return false; } + + virtual bool forEachObjectStoreRecord(int64_t databaseId, int64_t objectStoreId, ObjectStoreRecordCallback&) OVERRIDE { return false; } + + virtual void getIndexes(int64_t databaseId, int64_t objectStoreId, Vector<int64_t>& foundIds, Vector<String>& foundNames, Vector<IDBKeyPath>& foundKeyPaths, Vector<bool>& foundUniqueFlags, Vector<bool>& foundMultiEntryFlags) OVERRIDE { } + virtual bool createIndex(int64_t databaseId, int64_t objectStoreId, const String& name, const IDBKeyPath& keyPath, bool isUnique, bool isMultiEntry, int64_t& indexId) OVERRIDE { return false; } + virtual void deleteIndex(int64_t databaseId, int64_t objectStoreId, int64_t indexId) OVERRIDE { } + virtual bool putIndexDataForRecord(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKey&, const ObjectStoreRecordIdentifier*) OVERRIDE { return false; } + virtual bool deleteIndexDataForRecord(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const ObjectStoreRecordIdentifier*) OVERRIDE { return false; } + virtual String getObjectViaIndex(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKey&) OVERRIDE { return String(); } + virtual PassRefPtr<IDBKey> getPrimaryKeyViaIndex(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKey&) OVERRIDE { return PassRefPtr<IDBKey>(); } + virtual bool keyExistsInIndex(int64_t databaseid, int64_t objectStoreId, int64_t indexId, const IDBKey& indexKey, RefPtr<IDBKey>& foundPrimaryKey) OVERRIDE { return false; } + + virtual PassRefPtr<Cursor> openObjectStoreCursor(int64_t databaseId, int64_t objectStoreId, const IDBKeyRange*, IDBCursor::Direction) OVERRIDE { return PassRefPtr<Cursor>(); } + virtual PassRefPtr<Cursor> openIndexKeyCursor(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKeyRange*, IDBCursor::Direction) OVERRIDE { return PassRefPtr<Cursor>(); } + virtual PassRefPtr<Cursor> openIndexCursor(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKeyRange*, IDBCursor::Direction) OVERRIDE { return PassRefPtr<Cursor>(); } + + virtual PassRefPtr<Transaction> createTransaction() OVERRIDE { return PassRefPtr<Transaction>(); } +}; + +} // namespace WebCore + +#endif // IDBFakeBackingStore_h diff --git a/Source/WebKit/chromium/tests/IDBKeyPathTest.cpp b/Source/WebKit/chromium/tests/IDBKeyPathTest.cpp index e2fdaebc2..7d662c009 100644 --- a/Source/WebKit/chromium/tests/IDBKeyPathTest.cpp +++ b/Source/WebKit/chromium/tests/IDBKeyPathTest.cpp @@ -37,6 +37,10 @@ namespace { void checkKeyPath(const String& keyPath, const Vector<String>& expected, int parserError) { + IDBKeyPath idbKeyPath(keyPath); + ASSERT_EQ(idbKeyPath.type(), IDBKeyPath::StringType); + ASSERT_EQ(idbKeyPath.isValid(), (parserError == IDBKeyPathParseErrorNone)); + IDBKeyPathParseError error; Vector<String> keyPathElements; IDBParseKeyPath(keyPath, keyPathElements, error); diff --git a/Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp b/Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp index eb9962d58..8f5b8ef01 100644 --- a/Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp +++ b/Source/WebKit/chromium/tests/IDBLevelDBCodingTest.cpp @@ -30,6 +30,7 @@ #if USE(LEVELDB) #include "IDBKey.h" +#include "IDBKeyPath.h" #include "LevelDBSlice.h" #include <gtest/gtest.h> #include <wtf/Vector.h> @@ -418,6 +419,133 @@ TEST(IDBLevelDBCodingTest, EncodeDecodeIDBKey) EXPECT_EQ(0, decodeIDBKey(v.data(), v.data() + v.size() - 1, decodedKey)); } +TEST(IDBLevelDBCodingTest, EncodeIDBKeyPath) +{ + const unsigned char kIDBKeyPathTypeCodedByte1 = 0; + const unsigned char kIDBKeyPathTypeCodedByte2 = 0; + { + IDBKeyPath keyPath; + EXPECT_EQ(keyPath.type(), IDBKeyPath::NullType); + Vector<char> v = encodeIDBKeyPath(keyPath); + EXPECT_EQ(v.size(), 3U); + EXPECT_EQ(v[0], kIDBKeyPathTypeCodedByte1); + EXPECT_EQ(v[1], kIDBKeyPathTypeCodedByte2); + EXPECT_EQ(v[2], IDBKeyPath::NullType); + } + + { + Vector<String> testCases; + testCases.append(""); + testCases.append("foo"); + testCases.append("foo.bar"); + + for (size_t i = 0; i < testCases.size(); ++i) { + IDBKeyPath keyPath = IDBKeyPath(testCases[i]); + Vector<char> v = encodeIDBKeyPath(keyPath); + EXPECT_EQ(v.size(), encodeStringWithLength(testCases[i]).size() + 3); + const char* p = v.data(); + const char* limit = v.data() + v.size(); + EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte1); + EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte2); + EXPECT_EQ(*p++, IDBKeyPath::StringType); + String string; + p = decodeStringWithLength(p, limit, string); + EXPECT_EQ(string, testCases[i]); + EXPECT_EQ(p, limit); + } + } + + { + Vector<String> testCase; + testCase.append(""); + testCase.append("foo"); + testCase.append("foo.bar"); + + IDBKeyPath keyPath(testCase); + EXPECT_EQ(keyPath.type(), IDBKeyPath::ArrayType); + Vector<char> v = encodeIDBKeyPath(keyPath); + const char* p = v.data(); + const char* limit = v.data() + v.size(); + EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte1); + EXPECT_EQ(*p++, kIDBKeyPathTypeCodedByte2); + EXPECT_EQ(*p++, IDBKeyPath::ArrayType); + int64_t count; + p = decodeVarInt(p, limit, count); + EXPECT_EQ(count, static_cast<int64_t>(testCase.size())); + for (size_t i = 0; i < static_cast<size_t>(count); ++i) { + String string; + p = decodeStringWithLength(p, limit, string); + EXPECT_EQ(string, testCase[i]); + } + EXPECT_EQ(p, limit); + } +} + +TEST(IDBLevelDBCodingTest, DecodeIDBKeyPath) +{ + const unsigned char kIDBKeyPathTypeCodedByte1 = 0; + const unsigned char kIDBKeyPathTypeCodedByte2 = 0; + { + // Legacy encoding of string key paths. + Vector<String> testCases; + testCases.append(""); + testCases.append("foo"); + testCases.append("foo.bar"); + + for (size_t i = 0; i < testCases.size(); ++i) { + Vector<char> v = encodeString(testCases[i]); + IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size()); + EXPECT_EQ(keyPath.type(), IDBKeyPath::StringType); + EXPECT_EQ(testCases[i], keyPath.string()); + } + } + { + Vector<char> v; + v.append(kIDBKeyPathTypeCodedByte1); + v.append(kIDBKeyPathTypeCodedByte2); + v.append(IDBKeyPath::NullType); + IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size()); + EXPECT_EQ(keyPath.type(), IDBKeyPath::NullType); + EXPECT_TRUE(keyPath.isNull()); + } + { + Vector<String> testCases; + testCases.append(""); + testCases.append("foo"); + testCases.append("foo.bar"); + + for (size_t i = 0; i < testCases.size(); ++i) { + Vector<char> v; + v.append(kIDBKeyPathTypeCodedByte1); + v.append(kIDBKeyPathTypeCodedByte2); + v.append(IDBKeyPath::StringType); + v.append(encodeStringWithLength(testCases[i])); + IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size()); + EXPECT_EQ(keyPath.type(), IDBKeyPath::StringType); + EXPECT_EQ(testCases[i], keyPath.string()); + } + } + { + Vector<String> testCase; + testCase.append(""); + testCase.append("foo"); + testCase.append("foo.bar"); + + Vector<char> v; + v.append(kIDBKeyPathTypeCodedByte1); + v.append(kIDBKeyPathTypeCodedByte2); + v.append(IDBKeyPath::ArrayType); + v.append(encodeVarInt(testCase.size())); + for (size_t i = 0; i < testCase.size(); ++i) + v.append(encodeStringWithLength(testCase[i])); + IDBKeyPath keyPath = decodeIDBKeyPath(v.data(), v.data() + v.size()); + EXPECT_EQ(keyPath.type(), IDBKeyPath::ArrayType); + EXPECT_EQ(keyPath.array().size(), testCase.size()); + for (size_t i = 0; i < testCase.size(); ++i) + EXPECT_EQ(keyPath.array()[i], testCase[i]); + } +} + TEST(IDBLevelDBCodingTest, ExtractAndCompareIDBKeys) { Vector<RefPtr<IDBKey> > keys; diff --git a/Source/WebKit/chromium/tests/LayerChromiumTest.cpp b/Source/WebKit/chromium/tests/LayerChromiumTest.cpp index a93eac7fa..491d48db5 100644 --- a/Source/WebKit/chromium/tests/LayerChromiumTest.cpp +++ b/Source/WebKit/chromium/tests/LayerChromiumTest.cpp @@ -522,6 +522,7 @@ TEST_F(LayerChromiumTest, checkPropertyChangeCausesCorrectBehavior) EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDoubleSided(false)); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDebugName("Test Layer")); EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setDrawCheckerboardForMissingTiles(!testLayer->drawCheckerboardForMissingTiles())); + EXECUTE_AND_VERIFY_SET_NEEDS_COMMIT_BEHAVIOR(1, testLayer->setForceRenderSurface(true)); // The above tests should not have caused a change to the needsDisplay flag. EXPECT_FALSE(testLayer->needsDisplay()); diff --git a/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp b/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp index 721f1fabb..eb2c07512 100644 --- a/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp +++ b/Source/WebKit/chromium/tests/PlatformContextSkiaTest.cpp @@ -724,7 +724,7 @@ TEST(PlatformContextSkiaTest, UnboundedDrawsAreClipped) context.setStrokeStyle(SolidStroke); // Make skia unable to compute fast bounds for our paths. - Vector<float> dashArray; + DashArray dashArray; dashArray.append(1); dashArray.append(0); context.setLineDash(dashArray, 0); @@ -771,7 +771,7 @@ TEST(PlatformContextSkiaTest, PreserveOpaqueOnlyMattersForFirstLayer) context.setStrokeStyle(SolidStroke); // Make skia unable to compute fast bounds for our paths. - Vector<float> dashArray; + DashArray dashArray; dashArray.append(1); dashArray.append(0); context.setLineDash(dashArray, 0); diff --git a/Source/WebKit/chromium/tests/WebFrameTest.cpp b/Source/WebKit/chromium/tests/WebFrameTest.cpp index 74251f3e8..a6ab77fc1 100644 --- a/Source/WebKit/chromium/tests/WebFrameTest.cpp +++ b/Source/WebKit/chromium/tests/WebFrameTest.cpp @@ -34,11 +34,13 @@ #include "Frame.h" #include "FrameTestHelpers.h" +#include "FrameView.h" #include "ResourceError.h" #include "WebDocument.h" #include "WebFindOptions.h" #include "WebFormElement.h" #include "WebFrameClient.h" +#include "WebFrameImpl.h" #include "WebRange.h" #include "WebScriptSource.h" #include "WebSearchableFormData.h" @@ -243,6 +245,43 @@ TEST_F(WebFrameTest, DeviceScaleFactorUsesDefaultWithoutViewportTag) // Force the layout to happen before leaving the test. webView->mainFrame()->contentAsText(1024).utf8(); } + +TEST_F(WebFrameTest, FixedLayoutInitializeAtMinimumPageScale) +{ + registerMockedHttpURLLoad("fixed_layout.html"); + + FixedLayoutTestWebViewClient client; + client.m_screenInfo.horizontalDPI = 160; + int viewportWidth = 640; + int viewportHeight = 480; + client.m_windowRect = WebRect(0, 0, viewportWidth, viewportHeight); + + // Make sure we initialize to minimum scale, even if the window size + // only becomes available after the load begins. + WebViewImpl* webViewImpl = static_cast<WebViewImpl*>(FrameTestHelpers::createWebViewAndLoad(m_baseURL + "fixed_layout.html", true, 0, &client)); + webViewImpl->enableFixedLayoutMode(true); + webViewImpl->settings()->setViewportEnabled(true); + webViewImpl->resize(WebSize(viewportWidth, viewportHeight)); + + int defaultFixedLayoutWidth = 980; + float minimumPageScaleFactor = viewportWidth / (float) defaultFixedLayoutWidth; + EXPECT_EQ(minimumPageScaleFactor, webViewImpl->pageScaleFactor()); + + // Assume the user has pinch zoomed to page scale factor 2. + float userPinchPageScaleFactor = 2; + webViewImpl->setPageScaleFactorPreservingScrollOffset(userPinchPageScaleFactor); + webViewImpl->mainFrameImpl()->frameView()->layout(); + + // Make sure we don't reset to initial scale if the page continues to load. + bool isNewNavigation; + webViewImpl->didCommitLoad(&isNewNavigation, false); + webViewImpl->didChangeContentsSize(); + EXPECT_EQ(userPinchPageScaleFactor, webViewImpl->pageScaleFactor()); + + // Make sure we don't reset to initial scale if the viewport size changes. + webViewImpl->resize(WebSize(viewportWidth, viewportHeight + 100)); + EXPECT_EQ(userPinchPageScaleFactor, webViewImpl->pageScaleFactor()); +} #endif #if ENABLE(GESTURE_EVENTS) diff --git a/Source/WebKit/chromium/tests/WebLayerTest.cpp b/Source/WebKit/chromium/tests/WebLayerTest.cpp index 7c0831f90..8fc7c93bd 100644 --- a/Source/WebKit/chromium/tests/WebLayerTest.cpp +++ b/Source/WebKit/chromium/tests/WebLayerTest.cpp @@ -53,10 +53,12 @@ public: MOCK_METHOD0(scheduleComposite, void()); virtual void updateAnimations(double frameBeginTime) { } + virtual void didBeginFrame() { } virtual void layout() { } virtual void applyScrollAndScale(const WebSize& scrollDelta, float scaleFactor) { } virtual WebGraphicsContext3D* createContext3D() { return CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes()).leakPtr(); } virtual void didRebindGraphicsContext(bool success) { } + virtual void willCommit() { } virtual void didCommitAndDrawFrame() { } virtual void didCompleteSwapBuffers() { } }; diff --git a/Source/WebKit/chromium/tests/WebLayerTreeViewTest.cpp b/Source/WebKit/chromium/tests/WebLayerTreeViewTest.cpp new file mode 100644 index 000000000..2df259f76 --- /dev/null +++ b/Source/WebKit/chromium/tests/WebLayerTreeViewTest.cpp @@ -0,0 +1,220 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "platform/WebLayerTreeView.h" + +#include "CompositorFakeWebGraphicsContext3D.h" +#include "WebCompositor.h" +#include "public/WebLayer.h" +#include "public/WebLayerTreeViewClient.h" +#include "public/WebThread.h" +#include <gmock/gmock.h> +#include <public/Platform.h> + +using namespace WebKit; +using testing::Mock; +using testing::Test; + +namespace { + +class MockWebLayerTreeViewClient : public WebLayerTreeViewClient { +public: + virtual void scheduleComposite() OVERRIDE { } + virtual void updateAnimations(double frameBeginTime) OVERRIDE { } + MOCK_METHOD0(willBeginFrame, void()); + MOCK_METHOD0(didBeginFrame, void()); + virtual void layout() OVERRIDE { } + virtual void applyScrollAndScale(const WebSize& scrollDelta, float scaleFactor) OVERRIDE { } + virtual WebGraphicsContext3D* createContext3D() OVERRIDE { return CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes()).leakPtr(); } + virtual void didRebindGraphicsContext(bool success) OVERRIDE { } + MOCK_METHOD0(willCommit, void()); + MOCK_METHOD0(didCommit, void()); + virtual void didCommitAndDrawFrame() OVERRIDE { } + virtual void didCompleteSwapBuffers() OVERRIDE { } +}; + +class MockWebLayerTreeViewClientForThreadedTests : public MockWebLayerTreeViewClient { +public: + virtual void didBeginFrame() OVERRIDE + { + WebKit::Platform::current()->currentThread()->exitRunLoop(); + MockWebLayerTreeViewClient::didBeginFrame(); + } +}; + +class WebLayerTreeViewTestBase : public Test { +protected: + virtual void initializeCompositor() = 0; + virtual WebLayerTreeViewClient* client() = 0; + +public: + virtual void SetUp() + { + initializeCompositor(); + m_rootLayer = WebLayer::create(); + EXPECT_TRUE(m_view.initialize(client(), m_rootLayer, WebLayerTreeView::Settings())); + m_view.setSurfaceReady(); + } + + virtual void TearDown() + { + Mock::VerifyAndClearExpectations(client()); + + m_view.setRootLayer(0); + m_rootLayer.reset(); + m_view.reset(); + WebKit::WebCompositor::shutdown(); + } + +protected: + WebLayer m_rootLayer; + WebLayerTreeView m_view; +}; + +class WebLayerTreeViewSingleThreadTest : public WebLayerTreeViewTestBase { +protected: + void composite() + { + m_view.composite(); + } + + virtual void initializeCompositor() OVERRIDE + { + WebKit::WebCompositor::initialize(0); + } + + virtual WebLayerTreeViewClient* client() OVERRIDE + { + return &m_client; + } + + MockWebLayerTreeViewClient m_client; +}; + +class CancelableTaskWrapper : public RefCounted<CancelableTaskWrapper> { + class Task : public WebThread::Task { + public: + Task(CancelableTaskWrapper* cancelableTask) + : m_cancelableTask(cancelableTask) + { + } + + private: + virtual void run() OVERRIDE + { + m_cancelableTask->runIfNotCanceled(); + } + + RefPtr<CancelableTaskWrapper> m_cancelableTask; + }; + +public: + CancelableTaskWrapper(PassOwnPtr<WebThread::Task> task) + : m_task(task) + { + } + + void cancel() + { + m_task.clear(); + } + + WebThread::Task* createTask() + { + ASSERT(m_task); + return new Task(this); + } + + void runIfNotCanceled() + { + if (!m_task) + return; + m_task->run(); + m_task.clear(); + } + +private: + OwnPtr<WebThread::Task> m_task; +}; + +class WebLayerTreeViewThreadedTest : public WebLayerTreeViewTestBase { +protected: + class TimeoutTask : public WebThread::Task { + virtual void run() OVERRIDE + { + WebKit::Platform::current()->currentThread()->exitRunLoop(); + } + }; + + void composite() + { + m_view.setNeedsRedraw(); + RefPtr<CancelableTaskWrapper> timeoutTask = adoptRef(new CancelableTaskWrapper(adoptPtr(new TimeoutTask()))); + WebKit::Platform::current()->currentThread()->postDelayedTask(timeoutTask->createTask(), 5000); + WebKit::Platform::current()->currentThread()->enterRunLoop(); + timeoutTask->cancel(); + m_view.finishAllRendering(); + } + + virtual void initializeCompositor() OVERRIDE + { + m_webThread = adoptPtr(WebKit::Platform::current()->createThread("WebLayerTreeViewTest")); + WebCompositor::initialize(m_webThread.get()); + } + + virtual WebLayerTreeViewClient* client() OVERRIDE + { + return &m_client; + } + + MockWebLayerTreeViewClientForThreadedTests m_client; + OwnPtr<WebThread> m_webThread; +}; + +TEST_F(WebLayerTreeViewSingleThreadTest, InstrumentationCallbacks) +{ + ::testing::InSequence dummy; + + EXPECT_CALL(m_client, willCommit()); + EXPECT_CALL(m_client, didCommit()); + EXPECT_CALL(m_client, didBeginFrame()); + + composite(); +} + +TEST_F(WebLayerTreeViewThreadedTest, InstrumentationCallbacks) +{ + ::testing::InSequence dummy; + + EXPECT_CALL(m_client, willBeginFrame()); + EXPECT_CALL(m_client, willCommit()); + EXPECT_CALL(m_client, didCommit()); + EXPECT_CALL(m_client, didBeginFrame()); + + composite(); +} + +} // namespace diff --git a/Source/WebKit/chromium/tests/WebTransformationMatrixTest.cpp b/Source/WebKit/chromium/tests/WebTransformationMatrixTest.cpp index af291698a..2888e0d7c 100644 --- a/Source/WebKit/chromium/tests/WebTransformationMatrixTest.cpp +++ b/Source/WebKit/chromium/tests/WebTransformationMatrixTest.cpp @@ -24,9 +24,11 @@ #include "config.h" -#include "../../../../Platform/chromium/public/WebTransformationMatrix.h" +#include <public/WebTransformationMatrix.h> +#include "CCLayerTreeTestCommon.h" #include <gtest/gtest.h> +#include <wtf/MathExtras.h> #define EXPECT_ROW1_EQ(a, b, c, d, matrix) \ EXPECT_FLOAT_EQ((a), (matrix).m11()); \ @@ -74,6 +76,7 @@ EXPECT_NEAR((d), (matrix).m43(), (errorThreshold)); #define ERROR_THRESHOLD 1e-14 +#define LOOSE_ERROR_THRESHOLD 1e-7 using namespace WebKit; @@ -926,7 +929,7 @@ TEST(WebTransformationMatrixTest, verifyIsIdentityOrTranslation) EXPECT_FALSE(A.isIdentityOrTranslation()); } -TEST(WebTransformationMatrixTest, isIntegerTranslation) +TEST(WebTransformationMatrixTest, verifyIsIntegerTranslation) { WebTransformationMatrix A; @@ -953,4 +956,329 @@ TEST(WebTransformationMatrixTest, isIntegerTranslation) EXPECT_TRUE(A.isIntegerTranslation()); } +TEST(WebTransformationMatrixTest, verifyBlendForTranslation) +{ + WebTransformationMatrix from; + from.translate3d(100, 200, 100); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.translate3d(200, 100, 300); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + to.makeIdentity(); + to.translate3d(200, 100, 300); + to.blend(from, 0.25); + EXPECT_ROW1_EQ(1, 0, 0, 125, to); + EXPECT_ROW2_EQ(0, 1, 0, 175, to); + EXPECT_ROW3_EQ(0, 0, 1, 150, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.translate3d(200, 100, 300); + to.blend(from, 0.5); + EXPECT_ROW1_EQ(1, 0, 0, 150, to); + EXPECT_ROW2_EQ(0, 1, 0, 150, to); + EXPECT_ROW3_EQ(0, 0, 1, 200, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.translate3d(200, 100, 300); + to.blend(from, 1); + EXPECT_ROW1_EQ(1, 0, 0, 200, to); + EXPECT_ROW2_EQ(0, 1, 0, 100, to); + EXPECT_ROW3_EQ(0, 0, 1, 300, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForScale) +{ + WebTransformationMatrix from; + from.scale3d(100, 200, 100); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.scale3d(200, 100, 300); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + to.makeIdentity(); + to.scale3d(200, 100, 300); + to.blend(from, 0.25); + EXPECT_ROW1_EQ(125, 0, 0, 0, to); + EXPECT_ROW2_EQ(0, 175, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 150, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.scale3d(200, 100, 300); + to.blend(from, 0.5); + EXPECT_ROW1_EQ(150, 0, 0, 0, to); + EXPECT_ROW2_EQ(0, 150, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 200, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.scale3d(200, 100, 300); + to.blend(from, 1); + EXPECT_ROW1_EQ(200, 0, 0, 0, to); + EXPECT_ROW2_EQ(0, 100, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 300, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForSkewX) +{ + WebTransformationMatrix from; + from.skewX(0); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.skewX(45); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + to.makeIdentity(); + to.skewX(45); + to.blend(from, 0.5); + EXPECT_ROW1_EQ(1, 0.5, 0, 0, to); + EXPECT_ROW2_EQ(0, 1, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.skewX(45); + to.blend(from, 0.25); + EXPECT_ROW1_EQ(1, 0.25, 0, 0, to); + EXPECT_ROW2_EQ(0, 1, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.skewX(45); + to.blend(from, 1); + EXPECT_ROW1_EQ(1, 1, 0, 0, to); + EXPECT_ROW2_EQ(0, 1, 0, 0, to); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForSkewY) +{ + // NOTE CAREFULLY: Decomposition of skew and rotation terms of the matrix is + // inherently underconstrained, and so it does not always compute the originally + // intended skew parameters. The current implementation uses QR decomposition, which + // decomposes the shear into a rotation + non-uniform scale. + // + // It is unlikely that the decomposition implementation will need to change very + // often, so to get any test coverage, the compromise is to verify the exact matrix + // that the blend() operation produces. + // + // This problem also potentially exists for skewX, but the current QR decomposition + // implementation just happens to decompose those test matrices intuitively. + + WebTransformationMatrix from; + from.skewY(0); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.skewY(45); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + to.makeIdentity(); + to.skewY(45); + to.blend(from, 0.25); + EXPECT_ROW1_NEAR(1.0823489449280947471976333, 0.0464370719145053845178239, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0.2152925909665224513123150, 0.9541702441750861130032035, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.skewY(45); + to.blend(from, 0.5); + EXPECT_ROW1_NEAR(1.1152212925809066312865525, 0.0676495144007326631996335, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0.4619397844342648662419037, 0.9519009045724774464858342, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + // Unfortunately, this case suffers from uncomfortably large precision error. + to.makeIdentity(); + to.skewY(45); + to.blend(from, 1); + EXPECT_ROW1_NEAR(1, 0, 0, 0, to, LOOSE_ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(1, 1, 0, 0, to, LOOSE_ERROR_THRESHOLD); + EXPECT_ROW3_EQ(0, 0, 1, 0, to); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForRotationAboutX) +{ + // Even though blending uses quaternions, axis-aligned rotations should blend the same + // with quaternions or Euler angles. So we can test rotation blending by comparing + // against manually specified matrices from Euler angles. + + WebTransformationMatrix from; + from.rotate3d(1, 0, 0, 0); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.rotate3d(1, 0, 0, 90); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + double expectedRotationAngle = 22.5 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(1, 0, 0, 90); + to.blend(from, 0.25); + EXPECT_ROW1_NEAR(1, 0, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, sin(expectedRotationAngle), cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + expectedRotationAngle = 45.0 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(1, 0, 0, 90); + to.blend(from, 0.5); + EXPECT_ROW1_NEAR(1, 0, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, sin(expectedRotationAngle), cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.rotate3d(1, 0, 0, 90); + to.blend(from, 1); + EXPECT_ROW1_NEAR(1, 0, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, 0, -1, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, 1, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForRotationAboutY) +{ + WebTransformationMatrix from; + from.rotate3d(0, 1, 0, 0); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.rotate3d(0, 1, 0, 90); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + double expectedRotationAngle = 22.5 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(0, 1, 0, 90); + to.blend(from, 0.25); + EXPECT_ROW1_NEAR(cos(expectedRotationAngle), 0, sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, 1, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(-sin(expectedRotationAngle), 0, cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + expectedRotationAngle = 45.0 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(0, 1, 0, 90); + to.blend(from, 0.5); + EXPECT_ROW1_NEAR(cos(expectedRotationAngle), 0, sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, 1, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(-sin(expectedRotationAngle), 0, cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.rotate3d(0, 1, 0, 90); + to.blend(from, 1); + EXPECT_ROW1_NEAR(0, 0, 1, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(0, 1, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(-1, 0, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + +TEST(WebTransformationMatrixTest, verifyBlendForRotationAboutZ) +{ + WebTransformationMatrix from; + from.rotate3d(0, 0, 1, 0); + + WebTransformationMatrix to; + + to.makeIdentity(); + to.rotate3d(0, 0, 1, 90); + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + double expectedRotationAngle = 22.5 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(0, 0, 1, 90); + to.blend(from, 0.25); + EXPECT_ROW1_NEAR(cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(sin(expectedRotationAngle), cos(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, 0, 1, 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + expectedRotationAngle = 45.0 * piDouble / 180.0; + to.makeIdentity(); + to.rotate3d(0, 0, 1, 90); + to.blend(from, 0.5); + EXPECT_ROW1_NEAR(cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(sin(expectedRotationAngle), cos(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, 0, 1, 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); + + to.makeIdentity(); + to.rotate3d(0, 0, 1, 90); + to.blend(from, 1); + EXPECT_ROW1_NEAR(0, -1, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW2_NEAR(1, 0, 0, 0, to, ERROR_THRESHOLD); + EXPECT_ROW3_NEAR(0, 0, 1, 0, to, ERROR_THRESHOLD); + EXPECT_ROW4_EQ(0, 0, 0, 1, to); +} + + +TEST(WebTransformationMatrixTest, verifyBlendForCompositeTransform) +{ + // Verify that the blending was done with a decomposition in correct order by blending + // a composite transform. + // Using matrix x vector notation (Ax = b, where x is column vector), the ordering should be: + // perspective * translation * rotation * skew * scale + // + // It is not as important (or meaningful) to check intermediate interpolations; order + // of operations will be tested well enough by the end cases that are easier to + // specify. + + WebTransformationMatrix from; + WebTransformationMatrix to; + + WebTransformationMatrix expectedEndOfAnimation; + expectedEndOfAnimation.applyPerspective(1); + expectedEndOfAnimation.translate3d(10, 20, 30); + expectedEndOfAnimation.rotate3d(0, 0, 1, 25); + expectedEndOfAnimation.skewY(45); + expectedEndOfAnimation.scale3d(6, 7, 8); + + to = expectedEndOfAnimation; + to.blend(from, 0); + EXPECT_TRANSFORMATION_MATRIX_EQ(from, to); + + to = expectedEndOfAnimation; + to.blend(from, 1); + + // Recomposing the matrix results in a normalized matrix, so to verify we need to + // normalize the expectedEndOfAnimation before comparing elements. Normalizing means + // dividing everything by expectedEndOfAnimation.m44(). + WebTransformationMatrix normalizedExpectedEndOfAnimation = expectedEndOfAnimation; + WebTransformationMatrix normalizationMatrix; + normalizationMatrix.setM11(1 / expectedEndOfAnimation.m44()); + normalizationMatrix.setM22(1 / expectedEndOfAnimation.m44()); + normalizationMatrix.setM33(1 / expectedEndOfAnimation.m44()); + normalizationMatrix.setM44(1 / expectedEndOfAnimation.m44()); + normalizedExpectedEndOfAnimation.multiply(normalizationMatrix); + + EXPECT_TRANSFORMATION_MATRIX_EQ(normalizedExpectedEndOfAnimation, to); +} + } // namespace diff --git a/Source/WebKit/chromium/tests/data/fixed_layout.html b/Source/WebKit/chromium/tests/data/fixed_layout.html new file mode 100644 index 000000000..a89cecae9 --- /dev/null +++ b/Source/WebKit/chromium/tests/data/fixed_layout.html @@ -0,0 +1 @@ +<body>Ordinary non-mobile page</body> |