/* * Copyright (C) 2009, 2010 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "config.h" #if USE(ACCELERATED_COMPOSITING) #include "RenderLayerCompositor.h" #include "AnimationController.h" #include "CanvasRenderingContext.h" #include "CSSPropertyNames.h" #include "Chrome.h" #include "ChromeClient.h" #include "Frame.h" #include "FrameView.h" #include "GraphicsLayer.h" #include "HTMLCanvasElement.h" #include "HTMLIFrameElement.h" #include "HTMLNames.h" #include "HitTestResult.h" #include "NodeList.h" #include "Page.h" #include "RenderApplet.h" #include "RenderEmbeddedObject.h" #include "RenderFullScreen.h" #include "RenderIFrame.h" #include "RenderLayerBacking.h" #include "RenderReplica.h" #include "RenderVideo.h" #include "RenderView.h" #include "Settings.h" #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) #include "HTMLMediaElement.h" #endif #if PROFILE_LAYER_REBUILD #include #endif #ifndef NDEBUG #include "RenderTreeAsText.h" #endif #if ENABLE(3D_RENDERING) // This symbol is used to determine from a script whether 3D rendering is enabled (via 'nm'). bool WebCoreHas3DRendering = true; #endif namespace WebCore { using namespace HTMLNames; struct CompositingState { CompositingState(RenderLayer* compAncestor) : m_compositingAncestor(compAncestor) , m_subtreeIsCompositing(false) #if ENABLE(COMPOSITED_FIXED_ELEMENTS) , m_positionedSibling(false) , m_hasFixedElement(false) #endif #if ENABLE(ANDROID_OVERFLOW_SCROLL) , m_hasScrollableElement(false) #endif #ifndef NDEBUG , m_depth(0) #endif { } RenderLayer* m_compositingAncestor; bool m_subtreeIsCompositing; // m_compositingBounds is only used in computeCompositingRequirements. It can be either the // ancestor bounds or the bounds for the sibling layers which are above the composited layer. // It is used to reject creating unnecesary layers. IntRect m_compositingBounds; #if ENABLE(COMPOSITED_FIXED_ELEMENTS) bool m_positionedSibling; bool m_hasFixedElement; #endif #if ENABLE(ANDROID_OVERFLOW_SCROLL) bool m_hasScrollableElement; #endif #ifndef NDEBUG int m_depth; #endif }; RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView) : m_renderView(renderView) , m_rootPlatformLayer(0) , m_updateCompositingLayersTimer(this, &RenderLayerCompositor::updateCompositingLayersTimerFired) , m_hasAcceleratedCompositing(true) , m_compositingTriggers(static_cast(ChromeClient::AllTriggers)) , m_showDebugBorders(false) , m_showRepaintCounter(false) , m_compositingConsultsOverlap(true) , m_compositingDependsOnGeometry(false) , m_compositing(false) , m_compositingLayersNeedRebuild(false) , m_flushingLayers(false) , m_forceCompositingMode(false) , m_rootLayerAttachment(RootLayerUnattached) #if PROFILE_LAYER_REBUILD , m_rootLayerUpdateCount(0) #endif // PROFILE_LAYER_REBUILD { Settings* settings = m_renderView->document()->settings(); // Even when forcing compositing mode, ignore child frames, or this will trigger // layer creation from the enclosing RenderIFrame. ASSERT(m_renderView->document()->frame()); if (settings && settings->forceCompositingMode() && settings->acceleratedCompositingEnabled() && !m_renderView->document()->frame()->tree()->parent()) { m_forceCompositingMode = true; enableCompositingMode(); } } RenderLayerCompositor::~RenderLayerCompositor() { ASSERT(m_rootLayerAttachment == RootLayerUnattached); } void RenderLayerCompositor::enableCompositingMode(bool enable /* = true */) { if (enable != m_compositing) { m_compositing = enable; if (m_compositing) { ensureRootPlatformLayer(); notifyIFramesOfCompositingChange(); } else destroyRootPlatformLayer(); } } void RenderLayerCompositor::cacheAcceleratedCompositingFlags() { bool hasAcceleratedCompositing = false; bool showDebugBorders = false; bool showRepaintCounter = false; if (Settings* settings = m_renderView->document()->settings()) { hasAcceleratedCompositing = settings->acceleratedCompositingEnabled(); showDebugBorders = settings->showDebugBorders(); showRepaintCounter = settings->showRepaintCounter(); } // We allow the chrome to override the settings, in case the page is rendered // on a chrome that doesn't allow accelerated compositing. if (hasAcceleratedCompositing) { Frame* frame = m_renderView->frameView()->frame(); Page* page = frame ? frame->page() : 0; if (page) { ChromeClient* chromeClient = page->chrome()->client(); m_compositingTriggers = chromeClient->allowedCompositingTriggers(); hasAcceleratedCompositing = m_compositingTriggers; } } if (hasAcceleratedCompositing != m_hasAcceleratedCompositing || showDebugBorders != m_showDebugBorders || showRepaintCounter != m_showRepaintCounter) setCompositingLayersNeedRebuild(); m_hasAcceleratedCompositing = hasAcceleratedCompositing; m_showDebugBorders = showDebugBorders; m_showRepaintCounter = showRepaintCounter; } bool RenderLayerCompositor::canRender3DTransforms() const { return hasAcceleratedCompositing() && (m_compositingTriggers & ChromeClient::ThreeDTransformTrigger); } void RenderLayerCompositor::setCompositingLayersNeedRebuild(bool needRebuild) { if (inCompositingMode()) m_compositingLayersNeedRebuild = needRebuild; } void RenderLayerCompositor::scheduleLayerFlush() { Frame* frame = m_renderView->frameView()->frame(); Page* page = frame ? frame->page() : 0; if (!page) return; page->chrome()->client()->scheduleCompositingLayerSync(); } void RenderLayerCompositor::flushPendingLayerChanges() { ASSERT(!m_flushingLayers); m_flushingLayers = true; // FIXME: FrameView::syncCompositingStateRecursive() calls this for each // frame, so when compositing layers are connected between frames, we'll // end up syncing subframe's layers multiple times. // https://bugs.webkit.org/show_bug.cgi?id=52489 if (GraphicsLayer* rootLayer = rootPlatformLayer()) rootLayer->syncCompositingState(); ASSERT(m_flushingLayers); m_flushingLayers = false; } RenderLayerCompositor* RenderLayerCompositor::enclosingCompositorFlushingLayers() const { if (!m_renderView->frameView()) return 0; for (Frame* frame = m_renderView->frameView()->frame(); frame; frame = frame->tree()->parent()) { RenderLayerCompositor* compositor = frame->contentRenderer() ? frame->contentRenderer()->compositor() : 0; if (compositor->isFlushingLayers()) return compositor; } return 0; } void RenderLayerCompositor::scheduleCompositingLayerUpdate() { if (!m_updateCompositingLayersTimer.isActive()) m_updateCompositingLayersTimer.startOneShot(0); } bool RenderLayerCompositor::compositingLayerUpdatePending() const { return m_updateCompositingLayersTimer.isActive(); } void RenderLayerCompositor::updateCompositingLayersTimerFired(Timer*) { updateCompositingLayers(); } void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType updateType, RenderLayer* updateRoot) { m_updateCompositingLayersTimer.stop(); if (!m_compositingDependsOnGeometry && !m_compositing) return; bool checkForHierarchyUpdate = m_compositingDependsOnGeometry; bool needGeometryUpdate = false; switch (updateType) { case CompositingUpdateAfterLayoutOrStyleChange: case CompositingUpdateOnPaitingOrHitTest: checkForHierarchyUpdate = true; break; case CompositingUpdateOnScroll: if (m_compositingConsultsOverlap) checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates. needGeometryUpdate = true; break; } if (!checkForHierarchyUpdate && !needGeometryUpdate) return; bool needHierarchyUpdate = m_compositingLayersNeedRebuild; if (!updateRoot || m_compositingConsultsOverlap) { // Only clear the flag if we're updating the entire hierarchy. m_compositingLayersNeedRebuild = false; updateRoot = rootRenderLayer(); } #if PROFILE_LAYER_REBUILD ++m_rootLayerUpdateCount; double startTime = WTF::currentTime(); #endif if (checkForHierarchyUpdate) { // Go through the layers in presentation order, so that we can compute which RenderLayers need compositing layers. // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex. CompositingState compState(updateRoot); bool layersChanged = false; #if ENABLE(COMPOSITED_FIXED_ELEMENTS) compState.m_positionedSibling = false; compState.m_hasFixedElement = false; #endif #if ENABLE(ANDROID_OVERFLOW_SCROLL) compState.m_hasScrollableElement = false; #endif if (m_compositingConsultsOverlap) { OverlapMap overlapTestRequestMap; computeCompositingRequirements(updateRoot, &overlapTestRequestMap, compState, layersChanged); } else computeCompositingRequirements(updateRoot, 0, compState, layersChanged); needHierarchyUpdate |= layersChanged; } if (needHierarchyUpdate) { // Update the hierarchy of the compositing layers. CompositingState compState(updateRoot); Vector childList; rebuildCompositingLayerTree(updateRoot, compState, childList); // Host the document layer in the RenderView's root layer. if (updateRoot == rootRenderLayer()) { if (childList.isEmpty()) destroyRootPlatformLayer(); else m_rootPlatformLayer->setChildren(childList); } } else if (needGeometryUpdate) { // We just need to do a geometry update. This is only used for position:fixed scrolling; // most of the time, geometry is updated via RenderLayer::styleChanged(). updateLayerTreeGeometry(updateRoot); } #if PROFILE_LAYER_REBUILD double endTime = WTF::currentTime(); if (updateRoot == rootRenderLayer()) fprintf(stderr, "Update %d: computeCompositingRequirements for the world took %fms\n", m_rootLayerUpdateCount, 1000.0 * (endTime - startTime)); #endif ASSERT(updateRoot || !m_compositingLayersNeedRebuild); if (!hasAcceleratedCompositing()) enableCompositingMode(false); } bool RenderLayerCompositor::updateBacking(RenderLayer* layer, CompositingChangeRepaint shouldRepaint) { bool layerChanged = false; #if ENABLE(ANDROID_OVERFLOW_SCROLL) if (needsToBeComposited(layer) || layer->shouldComposite()) { #else if (needsToBeComposited(layer)) { #endif enableCompositingMode(); // 3D transforms turn off the testing of overlap. if (requiresCompositingForTransform(layer->renderer())) setCompositingConsultsOverlap(false); #if ENABLE(ANDROID_OVERFLOW_SCROLL) // If we are a child of a scrollable layer, ignore the overlap from the // scrollable layer as it can cause child layers to become composited // siblings and will not scroll with the main content layer. if (layer->hasOverflowParent()) setCompositingConsultsOverlap(false); #endif if (!layer->backing()) { // If we need to repaint, do so before making backing if (shouldRepaint == CompositingChangeRepaintNow) repaintOnCompositingChange(layer); layer->ensureBacking(); #if PLATFORM(MAC) && USE(CA) if (m_renderView->document()->settings()->acceleratedDrawingEnabled()) layer->backing()->graphicsLayer()->setAcceleratesDrawing(true); else if (layer->renderer()->isCanvas()) { HTMLCanvasElement* canvas = static_cast(layer->renderer()->node()); if (canvas->renderingContext() && canvas->renderingContext()->isAccelerated()) layer->backing()->graphicsLayer()->setAcceleratesDrawing(true); } #endif layerChanged = true; } } else { if (layer->backing()) { // If we're removing backing on a reflection, clear the source GraphicsLayer's pointer to // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection // are both either composited, or not composited. if (layer->isReflection()) { RenderLayer* sourceLayer = toRenderBoxModelObject(layer->renderer()->parent())->layer(); if (RenderLayerBacking* backing = sourceLayer->backing()) { ASSERT(backing->graphicsLayer()->replicaLayer() == layer->backing()->graphicsLayer()); backing->graphicsLayer()->setReplicatedByLayer(0); } } layer->clearBacking(); layerChanged = true; // The layer's cached repaints rects are relative to the repaint container, so change when // compositing changes; we need to update them here. layer->computeRepaintRects(); // If we need to repaint, do so now that we've removed the backing if (shouldRepaint == CompositingChangeRepaintNow) repaintOnCompositingChange(layer); } } #if ENABLE(VIDEO) if (layerChanged && layer->renderer()->isVideo()) { // If it's a video, give the media player a chance to hook up to the layer. RenderVideo* video = toRenderVideo(layer->renderer()); video->acceleratedRenderingStateChanged(); } #endif if (layerChanged && layer->renderer()->isRenderPart()) { RenderLayerCompositor* innerCompositor = frameContentsCompositor(toRenderPart(layer->renderer())); if (innerCompositor && innerCompositor->inCompositingMode()) innerCompositor->updateRootLayerAttachment(); } return layerChanged; } bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, CompositingChangeRepaint shouldRepaint) { bool layerChanged = updateBacking(layer, shouldRepaint); // See if we need content or clipping layers. Methods called here should assume // that the compositing state of descendant layers has not been updated yet. if (layer->backing() && layer->backing()->updateGraphicsLayerConfiguration()) layerChanged = true; return layerChanged; } void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer) { // If the renderer is not attached yet, no need to repaint. if (layer->renderer() != m_renderView && !layer->renderer()->parent()) return; RenderBoxModelObject* repaintContainer = layer->renderer()->containerForRepaint(); if (!repaintContainer) repaintContainer = m_renderView; layer->repaintIncludingNonCompositingDescendants(repaintContainer); if (repaintContainer == m_renderView) { // The contents of this layer may be moving between the window // and a GraphicsLayer, so we need to make sure the window system // synchronizes those changes on the screen. m_renderView->frameView()->setNeedsOneShotDrawingSynchronization(); } } // The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant // RenderLayers that are rendered by the composited RenderLayer. IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer) { if (!canBeComposited(layer)) return IntRect(); IntRect boundingBoxRect = layer->localBoundingBox(); if (layer->renderer()->isRoot()) { // If the root layer becomes composited (e.g. because some descendant with negative z-index is composited), // then it has to be big enough to cover the viewport in order to display the background. This is akin // to the code in RenderBox::paintRootBoxFillLayers(). if (m_renderView->frameView()) { int rw = m_renderView->frameView()->contentsWidth(); int rh = m_renderView->frameView()->contentsHeight(); boundingBoxRect.setWidth(max(boundingBoxRect.width(), rw - boundingBoxRect.x())); boundingBoxRect.setHeight(max(boundingBoxRect.height(), rh - boundingBoxRect.y())); } } IntRect unionBounds = boundingBoxRect; if (layer->renderer()->hasOverflowClip() || layer->renderer()->hasMask()) { int ancestorRelX = 0, ancestorRelY = 0; layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY); boundingBoxRect.move(ancestorRelX, ancestorRelY); return boundingBoxRect; } if (RenderLayer* reflection = layer->reflectionLayer()) { if (!reflection->isComposited()) { IntRect childUnionBounds = calculateCompositedBounds(reflection, layer); unionBounds.unite(childUnionBounds); } } ASSERT(layer->isStackingContext() || (!layer->m_posZOrderList || layer->m_posZOrderList->size() == 0)); if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); if (!curLayer->isComposited()) { IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer); unionBounds.unite(childUnionBounds); } } } if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); if (!curLayer->isComposited()) { IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer); unionBounds.unite(childUnionBounds); } } } if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); if (!curLayer->isComposited()) { IntRect curAbsBounds = calculateCompositedBounds(curLayer, layer); unionBounds.unite(curAbsBounds); } } } if (layer->paintsWithTransform(PaintBehaviorNormal)) { TransformationMatrix* affineTrans = layer->transform(); boundingBoxRect = affineTrans->mapRect(boundingBoxRect); unionBounds = affineTrans->mapRect(unionBounds); } int ancestorRelX = 0, ancestorRelY = 0; layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY); unionBounds.move(ancestorRelX, ancestorRelY); return unionBounds; } void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer* /*child*/) { setCompositingLayersNeedRebuild(); } void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child) { if (!child->isComposited() || parent->renderer()->documentBeingDestroyed()) return; setCompositingParent(child, 0); RenderLayer* compLayer = parent->enclosingCompositingLayer(); if (compLayer) { ASSERT(compLayer->backing()); IntRect compBounds = child->backing()->compositedBounds(); int offsetX = 0, offsetY = 0; child->convertToLayerCoords(compLayer, offsetX, offsetY); compBounds.move(offsetX, offsetY); compLayer->setBackingNeedsRepaintInRect(compBounds); // The contents of this layer may be moving from a GraphicsLayer to the window, // so we need to make sure the window system synchronizes those changes on the screen. m_renderView->frameView()->setNeedsOneShotDrawingSynchronization(); } setCompositingLayersNeedRebuild(); } RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer* layer) const { for (RenderLayer* curr = layer->parent(); curr != 0; curr = curr->parent()) { if (curr->isStackingContext()) return 0; if (curr->renderer()->hasOverflowClip() || curr->renderer()->hasClip()) return curr; } return 0; } void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed) { if (layer->isRootLayer()) return; if (!boundsComputed) { layerBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox(); // Empty rects never intersect, but we need them to for the purposes of overlap testing. if (layerBounds.isEmpty()) layerBounds.setSize(IntSize(1, 1)); boundsComputed = true; } overlapMap.add(layer, layerBounds); } bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const IntRect& layerBounds) { RenderLayerCompositor::OverlapMap::const_iterator end = overlapMap.end(); for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) { const IntRect& bounds = it->second; if (layerBounds.intersects(bounds)) { return true; } } return false; } #if ENABLE(COMPOSITED_FIXED_ELEMENTS) bool RenderLayerCompositor::checkForPositionedElements(Vector* list) { int listSize = list->size(); int haveFixedLayer = -1; bool fixedSibling = false; bool positionedSibling = false; #if 0 // For absolute positioned elements, we need to check if they are followed // by a composited element; if so, they also need to be composited, as the // layer display rendering might be incorrect (absolute elements being // removed from the flow). for (int i = 0; i < listSize; ++i) { RenderLayer* currentLayer = list->at(i); if (!needsToBeComposited(currentLayer) && !currentLayer->shouldComposite() && currentLayer->renderer()->isPositioned()) { positionedSibling = true; // check if there is a composited layer later, if so we should be // composited. for (int j = i + 1; j < listSize; ++j) { RenderLayer* layer = list->at(j); if (needsToBeComposited(layer)) { currentLayer->setShouldComposite(true); break; } } break; } } #endif // If we find a fixed layer, let's mark all the following layers as being // composited. The layers' surfaces will be merged if needed UI-side. for (int j = 0; j < listSize; ++j) { RenderLayer* currentLayer = list->at(j); // clear the composited flag first currentLayer->setShouldComposite(false); if (currentLayer->isFixed() && needsToBeComposited(currentLayer)) { // Ignore fixed layers with a width or height or 1 or less... IntRect currentLayerBounds = currentLayer->renderer()->localToAbsoluteQuad( FloatRect(currentLayer->localBoundingBox())).enclosingBoundingBox(); if (currentLayerBounds.width() > 1 && currentLayerBounds.height() > 1) { haveFixedLayer = j; fixedSibling = true; } continue; } if (haveFixedLayer != -1) currentLayer->setShouldComposite(true); } return positionedSibling || fixedSibling; } #endif // Recurse through the layers in z-index and overflow order (which is equivalent to painting order) // For the z-order children of a compositing layer: // If a child layers has a compositing layer, then all subsequent layers must // be compositing in order to render above that layer. // // If a child in the negative z-order list is compositing, then the layer itself // must be compositing so that its contents render over that child. // This implies that its positive z-index children must also be compositing. // void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, OverlapMap* overlapMap, struct CompositingState& compositingState, bool& layersChanged) { layer->updateLayerPosition(); layer->updateZOrderLists(); layer->updateNormalFlowList(); #if PLATFORM(ANDROID) RenderObject* renderer = layer->renderer(); bool intCom = requiresCompositingLayer(layer); layer->setIntrinsicallyComposited(intCom); #endif // Clear the flag layer->setHasCompositingDescendant(false); bool mustOverlapCompositedLayers = compositingState.m_subtreeIsCompositing; bool haveComputedBounds = false; IntRect absBounds; if (overlapMap && !overlapMap->isEmpty()) { // If we're testing for overlap, we only need to composite if we overlap something that is already composited. absBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox(); // Empty rects never intersect, but we need them to for the purposes of overlap testing. if (absBounds.isEmpty()) absBounds.setSize(IntSize(1, 1)); haveComputedBounds = true; // If the current subtree is not compositing, and the layer is fully inside the current compositing bounnds, // there is no need to do the overlap test. This reduces the total number of the composited layers. if (compositingState.m_subtreeIsCompositing || !compositingState.m_compositingBounds.contains(absBounds)) mustOverlapCompositedLayers = overlapsCompositedLayers(*overlapMap, absBounds); } layer->setMustOverlapCompositedLayers(mustOverlapCompositedLayers); // The children of this layer don't need to composite, unless there is // a compositing layer among them, so start by inheriting the compositing // ancestor with m_subtreeIsCompositing set to false. CompositingState childState(compositingState.m_compositingAncestor); if (compositingState.m_subtreeIsCompositing) childState.m_compositingBounds = absBounds; else childState.m_compositingBounds = compositingState.m_compositingBounds; #ifndef NDEBUG ++childState.m_depth; #endif bool willBeComposited = needsToBeComposited(layer); #if 0 && ENABLE(COMPOSITED_FIXED_ELEMENTS) willBeComposited |= layer->shouldComposite(); layer->setMustOverlapCompositedLayers(layer->shouldComposite()); #endif #if ENABLE(ANDROID_OVERFLOW_SCROLL) // tell the parent it has scrollable descendants. if (layer->hasOverflowScroll()) compositingState.m_hasScrollableElement = true; #endif #if ENABLE(COMPOSITED_FIXED_ELEMENTS) if (layer->isFixed()) compositingState.m_hasFixedElement = true; #endif if (willBeComposited) { // Tell the parent it has compositing descendants. compositingState.m_subtreeIsCompositing = true; // This layer now acts as the ancestor for kids. childState.m_compositingAncestor = layer; childState.m_compositingBounds = absBounds; if (overlapMap) addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds); } #if ENABLE(VIDEO) // Video is special. It's a replaced element with a content layer, but has shadow content // for the controller that must render in front. Without this, the controls fail to show // when the video element is a stacking context (e.g. due to opacity or transform). if (willBeComposited && layer->renderer()->isVideo()) childState.m_subtreeIsCompositing = true; #endif if (layer->isStackingContext()) { ASSERT(!layer->m_zOrderListsDirty); if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) childState.m_positionedSibling = compositingState.m_positionedSibling; if (checkForPositionedElements(negZOrderList)) childState.m_positionedSibling = true; #endif for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged); // If we have to make a layer for this child, make one now so we can have a contents layer // (since we need to ensure that the -ve z-order child renders underneath our contents). #ifdef ANDROID // Normally we try to reduce the number of layers by not promoting all fixed // or scrollable elements to their own compositing layer. But in the case that // we have such an element in the negative z-order, we must make it a layer // otherwise the content will be painted at a higher z-index. This breaks pages // that set a large image with a z-index of -1 to implement a background image, // for example. bool childRequiresCompositing = childState.m_hasFixedElement || childState.m_hasScrollableElement; if (!willBeComposited && (childState.m_subtreeIsCompositing || childRequiresCompositing)) { #else if (!willBeComposited && childState.m_subtreeIsCompositing) { #endif // make layer compositing layer->setMustOverlapCompositedLayers(true); childState.m_compositingAncestor = layer; if (overlapMap) addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds); willBeComposited = true; } } } } ASSERT(!layer->m_normalFlowListDirty); if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) childState.m_positionedSibling = compositingState.m_positionedSibling; if (checkForPositionedElements(normalFlowList)) childState.m_positionedSibling = true; #endif for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged); } } if (layer->isStackingContext()) { if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); #if ENABLE(COMPOSITED_FIXED_ELEMENTS) childState.m_positionedSibling = compositingState.m_positionedSibling; if (checkForPositionedElements(posZOrderList)) childState.m_positionedSibling = true; #endif for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); computeCompositingRequirements(curLayer, overlapMap, childState, layersChanged); } } } // If we just entered compositing mode, the root will have become composited (as long as accelerated compositing is enabled). if (layer->isRootLayer()) { if (inCompositingMode() && m_hasAcceleratedCompositing) willBeComposited = true; } ASSERT(willBeComposited == needsToBeComposited(layer)); // If we have a software transform, and we have layers under us, we need to also // be composited. Also, if we have opacity < 1, then we need to be a layer so that // the child layers are opaque, then rendered with opacity on this layer. if (!willBeComposited && canBeComposited(layer) && childState.m_subtreeIsCompositing && requiresCompositingWhenDescendantsAreCompositing(layer->renderer())) { layer->setMustOverlapCompositedLayers(true); if (overlapMap) addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds); willBeComposited = true; } ASSERT(willBeComposited == needsToBeComposited(layer)); if (layer->reflectionLayer()) layer->reflectionLayer()->setMustOverlapCompositedLayers(willBeComposited); // Subsequent layers in the parent stacking context also need to composite. if (childState.m_subtreeIsCompositing) compositingState.m_subtreeIsCompositing = true; #if ENABLE(COMPOSITED_FIXED_ELEMENTS) if (childState.m_hasFixedElement) compositingState.m_hasFixedElement = true; if (childState.m_positionedSibling) compositingState.m_positionedSibling = true; #endif #if ENABLE(ANDROID_OVERFLOW_SCROLL) if (childState.m_hasScrollableElement) compositingState.m_hasScrollableElement = true; #endif // Set the flag to say that this SC has compositing children. layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing); // setHasCompositingDescendant() may have changed the answer to needsToBeComposited() when clipping, // so test that again. if (!willBeComposited && canBeComposited(layer) && clipsCompositingDescendants(layer)) { if (overlapMap) addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds); willBeComposited = true; } // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need // to be composited, then we can drop out of compositing mode altogether. #if ENABLE(ANDROID_OVERFLOW_SCROLL) // We also need to check that we don't have a scrollable layer, as this // would not have set the m_subtreeIsCompositing flag if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !childState.m_hasScrollableElement && !childState.m_positionedSibling && !childState.m_hasFixedElement && !requiresCompositingLayer(layer) && !m_forceCompositingMode) { #else if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !requiresCompositingLayer(layer) && !m_forceCompositingMode) { #endif enableCompositingMode(false); willBeComposited = false; } // If the layer is going into compositing mode, repaint its old location. ASSERT(willBeComposited == needsToBeComposited(layer)); if (!layer->isComposited() && willBeComposited) repaintOnCompositingChange(layer); // Update backing now, so that we can use isComposited() reliably during tree traversal in rebuildCompositingLayerTree(). if (updateBacking(layer, CompositingChangeRepaintNow)) layersChanged = true; if (layer->reflectionLayer() && updateLayerCompositingState(layer->reflectionLayer(), CompositingChangeRepaintNow)) layersChanged = true; } void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer) { ASSERT(!parentLayer || childLayer->ancestorCompositingLayer() == parentLayer); ASSERT(childLayer->isComposited()); // It's possible to be called with a parent that isn't yet composited when we're doing // partial updates as required by painting or hit testing. Just bail in that case; // we'll do a full layer update soon. if (!parentLayer || !parentLayer->isComposited()) return; if (parentLayer) { GraphicsLayer* hostingLayer = parentLayer->backing()->parentForSublayers(); GraphicsLayer* hostedLayer = childLayer->backing()->childForSuperlayers(); hostingLayer->addChild(hostedLayer); } else childLayer->backing()->childForSuperlayers()->removeFromParent(); } void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer) { ASSERT(layer->isComposited()); GraphicsLayer* hostingLayer = layer->backing()->parentForSublayers(); hostingLayer->removeAllChildren(); } #if ENABLE(VIDEO) bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const { if (!m_hasAcceleratedCompositing) return false; return o->supportsAcceleratedRendering(); } #endif void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer* layer, const CompositingState& compositingState, Vector& childLayersOfEnclosingLayer) { // Make the layer compositing if necessary, and set up clipping and content layers. // Note that we can only do work here that is independent of whether the descendant layers // have been processed. computeCompositingRequirements() will already have done the repaint if necessary. RenderLayerBacking* layerBacking = layer->backing(); if (layerBacking) { // The compositing state of all our children has been updated already, so now // we can compute and cache the composited bounds for this layer. layerBacking->updateCompositedBounds(); if (RenderLayer* reflection = layer->reflectionLayer()) { if (reflection->backing()) reflection->backing()->updateCompositedBounds(); } layerBacking->updateGraphicsLayerConfiguration(); layerBacking->updateGraphicsLayerGeometry(); if (!layer->parent()) updateRootLayerPosition(); } // If this layer has backing, then we are collecting its children, otherwise appending // to the compositing child list of an enclosing layer. Vector layerChildren; Vector& childList = layerBacking ? layerChildren : childLayersOfEnclosingLayer; CompositingState childState = compositingState; if (layer->isComposited()) childState.m_compositingAncestor = layer; #ifndef NDEBUG ++childState.m_depth; #endif // The children of this stacking context don't need to composite, unless there is // a compositing layer among them, so start by assuming false. childState.m_subtreeIsCompositing = false; if (layer->isStackingContext()) { ASSERT(!layer->m_zOrderListsDirty); if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); rebuildCompositingLayerTree(curLayer, childState, childList); } } // If a negative z-order child is compositing, we get a foreground layer which needs to get parented. if (layerBacking && layerBacking->foregroundLayer()) childList.append(layerBacking->foregroundLayer()); } ASSERT(!layer->m_normalFlowListDirty); if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); rebuildCompositingLayerTree(curLayer, childState, childList); } } if (layer->isStackingContext()) { if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); rebuildCompositingLayerTree(curLayer, childState, childList); } } } if (layerBacking) { bool parented = false; if (layer->renderer()->isRenderPart()) parented = parentFrameContentLayers(toRenderPart(layer->renderer())); // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer. // Otherwise, the overflow control layers are normal children. if (!layerBacking->hasClippingLayer()) { if (GraphicsLayer* overflowControlLayer = layerBacking->layerForHorizontalScrollbar()) { overflowControlLayer->removeFromParent(); layerChildren.append(overflowControlLayer); } if (GraphicsLayer* overflowControlLayer = layerBacking->layerForVerticalScrollbar()) { overflowControlLayer->removeFromParent(); layerChildren.append(overflowControlLayer); } if (GraphicsLayer* overflowControlLayer = layerBacking->layerForScrollCorner()) { overflowControlLayer->removeFromParent(); layerChildren.append(overflowControlLayer); } } if (!parented) layerBacking->parentForSublayers()->setChildren(layerChildren); #if ENABLE(FULLSCREEN_API) // For the sake of clients of the full screen renderer, don't reparent // the full screen layer out from under them if they're in the middle of // animating. if (layer->renderer()->isRenderFullScreen() && toRenderFullScreen(layer->renderer())->isAnimating()) return; #endif childLayersOfEnclosingLayer.append(layerBacking->childForSuperlayers()); } } void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset) { if (m_overflowControlsHostLayer) m_overflowControlsHostLayer->setPosition(contentsOffset); } void RenderLayerCompositor::frameViewDidChangeSize() { if (m_clipLayer) { FrameView* frameView = m_renderView->frameView(); m_clipLayer->setSize(frameView->visibleContentRect(false /* exclude scrollbars */).size()); IntPoint scrollPosition = frameView->scrollPosition(); m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y())); updateOverflowControlsLayers(); } } void RenderLayerCompositor::frameViewDidScroll(const IntPoint& scrollPosition) { if (m_scrollLayer) m_scrollLayer->setPosition(FloatPoint(-scrollPosition.x(), -scrollPosition.y())); } String RenderLayerCompositor::layerTreeAsText(bool showDebugInfo) { if (compositingLayerUpdatePending()) updateCompositingLayers(); if (!m_rootPlatformLayer) return String(); // We skip dumping the scroll and clip layers to keep layerTreeAsText output // similar between platforms. return m_rootPlatformLayer->layerTreeAsText(showDebugInfo ? LayerTreeAsTextDebug : LayerTreeAsTextBehaviorNormal); } RenderLayerCompositor* RenderLayerCompositor::frameContentsCompositor(RenderPart* renderer) { if (!renderer->node()->isFrameOwnerElement()) return 0; HTMLFrameOwnerElement* element = static_cast(renderer->node()); if (Document* contentDocument = element->contentDocument()) { if (RenderView* view = contentDocument->renderView()) return view->compositor(); } return 0; } bool RenderLayerCompositor::parentFrameContentLayers(RenderPart* renderer) { RenderLayerCompositor* innerCompositor = frameContentsCompositor(renderer); if (!innerCompositor || !innerCompositor->inCompositingMode() || innerCompositor->rootLayerAttachment() != RootLayerAttachedViaEnclosingFrame) return false; RenderLayer* layer = renderer->layer(); if (!layer->isComposited()) return false; RenderLayerBacking* backing = layer->backing(); GraphicsLayer* hostingLayer = backing->parentForSublayers(); GraphicsLayer* rootLayer = innerCompositor->rootPlatformLayer(); if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) { hostingLayer->removeAllChildren(); hostingLayer->addChild(rootLayer); } return true; } // This just updates layer geometry without changing the hierarchy. void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer* layer) { if (RenderLayerBacking* layerBacking = layer->backing()) { // The compositing state of all our children has been updated already, so now // we can compute and cache the composited bounds for this layer. layerBacking->updateCompositedBounds(); if (RenderLayer* reflection = layer->reflectionLayer()) { if (reflection->backing()) reflection->backing()->updateCompositedBounds(); } layerBacking->updateGraphicsLayerConfiguration(); layerBacking->updateGraphicsLayerGeometry(); if (!layer->parent()) updateRootLayerPosition(); } if (layer->isStackingContext()) { ASSERT(!layer->m_zOrderListsDirty); if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateLayerTreeGeometry(negZOrderList->at(i)); } } ASSERT(!layer->m_normalFlowListDirty); if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) updateLayerTreeGeometry(normalFlowList->at(i)); } if (layer->isStackingContext()) { if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateLayerTreeGeometry(posZOrderList->at(i)); } } } // Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry. void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayer* compositingAncestor, RenderLayer* layer, RenderLayerBacking::UpdateDepth updateDepth) { if (layer != compositingAncestor) { if (RenderLayerBacking* layerBacking = layer->backing()) { layerBacking->updateCompositedBounds(); if (RenderLayer* reflection = layer->reflectionLayer()) { if (reflection->backing()) reflection->backing()->updateCompositedBounds(); } layerBacking->updateGraphicsLayerGeometry(); if (updateDepth == RenderLayerBacking::CompositingChildren) return; } } if (layer->reflectionLayer()) updateCompositingDescendantGeometry(compositingAncestor, layer->reflectionLayer(), updateDepth); if (!layer->hasCompositingDescendant()) return; if (layer->isStackingContext()) { if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateCompositingDescendantGeometry(compositingAncestor, negZOrderList->at(i), updateDepth); } } if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) updateCompositingDescendantGeometry(compositingAncestor, normalFlowList->at(i), updateDepth); } if (layer->isStackingContext()) { if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateCompositingDescendantGeometry(compositingAncestor, posZOrderList->at(i), updateDepth); } } } void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const IntRect& absRect) { recursiveRepaintLayerRect(rootRenderLayer(), absRect); } void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect) { // FIXME: This method does not work correctly with transforms. if (layer->isComposited()) layer->setBackingNeedsRepaintInRect(rect); if (layer->hasCompositingDescendant()) { if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); int x = 0; int y = 0; curLayer->convertToLayerCoords(layer, x, y); IntRect childRect(rect); childRect.move(-x, -y); recursiveRepaintLayerRect(curLayer, childRect); } } if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); int x = 0; int y = 0; curLayer->convertToLayerCoords(layer, x, y); IntRect childRect(rect); childRect.move(-x, -y); recursiveRepaintLayerRect(curLayer, childRect); } } } if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); int x = 0; int y = 0; curLayer->convertToLayerCoords(layer, x, y); IntRect childRect(rect); childRect.move(-x, -y); recursiveRepaintLayerRect(curLayer, childRect); } } } RenderLayer* RenderLayerCompositor::rootRenderLayer() const { return m_renderView->layer(); } GraphicsLayer* RenderLayerCompositor::rootPlatformLayer() const { if (m_overflowControlsHostLayer) return m_overflowControlsHostLayer.get(); return m_rootPlatformLayer.get(); } void RenderLayerCompositor::didMoveOnscreen() { if (!inCompositingMode() || m_rootLayerAttachment != RootLayerUnattached) return; RootLayerAttachment attachment = shouldPropagateCompositingToEnclosingFrame() ? RootLayerAttachedViaEnclosingFrame : RootLayerAttachedViaChromeClient; attachRootPlatformLayer(attachment); } void RenderLayerCompositor::willMoveOffscreen() { if (!inCompositingMode() || m_rootLayerAttachment == RootLayerUnattached) return; detachRootPlatformLayer(); } void RenderLayerCompositor::updateRootLayerPosition() { if (m_rootPlatformLayer) { m_rootPlatformLayer->setSize(FloatSize(m_renderView->docWidth(), m_renderView->docHeight())); m_rootPlatformLayer->setPosition(FloatPoint(m_renderView->docLeft(), m_renderView->docTop())); } if (m_clipLayer) { FrameView* frameView = m_renderView->frameView(); m_clipLayer->setSize(frameView->visibleContentRect(false /* exclude scrollbars */).size()); } } void RenderLayerCompositor::didStartAcceleratedAnimation(CSSPropertyID property) { // If an accelerated animation or transition runs, we have to turn off overlap checking because // we don't do layout for every frame, but we have to ensure that the layering is // correct between the animating object and other objects on the page. if (property == CSSPropertyWebkitTransform) setCompositingConsultsOverlap(false); } bool RenderLayerCompositor::has3DContent() const { return layerHas3DContent(rootRenderLayer()); } bool RenderLayerCompositor::allowsIndependentlyCompositedFrames(const FrameView* view) { #if PLATFORM(MAC) // frames are only independently composited in Mac pre-WebKit2. return view->platformWidget(); #endif return false; } bool RenderLayerCompositor::shouldPropagateCompositingToEnclosingFrame() const { #if PLATFORM(ANDROID) if (enclosingFrameElement() && !allowsIndependentlyCompositedFrames(m_renderView->frameView())) return true; #endif // Parent document content needs to be able to render on top of a composited frame, so correct behavior // is to have the parent document become composited too. However, this can cause problems on platforms that // use native views for frames (like Mac), so disable that behavior on those platforms for now. HTMLFrameOwnerElement* ownerElement = enclosingFrameElement(); RenderObject* renderer = ownerElement ? ownerElement->renderer() : 0; // If we are the top-level frame, don't propagate. if (!ownerElement) return false; if (!allowsIndependentlyCompositedFrames(m_renderView->frameView())) return true; if (!renderer || !renderer->isRenderPart()) return false; // On Mac, only propagate compositing if the frame is overlapped in the parent // document, or the parent is already compositing, or the main frame is scaled. Frame* frame = m_renderView->frameView()->frame(); Page* page = frame ? frame->page() : 0; if (page->mainFrame()->pageScaleFactor() != 1) return true; RenderPart* frameRenderer = toRenderPart(renderer); if (frameRenderer->widget()) { ASSERT(frameRenderer->widget()->isFrameView()); FrameView* view = static_cast(frameRenderer->widget()); if (view->isOverlappedIncludingAncestors() || view->hasCompositingAncestor()) return true; } return false; } HTMLFrameOwnerElement* RenderLayerCompositor::enclosingFrameElement() const { if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement()) return (ownerElement->hasTagName(iframeTag) || ownerElement->hasTagName(frameTag) || ownerElement->hasTagName(objectTag)) ? ownerElement : 0; return 0; } bool RenderLayerCompositor::needsToBeComposited(const RenderLayer* layer) const { if (!canBeComposited(layer)) return false; // The root layer always has a compositing layer, but it may not have backing. #if PLATFORM(ANDROID) // If we do not have a root platform layer, don't use the // mustOverlapCompositedLayers() as a cue that this layer needs to be // composited -- the layers tree has been detached. // Otherwise we can end up in a cycle where updateBacking() switches composited // mode on because a layer has mustOverlapCompositedLayers() (by calling // enableCompositingMode()), while computeCompositingRequirements() will // (correctly) say that we do not need to be in composited mode and turns it // off, rince and repeat... return requiresCompositingLayer(layer) || (m_rootPlatformLayer && layer->mustOverlapCompositedLayers()) || (inCompositingMode() && layer->isRootLayer()); #else return requiresCompositingLayer(layer) || layer->mustOverlapCompositedLayers() || (inCompositingMode() && layer->isRootLayer()); #endif } #if PLATFORM(ANDROID) bool RenderLayerCompositor::requiresCompositingForAndroidLayers(const RenderLayer* layer) const { #if ENABLE(ANDROID_OVERFLOW_SCROLL) if (layer->hasOverflowScroll()) return true; if (layer->isRootLayer() && m_renderView->frameView()->hasOverflowScroll()) return true; #endif #if ENABLE(COMPOSITED_FIXED_ELEMENTS) // Enable composited layers (for fixed elements) if (layer->isFixed()) return true; #endif if (layer->renderer()->isCanvas()) return true; if (layer->renderer()->style()->hasFixedBackgroundImage()) return true; return false; } #endif // Note: this specifies whether the RL needs a compositing layer for intrinsic reasons. // Use needsToBeComposited() to determine if a RL actually needs a compositing layer. // static bool RenderLayerCompositor::requiresCompositingLayer(const RenderLayer* layer) const { RenderObject* renderer = layer->renderer(); // The compositing state of a reflection should match that of its reflected layer. if (layer->isReflection()) { renderer = renderer->parent(); // The RenderReplica's parent is the object being reflected. layer = toRenderBoxModelObject(renderer)->layer(); } return requiresCompositingForTransform(renderer) #if PLATFORM(ANDROID) || requiresCompositingForAndroidLayers(layer) #endif || requiresCompositingForVideo(renderer) || requiresCompositingForCanvas(renderer) || requiresCompositingForPlugin(renderer) || requiresCompositingForFrame(renderer) || (canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden) || clipsCompositingDescendants(layer) || requiresCompositingForAnimation(renderer) || requiresCompositingForFullScreen(renderer); } bool RenderLayerCompositor::canBeComposited(const RenderLayer* layer) const { return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer(); } // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips, // up to the enclosing compositing ancestor. This is required because compositing layers are parented // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy. // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy, // but a sibling in the z-order hierarchy. bool RenderLayerCompositor::clippedByAncestor(RenderLayer* layer) const { if (!layer->isComposited() || !layer->parent()) return false; RenderLayer* compositingAncestor = layer->ancestorCompositingLayer(); if (!compositingAncestor) return false; // If the compositingAncestor clips, that will be taken care of by clipsCompositingDescendants(), // so we only care about clipping between its first child that is our ancestor (the computeClipRoot), // and layer. RenderLayer* computeClipRoot = 0; RenderLayer* curr = layer; while (curr) { RenderLayer* next = curr->parent(); if (next == compositingAncestor) { computeClipRoot = curr; break; } curr = next; } if (!computeClipRoot || computeClipRoot == layer) return false; IntRect backgroundRect = layer->backgroundClipRect(computeClipRoot, true); return backgroundRect != PaintInfo::infiniteRect(); } // Return true if the given layer is a stacking context and has compositing child // layers that it needs to clip. In this case we insert a clipping GraphicsLayer // into the hierarchy between this layer and its children in the z-order hierarchy. bool RenderLayerCompositor::clipsCompositingDescendants(const RenderLayer* layer) const { #if ENABLE(ANDROID_OVERFLOW_SCROLL) if (layer->hasOverflowScroll()) return false; #endif return layer->hasCompositingDescendant() && (layer->renderer()->hasOverflowClip() || layer->renderer()->hasClip()); } bool RenderLayerCompositor::requiresCompositingForTransform(RenderObject* renderer) const { if (!(m_compositingTriggers & ChromeClient::ThreeDTransformTrigger)) return false; RenderStyle* style = renderer->style(); // Note that we ask the renderer if it has a transform, because the style may have transforms, // but the renderer may be an inline that doesn't suppport them. return renderer->hasTransform() && (style->transform().has3DOperation() || style->transformStyle3D() == TransformStyle3DPreserve3D || style->hasPerspective()); } bool RenderLayerCompositor::requiresCompositingForVideo(RenderObject* renderer) const { if (!(m_compositingTriggers & ChromeClient::VideoTrigger)) return false; #if ENABLE(VIDEO) if (renderer->isVideo()) { RenderVideo* video = toRenderVideo(renderer); return video->shouldDisplayVideo() && canAccelerateVideoRendering(video); } #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) else if (renderer->isRenderPart()) { if (!m_hasAcceleratedCompositing) return false; Node* node = renderer->node(); if (!node || (!node->hasTagName(HTMLNames::videoTag) && !node->hasTagName(HTMLNames::audioTag))) return false; HTMLMediaElement* mediaElement = static_cast(node); return mediaElement->player() ? mediaElement->player()->supportsAcceleratedRendering() : false; } #endif // ENABLE(PLUGIN_PROXY_FOR_VIDEO) #else UNUSED_PARAM(renderer); #endif return false; } bool RenderLayerCompositor::requiresCompositingForCanvas(RenderObject* renderer) const { if (!(m_compositingTriggers & ChromeClient::CanvasTrigger)) return false; if (renderer->isCanvas()) { HTMLCanvasElement* canvas = static_cast(renderer->node()); return canvas->renderingContext() && canvas->renderingContext()->isAccelerated(); } return false; } bool RenderLayerCompositor::requiresCompositingForPlugin(RenderObject* renderer) const { if (!(m_compositingTriggers & ChromeClient::PluginTrigger)) return false; bool composite = (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing()) || (renderer->isApplet() && toRenderApplet(renderer)->allowsAcceleratedCompositing()); if (!composite) return false; m_compositingDependsOnGeometry = true; RenderWidget* pluginRenderer = toRenderWidget(renderer); // If we can't reliably know the size of the plugin yet, don't change compositing state. if (pluginRenderer->needsLayout()) return pluginRenderer->hasLayer() && pluginRenderer->layer()->isComposited(); // Don't go into compositing mode if height or width are zero, or size is 1x1. IntRect contentBox = pluginRenderer->contentBoxRect(); #if PLATFORM(ANDROID) // allow all plugins including 1x1 to be composited, so that they are drawn, // and acquire an ANativeWindow on the UI thread return contentBox.height() * contentBox.width() > 0; #else return contentBox.height() * contentBox.width() > 1; #endif } bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer) const { if (!renderer->isRenderPart()) return false; RenderPart* frameRenderer = toRenderPart(renderer); if (!frameRenderer->requiresAcceleratedCompositing()) return false; m_compositingDependsOnGeometry = true; RenderLayerCompositor* innerCompositor = frameContentsCompositor(frameRenderer); if (!innerCompositor || !innerCompositor->shouldPropagateCompositingToEnclosingFrame()) return false; // If we can't reliably know the size of the iframe yet, don't change compositing state. if (renderer->needsLayout()) return frameRenderer->hasLayer() && frameRenderer->layer()->isComposited(); // Don't go into compositing mode if height or width are zero. IntRect contentBox = frameRenderer->contentBoxRect(); return contentBox.height() * contentBox.width() > 0; } bool RenderLayerCompositor::requiresCompositingForAnimation(RenderObject* renderer) const { if (!(m_compositingTriggers & ChromeClient::AnimationTrigger)) return false; if (AnimationController* animController = renderer->animation()) { #if PLATFORM(ANDROID) // android renders an opacity animation much faster if it's composited return (animController->isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity)) #else return (animController->isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity) && inCompositingMode()) #endif || animController->isRunningAnimationOnRenderer(renderer, CSSPropertyWebkitTransform); } return false; } bool RenderLayerCompositor::requiresCompositingWhenDescendantsAreCompositing(RenderObject* renderer) const { return renderer->hasTransform() || renderer->isTransparent() || renderer->hasMask() || renderer->hasReflection(); } bool RenderLayerCompositor::requiresCompositingForFullScreen(RenderObject* renderer) const { #if ENABLE(FULLSCREEN_API) return renderer->isRenderFullScreen() && toRenderFullScreen(renderer)->isAnimating(); #else UNUSED_PARAM(renderer); return false; #endif } // If an element has negative z-index children, those children render in front of the // layer background, so we need an extra 'contents' layer for the foreground of the layer // object. bool RenderLayerCompositor::needsContentsCompositingLayer(const RenderLayer* layer) const { return (layer->m_negZOrderList && layer->m_negZOrderList->size() > 0); } bool RenderLayerCompositor::requiresScrollLayer(RootLayerAttachment attachment) const { // We need to handle our own scrolling if we're: return !m_renderView->frameView()->platformWidget() // viewless (i.e. non-Mac, or Mac in WebKit2) || attachment == RootLayerAttachedViaEnclosingFrame; // a composited frame on Mac } static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip) { if (!scrollbar) return; context.save(); const IntRect& scrollbarRect = scrollbar->frameRect(); context.translate(-scrollbarRect.x(), -scrollbarRect.y()); IntRect transformedClip = clip; transformedClip.move(scrollbarRect.x(), scrollbarRect.y()); scrollbar->paint(&context, transformedClip); context.restore(); } void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& clip) { if (graphicsLayer == layerForHorizontalScrollbar()) paintScrollbar(m_renderView->frameView()->horizontalScrollbar(), context, clip); else if (graphicsLayer == layerForVerticalScrollbar()) paintScrollbar(m_renderView->frameView()->verticalScrollbar(), context, clip); else if (graphicsLayer == layerForScrollCorner()) { const IntRect& scrollCorner = m_renderView->frameView()->scrollCornerRect(); context.save(); context.translate(-scrollCorner.x(), -scrollCorner.y()); IntRect transformedClip = clip; transformedClip.move(scrollCorner.x(), scrollCorner.y()); m_renderView->frameView()->paintScrollCorner(&context, transformedClip); context.restore(); } } static bool shouldCompositeOverflowControls(ScrollView* view) { if (view->platformWidget()) return false; #if !PLATFORM(CHROMIUM) if (!view->hasOverlayScrollbars()) return false; #endif return true; } bool RenderLayerCompositor::requiresHorizontalScrollbarLayer() const { ScrollView* view = m_renderView->frameView(); return shouldCompositeOverflowControls(view) && view->horizontalScrollbar(); } bool RenderLayerCompositor::requiresVerticalScrollbarLayer() const { ScrollView* view = m_renderView->frameView(); return shouldCompositeOverflowControls(view) && view->verticalScrollbar(); } bool RenderLayerCompositor::requiresScrollCornerLayer() const { ScrollView* view = m_renderView->frameView(); return shouldCompositeOverflowControls(view) && view->isScrollCornerVisible(); } void RenderLayerCompositor::updateOverflowControlsLayers() { bool layersChanged = false; if (requiresHorizontalScrollbarLayer()) { m_layerForHorizontalScrollbar = GraphicsLayer::create(this); #ifndef NDEBUG m_layerForHorizontalScrollbar->setName("horizontal scrollbar"); #endif m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get()); layersChanged = true; } else if (m_layerForHorizontalScrollbar) { m_layerForHorizontalScrollbar->removeFromParent(); m_layerForHorizontalScrollbar = 0; layersChanged = true; } if (requiresVerticalScrollbarLayer()) { m_layerForVerticalScrollbar = GraphicsLayer::create(this); #ifndef NDEBUG m_layerForVerticalScrollbar->setName("vertical scrollbar"); #endif m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get()); layersChanged = true; } else if (m_layerForVerticalScrollbar) { m_layerForVerticalScrollbar->removeFromParent(); m_layerForVerticalScrollbar = 0; layersChanged = true; } if (requiresScrollCornerLayer()) { m_layerForScrollCorner = GraphicsLayer::create(this); #ifndef NDEBUG m_layerForScrollCorner->setName("scroll corner"); #endif m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get()); layersChanged = true; } else if (m_layerForScrollCorner) { m_layerForScrollCorner->removeFromParent(); m_layerForScrollCorner = 0; layersChanged = true; } if (layersChanged) m_renderView->frameView()->positionScrollbarLayers(); } void RenderLayerCompositor::ensureRootPlatformLayer() { RootLayerAttachment expectedAttachment = shouldPropagateCompositingToEnclosingFrame() ? RootLayerAttachedViaEnclosingFrame : RootLayerAttachedViaChromeClient; if (expectedAttachment == m_rootLayerAttachment) return; if (!m_rootPlatformLayer) { m_rootPlatformLayer = GraphicsLayer::create(0); #ifndef NDEBUG m_rootPlatformLayer->setName("Root platform"); #endif m_rootPlatformLayer->setSize(FloatSize(m_renderView->maxXLayoutOverflow(), m_renderView->maxYLayoutOverflow())); m_rootPlatformLayer->setPosition(FloatPoint()); // Need to clip to prevent transformed content showing outside this frame m_rootPlatformLayer->setMasksToBounds(true); } if (requiresScrollLayer(expectedAttachment)) { if (!m_overflowControlsHostLayer) { ASSERT(!m_scrollLayer); ASSERT(!m_clipLayer); // Create a layer to host the clipping layer and the overflow controls layers. m_overflowControlsHostLayer = GraphicsLayer::create(0); #ifndef NDEBUG m_overflowControlsHostLayer->setName("overflow controls host"); #endif // Create a clipping layer if this is an iframe m_clipLayer = GraphicsLayer::create(this); #ifndef NDEBUG m_clipLayer->setName("iframe Clipping"); #endif m_clipLayer->setMasksToBounds(true); m_scrollLayer = GraphicsLayer::create(this); #ifndef NDEBUG m_scrollLayer->setName("iframe scrolling"); #endif // Hook them up m_overflowControlsHostLayer->addChild(m_clipLayer.get()); m_clipLayer->addChild(m_scrollLayer.get()); m_scrollLayer->addChild(m_rootPlatformLayer.get()); frameViewDidChangeSize(); frameViewDidScroll(m_renderView->frameView()->scrollPosition()); } } else { if (m_overflowControlsHostLayer) { m_overflowControlsHostLayer = 0; m_clipLayer = 0; m_scrollLayer = 0; } } // Check to see if we have to change the attachment if (m_rootLayerAttachment != RootLayerUnattached) detachRootPlatformLayer(); attachRootPlatformLayer(expectedAttachment); } void RenderLayerCompositor::destroyRootPlatformLayer() { if (!m_rootPlatformLayer) return; detachRootPlatformLayer(); if (m_layerForHorizontalScrollbar) { m_layerForHorizontalScrollbar->removeFromParent(); m_layerForHorizontalScrollbar = 0; if (Scrollbar* horizontalScrollbar = m_renderView->frameView()->verticalScrollbar()) m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, IntRect(IntPoint(0, 0), horizontalScrollbar->frameRect().size())); } if (m_layerForVerticalScrollbar) { m_layerForVerticalScrollbar->removeFromParent(); m_layerForVerticalScrollbar = 0; if (Scrollbar* verticalScrollbar = m_renderView->frameView()->verticalScrollbar()) m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, IntRect(IntPoint(0, 0), verticalScrollbar->frameRect().size())); } if (m_layerForScrollCorner) { m_layerForScrollCorner = 0; m_renderView->frameView()->invalidateScrollCorner(); } if (m_overflowControlsHostLayer) { m_overflowControlsHostLayer = 0; m_clipLayer = 0; m_scrollLayer = 0; } ASSERT(!m_scrollLayer); m_rootPlatformLayer = 0; } void RenderLayerCompositor::attachRootPlatformLayer(RootLayerAttachment attachment) { if (!m_rootPlatformLayer) return; switch (attachment) { case RootLayerUnattached: ASSERT_NOT_REACHED(); break; case RootLayerAttachedViaChromeClient: { Frame* frame = m_renderView->frameView()->frame(); Page* page = frame ? frame->page() : 0; if (!page) return; page->chrome()->client()->attachRootGraphicsLayer(frame, rootPlatformLayer()); break; } case RootLayerAttachedViaEnclosingFrame: { // The layer will get hooked up via RenderLayerBacking::updateGraphicsLayerConfiguration() // for the frame's renderer in the parent document. scheduleNeedsStyleRecalc(m_renderView->document()->ownerElement()); break; } } m_rootLayerAttachment = attachment; rootLayerAttachmentChanged(); } void RenderLayerCompositor::detachRootPlatformLayer() { if (!m_rootPlatformLayer || m_rootLayerAttachment == RootLayerUnattached) return; switch (m_rootLayerAttachment) { case RootLayerAttachedViaEnclosingFrame: { // The layer will get unhooked up via RenderLayerBacking::updateGraphicsLayerConfiguration() // for the frame's renderer in the parent document. if (m_overflowControlsHostLayer) m_overflowControlsHostLayer->removeFromParent(); else m_rootPlatformLayer->removeFromParent(); if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement()) scheduleNeedsStyleRecalc(ownerElement); break; } case RootLayerAttachedViaChromeClient: { Frame* frame = m_renderView->frameView()->frame(); Page* page = frame ? frame->page() : 0; if (!page) return; page->chrome()->client()->attachRootGraphicsLayer(frame, 0); } break; case RootLayerUnattached: break; } m_rootLayerAttachment = RootLayerUnattached; rootLayerAttachmentChanged(); } void RenderLayerCompositor::updateRootLayerAttachment() { ensureRootPlatformLayer(); } void RenderLayerCompositor::rootLayerAttachmentChanged() { // The attachment can affect whether the RenderView layer's paintingGoesToWindow() behavior, // so call updateGraphicsLayerGeometry() to udpate that. RenderLayer* layer = m_renderView->layer(); if (RenderLayerBacking* backing = layer ? layer->backing() : 0) backing->updateDrawsContent(); } static void needsStyleRecalcCallback(Node* node) { node->setNeedsStyleRecalc(SyntheticStyleChange); } void RenderLayerCompositor::scheduleNeedsStyleRecalc(Element* element) { if (ContainerNode::postAttachCallbacksAreSuspended()) ContainerNode::queuePostAttachCallback(needsStyleRecalcCallback, element); else element->setNeedsStyleRecalc(SyntheticStyleChange); } // IFrames are special, because we hook compositing layers together across iframe boundaries // when both parent and iframe content are composited. So when this frame becomes composited, we have // to use a synthetic style change to get the iframes into RenderLayers in order to allow them to composite. void RenderLayerCompositor::notifyIFramesOfCompositingChange() { Frame* frame = m_renderView->frameView() ? m_renderView->frameView()->frame() : 0; if (!frame) return; for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->traverseNext(frame)) { if (child->document() && child->document()->ownerElement()) scheduleNeedsStyleRecalc(child->document()->ownerElement()); } // Compositing also affects the answer to RenderIFrame::requiresAcceleratedCompositing(), so // we need to schedule a style recalc in our parent document. if (HTMLFrameOwnerElement* ownerElement = m_renderView->document()->ownerElement()) scheduleNeedsStyleRecalc(ownerElement); } bool RenderLayerCompositor::layerHas3DContent(const RenderLayer* layer) const { const RenderStyle* style = layer->renderer()->style(); if (style && (style->transformStyle3D() == TransformStyle3DPreserve3D || style->hasPerspective() || style->transform().has3DOperation())) return true; if (layer->isStackingContext()) { if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = negZOrderList->at(i); if (layerHas3DContent(curLayer)) return true; } } if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = posZOrderList->at(i); if (layerHas3DContent(curLayer)) return true; } } } if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) { RenderLayer* curLayer = normalFlowList->at(i); if (layerHas3DContent(curLayer)) return true; } } return false; } void RenderLayerCompositor::updateContentsScale(float scale, RenderLayer* layer) { if (!layer) layer = rootRenderLayer(); layer->updateContentsScale(scale); if (layer->isStackingContext()) { if (Vector* negZOrderList = layer->negZOrderList()) { size_t listSize = negZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateContentsScale(scale, negZOrderList->at(i)); } if (Vector* posZOrderList = layer->posZOrderList()) { size_t listSize = posZOrderList->size(); for (size_t i = 0; i < listSize; ++i) updateContentsScale(scale, posZOrderList->at(i)); } } if (Vector* normalFlowList = layer->normalFlowList()) { size_t listSize = normalFlowList->size(); for (size_t i = 0; i < listSize; ++i) updateContentsScale(scale, normalFlowList->at(i)); } } } // namespace WebCore #endif // USE(ACCELERATED_COMPOSITING)