void RenderLayerClipper::clearClipRectsIncludingDescendants() { m_cache = nullptr; for (RenderLayer* layer = m_renderer.layer()->firstChild(); layer; layer = layer->nextSibling()) layer->clipper().clearClipRectsIncludingDescendants(); }
void RenderLayerStackingNode::rebuildZOrderLists(OwnPtr<Vector<RenderLayerStackingNode*> >& posZOrderList, OwnPtr<Vector<RenderLayerStackingNode*> >& negZOrderList, const RenderLayerStackingNode* nodeToForceAsStackingContainer, CollectLayersBehavior collectLayersBehavior) { for (RenderLayer* child = layer()->firstChild(); child; child = child->nextSibling()) { if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionLayer() != child) child->stackingNode()->collectLayers(posZOrderList, negZOrderList, nodeToForceAsStackingContainer, collectLayersBehavior); } // Sort the two lists. if (posZOrderList) std::stable_sort(posZOrderList->begin(), posZOrderList->end(), compareZIndex); if (negZOrderList) std::stable_sort(negZOrderList->begin(), negZOrderList->end(), compareZIndex); // Append layers for top layer elements after normal layer collection, to ensure they are on top regardless of z-indexes. // The renderers of top layer elements are children of the view, sorted in top layer stacking order. if (layer()->isRootLayer()) { RenderObject* view = renderer()->view(); for (RenderObject* child = view->firstChild(); child; child = child->nextSibling()) { Element* childElement = (child->node() && child->node()->isElementNode()) ? toElement(child->node()) : 0; if (childElement && childElement->isInTopLayer()) { RenderLayer* layer = toRenderLayerModelObject(child)->layer(); // Create the buffer if it doesn't exist yet. if (!posZOrderList) posZOrderList = adoptPtr(new Vector<RenderLayerStackingNode*>); posZOrderList->append(layer->stackingNode()); } } } }
void GraphicsLayerUpdater::updateRecursive(RenderLayer& layer, UpdateType updateType, const UpdateContext& context, Vector<RenderLayer*>& layersNeedingPaintInvalidation) { if (layer.hasCompositedLayerMapping()) { CompositedLayerMapping* mapping = layer.compositedLayerMapping(); if (updateType == ForceUpdate || mapping->needsGraphicsLayerUpdate()) { const RenderLayer* compositingContainer = context.compositingContainer(layer); ASSERT(compositingContainer == layer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf)); if (mapping->updateGraphicsLayerConfiguration()) m_needsRebuildTree = true; mapping->updateGraphicsLayerGeometry(compositingContainer, context.compositingStackingContext(), layersNeedingPaintInvalidation); if (mapping->hasUnpositionedOverflowControlsLayers()) layer.scrollableArea()->positionOverflowControls(IntSize()); updateType = mapping->updateTypeForChildren(updateType); mapping->clearNeedsGraphicsLayerUpdate(); } } UpdateContext childContext(context, layer); for (RenderLayer* child = layer.firstChild(); child; child = child->nextSibling()) updateRecursive(*child, updateType, childContext, layersNeedingPaintInvalidation); }
void GraphicsLayerUpdater::update(RenderLayer& layer, UpdateType updateType) { if (layer.hasCompositedLayerMapping()) { CompositedLayerMappingPtr mapping = layer.compositedLayerMapping(); // Note carefully: here we assume that the compositing state of all descendants have been updated already, // so it is legitimate to compute and cache the composited bounds for this layer. mapping->updateCompositedBounds(updateType); if (RenderLayerReflectionInfo* reflection = layer.reflectionInfo()) { if (reflection->reflectionLayer()->hasCompositedLayerMapping()) reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds(ForceUpdate); } mapping->updateGraphicsLayerConfiguration(); updateType = mapping->updateGraphicsLayerGeometry(updateType); mapping->clearNeedsGeometryUpdate(); if (!layer.parent()) layer.compositor()->updateRootLayerPosition(); if (mapping->hasUnpositionedOverflowControlsLayers()) layer.scrollableArea()->positionOverflowControls(); } for (RenderLayer* child = layer.firstChild(); child; child = child->nextSibling()) update(*child, updateType); }
void RenderLayerClipper::clearClipRectsIncludingDescendants(ClipRectsCacheSlot cacheSlot) { if (m_cache) m_cache->clear(cacheSlot); for (RenderLayer* layer = m_renderer.layer()->firstChild(); layer; layer = layer->nextSibling()) layer->clipper().clearClipRectsIncludingDescendants(cacheSlot); }
void GraphicsLayerUpdater::assertNeedsToUpdateGraphicsLayerBitsCleared(RenderLayer& layer) { if (layer.hasCompositedLayerMapping()) layer.compositedLayerMapping()->assertNeedsToUpdateGraphicsLayerBitsCleared(); for (RenderLayer* child = layer.firstChild(); child; child = child->nextSibling()) assertNeedsToUpdateGraphicsLayerBitsCleared(*child); }
void CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(RenderLayer* layer) { ASSERT(!layer->childNeedsCompositingInputsUpdate()); ASSERT(!layer->needsCompositingInputsUpdate()); for (RenderLayer* child = layer->firstChild(); child; child = child->nextSibling()) assertNeedsCompositingInputsUpdateBitsCleared(child); }
void RenderLayerStackingNode::collectLayers(OwnPtr<Vector<RenderLayerStackingNode*> >& posBuffer, OwnPtr<Vector<RenderLayerStackingNode*> >& negBuffer, const RenderLayerStackingNode* nodeToForceAsStackingContainer, CollectLayersBehavior collectLayersBehavior) { if (layer()->isInTopLayer()) return; layer()->updateDescendantDependentFlags(); bool isStacking = false; bool isNormalFlow = false; switch (collectLayersBehavior) { case ForceLayerToStackingContainer: ASSERT(nodeToForceAsStackingContainer); if (this == nodeToForceAsStackingContainer) { isStacking = true; isNormalFlow = false; } else { isStacking = isStackingContext(); isNormalFlow = shouldBeNormalFlowOnlyIgnoringCompositedScrolling(); } break; case OverflowScrollCanBeStackingContainers: ASSERT(!nodeToForceAsStackingContainer); isStacking = isStackingContainer(); isNormalFlow = isNormalFlowOnly(); break; case OnlyStackingContextsCanBeStackingContainers: isStacking = isStackingContext(); isNormalFlow = shouldBeNormalFlowOnlyIgnoringCompositedScrolling(); break; } // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists. if (!isNormalFlow && !layer()->isOutOfFlowRenderFlowThread()) { // Determine which buffer the child should be in. OwnPtr<Vector<RenderLayerStackingNode*> >& buffer = (zIndex() >= 0) ? posBuffer : negBuffer; // Create the buffer if it doesn't exist yet. if (!buffer) buffer = adoptPtr(new Vector<RenderLayerStackingNode*>); // Append ourselves at the end of the appropriate buffer. buffer->append(this); } // Recur into our children to collect more layers, but only if we don't establish // a stacking context/container. if (!isStacking) { for (RenderLayer* child = layer()->firstChild(); child; child = child->nextSibling()) { // Ignore reflections. if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionLayer() != child) child->stackingNode()->collectLayers(posBuffer, negBuffer, nodeToForceAsStackingContainer, collectLayersBehavior); } } }
void CompositingInputsUpdater::update(RenderLayer* layer, UpdateType updateType, AncestorInfo info) { if (!layer->childNeedsCompositingInputsUpdate() && updateType != ForceUpdate) return; m_geometryMap.pushMappingsToAncestor(layer, layer->parent()); if (layer->hasCompositedLayerMapping()) info.enclosingCompositedLayer = layer; if (layer->needsCompositingInputsUpdate()) { if (info.enclosingCompositedLayer) info.enclosingCompositedLayer->compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree); updateType = ForceUpdate; } if (updateType == ForceUpdate) { RenderLayer::CompositingInputs properties; if (!layer->isRootLayer()) { properties.clippedAbsoluteBoundingBox = enclosingIntRect(m_geometryMap.absoluteRect(layer->boundingBoxForCompositingOverlapTest())); // FIXME: Setting the absBounds to 1x1 instead of 0x0 makes very little sense, // but removing this code will make JSGameBench sad. // See https://codereview.chromium.org/13912020/ if (properties.clippedAbsoluteBoundingBox.isEmpty()) properties.clippedAbsoluteBoundingBox.setSize(IntSize(1, 1)); IntRect clipRect = pixelSnappedIntRect(layer->clipper().backgroundClipRect(ClipRectsContext(m_rootRenderLayer, AbsoluteClipRects)).rect()); properties.clippedAbsoluteBoundingBox.intersect(clipRect); const RenderLayer* parent = layer->parent(); properties.opacityAncestor = parent->isTransparent() ? parent : parent->compositingInputs().opacityAncestor; properties.transformAncestor = parent->hasTransform() ? parent : parent->compositingInputs().transformAncestor; properties.filterAncestor = parent->hasFilter() ? parent : parent->compositingInputs().filterAncestor; if (layer->renderer()->isOutOfFlowPositioned() && info.ancestorScrollingLayer && !layer->subtreeIsInvisible()) { const RenderObject* container = layer->renderer()->containingBlock(); const RenderObject* scroller = info.ancestorScrollingLayer->renderer(); properties.isUnclippedDescendant = scroller != container && scroller->isDescendantOf(container); } } layer->updateCompositingInputs(properties); } if (layer->scrollsOverflow()) info.ancestorScrollingLayer = layer; for (RenderLayer* child = layer->firstChild(); child; child = child->nextSibling()) update(child, updateType, info); m_geometryMap.popMappingsToAncestor(layer->parent()); layer->clearChildNeedsCompositingInputsUpdate(); }
void RenderLayerClipper::clearClipRectsIncludingDescendants(ClipRectsType typeToClear) { // FIXME: it's not clear how this layer not having clip rects guarantees that no descendants have any. if (!m_clipRectsCache) return; clearClipRects(typeToClear); for (RenderLayer* layer = m_renderer->layer()->firstChild(); layer; layer = layer->nextSibling()) layer->clipper().clearClipRectsIncludingDescendants(typeToClear); }
void InspectorLayerTreeAgent::buildLayerIdToNodeIdMap(RenderLayer* root, LayerIdToNodeIdMap& layerIdToNodeIdMap) { if (root->hasCompositedLayerMapping()) { if (Node* node = root->renderer()->generatingNode()) { GraphicsLayer* graphicsLayer = root->compositedLayerMapping()->childForSuperlayers(); layerIdToNodeIdMap.set(graphicsLayer->platformLayer()->id(), idForNode(node)); } } for (RenderLayer* child = root->firstChild(); child; child = child->nextSibling()) buildLayerIdToNodeIdMap(child, layerIdToNodeIdMap); if (!root->renderer()->isRenderIFrame()) return; FrameView* childFrameView = toFrameView(toRenderWidget(root->renderer())->widget()); if (RenderView* childRenderView = childFrameView->renderView()) { if (RenderLayerCompositor* childCompositor = childRenderView->compositor()) buildLayerIdToNodeIdMap(childCompositor->rootRenderLayer(), layerIdToNodeIdMap); } }
void RenderLayerStackingNode::collectLayers(OwnPtr<Vector<RenderLayerStackingNode*> >& posBuffer, OwnPtr<Vector<RenderLayerStackingNode*> >& negBuffer) { if (layer()->isInTopLayer()) return; layer()->updateDescendantDependentFlags(); if (!isNormalFlowOnly()) { OwnPtr<Vector<RenderLayerStackingNode*> >& buffer = (zIndex() >= 0) ? posBuffer : negBuffer; if (!buffer) buffer = adoptPtr(new Vector<RenderLayerStackingNode*>); buffer->append(this); } if (!isStackingContext()) { for (RenderLayer* child = layer()->firstChild(); child; child = child->nextSibling()) { if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionLayer() != child) child->stackingNode()->collectLayers(posBuffer, negBuffer); } } }
void RenderLayerStackingNode::updateNormalFlowList() { if (!m_normalFlowListDirty) return; ASSERT(m_layerListMutationAllowed); for (RenderLayer* child = layer()->firstChild(); child; child = child->nextSibling()) { if (child->stackingNode()->isNormalFlowOnly() && (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionLayer() != child)) { if (!m_normalFlowList) m_normalFlowList = adoptPtr(new Vector<RenderLayerStackingNode*>); m_normalFlowList->append(child->stackingNode()); } } #if ASSERT_ENABLED updateStackingParentForNormalFlowList(this); #endif m_normalFlowListDirty = false; }
void RenderLayerStackingNode::rebuildZOrderLists() { ASSERT(m_layerListMutationAllowed); ASSERT(isDirtyStackingContext()); for (RenderLayer* child = layer()->firstChild(); child; child = child->nextSibling()) { if (!layer()->reflectionInfo() || layer()->reflectionInfo()->reflectionLayer() != child) child->stackingNode()->collectLayers(m_posZOrderList, m_negZOrderList); } // Sort the two lists. if (m_posZOrderList) std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compareZIndex); if (m_negZOrderList) std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compareZIndex); // Append layers for top layer elements after normal layer collection, to ensure they are on top regardless of z-indexes. // The renderers of top layer elements are children of the view, sorted in top layer stacking order. if (layer()->isRootLayer()) { RenderView* view = renderer()->view(); for (RenderObject* child = view->firstChild(); child; child = child->nextSibling()) { Element* childElement = (child->node() && child->node()->isElementNode()) ? toElement(child->node()) : 0; if (childElement && childElement->isInTopLayer()) { RenderLayer* layer = toRenderLayerModelObject(child)->layer(); // Create the buffer if it doesn't exist yet. if (!m_posZOrderList) m_posZOrderList = adoptPtr(new Vector<RenderLayerStackingNode*>); m_posZOrderList->append(layer->stackingNode()); } } } #if ASSERT_ENABLED updateStackingParentForZOrderLists(this); #endif m_zOrderListsDirty = false; }
void GraphicsLayerUpdater::update(RenderLayer& layer, UpdateType updateType, const UpdateContext& context) { if (layer.hasCompositedLayerMapping()) { CompositedLayerMappingPtr mapping = layer.compositedLayerMapping(); const RenderLayer* compositingContainer = context.compositingContainer(layer); ASSERT(compositingContainer == layer.ancestorCompositingLayer()); if (mapping->updateRequiresOwnBackingStoreForAncestorReasons(compositingContainer)) updateType = ForceUpdate; // Note carefully: here we assume that the compositing state of all descendants have been updated already, // so it is legitimate to compute and cache the composited bounds for this layer. mapping->updateCompositedBounds(updateType); if (RenderLayerReflectionInfo* reflection = layer.reflectionInfo()) { if (reflection->reflectionLayer()->hasCompositedLayerMapping()) reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds(ForceUpdate); } if (mapping->updateGraphicsLayerConfiguration(updateType)) m_needsRebuildTree = true; mapping->updateGraphicsLayerGeometry(updateType, compositingContainer); updateType = mapping->updateTypeForChildren(updateType); mapping->clearNeedsGraphicsLayerUpdate(); if (!layer.parent()) layer.compositor()->updateRootLayerPosition(); if (mapping->hasUnpositionedOverflowControlsLayers()) layer.scrollableArea()->positionOverflowControls(); } UpdateContext childContext(context, layer); for (RenderLayer* child = layer.firstChild(); child; child = child->nextSibling()) update(*child, updateType, childContext); }