Changeset 112332 in webkit

Timestamp:

Mar 27, 2012 4:49:04 PM (12 years ago)

Author:

commit-queue@webkit.org

Message:

[chromium] Unknown transforms should be treated as non-axis aligned on main thread
​https://bugs.webkit.org/show_bug.cgi?id=82370

Patch by Dana Jansens <​danakj@chromium.org> on 2012-03-27
Reviewed by Adrienne Walker.

Source/WebCore:

On main thread, animating transforms have "unknown" values as they are changing
out of sync on the impl thread. So treat them as non-axis-aligned since they
may be, when deciding to create a render surface.

In addition, since surfaces are cheap on main thread, create one for all layers
with animating transforms and a drawing descendant, as this allows paint culling
within the layer's subtree (the animated transform won't affect drawTransforms
inside the subtree).

Also renamed the layerIsInAnimatingSubtreeFor* to animatingTransformTo*.
The old name made me pause and think what it meant and I'm the one who
created it. Hopefully this is more clear.

Unit test: CCLayerTreeHostCommonTest.verifyAnimationsForRenderSurfaceHierarchy

• platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:

(WebCore::transformToParentIsKnown):
(WebCore):
(WebCore::subtreeShouldRenderToSeparateSurface):
(WebCore::calculateDrawTransformsAndVisibilityInternal):

Source/WebKit/chromium:

• tests/CCLayerTreeHostCommonTest.cpp:

(WebKitTests::TEST):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp (modified) (5 diffs)
• WebKit/chromium/ChangeLog (modified) (1 diff)
• WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp (modified) (5 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-03-27  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Unknown transforms should be treated as non-axis aligned on main thread
+        https://bugs.webkit.org/show_bug.cgi?id=82370
+
+        Reviewed by Adrienne Walker.
+
+        On main thread, animating transforms have "unknown" values as they are changing
+        out of sync on the impl thread. So treat them as non-axis-aligned since they
+        may be, when deciding to create a render surface.
+
+        In addition, since surfaces are cheap on main thread, create one for all layers
+        with animating transforms and a drawing descendant, as this allows paint culling
+        within the layer's subtree (the animated transform won't affect drawTransforms
+        inside the subtree).
+
+        Also renamed the layerIsInAnimatingSubtreeFor* to animatingTransformTo*.
+        The old name made me pause and think what it meant and I'm the one who
+        created it. Hopefully this is more clear.
+
+        Unit test: CCLayerTreeHostCommonTest.verifyAnimationsForRenderSurfaceHierarchy
+
+        * platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp:
+        (WebCore::transformToParentIsKnown):
+        (WebCore):
+        (WebCore::subtreeShouldRenderToSeparateSurface):
+        (WebCore::calculateDrawTransformsAndVisibilityInternal):
+
 2012-03-27  Dirk Pranke  <dpranke@chromium.org>
 

trunk/Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHostCommon.cpp

@@ -140 +140 @@
 }
 
+static inline bool transformToParentIsKnown(CCLayerImpl*)
+{
+    return true;
+}
+
+static inline bool transformToParentIsKnown(LayerChromium* layer)
+{
+    return !layer->transformIsAnimating();
+}
+
 template<typename LayerType>
 static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent)
@@ -170 +180 @@
     // treated as a 3D object by its parent (i.e. parent does preserve-3d).
     if (layer->parent() && layer->parent()->preserves3D() && !layer->preserves3D() && descendantDrawsContent)
+        return true;
+
+    // On the main thread side, animating transforms are unknown, and may cause a RenderSurface on the impl side.
+    // Since they are cheap, we create a rendersurface for all animating transforms to cover these cases, and so
+    // that we can consider descendants as not animating relative to their target to aid culling.
+    if (!transformToParentIsKnown(layer) && descendantDrawsContent)
         return true;
 
@@ -316 +332 @@
     combinedTransform = combinedTransform.multiply(layerLocalTransform);
 
-    bool layerIsInAnimatingSubtreeForSurface = layer->transformIsAnimating();
-    bool layerIsInAnimatingSubtreeForScreen = layer->transformIsAnimating();
+    bool animatingTransformToTarget = layer->transformIsAnimating();
+    bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
-        layerIsInAnimatingSubtreeForSurface |= layer->parent()->drawTransformIsAnimating();
-        layerIsInAnimatingSubtreeForScreen |= layer->parent()->screenSpaceTransformIsAnimating();
+        animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
+        animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
@@ -357 +373 @@
         renderSurface->setOriginTransform(surfaceOriginTransform);
 
