Changeset 156451 in webkit for trunk/Source/WebCore/rendering/RenderFlowThread.cpp

Timestamp:

Sep 26, 2013, 1:20:57 AM (12 years ago)

Author:

[email protected]

Message:

[CSS Regions] The layers from the flow thread should be collected under the regions' layers.
​https://bugs.webkit.org/show_bug.cgi?id=120457

Patch by Mihai Maerean <Mihai Maerean> on 2013-09-26
Reviewed by David Hyatt.

Source/WebCore:

This patch is based on the work of Alexandru Chiculita at ​https://bugs.webkit.org/attachment.cgi?id=203872&action=review

The composited layers inside the named flow threads are collected as part of the regions.
When a region displays a layer that needs accelerated compositing we activate the accelerated compositing for
that region too (inside RenderFlowThread::updateAllLayerToRegionMappings).

Tests: fast/regions/layers/accelerated-compositing/crash-transform-inside-region.html

fast/regions/layers/accelerated-compositing/floated-region-with-transformed-child.html
fast/regions/layers/accelerated-compositing/move-layer-from-one-region-to-another.html
fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding.html
fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-for-video.html
fast/regions/layers/accelerated-compositing/region-as-layer-in-another-flowthread.html
fast/regions/layers/accelerated-compositing/transform-transparent-positioned-video-inside-region.html
fast/regions/layers/accelerated-compositing/transformed-layer-inside-transformed-layer.html
fast/regions/layers/accelerated-compositing/z-index.html: Added.
fast/regions/layers/accelerated-compositing/z-index-update.html: Added.

• rendering/FlowThreadController.cpp:

(WebCore::FlowThreadController::updateRenderFlowThreadLayersIfNeeded):

• rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::layout): When the layout of the flow thread is over (including the 2 phase layout),
we update all the mappings between the layers inside the flow thread and the regions where those layers will be
painted.
(WebCore::RenderFlowThread::hasCompositingRegionDescendant): Whether any of the regions has a compositing descendant.
(WebCore::RenderFlowThread::getLayerListForRegion):
(WebCore::RenderFlowThread::regionForCompositedLayer):
(WebCore::RenderFlowThread::cachedRegionForCompositedLayer):
(WebCore::RenderFlowThread::updateLayerToRegionMappings): Triggers an update of the layers if a layer has moved
from a region to another since the last update.
(WebCore::RenderFlowThread::updateAllLayerToRegionMappings):

• rendering/RenderFlowThread.h:
• rendering/RenderGeometryMap.cpp:

(WebCore::RenderGeometryMap::pushRenderFlowThread):

• rendering/RenderGeometryMap.h:
• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::calculateLayerBounds): The RenderNamedFlowThread is ignored when we calculate the bounds
of the RenderView.

• rendering/RenderLayer.h:
• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::shouldClipCompositedBounds): Not if it's inside an out of flow Flow Thread.
(WebCore::RenderLayerBacking::updateGraphicsLayerGeometry): Now adjusts the ancestorCompositingBounds for the FlowThread.
(WebCore::enclosingFlowThreadAncestor):
(WebCore::RenderLayerBacking::adjustAncestorCompositingBoundsForFlowThread): Make sure that the region propagates
its borders, paddings, outlines or box-shadows to layers inside it.

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

(WebCore::RenderLayerCompositor::computeCompositingRequirements): Now calls computeRegionCompositingRequirements.
(WebCore::RenderLayerCompositor::computeRegionCompositingRequirements):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTree): Do not iterate the RenderFlowThread directly. We
are going to collect composited layers as part of regions.
(WebCore::RenderLayerCompositor::rebuildRegionCompositingLayerTree):
(WebCore::RenderLayerCompositor::canBeComposited): CSS Regions flow threads do not need to be composited as we
use composited RenderRegions to render the background of the RenderFlowThread.
(WebCore::RenderLayerCompositor::requiresCompositingForIndirectReason): If it's a region.

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

(WebCore::RenderMultiColumnSet::adjustRegionBoundsFromFlowThreadPortionRect):

• rendering/RenderMultiColumnSet.h:
• rendering/RenderElement.cpp:

(WebCore::RenderObject::propagateStyleToAnonymousChildren): Not for RenderFlowThreads, as they are updated
through the RenderView::styleDidChange function.

