Changeset 156478 in webkit


Ignore:
Timestamp:
Sep 26, 2013 11:13:00 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r156451.
​http://trac.webkit.org/changeset/156451
​https://bugs.webkit.org/show_bug.cgi?id=121965

Broke two fast/multicol tests. (Requested by kling on
#webkit).

Source/WebCore:

  • rendering/FlowThreadController.cpp:

(WebCore::FlowThreadController::updateRenderFlowThreadLayersIfNeeded):

  • rendering/RenderElement.cpp:

(WebCore::RenderElement::propagateStyleToAnonymousChildren):

  • rendering/RenderFlowThread.cpp:

(WebCore::RenderFlowThread::layout):
(WebCore::RenderFlowThread::regionForCompositedLayer):
(WebCore::RenderFlowThread::updateRegionForRenderLayer):
(WebCore::RenderFlowThread::updateLayerToRegionMappings):

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

(WebCore::RenderLayer::calculateLayerBounds):

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

(WebCore::RenderLayerBacking::shouldClipCompositedBounds):
(WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):

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

(WebCore::RenderLayerCompositor::computeCompositingRequirements):
(WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
(WebCore::RenderLayerCompositor::canBeComposited):
(WebCore::RenderLayerCompositor::requiresCompositingForIndirectReason):

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

(WebCore::RenderRegion::setRequiresLayerForCompositing):

  • rendering/RenderRegion.h:
  • rendering/RenderRegionSet.h:
  • rendering/RenderTreeAsText.cpp:

(WebCore::writeLayers):

LayoutTests:

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

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r156470 r156478  
     12013-09-26  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r156451.
     4        http://trac.webkit.org/changeset/156451
     5        https://bugs.webkit.org/show_bug.cgi?id=121965
     6
     7        Broke two fast/multicol tests. (Requested by kling on
     8        #webkit).
     9
     10        * fast/regions/layers/accelerated-compositing/crash-transform-inside-region-expected.html: Removed.
     11        * fast/regions/layers/accelerated-compositing/crash-transform-inside-region.html: Removed.
     12        * fast/regions/layers/accelerated-compositing/floated-region-with-transformed-child-expected.html: Removed.
     13        * fast/regions/layers/accelerated-compositing/floated-region-with-transformed-child.html: Removed.
     14        * fast/regions/layers/accelerated-compositing/move-layer-from-one-region-to-another-expected.html: Removed.
     15        * fast/regions/layers/accelerated-compositing/move-layer-from-one-region-to-another.html: Removed.
     16        * fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-expected.html: Removed.
     17        * fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-for-video-expected.html: Removed.
     18        * fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding-for-video.html: Removed.
     19        * fast/regions/layers/accelerated-compositing/propagate-region-box-shadow-border-padding.html: Removed.
     20        * fast/regions/layers/accelerated-compositing/region-as-layer-in-another-flowthread-expected.html: Removed.
     21        * fast/regions/layers/accelerated-compositing/region-as-layer-in-another-flowthread.html: Removed.
     22        * fast/regions/layers/accelerated-compositing/transform-transparent-positioned-video-inside-region-expected.html: Removed.
     23        * fast/regions/layers/accelerated-compositing/transform-transparent-positioned-video-inside-region.html: Removed.
     24        * fast/regions/layers/accelerated-compositing/transformed-layer-inside-transformed-layer-expected.html: Removed.
     25        * fast/regions/layers/accelerated-compositing/transformed-layer-inside-transformed-layer.html: Removed.
     26        * fast/regions/layers/accelerated-compositing/z-index-expected.html: Removed.
     27        * fast/regions/layers/accelerated-compositing/z-index-update-expected.html: Removed.
     28        * fast/regions/layers/accelerated-compositing/z-index-update.html: Removed.
     29        * fast/regions/layers/accelerated-compositing/z-index.html: Removed.
     30
    1312013-09-26  Andreas Kling  <akling@apple.com>
    232

  • trunk/Source/WebCore/ChangeLog

    r156473 r156478  
     12013-09-26  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r156451.
     4        http://trac.webkit.org/changeset/156451
     5        https://bugs.webkit.org/show_bug.cgi?id=121965
     6
     7        Broke two fast/multicol tests. (Requested by kling on
     8        #webkit).
     9
     10        * rendering/FlowThreadController.cpp:
     11        (WebCore::FlowThreadController::updateRenderFlowThreadLayersIfNeeded):
     12        * rendering/RenderElement.cpp:
     13        (WebCore::RenderElement::propagateStyleToAnonymousChildren):
     14        * rendering/RenderFlowThread.cpp:
     15        (WebCore::RenderFlowThread::layout):
     16        (WebCore::RenderFlowThread::regionForCompositedLayer):
     17        (WebCore::RenderFlowThread::updateRegionForRenderLayer):
     18        (WebCore::RenderFlowThread::updateLayerToRegionMappings):
     19        * rendering/RenderFlowThread.h:
     20        * rendering/RenderGeometryMap.cpp:
     21        * rendering/RenderGeometryMap.h:
     22        * rendering/RenderLayer.cpp:
     23        (WebCore::RenderLayer::calculateLayerBounds):
     24        * rendering/RenderLayer.h:
     25        * rendering/RenderLayerBacking.cpp:
     26        (WebCore::RenderLayerBacking::shouldClipCompositedBounds):
     27        (WebCore::RenderLayerBacking::updateGraphicsLayerGeometry):
     28        * rendering/RenderLayerBacking.h:
     29        * rendering/RenderLayerCompositor.cpp:
     30        (WebCore::RenderLayerCompositor::computeCompositingRequirements):
     31        (WebCore::RenderLayerCompositor::rebuildCompositingLayerTree):
     32        (WebCore::RenderLayerCompositor::canBeComposited):
     33        (WebCore::RenderLayerCompositor::requiresCompositingForIndirectReason):
     34        * rendering/RenderLayerCompositor.h:
     35        * rendering/RenderMultiColumnSet.cpp:
     36        * rendering/RenderMultiColumnSet.h:
     37        * rendering/RenderRegion.cpp:
     38        (WebCore::RenderRegion::setRequiresLayerForCompositing):
     39        * rendering/RenderRegion.h:
     40        * rendering/RenderRegionSet.h:
     41        * rendering/RenderTreeAsText.cpp:
     42        (WebCore::writeLayers):
     43
    1442013-09-26  Eric Carlson  <eric.carlson@apple.com>
    245

  • trunk/Source/WebCore/rendering/FlowThreadController.cpp

    r156451 r156478  
    271271    for (RenderNamedFlowThreadList::reverse_iterator iter = m_renderNamedFlowThreadList->rbegin(); iter != m_renderNamedFlowThreadList->rend(); ++iter) {
    272272        RenderNamedFlowThread* flowRenderer = *iter;
    273         flowRenderer->updateAllLayerToRegionMappingsIfNeeded();
     273        flowRenderer->updateLayerToRegionMappingsIfNeeded();
    274274    }
    275275}

  • trunk/Source/WebCore/rendering/RenderElement.cpp

    r156451 r156478  
    671671#endif
    672672
    673         // RenderFlowThreads are updated through the RenderView::styleDidChange function.
    674         if (child->isRenderFlowThread())
    675             continue;
    676 
    677673        RefPtr<RenderStyle> newStyle = RenderStyle::createAnonymousStyleWithDisplay(style(), child->style()->display());
    678674        if (style()->specifiesColumns()) {

  • trunk/Source/WebCore/rendering/RenderFlowThread.cpp

    r156451 r156478  
    237237    // containers, but just adjusting the position of the RenderLayerBacking.
    238238    if (!m_needsTwoPhasesLayout) {
    239         // If we have layers that moved from one region to another, we trigger
     239        updateLayerToRegionMappings();
     240        // FIXME: If we have layers that moved from one region to another, we should trigger
    240241        // a composited layers rebuild in here to make sure that the regions will collect the right layers.
    241         if (isOutOfFlowRenderFlowThread() && updateAllLayerToRegionMappings())
    242             layer()->compositor().setCompositingLayersNeedRebuild();
    243242    }
    244243#endif
    … …  
    252251
    253252#if USE(ACCELERATED_COMPOSITING)
    254 bool RenderFlowThread::hasCompositingRegionDescendant() const
    255 {
    256     for (RenderRegionList::const_iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
    257         RenderRegion* region = *iter;
    258         if (region->hasLayer() && region->layer()->hasCompositingDescendant())
    259             return true;
    260     }
    261     return false;
    262 }
    263 
    264 const RenderLayerList* RenderFlowThread::getLayerListForRegion(RenderRegion* region) const
    265 {
    266     if (!m_regionToLayerListMap)
    267         return 0;
    268     ASSERT(!m_layersToRegionMappingsDirty);
    269     RegionToLayerListMap::const_iterator iterator = m_regionToLayerListMap->find(region);
    270     return iterator == m_regionToLayerListMap->end() ? 0 : &iterator->value;
    271 }
    272 
    273 // FIXME: make it const when it won't be calling regionAtBlockOffset.
    274253RenderRegion* RenderFlowThread::regionForCompositedLayer(RenderLayer* childLayer)
    275254{
    276     if (childLayer->renderBox()) {
    277         RenderRegion* startRegion = 0;
    278         RenderRegion* endRegion = 0;
    279         getRegionRangeForBox(childLayer->renderBox(), startRegion, endRegion);
    280         // The video tag is such a box that doesn't have a region range because it's inline (by default).
    281         if (startRegion)
    282             return startRegion;
    283     }
    284 
    285     // FIXME: remove this when we'll have region ranges for inlines as well.
    286     LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer->renderer().localToContainerPoint(LayoutPoint(), this, ApplyContainerFlip));
     255    LayoutPoint leftTopLocation = childLayer->renderBox() ? childLayer->renderBox()->flipForWritingMode(LayoutPoint()) : LayoutPoint();
     256    LayoutPoint flowThreadOffset = flooredLayoutPoint(childLayer->renderer().localToContainerPoint(leftTopLocation, this, ApplyContainerFlip));
    287257    return regionAtBlockOffset(0, flipForWritingMode(isHorizontalWritingMode() ? flowThreadOffset.y() : flowThreadOffset.x()), true, DisallowRegionAutoGeneration);
    288258}
    289259
    290 RenderRegion* RenderFlowThread::cachedRegionForCompositedLayer(RenderLayer* childLayer) const
    291 {
    292     if (!m_layerToRegionMap)
    293         return 0;
    294     ASSERT(!m_layersToRegionMappingsDirty);
    295     return m_layerToRegionMap->get(childLayer);
    296 }
    297 
    298 // FIXME: Make it const when regionForCompositedLayer will be const.
    299 void RenderFlowThread::updateLayerToRegionMappings(RenderLayer* layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
     260void RenderFlowThread::updateRegionForRenderLayer(RenderLayer* layer, LayerToRegionMap& layerToRegionMap, RegionToLayerListMap& regionToLayerListMap, bool& needsLayerUpdate)
    300261{
    301262    RenderRegion* region = regionForCompositedLayer(layer);
    302263    if (!needsLayerUpdate) {
     264        ASSERT(m_layerToRegionMap);
    303265        // Figure out if we moved this layer from a region to the other.
    304         RenderRegion* previousRegion = cachedRegionForCompositedLayer(layer);
     266        RenderRegion* previousRegion = m_layerToRegionMap->get(layer);
    305267        if (previousRegion != region)
    306268            needsLayerUpdate = true;
    307269    }
    308 
    309270    if (!region)
    310271        return;
    311 
    312272    layerToRegionMap.set(layer, region);
    313 
    314273    RegionToLayerListMap::iterator iterator = regionToLayerListMap.find(region);
    315274    RenderLayerList& list = iterator == regionToLayerListMap.end() ? regionToLayerListMap.set(region, RenderLayerList()).iterator->value : iterator->value;
    316     ASSERT(!list.contains(layer));
    317275    list.append(layer);
    318276}
    319277
    320 bool RenderFlowThread::updateAllLayerToRegionMappings()
     278bool RenderFlowThread::updateLayerToRegionMappings()
    321279{
    322280    // We only need to map layers to regions for named flow threads.
    … …  
    331289
    332290    // If the RenderFlowThread had a z-index layer update, then we need to update the composited layers too.
    333     bool needsLayerUpdate = layer()->isDirtyRenderFlowThread() || m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
     291    bool needsLayerUpdate = m_layersToRegionMappingsDirty || !m_layerToRegionMap.get();
    334292    layer()->updateLayerListsIfNeeded();
    335293
    … …  
    337295    RegionToLayerListMap regionToLayerListMap;
    338296
    339     RenderLayerList* lists[] = { layer()->negZOrderList(), layer()->normalFlowList(), layer()->posZOrderList()};
    340     for (size_t listIndex = 0; listIndex < sizeof(lists) / sizeof(lists[0]); ++listIndex)
    341         if (RenderLayerList* list = lists[listIndex])
    342             for (size_t i = 0, listSize = list->size(); i < listSize; ++i)
    343                 updateLayerToRegionMappings(list->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
     297    if (Vector<RenderLayer*>* negZOrderList = layer()->negZOrderList()) {
     298        size_t listSize = negZOrderList->size();
     299        for (size_t i = 0; i < listSize; ++i)
     300            updateRegionForRenderLayer(negZOrderList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
     301    }
     302
     303    if (Vector<RenderLayer*>* normalFlowList = layer()->normalFlowList()) {
     304        size_t listSize = normalFlowList->size();
     305        for (size_t i = 0; i < listSize; ++i)
     306            updateRegionForRenderLayer(normalFlowList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
     307    }
     308   
     309    if (Vector<RenderLayer*>* posZOrderList = layer()->posZOrderList()) {
     310        size_t listSize = posZOrderList->size();
     311        for (size_t i = 0; i < listSize; ++i)
     312            updateRegionForRenderLayer(posZOrderList->at(i), layerToRegionMap, regionToLayerListMap, needsLayerUpdate);
     313    }
    344314
    345315    if (needsLayerUpdate) {
    … …  
    348318        m_layerToRegionMap->swap(layerToRegionMap);
    349319
    350         if (!m_regionToLayerListMap)
    351             m_regionToLayerListMap = adoptPtr(new RegionToLayerListMap());
    352         m_regionToLayerListMap->swap(regionToLayerListMap);
    353 
    354320        for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
    355321            RenderRegion* region = *iter;
    356             region->setRequiresLayerForCompositing(m_regionToLayerListMap->contains(region));
     322            region->setRequiresLayerForCompositing(regionToLayerListMap.contains(region));
    357323        }
    358324    }

  • trunk/Source/WebCore/rendering/RenderFlowThread.h

    r156451 r156478  
    4545class RenderRegion;
    4646
    47 #if USE(ACCELERATED_COMPOSITING)
    4847typedef ListHashSet<RenderRegion*> RenderRegionList;
    4948typedef Vector<RenderLayer*> RenderLayerList;
    5049typedef HashMap<RenderRegion*, RenderLayerList> RegionToLayerListMap;
    5150typedef HashMap<RenderLayer*, RenderRegion*> LayerToRegionMap;
    52 #endif
    5351
    5452// RenderFlowThread is used to collect all the render objects that participate in a
    … …  
    119117
    120118    RenderRegion* regionAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastRegion = false, RegionAutoGenerationPolicy = AllowRegionAutoGeneration);
     119
     120    const RenderLayerList* getLayerListForRegion(RenderRegion*) const;
    121121
    122122    bool regionsHaveUniformLogicalWidth() const { return m_regionsHaveUniformLogicalWidth; }
    … …  
    182182
    183183#if USE(ACCELERATED_COMPOSITING)
    184     // Whether any of the regions has a compositing descendant.
    185     bool hasCompositingRegionDescendant() const;
    186 
    187184    void setNeedsLayerToRegionMappingsUpdate() { m_layersToRegionMappingsDirty = true; }
    188     void updateAllLayerToRegionMappingsIfNeeded()
     185    void updateLayerToRegionMappingsIfNeeded()
    189186    {
    190187        if (m_layersToRegionMappingsDirty)
    191             updateAllLayerToRegionMappings();
     188            updateLayerToRegionMappings();
    192189    }
    193 
    194     const RenderLayerList* getLayerListForRegion(RenderRegion*) const;
    195 
    196     RenderRegion* regionForCompositedLayer(RenderLayer*); // By means of getRegionRangeForBox or regionAtBlockOffset.
    197     RenderRegion* cachedRegionForCompositedLayer(RenderLayer*) const;
    198190#endif
    199191
    … …  
    231223
    232224#if USE(ACCELERATED_COMPOSITING)
    233     bool updateAllLayerToRegionMappings();
    234 
    235     // Triggers a layers' update if a layer has moved from a region to another since the last update.
    236     void updateLayerToRegionMappings(RenderLayer*, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
     225    RenderRegion* regionForCompositedLayer(RenderLayer*);
     226    bool updateLayerToRegionMappings();
     227    void updateRegionForRenderLayer(RenderLayer*, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
    237228#endif
    238229
    … …  
    314305
    315306#if USE(ACCELERATED_COMPOSITING)
    316     // To easily find the region where a layer should be painted.
    317307    OwnPtr<LayerToRegionMap> m_layerToRegionMap;
    318 
    319     // To easily find the list of layers that paint in a region.
    320     OwnPtr<RegionToLayerListMap> m_regionToLayerListMap;
    321308#endif
    322309

  • trunk/Source/WebCore/rendering/RenderGeometryMap.cpp

    r156451 r156478  
    2727#include "RenderGeometryMap.h"
    2828
    29 #include "RenderFlowThread.h"
    3029#include "RenderLayer.h"
    3130#include "RenderView.h"
    … …  
    253252}
    254253
    255 void RenderGeometryMap::pushRenderFlowThread(const RenderFlowThread* flowThread)
    256 {
    257     m_mapping.append(RenderGeometryMapStep(flowThread, false, false, false, false));
    258     stepInserted(m_mapping.last());
    259 }
    260 
    261254void RenderGeometryMap::popMappingsToAncestor(const RenderLayerModelObject* ancestorRenderer)
    262255{

  • trunk/Source/WebCore/rendering/RenderGeometryMap.h

    r156451 r156478  
    3737namespace WebCore {
    3838
    39 class RenderFlowThread;
    4039class RenderLayer;
    4140class RenderLayerModelObject;
    … …  
    112111    // RenderView gets special treatment, because it applies the scroll offset only for elements inside in fixed position.
    113112    void pushView(const RenderView*, const LayoutSize& scrollOffset, const TransformationMatrix* = 0);
    114     void pushRenderFlowThread(const RenderFlowThread*);
    115113
    116114private:

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r156451 r156478  
    55365536        for (size_t i = 0; i < listSize; ++i) {
    55375537            RenderLayer* curLayer = posZOrderList->at(i);
    5538             // The RenderNamedFlowThread is ignored when we calculate the bounds of the RenderView.
    5539             if ((flags & IncludeCompositedDescendants || !curLayer->isComposited()) && !curLayer->isOutOfFlowRenderFlowThread()) {
     5538            if (flags & IncludeCompositedDescendants || !curLayer->isComposited()) {
    55405539                LayoutRect childUnionBounds = curLayer->calculateLayerBounds(this, 0, descendantFlags);
    55415540                unionBounds.unite(childUnionBounds);

  • trunk/Source/WebCore/rendering/RenderLayer.h

    r156451 r156478  
    758758#if USE(ACCELERATED_COMPOSITING)
    759759    bool isComposited() const { return m_backing != 0; }
    760     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
    761760    bool hasCompositedMask() const;
    762761    RenderLayerBacking* backing() const { return m_backing.get(); }
    … …  
    822821#endif
    823822   
    824     bool isRenderFlowThread() const { return renderer().isRenderFlowThread(); }
    825823    bool isOutOfFlowRenderFlowThread() const { return renderer().isOutOfFlowRenderFlowThread(); }
    826     bool isInsideFlowThread() const { return renderer().flowThreadState() != RenderObject::NotInsideFlowThread; }
    827     bool isInsideOutOfFlowThread() const { return renderer().flowThreadState() == RenderObject::InsideOutOfFlowThread; }
    828     bool isDirtyRenderFlowThread() const
    829     {
    830         ASSERT(isRenderFlowThread());
    831         return m_zOrderListsDirty || m_normalFlowListDirty;
    832     }
    833824
    834825private:
    … …  
    11031094   
    11041095#if USE(ACCELERATED_COMPOSITING)   
     1096    bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
    11051097    void setHasCompositingDescendant(bool b)  { m_hasCompositingDescendant = b; }
    11061098   

  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r156472 r156478  
    4848#include "PluginViewBase.h"
    4949#include "ProgressTracker.h"
    50 #include "RenderFlowThread.h"
    5150#include "RenderIFrame.h"
    5251#include "RenderImage.h"
    5352#include "RenderLayerCompositor.h"
    5453#include "RenderEmbeddedObject.h"
    55 #include "RenderRegion.h"
    5654#include "RenderVideo.h"
    5755#include "RenderView.h"
    … …  
    408406
    409407    if (layerOrAncestorIsTransformedOrUsingCompositedScrolling(m_owningLayer))
    410         return false;
    411 
    412     if (m_owningLayer->isInsideOutOfFlowThread())
    413408        return false;
    414409
    … …  
    649644    relativeCompositingBounds.moveBy(delta);
    650645
    651     adjustAncestorCompositingBoundsForFlowThread(ancestorCompositingBounds, compAncestor);
    652 
    653646    IntPoint graphicsLayerParentLocation;
    654647    if (compAncestor && compAncestor->backing()->hasClippingLayer()) {
    … …  
    846839    updateAfterWidgetResize();
    847840    registerScrollingLayers();
    848 }
    849 
    850 static RenderLayer* enclosingFlowThreadAncestor(RenderLayer* curr)
    851 {
    852     for (curr = curr->parent(); curr && !curr->isRenderFlowThread(); curr = curr->parent()) {
    853         if (curr->isStackingContainer() && curr->isComposited()) {
    854             // We only adjust the position of the first level of layers.
    855             return 0;
    856         }
    857     }
    858     return curr;
    859 }
    860 
    861 void RenderLayerBacking::adjustAncestorCompositingBoundsForFlowThread(IntRect& ancestorCompositingBounds, const RenderLayer* compositingAncestor) const
    862 {
    863     if (!m_owningLayer->isInsideFlowThread())
    864         return;
    865 
    866     RenderLayer* flowThreadLayer = m_owningLayer->isInsideOutOfFlowThread() ? m_owningLayer->stackingContainer() : enclosingFlowThreadAncestor(m_owningLayer);
    867     if (flowThreadLayer && flowThreadLayer->isRenderFlowThread()) {
    868         RenderFlowThread& flowThread = toRenderFlowThread(flowThreadLayer->renderer());
    869         if (m_owningLayer->isInsideOutOfFlowThread()) {
    870             // The RenderNamedFlowThread is not composited, as we need it to paint the
    871             // background layer of the regions. We need to compensate for that by manually
    872             // subtracting the position of the flow-thread.
    873             IntPoint flowPosition;
    874             flowThreadLayer->convertToPixelSnappedLayerCoords(compositingAncestor, flowPosition);
    875             ancestorCompositingBounds.moveBy(flowPosition);
    876         }
    877 
    878         // Move the ancestor position at the top of the region where the composited layer is going to display.
    879         RenderRegion* parentRegion = flowThread.cachedRegionForCompositedLayer(m_owningLayer);
    880         if (parentRegion) {
    881             IntPoint flowDelta;
    882             m_owningLayer->convertToPixelSnappedLayerCoords(flowThreadLayer, flowDelta);
    883             parentRegion->adjustRegionBoundsFromFlowThreadPortionRect(flowDelta, ancestorCompositingBounds);
    884             if (parentRegion->hasLayer() && parentRegion->layer()->backing()) {
    885                 // Make sure that the region propagates its borders, paddings, outlines or box-shadows to layers inside it.
    886                 // Note that the composited bounds of the RenderRegion are already calculated
    887                 // because RenderLayerCompositor::rebuildCompositingLayerTree will only
    888                 // iterate on the content of the region after the region itself is computed.
    889                 ancestorCompositingBounds.moveBy(roundedIntPoint(parentRegion->layer()->backing()->compositedBounds().location()));
    890                 ancestorCompositingBounds.move(-parentRegion->borderAndPaddingStart(), -parentRegion->borderAndPaddingBefore());
    891             }
    892         }
    893     }
    894841}
    895842

  • trunk/Source/WebCore/rendering/RenderLayerBacking.h

    r156451 r156478  
    279279    void paintIntoLayer(const GraphicsLayer*, GraphicsContext*, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase);
    280280
    281     // Helper function for updateGraphicsLayerGeometry.
    282     void adjustAncestorCompositingBoundsForFlowThread(IntRect& ancestorCompositingBounds, const RenderLayer* compositingAncestor) const;
    283 
    284281    static CSSPropertyID graphicsLayerToCSSProperty(AnimatedPropertyID);
    285282    static AnimatedPropertyID cssToGraphicsLayerProperty(CSSPropertyID);

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r156472 r156478  
    4747#include "Page.h"
    4848#include "RenderEmbeddedObject.h"
    49 #include "RenderFlowThread.h"
    5049#include "RenderFullScreen.h"
    5150#include "RenderGeometryMap.h"
    5251#include "RenderIFrame.h"
    5352#include "RenderLayerBacking.h"
    54 #include "RenderRegion.h"
    5553#include "RenderReplica.h"
    5654#include "RenderVideo.h"
    … …  
    949947    layer->updateLayerListsIfNeeded();
    950948
    951     if (layer->isOutOfFlowRenderFlowThread()) {
    952         layer->setHasCompositingDescendant(toRenderFlowThread(layer->renderer()).hasCompositingRegionDescendant());
    953         return;
    954     }
     949    if (layer->isOutOfFlowRenderFlowThread())
     950        return;
    955951
    956952    if (overlapMap)
    … …  
    10351031        }
    10361032    }
    1037 
    1038     if (layer->renderer().isRenderRegion()) {
    1039         // We are going to collect layers from the RenderFlowThread into the
    1040         // GraphicsLayer of the RenderRegion, but first we need to make sure that the
    1041         // region itself is going to have a composited layer. We only want to make
    1042         // regions composited when there's an actual layer that we need to move to that region.
    1043         computeRegionCompositingRequirements(&toRenderRegion(layer->renderer()), overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
    1044     }
    10451033   
    10461034    if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
    … …  
    11521140}
    11531141
    1154 void RenderLayerCompositor::computeRegionCompositingRequirements(RenderRegion* region, OverlapMap* overlapMap, CompositingState& childState, bool& layersChanged, bool& anyDescendantHas3DTransform)
    1155 {
    1156     if (!region->isValid() || !region->flowThread() || !region->flowThread()->isOutOfFlowRenderFlowThread())
    1157         return;
    1158 
    1159     RenderFlowThread* flowThread = region->flowThread();
    1160    
    1161     if (overlapMap)
    1162         overlapMap->geometryMap().pushRenderFlowThread(flowThread);
    1163 
    1164     if (const RenderLayerList* layerList = flowThread->getLayerListForRegion(region)) {
    1165         for (size_t i = 0, listSize = layerList->size(); i < listSize; ++i) {
    1166             RenderLayer* curLayer = layerList->at(i);
    1167             ASSERT(flowThread->regionForCompositedLayer(curLayer) == region);
    1168             computeCompositingRequirements(flowThread->layer(), curLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform);
    1169         }
    1170     }
    1171 
    1172     if (overlapMap)
    1173         overlapMap->geometryMap().popMappingsToAncestor(region);
    1174 }
    1175 
    11761142void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer)
    11771143{
    … …  
    12181184    // have been processed. computeCompositingRequirements() will already have done the repaint if necessary.
    12191185
    1220     // Do not iterate the RenderFlowThread directly. We are going to collect composited layers as part of regions.
    12211186    if (layer->isOutOfFlowRenderFlowThread())
    12221187        return;
    … …  
    12731238    }
    12741239
    1275     if (layer->renderer().isRenderRegion()) {
    1276         RenderRegion& region = toRenderRegion(layer->renderer());
    1277         // Note that for regions we always collect layers as if
    1278         // the region was a stacking context.
    1279         rebuildRegionCompositingLayerTree(&region, layerChildren, depth + 1);
    1280     }
    1281 
    12821240    if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
    12831241        size_t listSize = normalFlowList->size();
    … …  
    13261284
    13271285        childLayersOfEnclosingLayer.append(layerBacking->childForSuperlayers());
    1328     }
    1329 }
    1330 
    1331 void RenderLayerCompositor::rebuildRegionCompositingLayerTree(RenderRegion* region, Vector<GraphicsLayer*>& childList, int depth)
    1332 {
    1333     if (!region->isValid() || region->isRenderRegionSet())
    1334         return;
    1335 
    1336     RenderFlowThread* flowThread = region->flowThread();
    1337     // There's no need to move GraphicsLayers for Regions based multi-columns.
    1338     ASSERT(flowThread->isOutOfFlowRenderFlowThread());
    1339     if (const Vector<RenderLayer*>* layerList = flowThread->getLayerListForRegion(region)) {
    1340         size_t listSize = layerList->size();
    1341         for (size_t i = 0; i < listSize; ++i) {
    1342             RenderLayer* curLayer = layerList->at(i);
    1343             ASSERT(flowThread->regionForCompositedLayer(curLayer) == region);
    1344             rebuildCompositingLayerTree(curLayer, childList, depth + 1);
    1345         }
    13461286    }
    13471287}
    … …  
    18661806bool RenderLayerCompositor::canBeComposited(const RenderLayer* layer) const
    18671807{
    1868     // CSS Regions flow threads do not need to be composited as we use composited RenderRegions
    1869     // to render the background of the RenderFlowThread.
    1870     return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer() && !layer->isRenderFlowThread();
     1808    // FIXME: We disable accelerated compositing for elements in a RenderFlowThread as it doesn't work properly.
     1809    // See http://webkit.org/b/84900 to re-enable it.
     1810    return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer() && layer->renderer().flowThreadState() == RenderObject::NotInsideFlowThread;
    18711811}
    18721812
    … …  
    22512191    // When a layer has composited descendants, some effects, like 2d transforms, filters, masks etc must be implemented
    22522192    // via compositing so that they also apply to those composited descdendants.
    2253     if (hasCompositedDescendants && (layer->transform() || renderer->createsGroup() || renderer->hasReflection() || renderer->isRenderRegion())) {
     2193    if (hasCompositedDescendants && (layer->transform() || renderer->createsGroup() || renderer->hasReflection())) {
    22542194        reason = RenderLayer::IndirectCompositingForGraphicalEffect;
    22552195        return true;

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.h

    r156472 r156478  
    327327    void computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer*, OverlapMap*, struct CompositingState&, bool& layersChanged, bool& descendantHas3DTransform);
    328328   
    329     void computeRegionCompositingRequirements(RenderRegion*, OverlapMap*, CompositingState&, bool& layersChanged, bool& anyDescendantHas3DTransform);
    330 
    331329    // Recurses down the tree, parenting descendant compositing layers and collecting an array of child layers for the current compositing layer.
    332330    void rebuildCompositingLayerTree(RenderLayer*, Vector<GraphicsLayer*>& childGraphicsLayersOfEnclosingLayer, int depth);
    333 
    334     // Recurses down the RenderFlowThread tree, parenting descendant compositing layers and collecting an array of child
    335     // layers for the current compositing RenderRegion layer.
    336     void rebuildRegionCompositingLayerTree(RenderRegion*, Vector<GraphicsLayer*>& childList, int depth);
    337331
    338332    // Recurses down the tree, updating layer geometry only.

  • trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp

    r156451 r156478  
    517517}
    518518
    519 void RenderMultiColumnSet::adjustRegionBoundsFromFlowThreadPortionRect(const IntPoint& layerOffset, IntRect& regionBounds)
    520 {
    521     LayoutUnit layerLogicalTop = isHorizontalWritingMode() ? layerOffset.y() : layerOffset.x();
    522     unsigned startColumn = columnIndexAtOffset(layerLogicalTop);
    523    
    524     LayoutUnit colGap = columnGap();
    525     LayoutUnit colLogicalWidth = computedColumnWidth();
    526    
    527     LayoutRect flowThreadPortion = flowThreadPortionRectAt(startColumn);
    528     LayoutPoint translationOffset;
    529 
    530     LayoutUnit inlineOffset = startColumn * (colLogicalWidth + colGap);
    531     if (!style()->isLeftToRightDirection())
    532         inlineOffset = -inlineOffset;
    533     translationOffset.setX(inlineOffset);
    534        
    535     LayoutUnit blockOffset = isHorizontalWritingMode() ? -flowThreadPortion.y() : -flowThreadPortion.x();
    536     if (isFlippedBlocksWritingMode(style()->writingMode()))
    537         blockOffset = -blockOffset;
    538     translationOffset.setY(blockOffset);
    539    
    540     if (!isHorizontalWritingMode())
    541         translationOffset = translationOffset.transposedPoint();
    542 
    543     // FIXME: The translation needs to include the multicolumn set's content offset within the
    544     // multicolumn block as well. This won't be an issue until we start creating multiple multicolumn sets.
    545    
    546     regionBounds.moveBy(roundedIntPoint(-translationOffset));
    547 }
    548 
    549519const char* RenderMultiColumnSet::renderName() const
    550520{   

  • trunk/Source/WebCore/rendering/RenderMultiColumnSet.h

    r156451 r156478  
    121121    virtual void collectLayerFragments(LayerFragments&, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect) OVERRIDE;
    122122
    123     virtual void adjustRegionBoundsFromFlowThreadPortionRect(const IntPoint& layerOffset, IntRect& regionBounds) OVERRIDE;
    124 
    125123    virtual const char* renderName() const;
    126124   

  • trunk/Source/WebCore/rendering/RenderRegion.cpp

    r156451 r156478  
    727727    // composited layers that will display in this region.
    728728    ASSERT(!needsLayout());
    729 
    730729    if (m_requiresLayerForCompositing == requiresLayerForCompositing)
    731730        return;
    732731   
    733     bool requiredLayerBefore = requiresLayer();
     732    bool requiredLayer = requiresLayer();
    734733    m_requiresLayerForCompositing = requiresLayerForCompositing;
    735734
    736     if (requiredLayerBefore != requiresLayer())
     735    if (requiredLayer != requiresLayer())
    737736        updateLayerIfNeeded();
    738 }
    739 
    740 void RenderRegion::adjustRegionBoundsFromFlowThreadPortionRect(const IntPoint& layerOffset, IntRect& regionBounds)
    741 {
    742     LayoutRect flippedFlowThreadPortionRect = flowThreadPortionRect();
    743     flowThread()->flipForWritingMode(flippedFlowThreadPortionRect);
    744     regionBounds.moveBy(roundedIntPoint(flippedFlowThreadPortionRect.location()));
    745 
    746     UNUSED_PARAM(layerOffset);
    747737}
    748738#endif

  • trunk/Source/WebCore/rendering/RenderRegion.h

    r156451 r156478  
    143143    void setRequiresLayerForCompositing(bool);
    144144    virtual bool requiresLayer() const { return m_requiresLayerForCompositing || RenderBlock::requiresLayer(); }
    145 
    146     virtual void adjustRegionBoundsFromFlowThreadPortionRect(const IntPoint& layerOffset, IntRect& regionBounds); // layerOffset is needed for multi-column.
    147145#endif
    148146
    … …  
    255253}
    256254
    257 inline RenderRegion& toRenderRegion(RenderObject& object)
    258 {
    259     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderRegion());
    260     return static_cast<RenderRegion&>(object);
    261 }
    262 
    263 inline const RenderRegion& toRenderRegion(const RenderObject& object)
    264 {
    265     ASSERT_WITH_SECURITY_IMPLICATION(object.isRenderRegion());
    266     return static_cast<const RenderRegion&>(object);
    267 }
    268 
    269255// This will catch anyone doing an unnecessary cast.
    270256void toRenderRegion(const RenderRegion*);
    271 void toRenderRegion(const RenderRegion&);
    272257
    273258} // namespace WebCore

  • trunk/Source/WebCore/rendering/RenderRegionSet.h

    r156451 r156478  
    6161   
    6262    virtual bool isRenderRegionSet() const OVERRIDE FINAL { return true; }
    63 
    64     virtual bool requiresLayer() const { return false; }
    6563};
    6664

  • trunk/Source/WebCore/rendering/RenderTreeAsText.cpp

    r156451 r156478  
    803803        if (layerCount) {
    804804            int currIndent = indent;
    805             // We only print the header if there's at list a non-RenderNamedFlowThread part of the list.
    806             if (!posList->size() || !posList->at(0)->isOutOfFlowRenderFlowThread()) {
    807                 if (behavior & RenderAsTextShowLayerNesting) {
    808                     writeIndent(ts, indent);
    809                     ts << " positive z-order list(" << posList->size() << ")\n";
    810                     ++currIndent;
    811                 }
    812                 for (unsigned i = 0; i != posList->size(); ++i) {
    813                     // Do not print named flows twice.
    814                     if (!posList->at(i)->isOutOfFlowRenderFlowThread())
    815                         writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, currIndent, behavior);
    816                 }
     805            if (behavior & RenderAsTextShowLayerNesting) {
     806                writeIndent(ts, indent);
     807                ts << " positive z-order list(" << layerCount << ")\n";
     808                ++currIndent;
     809            }
     810            for (unsigned i = 0; i != posList->size(); ++i) {
     811                if (!posList->at(i)->isOutOfFlowRenderFlowThread())
     812                    writeLayers(ts, rootLayer, posList->at(i), paintDirtyRect, currIndent, behavior);
    817813            }
    818814        }
Note: See TracChangeset for help on using the changeset viewer.