<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[164759] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/164759">164759</a></dd>
<dt>Author</dt> <dd>simon.fraser@apple.com</dd>
<dt>Date</dt> <dd>2014-02-26 17:04:23 -0800 (Wed, 26 Feb 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Prepare for overflow scrolling nodes in the scrolling tree
https://bugs.webkit.org/show_bug.cgi?id=129398
Reviewed by Tim Horton.
Lay some groundwork for overflow:scrolling nodes in the scrolling tree.
Change terminology to refer to "scroll-coordinatored" layers now, not just viewport-constrained
layers.
A given layer can be both viewport-constrained and overflow-scrolling (e.g. position:fixed,
overflow:scroll), so handle that in RenderLayerBacking, and use some "reason" flags
in RenderLayerCompositor.
* page/FrameView.cpp:
(WebCore::FrameView::scrollLayerID): Rename
* page/scrolling/ScrollingStateTree.cpp:
(WebCore::ScrollingStateTree::attachNode): Remove invalid assertion.
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::RenderLayerBacking):
(WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):
(WebCore::RenderLayerBacking::updateScrollingLayers): Simplify the logic with
an early return.
(WebCore::RenderLayerBacking::detachFromScrollingCoordinator):
Allow a layer to play both viewport-constrained and scrolling roles
in the scrolling tree.
* rendering/RenderLayerBacking.h:
(WebCore::RenderLayerBacking::viewportConstrainedNodeID):
(WebCore::RenderLayerBacking::setViewportConstrainedNodeID):
(WebCore::RenderLayerBacking::scrollingNodeID):
(WebCore::RenderLayerBacking::setScrollingNodeID):
(WebCore::RenderLayerBacking::scrollingNodeIDForChildren):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::flushPendingLayerChanges):
(WebCore::RenderLayerCompositor::didFlushChangesForLayer):
(WebCore::RenderLayerCompositor::updateBacking):
(WebCore::RenderLayerCompositor::layerWillBeRemoved):
(WebCore::RenderLayerCompositor::fixedRootBackgroundLayerChanged):
(WebCore::RenderLayerCompositor::clearBackingForLayerIncludingDescendants):
(WebCore::RenderLayerCompositor::requiresCompositingLayer):
(WebCore::RenderLayerCompositor::requiresOwnBackingStore):
(WebCore::RenderLayerCompositor::reasonsForCompositing):
(WebCore::RenderLayerCompositor::requiresCompositingForScrolling):
(WebCore::isViewportConstrainedFixedOrStickyLayer):
(WebCore::isMainFrameScrollingOrOverflowScrolling):
(WebCore::RenderLayerCompositor::rootLayerAttachmentChanged):
(WebCore::RenderLayerCompositor::updateScrollCoordinatedStatus):
(WebCore::RenderLayerCompositor::removeFromScrollCoordinatedLayers):
(WebCore::nearestScrollCoordinatedAncestor):
(WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
(WebCore::RenderLayerCompositor::detachScrollCoordinatedLayer):
(WebCore::RenderLayerCompositor::registerAllViewportConstrainedLayers):
(WebCore::RenderLayerCompositor::willRemoveScrollingLayer):
(WebCore::RenderLayerCompositor::didAddScrollingLayer):
* rendering/RenderLayerCompositor.h:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorepageFrameViewcpp">trunk/Source/WebCore/page/FrameView.cpp</a></li>
<li><a href="#trunkSourceWebCorepagescrollingScrollingStateTreecpp">trunk/Source/WebCore/page/scrolling/ScrollingStateTree.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerBackingcpp">trunk/Source/WebCore/rendering/RenderLayerBacking.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerBackingh">trunk/Source/WebCore/rendering/RenderLayerBacking.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerCompositorcpp">trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderLayerCompositorh">trunk/Source/WebCore/rendering/RenderLayerCompositor.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/ChangeLog 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -1,3 +1,60 @@
</span><ins>+2014-02-26 Simon Fraser <simon.fraser@apple.com>
+
+ Prepare for overflow scrolling nodes in the scrolling tree
+ https://bugs.webkit.org/show_bug.cgi?id=129398
+
+ Reviewed by Tim Horton.
+
+ Lay some groundwork for overflow:scrolling nodes in the scrolling tree.
+ Change terminology to refer to "scroll-coordinatored" layers now, not just viewport-constrained
+ layers.
+
+ A given layer can be both viewport-constrained and overflow-scrolling (e.g. position:fixed,
+ overflow:scroll), so handle that in RenderLayerBacking, and use some "reason" flags
+ in RenderLayerCompositor.
+
+ * page/FrameView.cpp:
+ (WebCore::FrameView::scrollLayerID): Rename
+ * page/scrolling/ScrollingStateTree.cpp:
+ (WebCore::ScrollingStateTree::attachNode): Remove invalid assertion.
+ * rendering/RenderLayerBacking.cpp:
+ (WebCore::RenderLayerBacking::RenderLayerBacking):
+ (WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):
+ (WebCore::RenderLayerBacking::updateScrollingLayers): Simplify the logic with
+ an early return.
+ (WebCore::RenderLayerBacking::detachFromScrollingCoordinator):
+ Allow a layer to play both viewport-constrained and scrolling roles
+ in the scrolling tree.
+ * rendering/RenderLayerBacking.h:
+ (WebCore::RenderLayerBacking::viewportConstrainedNodeID):
+ (WebCore::RenderLayerBacking::setViewportConstrainedNodeID):
+ (WebCore::RenderLayerBacking::scrollingNodeID):
+ (WebCore::RenderLayerBacking::setScrollingNodeID):
+ (WebCore::RenderLayerBacking::scrollingNodeIDForChildren):
+ * rendering/RenderLayerCompositor.cpp:
+ (WebCore::RenderLayerCompositor::flushPendingLayerChanges):
+ (WebCore::RenderLayerCompositor::didFlushChangesForLayer):
+ (WebCore::RenderLayerCompositor::updateBacking):
+ (WebCore::RenderLayerCompositor::layerWillBeRemoved):
+ (WebCore::RenderLayerCompositor::fixedRootBackgroundLayerChanged):
+ (WebCore::RenderLayerCompositor::clearBackingForLayerIncludingDescendants):
+ (WebCore::RenderLayerCompositor::requiresCompositingLayer):
+ (WebCore::RenderLayerCompositor::requiresOwnBackingStore):
+ (WebCore::RenderLayerCompositor::reasonsForCompositing):
+ (WebCore::RenderLayerCompositor::requiresCompositingForScrolling):
+ (WebCore::isViewportConstrainedFixedOrStickyLayer):
+ (WebCore::isMainFrameScrollingOrOverflowScrolling):
+ (WebCore::RenderLayerCompositor::rootLayerAttachmentChanged):
+ (WebCore::RenderLayerCompositor::updateScrollCoordinatedStatus):
+ (WebCore::RenderLayerCompositor::removeFromScrollCoordinatedLayers):
+ (WebCore::nearestScrollCoordinatedAncestor):
+ (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
+ (WebCore::RenderLayerCompositor::detachScrollCoordinatedLayer):
+ (WebCore::RenderLayerCompositor::registerAllViewportConstrainedLayers):
+ (WebCore::RenderLayerCompositor::willRemoveScrollingLayer):
+ (WebCore::RenderLayerCompositor::didAddScrollingLayer):
+ * rendering/RenderLayerCompositor.h:
+
</ins><span class="cx"> 2014-02-26 Andy Estes <aestes@apple.com>
</span><span class="cx">
</span><span class="cx"> [iOS] Support network state notification using CPNetworkObserver
</span></span></pre></div>
<a id="trunkSourceWebCorepageFrameViewcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/FrameView.cpp (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/FrameView.cpp 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/page/FrameView.cpp 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -814,7 +814,7 @@
</span><span class="cx"> if (!backing)
</span><span class="cx"> return 0;
</span><span class="cx">
</span><del>- return backing->scrollLayerID();
</del><ins>+ return backing->scrollingNodeID();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(RUBBER_BANDING)
</span></span></pre></div>
<a id="trunkSourceWebCorepagescrollingScrollingStateTreecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/page/scrolling/ScrollingStateTree.cpp (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/page/scrolling/ScrollingStateTree.cpp 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/page/scrolling/ScrollingStateTree.cpp 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -108,8 +108,6 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case ScrollingNode: {
</span><del>- // FIXME: We currently only support child nodes that are fixed.
- ASSERT_NOT_REACHED();
</del><span class="cx"> OwnPtr<ScrollingStateScrollingNode> scrollingNode = ScrollingStateScrollingNode::create(*this, newNodeID);
</span><span class="cx"> newNode = scrollingNode.get();
</span><span class="cx"> parent->appendChild(scrollingNode.release());
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerBackingcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerBacking.cpp (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/rendering/RenderLayerBacking.cpp 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -109,7 +109,8 @@
</span><span class="cx">
</span><span class="cx"> RenderLayerBacking::RenderLayerBacking(RenderLayer& layer)
</span><span class="cx"> : m_owningLayer(layer)
</span><del>- , m_scrollLayerID(0)
</del><ins>+ , m_viewportConstrainedNodeID(0)
+ , m_scrollingNodeID(0)
</ins><span class="cx"> , m_artificiallyInflatedBounds(false)
</span><span class="cx"> , m_isMainFrameRenderViewLayer(false)
</span><span class="cx"> , m_usingTiledCacheLayer(false)
</span><span class="lines">@@ -951,9 +952,7 @@
</span><span class="cx"> m_scrollingContentsLayer->setSize(scrollSize);
</span><span class="cx"> // Scrolling the content layer does not need to trigger a repaint. The offset will be compensated away during painting.
</span><span class="cx"> // FIXME: The paint offset and the scroll offset should really be separate concepts.
</span><del>- m_scrollingContentsLayer->setOffsetFromRenderer(paddingBox.location() - FloatPoint() - scrollOffset, GraphicsLayer::DontSetNeedsDisplay);
-
- compositor().scrollingLayerAddedOrUpdated(&m_owningLayer);
</del><ins>+ m_scrollingContentsLayer->setOffsetFromRenderer(paddingBox.location() - IntPoint() - scrollOffset, GraphicsLayer::DontSetNeedsDisplay);
</ins><span class="cx"> #else
</span><span class="cx"> m_scrollingContentsLayer->setPosition(FloatPoint(-scrollOffset.width(), -scrollOffset.height()));
</span><span class="cx">
</span><span class="lines">@@ -992,7 +991,7 @@
</span><span class="cx"> updateDrawsContent(isSimpleContainer);
</span><span class="cx"> updateAfterWidgetResize();
</span><span class="cx">
</span><del>- compositor().updateViewportConstraintStatus(m_owningLayer);
</del><ins>+ compositor().updateScrollCoordinatedStatus(m_owningLayer);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderLayerBacking::adjustAncestorCompositingBoundsForFlowThread(LayoutRect& ancestorCompositingBounds, const RenderLayer* compositingAncestor) const
</span><span class="lines">@@ -1423,91 +1422,59 @@
</span><span class="cx">
</span><span class="cx"> bool RenderLayerBacking::updateScrollingLayers(bool needsScrollingLayers)
</span><span class="cx"> {
</span><del>- ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
</del><ins>+ if (needsScrollingLayers == !!m_scrollingLayer)
+ return false;
</ins><span class="cx">
</span><del>- bool layerChanged = false;
- if (needsScrollingLayers) {
- if (!m_scrollingLayer) {
- // Outer layer which corresponds with the scroll view.
- m_scrollingLayer = createGraphicsLayer("Scrolling container");
- m_scrollingLayer->setDrawsContent(false);
- m_scrollingLayer->setMasksToBounds(true);
</del><ins>+ if (!m_scrollingLayer) {
+ // Outer layer which corresponds with the scroll view.
+ m_scrollingLayer = createGraphicsLayer("Scrolling container");
+ m_scrollingLayer->setDrawsContent(false);
+ m_scrollingLayer->setMasksToBounds(true);
</ins><span class="cx">
</span><del>- // Inner layer which renders the content that scrolls.
- m_scrollingContentsLayer = createGraphicsLayer("Scrolled Contents");
- m_scrollingContentsLayer->setDrawsContent(true);
- GraphicsLayerPaintingPhase paintPhase = GraphicsLayerPaintOverflowContents | GraphicsLayerPaintCompositedScroll;
- if (!m_foregroundLayer)
- paintPhase |= GraphicsLayerPaintForeground;
- m_scrollingContentsLayer->setPaintingPhase(paintPhase);
- m_scrollingLayer->addChild(m_scrollingContentsLayer.get());
</del><ins>+ // Inner layer which renders the content that scrolls.
+ m_scrollingContentsLayer = createGraphicsLayer("Scrolled Contents");
+ m_scrollingContentsLayer->setDrawsContent(true);
+ GraphicsLayerPaintingPhase paintPhase = GraphicsLayerPaintOverflowContents | GraphicsLayerPaintCompositedScroll;
+ if (!m_foregroundLayer)
+ paintPhase |= GraphicsLayerPaintForeground;
+ m_scrollingContentsLayer->setPaintingPhase(paintPhase);
+ m_scrollingLayer->addChild(m_scrollingContentsLayer.get());
+ } else {
+ compositor().willRemoveScrollingLayer(m_owningLayer);
</ins><span class="cx">
</span><del>- layerChanged = true;
- if (scrollingCoordinator)
- scrollingCoordinator->scrollableAreaScrollLayerDidChange(&m_owningLayer);
-#if PLATFORM(IOS)
- if (m_owningLayer.parent())
- compositor().scrollingLayerAddedOrUpdated(&m_owningLayer);
-#endif
- }
- } else if (m_scrollingLayer) {
-#if PLATFORM(IOS)
- if (!renderer().documentBeingDestroyed())
- compositor().scrollingLayerRemoved(&m_owningLayer, m_scrollingLayer->platformLayer(), m_scrollingContentsLayer->platformLayer());
-#endif
</del><span class="cx"> willDestroyLayer(m_scrollingLayer.get());
</span><span class="cx"> willDestroyLayer(m_scrollingContentsLayer.get());
</span><span class="cx"> m_scrollingLayer = nullptr;
</span><span class="cx"> m_scrollingContentsLayer = nullptr;
</span><del>- layerChanged = true;
- if (scrollingCoordinator)
- scrollingCoordinator->scrollableAreaScrollLayerDidChange(&m_owningLayer);
</del><span class="cx"> }
</span><span class="cx">
</span><del>- if (layerChanged) {
- updateInternalHierarchy();
- m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
-#if !PLATFORM(IOS)
- m_graphicsLayer->setNeedsDisplay();
- compositor().scrollingLayerDidChange(m_owningLayer);
-#endif
- }
</del><ins>+ updateInternalHierarchy();
+ m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
+ m_graphicsLayer->setNeedsDisplay(); // Because painting phases changed.
</ins><span class="cx">
</span><del>- return layerChanged;
</del><ins>+ if (m_scrollingLayer)
+ compositor().didAddScrollingLayer(m_owningLayer);
+
+ return true;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerBacking::attachToScrollingCoordinatorWithParent(RenderLayerBacking* parent)
-{
- ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
- if (!scrollingCoordinator)
- return;
-
- // FIXME: When we support overflow areas, we will have to refine this for overflow areas that are also
- // positon:fixed.
- ScrollingNodeType nodeType;
- if (renderer().style().position() == FixedPosition)
- nodeType = FixedNode;
- else if (renderer().style().position() == StickyPosition)
- nodeType = StickyNode;
- else
- nodeType = ScrollingNode;
-
- ScrollingNodeID parentID = parent ? parent->scrollLayerID() : 0;
- m_scrollLayerID = scrollingCoordinator->attachToStateTree(nodeType, m_scrollLayerID ? m_scrollLayerID : scrollingCoordinator->uniqueScrollLayerID(), parentID);
-}
-
</del><span class="cx"> void RenderLayerBacking::detachFromScrollingCoordinator()
</span><span class="cx"> {
</span><del>- // If m_scrollLayerID is 0, then this backing is not attached to the ScrollingCoordinator.
- if (!m_scrollLayerID)
</del><ins>+ if (!m_scrollingNodeID && !m_viewportConstrainedNodeID)
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
</span><span class="cx"> if (!scrollingCoordinator)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- scrollingCoordinator->detachFromStateTree(m_scrollLayerID);
- m_scrollLayerID = 0;
</del><ins>+ if (m_scrollingNodeID)
+ scrollingCoordinator->detachFromStateTree(m_scrollingNodeID);
+
+ if (m_viewportConstrainedNodeID)
+ scrollingCoordinator->detachFromStateTree(m_viewportConstrainedNodeID);
+
+ m_scrollingNodeID = 0;
+ m_viewportConstrainedNodeID = 0;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GraphicsLayerPaintingPhase RenderLayerBacking::paintingPhaseForPrimaryLayer() const
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerBackingh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerBacking.h (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerBacking.h 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/rendering/RenderLayerBacking.h 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -31,6 +31,7 @@
</span><span class="cx"> #include "GraphicsLayer.h"
</span><span class="cx"> #include "GraphicsLayerClient.h"
</span><span class="cx"> #include "RenderLayer.h"
</span><ins>+#include "ScrollingCoordinator.h"
</ins><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="lines">@@ -101,10 +102,16 @@
</span><span class="cx"> GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
</span><span class="cx"> GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
</span><span class="cx">
</span><del>- void attachToScrollingCoordinatorWithParent(RenderLayerBacking* parent);
</del><span class="cx"> void detachFromScrollingCoordinator();
</span><del>- uint64_t scrollLayerID() const { return m_scrollLayerID; }
</del><ins>+
+ ScrollingNodeID viewportConstrainedNodeID() const { return m_viewportConstrainedNodeID; }
+ void setViewportConstrainedNodeID(ScrollingNodeID nodeID) { m_viewportConstrainedNodeID = nodeID; }
+
+ ScrollingNodeID scrollingNodeID() const { return m_scrollingNodeID; }
+ void setScrollingNodeID(ScrollingNodeID nodeID) { m_scrollingNodeID = nodeID; }
</ins><span class="cx">
</span><ins>+ ScrollingNodeID scrollingNodeIDForChildren() const { return m_scrollingNodeID ? m_scrollingNodeID : m_viewportConstrainedNodeID; }
+
</ins><span class="cx"> bool hasMaskLayer() const { return m_maskLayer != 0; }
</span><span class="cx">
</span><span class="cx"> GraphicsLayer* parentForSublayers() const;
</span><span class="lines">@@ -308,7 +315,8 @@
</span><span class="cx"> std::unique_ptr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
</span><span class="cx"> std::unique_ptr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
</span><span class="cx">
</span><del>- uint64_t m_scrollLayerID;
</del><ins>+ ScrollingNodeID m_viewportConstrainedNodeID;
+ ScrollingNodeID m_scrollingNodeID;
</ins><span class="cx">
</span><span class="cx"> LayoutRect m_compositedBounds;
</span><span class="cx"> LayoutSize m_devicePixelFractionFromRenderer;
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerCompositorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -439,10 +439,10 @@
</span><span class="cx"> client->didFlushCompositingLayers();
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- for (auto it = m_viewportConstrainedLayersNeedingUpdate.begin(), end = m_viewportConstrainedLayersNeedingUpdate.end(); it != end; ++it)
- registerOrUpdateViewportConstrainedLayer(**it);
</del><ins>+ for (auto it = m_scrollCoordinatedLayersNeedingUpdate.begin(), end = m_scrollCoordinatedLayersNeedingUpdate.end(); it != end; ++it)
+ updateScrollCoordinatedStatus(**it);
</ins><span class="cx">
</span><del>- m_viewportConstrainedLayersNeedingUpdate.clear();
</del><ins>+ m_scrollCoordinatedLayersNeedingUpdate.clear();
</ins><span class="cx"> startLayerFlushTimerIfNeeded();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -488,8 +488,8 @@
</span><span class="cx">
</span><span class="cx"> void RenderLayerCompositor::didFlushChangesForLayer(RenderLayer& layer, const GraphicsLayer* graphicsLayer)
</span><span class="cx"> {
</span><del>- if (m_viewportConstrainedLayers.contains(&layer))
- m_viewportConstrainedLayersNeedingUpdate.add(&layer);
</del><ins>+ if (m_scrollCoordinatedLayers.contains(&layer))
+ m_scrollCoordinatedLayersNeedingUpdate.add(&layer);
</ins><span class="cx">
</span><span class="cx"> #if PLATFORM(IOS)
</span><span class="cx"> if (m_scrollingLayers.contains(&layer))
</span><span class="lines">@@ -774,7 +774,7 @@
</span><span class="cx">
</span><span class="cx"> // At this time, the ScrollingCoordinator only supports the top-level frame.
</span><span class="cx"> if (layer.isRootLayer() && !m_renderView.document().ownerElement()) {
</span><del>- layer.backing()->attachToScrollingCoordinatorWithParent(0);
</del><ins>+ updateScrollCoordinatedStatus(layer);
</ins><span class="cx"> if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
</span><span class="cx"> scrollingCoordinator->frameViewRootLayerDidChange(&m_renderView.frameView());
</span><span class="cx"> #if ENABLE(RUBBER_BANDING)
</span><span class="lines">@@ -807,7 +807,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- removeViewportConstrainedLayer(layer);
</del><ins>+ detachScrollCoordinatedLayer(layer);
</ins><span class="cx">
</span><span class="cx"> layer.clearBacking();
</span><span class="cx"> layerChanged = true;
</span><span class="lines">@@ -930,7 +930,7 @@
</span><span class="cx"> if (!child.isComposited() || parent.renderer().documentBeingDestroyed())
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- removeViewportConstrainedLayer(child);
</del><ins>+ removeFromScrollCoordinatedLayers(child);
</ins><span class="cx"> repaintInCompositedAncestor(child, child.backing()->compositedBounds());
</span><span class="cx">
</span><span class="cx"> setCompositingParent(child, nullptr);
</span><span class="lines">@@ -1559,13 +1559,8 @@
</span><span class="cx"> if (m_renderView.documentBeingDestroyed())
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
- RenderLayerBacking* renderViewBacking = m_renderView.layer()->backing();
- if (!renderViewBacking)
- return;
-
- scrollingCoordinator->updateScrollingNode(renderViewBacking->scrollLayerID(), scrollLayer(), nullptr, fixedRootBackgroundLayer());
- }
</del><ins>+ if (m_renderView.layer()->isComposited())
+ updateScrollCoordinatedStatus(*m_renderView.layer());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> String RenderLayerCompositor::layerTreeAsText(LayerTreeFlags flags)
</span><span class="lines">@@ -1867,7 +1862,7 @@
</span><span class="cx"> void RenderLayerCompositor::clearBackingForLayerIncludingDescendants(RenderLayer& layer)
</span><span class="cx"> {
</span><span class="cx"> if (layer.isComposited()) {
</span><del>- removeViewportConstrainedLayer(layer);
</del><ins>+ removeFromScrollCoordinatedLayers(layer);
</ins><span class="cx"> layer.clearBacking();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1985,7 +1980,7 @@
</span><span class="cx"> || requiresCompositingForFilters(*renderer)
</span><span class="cx"> || requiresCompositingForPosition(*renderer, *renderer->layer(), viewportConstrainedNotCompositedReason)
</span><span class="cx"> #if PLATFORM(IOS)
</span><del>- || requiresCompositingForScrolling(*renderer)
</del><ins>+ || requiresCompositingForScrolling(*renderer->layer())
</ins><span class="cx"> #endif
</span><span class="cx"> || requiresCompositingForOverflowScrolling(*renderer->layer());
</span><span class="cx"> }
</span><span class="lines">@@ -2033,7 +2028,7 @@
</span><span class="cx"> || renderer.hasReflection()
</span><span class="cx"> || renderer.hasFilter()
</span><span class="cx"> #if PLATFORM(IOS)
</span><del>- || requiresCompositingForScrolling(renderer)
</del><ins>+ || requiresCompositingForScrolling(layer)
</ins><span class="cx"> #endif
</span><span class="cx"> )
</span><span class="cx"> return true;
</span><span class="lines">@@ -2093,7 +2088,7 @@
</span><span class="cx"> reasons |= renderer->style().position() == FixedPosition ? CompositingReasonPositionFixed : CompositingReasonPositionSticky;
</span><span class="cx">
</span><span class="cx"> #if PLATFORM(IOS)
</span><del>- if (requiresCompositingForScrolling(*renderer))
</del><ins>+ if (requiresCompositingForScrolling(*renderer->layer()))
</ins><span class="cx"> reasons |= CompositingReasonOverflowScrollingTouch;
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -2416,9 +2411,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if PLATFORM(IOS)
</span><del>-bool RenderLayerCompositor::requiresCompositingForScrolling(RenderLayerModelObject& renderer) const
</del><ins>+bool RenderLayerCompositor::requiresCompositingForScrolling(const RenderLayer& layer) const
</ins><span class="cx"> {
</span><del>- return renderer.hasLayer() && toRenderBoxModelObject(renderer).layer()->hasAcceleratedTouchScrolling();
</del><ins>+ return layer.hasAcceleratedTouchScrolling();
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -2464,6 +2459,7 @@
</span><span class="cx"> if (layer.renderer().style().position() != FixedPosition)
</span><span class="cx"> return false;
</span><span class="cx">
</span><ins>+ // FIXME: Handle fixed inside of a transform, which should not behave as fixed.
</ins><span class="cx"> for (RenderLayer* stackingContainer = layer.stackingContainer(); stackingContainer; stackingContainer = stackingContainer->stackingContainer()) {
</span><span class="cx"> if (stackingContainer->isComposited() && stackingContainer->renderer().style().position() == FixedPosition)
</span><span class="cx"> return false;
</span><span class="lines">@@ -2472,6 +2468,18 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+static bool isMainFrameScrollingOrOverflowScrolling(RenderView& view, const RenderLayer& layer)
+{
+ if (layer.isRootLayer() && !view.document().ownerElement())
+ return true;
+
+#if PLATFORM(IOS)
+ return layer.hasAcceleratedTouchScrolling();
+#else
+ return layer.needsCompositedScrolling();
+#endif
+}
+
</ins><span class="cx"> bool RenderLayerCompositor::requiresCompositingForPosition(RenderLayerModelObject& renderer, const RenderLayer& layer, RenderLayer::ViewportConstrainedNotCompositedReason* viewportConstrainedNotCompositedReason) const
</span><span class="cx"> {
</span><span class="cx"> // position:fixed elements that create their own stacking context (e.g. have an explicit z-index,
</span><span class="lines">@@ -3268,7 +3276,7 @@
</span><span class="cx"> void RenderLayerCompositor::rootLayerAttachmentChanged()
</span><span class="cx"> {
</span><span class="cx"> // The attachment can affect whether the RenderView layer's paintsIntoWindow() behavior,
</span><del>- // so call updateGraphicsLayerGeometry() to udpate that.
</del><ins>+ // so call updateDrawsContent() to update that.
</ins><span class="cx"> RenderLayer* layer = m_renderView.layer();
</span><span class="cx"> if (RenderLayerBacking* backing = layer ? layer->backing() : 0)
</span><span class="cx"> backing->updateDrawsContent();
</span><span class="lines">@@ -3342,28 +3350,30 @@
</span><span class="cx"> rootLayer->noteDeviceOrPageScaleFactorChangedIncludingDescendants();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerCompositor::updateViewportConstraintStatus(RenderLayer& layer)
</del><ins>+void RenderLayerCompositor::updateScrollCoordinatedStatus(RenderLayer& layer)
</ins><span class="cx"> {
</span><ins>+ ScrollCoordinationReasons coordinationReasons = 0;
</ins><span class="cx"> if (isViewportConstrainedFixedOrStickyLayer(layer))
</span><del>- addViewportConstrainedLayer(layer);
- else
- removeViewportConstrainedLayer(layer);
-}
</del><ins>+ coordinationReasons |= FixedOrSticky;
</ins><span class="cx">
</span><del>-void RenderLayerCompositor::addViewportConstrainedLayer(RenderLayer& layer)
-{
- m_viewportConstrainedLayers.add(&layer);
- registerOrUpdateViewportConstrainedLayer(layer);
</del><ins>+ if (isMainFrameScrollingOrOverflowScrolling(m_renderView, layer))
+ coordinationReasons |= Scrolling;
+
+ if (coordinationReasons) {
+ m_scrollCoordinatedLayers.add(&layer);
+ updateScrollCoordinatedLayer(layer, coordinationReasons);
+ } else
+ removeFromScrollCoordinatedLayers(layer);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerCompositor::removeViewportConstrainedLayer(RenderLayer& layer)
</del><ins>+void RenderLayerCompositor::removeFromScrollCoordinatedLayers(RenderLayer& layer)
</ins><span class="cx"> {
</span><del>- if (!m_viewportConstrainedLayers.contains(&layer))
</del><ins>+ if (!m_scrollCoordinatedLayers.contains(&layer))
</ins><span class="cx"> return;
</span><span class="cx">
</span><del>- unregisterViewportConstrainedLayer(layer);
- m_viewportConstrainedLayers.remove(&layer);
- m_viewportConstrainedLayersNeedingUpdate.remove(&layer);
</del><ins>+ removeFromScrollCoordinatedLayers(layer);
+ m_scrollCoordinatedLayers.remove(&layer);
+ m_scrollCoordinatedLayersNeedingUpdate.remove(&layer);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> FixedPositionViewportConstraints RenderLayerCompositor::computeFixedViewportConstraints(RenderLayer& layer) const
</span><span class="lines">@@ -3424,12 +3434,12 @@
</span><span class="cx"> return constraints;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static RenderLayerBacking* nearestScrollingCoordinatorAncestor(RenderLayer& layer)
</del><ins>+static RenderLayerBacking* nearestScrollCoordinatedAncestor(RenderLayer& layer)
</ins><span class="cx"> {
</span><span class="cx"> RenderLayer* ancestor = layer.parent();
</span><span class="cx"> while (ancestor) {
</span><span class="cx"> if (RenderLayerBacking* backing = ancestor->backing()) {
</span><del>- if (backing->scrollLayerID() && !ancestor->scrollsOverflow())
</del><ins>+ if (backing->scrollingNodeIDForChildren())
</ins><span class="cx"> return backing;
</span><span class="cx"> }
</span><span class="cx"> ancestor = ancestor->parent();
</span><span class="lines">@@ -3438,46 +3448,92 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerCompositor::registerOrUpdateViewportConstrainedLayer(RenderLayer& layer)
</del><ins>+void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, ScrollCoordinationReasons reasons)
</ins><span class="cx"> {
</span><del>- // FIXME: We should support sticky position here! And we should eventuall support fixed/sticky elements
- // that are inside non-main frames once we get non-main frames scrolling with the ScrollingCoordinator.
</del><ins>+ // FIXME: support scrolling layers in iframes.
</ins><span class="cx"> if (m_renderView.document().ownerElement())
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator();
</span><span class="cx"> if (!scrollingCoordinator)
</span><span class="cx"> return;
</span><ins>+
+ bool isRootLayer = &layer == m_renderView.layer();
</ins><span class="cx">
</span><del>- // FIXME: rename to supportsViewportConstrainedPositionLayers()?
- if (!scrollingCoordinator->supportsFixedPositionLayers() || !layer.parent())
</del><ins>+ // FIXME: Remove supportsFixedPositionLayers() since all platforms support them now.
+ if (!scrollingCoordinator->supportsFixedPositionLayers() || (!layer.parent() && !isRootLayer))
</ins><span class="cx"> return;
</span><span class="cx">
</span><del>- ASSERT(m_viewportConstrainedLayers.contains(&layer));
</del><ins>+ ASSERT(m_scrollCoordinatedLayers.contains(&layer));
</ins><span class="cx"> ASSERT(layer.isComposited());
</span><span class="cx">
</span><span class="cx"> RenderLayerBacking* backing = layer.backing();
</span><span class="cx"> if (!backing)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- ScrollingNodeID nodeID = backing->scrollLayerID();
- RenderLayerBacking* parent = nearestScrollingCoordinatorAncestor(layer);
- if (!parent)
</del><ins>+ RenderLayerBacking* parent = nearestScrollCoordinatedAncestor(layer);
+ if (!parent && !isRootLayer)
</ins><span class="cx"> return;
</span><span class="cx">
</span><ins>+ ScrollingNodeID parentNodeID = parent ? parent->scrollingNodeIDForChildren() : 0;
+
</ins><span class="cx"> // Always call this even if the backing is already attached because the parent may have changed.
</span><del>- backing->attachToScrollingCoordinatorWithParent(parent);
- nodeID = backing->scrollLayerID();
</del><ins>+ // If a node plays both roles, fixed/sticky is always the ancestor node of scrolling.
+ if (reasons & FixedOrSticky) {
+ ScrollingNodeID nodeID = backing->viewportConstrainedNodeID();
+ if (!nodeID)
+ nodeID = scrollingCoordinator->uniqueScrollLayerID();
</ins><span class="cx">
</span><del>- if (layer.renderer().isStickyPositioned())
- scrollingCoordinator->updateViewportConstrainedNode(nodeID, computeStickyViewportConstraints(layer), backing->graphicsLayer());
- else
- scrollingCoordinator->updateViewportConstrainedNode(nodeID, computeFixedViewportConstraints(layer), backing->graphicsLayer());
</del><ins>+ ScrollingNodeType nodeType = ScrollingNode;
+ if (layer.renderer().style().position() == FixedPosition)
+ nodeType = FixedNode;
+ else if (layer.renderer().style().position() == StickyPosition)
+ nodeType = StickyNode;
+ else
+ ASSERT_NOT_REACHED();
+
+ nodeID = scrollingCoordinator->attachToStateTree(nodeType, nodeID, parentNodeID);
+ backing->setViewportConstrainedNodeID(nodeID);
+
+ switch (nodeType) {
+ case FixedNode:
+ scrollingCoordinator->updateViewportConstrainedNode(nodeID, computeFixedViewportConstraints(layer), backing->graphicsLayer());
+ break;
+ case StickyNode:
+ scrollingCoordinator->updateViewportConstrainedNode(nodeID, computeStickyViewportConstraints(layer), backing->graphicsLayer());
+ break;
+ case ScrollingNode:
+ break;
+ }
+
+ parentNodeID = nodeID;
+ }
+
+ if (reasons & Scrolling) {
+ ScrollingNodeID nodeID = backing->scrollingNodeID();
+ if (!nodeID)
+ nodeID = scrollingCoordinator->uniqueScrollLayerID();
+
+ nodeID = scrollingCoordinator->attachToStateTree(ScrollingNode, nodeID, parentNodeID);
+ backing->setScrollingNodeID(nodeID);
+
+ GraphicsLayer* scrollingLayer = backing->scrollingLayer();
+ GraphicsLayer* scrolledContentsLayer = backing->scrollingContentsLayer();
+ GraphicsLayer* counterScrollingLayer = nullptr;
+
+ if (&layer == m_renderView.layer()) {
+ scrollingLayer = m_scrollLayer.get();
+ scrolledContentsLayer = nullptr;
+ counterScrollingLayer = fixedRootBackgroundLayer();
+ }
+
+ scrollingCoordinator->updateScrollingNode(nodeID, scrollingLayer, scrolledContentsLayer, counterScrollingLayer);
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerCompositor::unregisterViewportConstrainedLayer(RenderLayer& layer)
</del><ins>+void RenderLayerCompositor::detachScrollCoordinatedLayer(RenderLayer& layer)
</ins><span class="cx"> {
</span><del>- ASSERT(m_viewportConstrainedLayers.contains(&layer));
</del><ins>+ ASSERT(m_scrollCoordinatedLayers.contains(&layer));
</ins><span class="cx">
</span><span class="cx"> if (RenderLayerBacking* backing = layer.backing())
</span><span class="cx"> backing->detachFromScrollingCoordinator();
</span><span class="lines">@@ -3499,7 +3555,7 @@
</span><span class="cx"> LayerMap layerMap;
</span><span class="cx"> StickyContainerMap stickyContainerMap;
</span><span class="cx">
</span><del>- for (auto it = m_viewportConstrainedLayers.begin(), end = m_viewportConstrainedLayers.end(); it != end; ++it) {
</del><ins>+ for (auto it = m_scrollCoordinatedLayers.begin(), end = m_scrollCoordinatedLayers.end(); it != end; ++it) {
</ins><span class="cx"> RenderLayer& layer = **it;
</span><span class="cx"> ASSERT(layer.isComposited());
</span><span class="cx">
</span><span class="lines">@@ -3511,8 +3567,10 @@
</span><span class="cx"> ASSERT(enclosingTouchScrollableLayer->isComposited());
</span><span class="cx"> stickyContainerMap.add(layer.backing()->graphicsLayer()->platformLayer(), enclosingTouchScrollableLayer->backing()->scrollingLayer()->platformLayer());
</span><span class="cx"> }
</span><del>- } else
</del><ins>+ } else if (layer.renderer().style().position() == FixedPosition)
</ins><span class="cx"> constraints = std::make_unique<FixedPositionViewportConstraints>(computeFixedViewportConstraints(layer));
</span><ins>+ else
+ continue;
</ins><span class="cx">
</span><span class="cx"> layerMap.add(layer.backing()->graphicsLayer()->platformLayer(), adoptPtr(constraints.release()));
</span><span class="cx"> }
</span><span class="lines">@@ -3560,26 +3618,51 @@
</span><span class="cx"> client->removeScrollingLayer(layer.renderer().element(), backing->scrollingLayer()->platformLayer(), backing->scrollingContentsLayer()->platformLayer());
</span><span class="cx"> }
</span><span class="cx"> }
</span><ins>+#endif
</ins><span class="cx">
</span><del>-// Called when the size of the contentsLayer changes, and when the contentsLayer is replaced by another layer.
-void RenderLayerCompositor::scrollingLayerAddedOrUpdated(RenderLayer* layer)
</del><ins>+void RenderLayerCompositor::willRemoveScrollingLayer(RenderLayer& layer)
</ins><span class="cx"> {
</span><del>- ASSERT(!m_renderView.document().inPageCache());
- m_scrollingLayers.add(layer);
</del><ins>+ if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
+ RenderLayerBacking* backing = layer.backing();
+
+ if (backing)
+ scrollingCoordinator->detachFromStateTree(backing->scrollingNodeID());
+
+ // For Coordinated Graphics.
+ scrollingCoordinator->scrollableAreaScrollLayerDidChange(&layer);
+ return;
+ }
+
+#if PLATFORM(IOS)
+ m_scrollingLayersNeedingUpdate.remove(&layer);
+ m_scrollingLayers.remove(&layer);
+
+ if (m_renderView.document().inPageCache() || !layer.backing())
+ return;
+
+ if (ChromeClient* client = this->chromeClient()) {
+ PlatformLayer* scrollingLayer = layer.backing()->scrollingLayer()->platformLayer();
+ PlatformLayer* contentsLayer = layer.backing()->scrollingContentsLayer()->platformLayer();
+ client->removeScrollingLayer(layer.renderer().element(), scrollingLayer, contentsLayer);
+ }
+#endif
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void RenderLayerCompositor::scrollingLayerRemoved(RenderLayer* layer, PlatformLayer* scrollingLayer, PlatformLayer* contentsLayer)
</del><ins>+void RenderLayerCompositor::didAddScrollingLayer(RenderLayer& layer)
</ins><span class="cx"> {
</span><del>- m_scrollingLayersNeedingUpdate.remove(layer);
- m_scrollingLayers.remove(layer);
</del><ins>+ updateScrollCoordinatedStatus(layer);
</ins><span class="cx">
</span><del>- if (m_renderView.document().inPageCache())
</del><ins>+ if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
+ // For Coordinated Graphics.
+ scrollingCoordinator->scrollableAreaScrollLayerDidChange(&layer);
</ins><span class="cx"> return;
</span><ins>+ }
</ins><span class="cx">
</span><del>- if (ChromeClient* client = this->chromeClient())
- client->removeScrollingLayer(layer->renderer().element(), scrollingLayer, contentsLayer);
</del><ins>+#if PLATFORM(IOS)
+ ASSERT(!m_renderView.document().inPageCache());
+ m_scrollingLayers.add(&layer);
+#endif
</ins><span class="cx"> }
</span><del>-#endif
</del><span class="cx">
</span><span class="cx"> void RenderLayerCompositor::windowScreenDidChange(PlatformDisplayID displayID)
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderLayerCompositorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderLayerCompositor.h (164758 => 164759)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderLayerCompositor.h 2014-02-27 00:52:48 UTC (rev 164758)
+++ trunk/Source/WebCore/rendering/RenderLayerCompositor.h 2014-02-27 01:04:23 UTC (rev 164759)
</span><span class="lines">@@ -266,19 +266,20 @@
</span><span class="cx"> GraphicsLayer* updateLayerForFooter(bool wantsLayer);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- void updateViewportConstraintStatus(RenderLayer&);
- void removeViewportConstrainedLayer(RenderLayer&);
</del><ins>+ void updateScrollCoordinatedStatus(RenderLayer&);
+ void removeFromScrollCoordinatedLayers(RenderLayer&);
</ins><span class="cx">
</span><ins>+ void willRemoveScrollingLayer(RenderLayer&);
+ void didAddScrollingLayer(RenderLayer&);
+
</ins><span class="cx"> #if PLATFORM(IOS)
</span><span class="cx"> void registerAllViewportConstrainedLayers();
</span><span class="cx"> void unregisterAllViewportConstrainedLayers();
</span><span class="cx">
</span><del>- void scrollingLayerAddedOrUpdated(RenderLayer*);
- void scrollingLayerRemoved(RenderLayer*, PlatformLayer* scrollingLayer, PlatformLayer* contentsLayer);
-
</del><span class="cx"> void registerAllScrollingLayers();
</span><span class="cx"> void unregisterAllScrollingLayers();
</span><span class="cx"> #endif
</span><ins>+
</ins><span class="cx"> void resetTrackedRepaintRects();
</span><span class="cx"> void setTracksRepaints(bool);
</span><span class="cx">
</span><span class="lines">@@ -395,7 +396,7 @@
</span><span class="cx"> bool requiresCompositingForIndirectReason(RenderLayerModelObject&, bool hasCompositedDescendants, bool hasBlendedDescendants, bool has3DTransformedDescendants, RenderLayer::IndirectCompositingReason&) const;
</span><span class="cx">
</span><span class="cx"> #if PLATFORM(IOS)
</span><del>- bool requiresCompositingForScrolling(RenderLayerModelObject&) const;
</del><ins>+ bool requiresCompositingForScrolling(const RenderLayer&) const;
</ins><span class="cx">
</span><span class="cx"> void updateCustomLayersAfterFlush();
</span><span class="cx">
</span><span class="lines">@@ -403,10 +404,15 @@
</span><span class="cx">
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- void addViewportConstrainedLayer(RenderLayer&);
- void registerOrUpdateViewportConstrainedLayer(RenderLayer&);
- void unregisterViewportConstrainedLayer(RenderLayer&);
</del><ins>+ enum ScrollCoordinationReason {
+ FixedOrSticky = 1 << 0,
+ Scrolling = 1 << 1
+ };
+ typedef unsigned ScrollCoordinationReasons;
</ins><span class="cx">
</span><ins>+ void updateScrollCoordinatedLayer(RenderLayer&, ScrollCoordinationReasons);
+ void detachScrollCoordinatedLayer(RenderLayer&);
+
</ins><span class="cx"> FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
</span><span class="cx"> StickyPositionViewportConstraints computeStickyViewportConstraints(RenderLayer&) const;
</span><span class="cx">
</span><span class="lines">@@ -475,8 +481,8 @@
</span><span class="cx"> HashSet<RenderLayer*> m_scrollingLayers;
</span><span class="cx"> HashSet<RenderLayer*> m_scrollingLayersNeedingUpdate;
</span><span class="cx"> #endif
</span><del>- HashSet<RenderLayer*> m_viewportConstrainedLayers;
- HashSet<RenderLayer*> m_viewportConstrainedLayersNeedingUpdate;
</del><ins>+ HashSet<RenderLayer*> m_scrollCoordinatedLayers;
+ HashSet<RenderLayer*> m_scrollCoordinatedLayersNeedingUpdate;
</ins><span class="cx">
</span><span class="cx"> // Enclosing layer for overflow controls and the clipping layer
</span><span class="cx"> std::unique_ptr<GraphicsLayer> m_overflowControlsHostLayer;
</span></span></pre>
</div>
</div>
</body>
</html>