• rendering/RenderRegion.cpp:

(WebCore::RenderRegion::setRequiresLayerForCompositing):
(WebCore::RenderRegion::adjustRegionBoundsFromFlowThreadPortionRect):

• rendering/RenderRegion.h:

(WebCore::toRenderRegion):

• rendering/RenderRegionSet.h:

(WebCore::RenderRegionSet::requiresLayer): Never.

• rendering/RenderTreeAsText.cpp:

(WebCore::writeLayers):

LayoutTests:

• fast/regions/layers/accelerated-compositing/crash-transform-inside-region.html: Added.
• fast/regions/layers/accelerated-compositing/crash-transform-inside-region-expected.html: Added.
• fast/regions/layers/accelerated-compositing/floated-region-with-transformed-child.html: Added.
• fast/regions/layers/accelerated-compositing/floated-region-with-transformed-child-expected.html: Added.
• fast/regions/layers/accelerated-compositing/move-layer-from-one-region-to-another.html: Added.
• fast/regions/layers/accelerated-compositing/move-layer-from-one-region-to-another-expected.html: Added.
• fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding.html: Added.
• fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-expected.html: Added.
• fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-for-video.html: Added.
• fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-for-video-expected.html: Added.
• fast/regions/layers/accelerated-compositing/region-as-layer-in-another-flowthread.html: Added.
• fast/regions/layers/accelerated-compositing/region-as-layer-in-another-flowthread-expected.html: Added.
• fast/regions/layers/accelerated-compositing/transformed-layer-inside-transformed-layer.html: Added.
• fast/regions/layers/accelerated-compositing/transformed-layer-inside-transformed-layer-expected.html: Added.
• fast/regions/layers/accelerated-compositing/transform-transparent-positioned-video-inside-region.html: Added.
• fast/regions/layers/accelerated-compositing/transform-transparent-positioned-video-inside-region-expected.html: Added.
• fast/regions/layers/accelerated-compositing/z-index.html: Added.
• fast/regions/layers/accelerated-compositing/z-index-expected.html: Added.
• fast/regions/layers/accelerated-compositing/z-index-update-expected.html: Added.
• fast/regions/layers/accelerated-compositing/z-index-update.html: Added.

File:

• trunk/Source/WebCore/rendering/RenderFlowThread.cpp (modified) (5 diffs)

trunk/Source/WebCore/rendering/RenderFlowThread.cpp

@@ -237 +237 @@
     // containers, but just adjusting the position of the RenderLayerBacking.
     if (!m_needsTwoPhasesLayout) {
-        updateLayerToRegionMappings();
-        // FIXME: If we have layers that moved from one region to another, we should trigger
+        // If we have layers that moved from one region to another, we trigger
         // a composited layers rebuild in here to make sure that the regions will collect the right layers.
+        if (isOutOfFlowRenderFlowThread() && updateAllLayerToRegionMappings())
+            layer()->compositor().setCompositingLayersNeedRebuild();
     }
 #endif
@@ -251 +252 @@
 
 #if USE(ACCELERATED_COMPOSITING)
+bool RenderFlowThread::hasCompositingRegionDescendant() const
+{
+    for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
+        RenderRegion* region = *iter;
+        if (region->hasLayer() && region->layer()->hasCompositingDescendant())
+            return true;
+    }
+    return false;
+}
+
+const RenderLayerList* RenderFlowThread::getLayerListForRegion(RenderRegion* region) const
+{
+    if (!m_regionToLayerListMap)
+        return 0;
+    ASSERT(!m_layersToRegionMappingsDirty);
+    RegionToLayerListMap::const_iterator iterator = m_regionToLayerListMap->find(region);
+    return iterator == m_regionToLayerListMap->end() ? 0 : &iterator->value;
+}
+
+// FIXME: make it const when it won't be calling regionAtBlockOffset.
 RenderRegion* RenderFlowThread::regionForCompositedLayer(RenderLayer* childLayer)
 {
-    LayoutPoint leftTopLocation = childLayer->renderBox() ? childLayer->renderBox()->flipForWritingMode(LayoutPoint()) : LayoutPoint();
-    LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer->renderer().localToContainerPoint(leftTopLocation, this, ApplyContainerFlip));
+    if (childLayer->renderBox()) {
+        RenderRegion* startRegion = 0;
+        RenderRegion* endRegion = 0;
+        getRegionRangeForBox(childLayer->renderBox(), startRegion, endRegion);
+        // The video tag is such a box that doesn't have a region range because it's inline (by default).
+        if (startRegion)
+            return startRegion;
+    }
+
+    // FIXME: remove this when we'll have region ranges for inlines as well.
+    LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer->renderer().localToContainerPoint(LayoutPoint(), this, ApplyContainerFlip));
     return regionAtBlockOffset(0, flipForWritingMode(isHorizontalWritingMode() ? flowThreadOffset.y() : flowThreadOffset.x()), true, DisallowRegionAutoGeneration);
 }
 
