Changeset 147163 in webkit

Timestamp:

Mar 28, 2013 2:50:39 PM (11 years ago)

Author:

commit-queue@webkit.org

Message:

Support bottom-right anchored fixed-position elements during a pinch gesture
​https://bugs.webkit.org/show_bug.cgi?id=111670

Patch by Tien-Ren Chen <​trchen@chromium.org> on 2013-03-28
Reviewed by James Robinson.

Source/Platform:

Added WebLayerPositionConstraint for layers that need position
adjustment during threaded scrolling.
Currently it is only used for fixed-position layers.

• Platform.gypi:
• chromium/public/WebLayer.h:

(WebKit):
(WebLayer):
(WebKit::WebLayer::setPositionConstraint):
(WebKit::WebLayer::positionConstraint):
(WebKit::WebLayer::setFixedToContainerLayer):
(WebKit::WebLayer::fixedToContainerLayer):

• chromium/public/WebLayerPositionConstraint.h: Added.

(WebKit):
(WebLayerPositionConstraint):
(WebKit::WebLayerPositionConstraint::WebLayerPositionConstraint):
(WebKit::WebLayerPositionConstraint::fixedPosition):

Source/WebCore:

This patch adds support to bottom-right fixed-position elements by
introducing WebLayerPositionConstraint to WebLayer.

No new tests. Can't test until chromium patch landed.

• page/scrolling/ScrollingCoordinator.h:

(WebCore::ScrollingCoordinator::updateLayerPositionConstraint):

• page/scrolling/chromium/ScrollingCoordinatorChromium.cpp:

(WebCore::clearPositionConstraintExceptForLayer):
(WebCore):
(WebCore::computePositionConstraint):
(WebCore::ScrollingCoordinatorChromium::updateLayerPositionConstraint):

• page/scrolling/chromium/ScrollingCoordinatorChromium.h:

(ScrollingCoordinatorChromium):

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::registerScrollingLayers):

• rendering/RenderLayerBacking.h:

(WebCore::RenderLayerBacking::contentsContainmentLayer):
(RenderLayerBacking):

• rendering/RenderLayerCompositor.cpp:
• rendering/RenderLayerCompositor.h:

Location:

trunk/Source

Files:

• Platform/ChangeLog (modified) (1 diff)
• Platform/Platform.gypi (modified) (1 diff)
• Platform/chromium/public/WebLayer.h (modified) (4 diffs)
• Platform/chromium/public/WebLayerPositionConstraint.h (added)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/page/scrolling/ScrollingCoordinator.h (modified) (1 diff)
• WebCore/page/scrolling/chromium/ScrollingCoordinatorChromium.cpp (modified) (4 diffs)
• WebCore/page/scrolling/chromium/ScrollingCoordinatorChromium.h (modified) (1 diff)
• WebCore/rendering/RenderLayerBacking.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayerBacking.h (modified) (1 diff)
• WebCore/rendering/RenderLayerCompositor.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayerCompositor.h (modified) (1 diff)

trunk/Source/Platform/ChangeLog

@@ +1 @@
+2013-03-28  Tien-Ren Chen  <trchen@chromium.org>
+
+        Support bottom-right anchored fixed-position elements during a pinch gesture
+        https://bugs.webkit.org/show_bug.cgi?id=111670
+
+        Reviewed by James Robinson.
+
+        Added WebLayerPositionConstraint for layers that need position
+        adjustment during threaded scrolling.
+        Currently it is only used for fixed-position layers.
+
+        * Platform.gypi:
+        * chromium/public/WebLayer.h:
+        (WebKit):
+        (WebLayer):
+        (WebKit::WebLayer::setPositionConstraint):
+        (WebKit::WebLayer::positionConstraint):
+        (WebKit::WebLayer::setFixedToContainerLayer):
+        (WebKit::WebLayer::fixedToContainerLayer):
+        * chromium/public/WebLayerPositionConstraint.h: Added.
+        (WebKit):
+        (WebLayerPositionConstraint):
+        (WebKit::WebLayerPositionConstraint::WebLayerPositionConstraint):
+        (WebKit::WebLayerPositionConstraint::fixedPosition):
+
 2013-03-28  Zan Dobersek  <zdobersek@igalia.com>
 

trunk/Source/Platform/Platform.gypi

@@ -84 +84 @@
             'chromium/public/WebImageLayer.h',
             'chromium/public/WebLayer.h',
+            'chromium/public/WebLayerPositionConstraint.h',
             'chromium/public/WebLayerScrollClient.h',
             'chromium/public/WebLayerTreeView.h',

trunk/Source/Platform/chromium/public/WebLayer.h

@@ -30 +30 @@
 #include "WebColor.h"
 #include "WebCommon.h"