-        renderSurface->setTargetSurfaceTransformsAreAnimating(layerIsInAnimatingSubtreeForSurface);
-        renderSurface->setScreenSpaceTransformsAreAnimating(layerIsInAnimatingSubtreeForScreen);
-        layerIsInAnimatingSubtreeForSurface = false;
-        layer->setDrawTransformIsAnimating(layerIsInAnimatingSubtreeForSurface);
-        layer->setScreenSpaceTransformIsAnimating(layerIsInAnimatingSubtreeForScreen);
+        renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
+        renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
+        animatingTransformToTarget = false;
+        layer->setDrawTransformIsAnimating(animatingTransformToTarget);
+        layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
 
         // Update the aggregate hierarchy matrix to include the transform of the newly created RenderSurface.
@@ -388 +404 @@
     } else {
         layer->setDrawTransform(combinedTransform);
-        layer->setDrawTransformIsAnimating(layerIsInAnimatingSubtreeForSurface);
-        layer->setScreenSpaceTransformIsAnimating(layerIsInAnimatingSubtreeForScreen);
+        layer->setDrawTransformIsAnimating(animatingTransformToTarget);
+        layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
         transformedLayerRect = enclosingIntRect(layer->drawTransform().mapRect(layerRect));
 

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-03-27  Dana Jansens  <danakj@chromium.org>
+
+        [chromium] Unknown transforms should be treated as non-axis aligned on main thread
+        https://bugs.webkit.org/show_bug.cgi?id=82370
+
+        Reviewed by Adrienne Walker.
+
+        * tests/CCLayerTreeHostCommonTest.cpp:
+        (WebKitTests::TEST):
+
 2012-03-27  Dana Jansens  <danakj@chromium.org>
 

trunk/Source/WebKit/chromium/tests/CCLayerTreeHostCommonTest.cpp

@@ -677 +677 @@
     // In combination with descendantDrawsContent, opacity != 1 forces the layer to have a new renderSurface.
     addOpacityTransitionToController(*renderSurface1->layerAnimationController(), 10, 1, 0, false);
-    addOpacityTransitionToController(*renderSurface2->layerAnimationController(), 10, 1, 0, false);
-
-    // Also put an animation on a layer without descendants.
+
+    // Also put an animated opacity on a layer without descendants.
     addOpacityTransitionToController(*grandChildOfRoot->layerAnimationController(), 10, 1, 0, false);
 
@@ -687 +686 @@
     sublayerTransform.scale3d(10.0, 1.0, 1.0);
 
-    // Put transform animations on child, renderSurface2, grandChildOfRoot, and grandChildOfRS2
-    addAnimatedTransformToController(*childOfRoot->layerAnimationController(), 10, 30, 0);
+    // In combination with descendantDrawsContent, an animated transform forces the layer to have a new renderSurface.
+    addAnimatedTransformToController(*renderSurface2->layerAnimationController(), 10, 30, 0);
+
+    // Also put transform animations on grandChildOfRoot, and grandChildOfRS2
     addAnimatedTransformToController(*grandChildOfRoot->layerAnimationController(), 10, 30, 0);
-    addAnimatedTransformToController(*renderSurface2->layerAnimationController(), 10, 30, 0);
     addAnimatedTransformToController(*grandChildOfRS2->layerAnimationController(), 10, 30, 0);
 
@@ -743 +743 @@
     EXPECT_FALSE(grandChildOfRS1->drawOpacityIsAnimating());
     EXPECT_FALSE(renderSurface2->drawOpacityIsAnimating());
-    EXPECT_TRUE(renderSurface2->renderSurface()->drawOpacityIsAnimating());
+    EXPECT_FALSE(renderSurface2->renderSurface()->drawOpacityIsAnimating());
     EXPECT_FALSE(childOfRS2->drawOpacityIsAnimating());
     EXPECT_FALSE(grandChildOfRS2->drawOpacityIsAnimating());
@@ -750 +750 @@
     //
     EXPECT_FALSE(parent->drawTransformIsAnimating());
-    EXPECT_TRUE(childOfRoot->drawTransformIsAnimating());
+    EXPECT_FALSE(childOfRoot->drawTransformIsAnimating());
     EXPECT_TRUE(grandChildOfRoot->drawTransformIsAnimating());
     EXPECT_FALSE(renderSurface1->drawTransformIsAnimating());
@@ -764 +764 @@
     //
     EXPECT_FALSE(parent->screenSpaceTransformIsAnimating());
-    EXPECT_TRUE(childOfRoot->screenSpaceTransformIsAnimating());
+    EXPECT_FALSE(childOfRoot->screenSpaceTransformIsAnimating());
     EXPECT_TRUE(grandChildOfRoot->screenSpaceTransformIsAnimating());
     EXPECT_FALSE(renderSurface1->screenSpaceTransformIsAnimating());