-void RenderFlowThread::updateRegionForRenderLayer(RenderLayer* layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
+RenderRegion* RenderFlowThread::cachedRegionForCompositedLayer(RenderLayer* childLayer) const
+{
+    if (!m_layerToRegionMap)
+        return 0;
+    ASSERT(!m_layersToRegionMappingsDirty);
+    return m_layerToRegionMap->get(childLayer);
+}
+
+// FIXME: Make it const when regionForCompositedLayer will be const.
+void RenderFlowThread::updateLayerToRegionMappings(RenderLayer* layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
 {
     RenderRegion* region = regionForCompositedLayer(layer);
     if (!needsLayerUpdate) {
-        ASSERT(m_layerToRegionMap);
         // Figure out if we moved this layer from a region to the other.
-        RenderRegion* previousRegion = m_layerToRegionMap->get(layer);
+        RenderRegion* previousRegion = cachedRegionForCompositedLayer(layer);
         if (previousRegion != region)
             needsLayerUpdate = true;
     }
+
     if (!region)
         return;
+
     layerToRegionMap.set(layer, region);
+
     RegionToLayerListMap::iterator iterator = regionToLayerListMap.find(region);
     RenderLayerList& list = iterator == regionToLayerListMap.end() ? regionToLayerListMap.set(region, RenderLayerList()).iterator->value : iterator->value;
+    ASSERT(!list.contains(layer));
     list.append(layer);
 }
 
-bool RenderFlowThread::updateLayerToRegionMappings()
+bool RenderFlowThread::updateAllLayerToRegionMappings()
 {
     // We only need to map layers to regions for named flow threads.
@@ -289 +331 @@
 
     // If the RenderFlowThread had a z-index layer update, then we need to update the composited layers too.
-    bool needsLayerUpdate = m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
+    bool needsLayerUpdate = layer()->isDirtyRenderFlowThread() || m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
     layer()->updateLayerListsIfNeeded();
 
@@ -295 +337 @@
     RegionToLayerListMap regionToLayerListMap;
 
-    if (Vector<RenderLayer*>* negZOrderList = layer()->negZOrderList()) {
-        size_t listSize = negZOrderList->size();
-        for (size_t i = 0; i < listSize; ++i)
-            updateRegionForRenderLayer(negZOrderList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
-    }
-
-    if (Vector<RenderLayer*>* normalFlowList = layer()->normalFlowList()) {
-        size_t listSize = normalFlowList->size();
-        for (size_t i = 0; i < listSize; ++i)
-            updateRegionForRenderLayer(normalFlowList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
-    }
-    
-    if (Vector<RenderLayer*>* posZOrderList = layer()->posZOrderList()) {
-        size_t listSize = posZOrderList->size();
-        for (size_t i = 0; i < listSize; ++i)
-            updateRegionForRenderLayer(posZOrderList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
-    }
+    RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList()};
+    for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex)
+        if (RenderLayerList* list = lists[listIndex])
+            for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
+                updateLayerToRegionMappings(list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
 
     if (needsLayerUpdate) {
@@ -318 +348 @@
         m_layerToRegionMap->swap(layerToRegionMap);
 
+        if (!m_regionToLayerListMap)
+            m_regionToLayerListMap = adoptPtr(new RegionToLayerListMap());
+        m_regionToLayerListMap->swap(regionToLayerListMap);
+
         for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
             RenderRegion* region = *iter;
-            region->setRequiresLayerForCompositing(regionToLayerListMap.contains(region));
+            region->setRequiresLayerForCompositing(m_regionToLayerListMap->contains(region));
         }
     }