+
+// Remove after making setPositionConstraint() pure virtual.
+#include "WebLayerPositionConstraint.h"
+
 #include "WebPoint.h"
 #include "WebPrivatePtr.h"
@@ -45 +49 @@
 struct WebFloatPoint;
 struct WebFloatRect;
+struct WebLayerPositionConstraint;
 struct WebSize;
 
@@ -190 +195 @@
     virtual bool isContainerForFixedPositionLayers() const = 0;
 
-    virtual void setFixedToContainerLayer(bool) = 0;
-    virtual bool fixedToContainerLayer() const = 0;
+    // This function sets layer position constraint. The constraint will be used
+    // to adjust layer position during threaded scrolling.
+    // FIXME: Make pure virtual after implementation lands.
+    virtual void setPositionConstraint(const WebLayerPositionConstraint& constraint) { setFixedToContainerLayer(constraint.isFixedPosition); }
+    virtual WebLayerPositionConstraint positionConstraint() const { return WebLayerPositionConstraint(); }
 
     // The scroll client is notified when the scroll position of the WebLayer
@@ -206 +214 @@
     // True if the layer is not part of a tree attached to a WebLayerTreeView.
     virtual bool isOrphan() const = 0;
+
+    // DEPRECATED
+    virtual void setFixedToContainerLayer(bool) { }
+    virtual bool fixedToContainerLayer() const { return positionConstraint().isFixedPosition; }
 };
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-03-28  Tien-Ren Chen  <trchen@chromium.org>
+
+        Support bottom-right anchored fixed-position elements during a pinch gesture
+        https://bugs.webkit.org/show_bug.cgi?id=111670
+
+        Reviewed by James Robinson.
+
+        This patch adds support to bottom-right fixed-position elements by
+        introducing WebLayerPositionConstraint to WebLayer.
+
+        No new tests. Can't test until chromium patch landed.
+
+        * page/scrolling/ScrollingCoordinator.h:
+        (WebCore::ScrollingCoordinator::updateLayerPositionConstraint):
+        * page/scrolling/chromium/ScrollingCoordinatorChromium.cpp:
+        (WebCore::clearPositionConstraintExceptForLayer):
+        (WebCore):
+        (WebCore::computePositionConstraint):
+        (WebCore::ScrollingCoordinatorChromium::updateLayerPositionConstraint):
+        * page/scrolling/chromium/ScrollingCoordinatorChromium.h:
+        (ScrollingCoordinatorChromium):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::registerScrollingLayers):
+        * rendering/RenderLayerBacking.h:
+        (WebCore::RenderLayerBacking::contentsContainmentLayer):
+        (RenderLayerBacking):
+        * rendering/RenderLayerCompositor.cpp:
+        * rendering/RenderLayerCompositor.h:
+
 2013-03-28  James Robinson  <jamesr@chromium.org>
 

trunk/Source/WebCore/page/scrolling/ScrollingCoordinator.h

@@ -154 +154 @@
     virtual void scrollableAreaScrollbarLayerDidChange(ScrollableArea*, ScrollbarOrientation) { }
     virtual void setLayerIsContainerForFixedPositionLayers(GraphicsLayer*, bool) { }
-    virtual void setLayerIsFixedToContainerLayer(GraphicsLayer*, bool) { }
+    virtual void updateLayerPositionConstraint(RenderLayer*) { }
     virtual void touchEventTargetRectsDidChange(const Document*) { }
 

trunk/Source/WebCore/page/scrolling/chromium/ScrollingCoordinatorChromium.cpp

@@ -33 +33 @@
 #include "Page.h"
 #include "Region.h"
+#include "RenderLayerBacking.h"
 #include "RenderLayerCompositor.h"
 #include "RenderView.h"
@@ -40 +41 @@
 #include <public/Platform.h>
 #include <public/WebCompositorSupport.h>
+#include <public/WebLayerPositionConstraint.h>
 #include <public/WebScrollbar.h>
 #include <public/WebScrollbarLayer.h>
@@ -46 +48 @@
 
 using WebKit::WebLayer;
+using WebKit::WebLayerPositionConstraint;
 using WebKit::WebRect;
 using WebKit::WebScrollbarLayer;
@@ -234 +237 @@
 }
 
-void ScrollingCoordinatorChromium::setLayerIsFixedToContainerLayer(GraphicsLayer* layer, bool enable)
-{
-    if (WebLayer* scrollableLayer = scrollingWebLayerForGraphicsLayer(layer))
-        scrollableLayer->setFixedToContainerLayer(enable);
+static void clearPositionConstraintExceptForLayer(GraphicsLayer* layer, GraphicsLayer* except)
+{
+    if (layer && layer != except && scrollingWebLayerForGraphicsLayer(layer))
+        scrollingWebLayerForGraphicsLayer(layer)->setPositionConstraint(WebLayerPositionConstraint());
+}
+
+static WebLayerPositionConstraint computePositionConstraint(const RenderLayer* layer)
+{
+    ASSERT(layer->isComposited());
+    do {
+        if (layer->renderer()->style()->position() == FixedPosition) {
+            const RenderObject* fixedPositionObject = layer->renderer();
+            bool fixedToRight = !fixedPositionObject->style()->right().isAuto();
+            bool fixedToBottom = !fixedPositionObject->style()->bottom().isAuto();
+            return WebLayerPositionConstraint::fixedPosition(fixedToRight, fixedToBottom);
+        }
+
+        layer = layer->parent();
+    } while (layer && !layer->isComposited());
+    return WebLayerPositionConstraint();
+}
+
+void ScrollingCoordinatorChromium::updateLayerPositionConstraint(RenderLayer* layer)
+{
+    ASSERT(layer->backing());
+    RenderLayerBacking* backing = layer->backing();
+    GraphicsLayer* mainLayer = backing->childForSuperlayers();
+
+    // Avoid unnecessary commits
+    clearPositionConstraintExceptForLayer(backing->ancestorClippingLayer(), mainLayer);
+    clearPositionConstraintExceptForLayer(backing->contentsContainmentLayer(), mainLayer);
+    clearPositionConstraintExceptForLayer(backing->graphicsLayer(), mainLayer);
+
+    if (WebLayer* scrollableLayer = scrollingWebLayerForGraphicsLayer(mainLayer))
+        scrollableLayer->setPositionConstraint(computePositionConstraint(layer));
 }
 

trunk/Source/WebCore/page/scrolling/chromium/ScrollingCoordinatorChromium.h

@@ -54 +54 @@
 
     // Attach/detach layer position to ancestor fixed position container.
-    virtual void setLayerIsFixedToContainerLayer(GraphicsLayer*, bool);
+    virtual void updateLayerPositionConstraint(RenderLayer*);
 
     // Should be called when a ScrollableArea is getting destroyed.

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -861 +861 @@
     compositor()->updateViewportConstraintStatus(m_owningLayer);
 
-    // FIXME: it would be nice to avoid all this work if the platform doesn't implement setLayerIsFixedToContainerLayer().
-    if (renderer()->style()->position() == FixedPosition || compositor()->fixedPositionedByAncestor(m_owningLayer))
-        scrollingCoordinator->setLayerIsFixedToContainerLayer(childForSuperlayers(), true);
-    else {
-        if (m_ancestorClippingLayer)
-            scrollingCoordinator->setLayerIsFixedToContainerLayer(m_ancestorClippingLayer.get(), false);
-        scrollingCoordinator->setLayerIsFixedToContainerLayer(m_graphicsLayer.get(), false);
-    }
+    if (!scrollingCoordinator->supportsFixedPositionLayers())
+        return;
+
+    scrollingCoordinator->updateLayerPositionConstraint(m_owningLayer);
+
     // Page scale is applied as a transform on the root render view layer. Because the scroll
     // layer is further up in the hierarchy, we need to avoid marking the root render view

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -88 +88 @@
     GraphicsLayer* ancestorClippingLayer() const { return m_ancestorClippingLayer.get(); }
 
+    GraphicsLayer* contentsContainmentLayer() const { return m_contentsContainmentLayer.get(); }
+
     bool hasContentsLayer() const { return m_foregroundLayer != 0; }
     GraphicsLayer* foregroundLayer() const { return m_foregroundLayer.get(); }

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -1938 +1938 @@
 }
 
-// Return true if there is an ancestor layer that is fixed positioned to the view.
-// Note that if the ancestor has a stacking context and is fixed position then this method
-// will return false.
-bool RenderLayerCompositor::fixedPositionedByAncestor(const RenderLayer* layer) const
-{
-    if (!layer->isComposited() || !layer->parent())
-        return false;
-
-    const RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
-    if (!compositingAncestor)
-        return false;
-
-    const RenderLayer* curr = layer;
-    while (curr) {
-        const RenderLayer* next = curr->parent();
-        if (next == compositingAncestor)
-            return false;
-
-        if (next && next->renderer()->style()->position() == FixedPosition)
-            return true;
-        curr = next;
-    }
-    return false;
-}
-
 bool RenderLayerCompositor::requiresCompositingForScrollableFrame() const
 {

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -155 +155 @@
     bool clipsCompositingDescendants(const RenderLayer*) const;
 
-    // Whether the layer is fixed positioned to the view by an ancestor layer.
-    bool fixedPositionedByAncestor(const RenderLayer*) const;
-
     // Whether the given layer needs an extra 'contents' layer.
     bool needsContentsCompositingLayer(const RenderLayer*) const;