2009-01-15  Simon Fraser  <simon.fraser@apple.com>

        Reviewed by NOBODY (OOPS!).

        https://bugs.webkit.org/show_bug.cgi?id=23357

        New files to support accelerated compositing at the RenderLayer

        level.

        * WebCore.xcodeproj/project.pbxproj:

        New files added to project.

        * rendering/RenderLayerBacking.cpp: Added.

        * rendering/RenderLayerBacking.h: Added.

        New object to store compositing-related data for a single

        RenderLayer.

        * rendering/RenderLayerCompositor.cpp: Added.

        * rendering/RenderLayerCompositor.h: Added.

        Per-RenderView controller object for compositing hierarchy

        maintenance.

		0F580CFD0F12DE9B0051D689 /* RenderLayerCompositor.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580CF90F12DE9B0051D689 /* RenderLayerCompositor.h */; };

		0F580CFE0F12DE9B0051D689 /* RenderLayerCompositor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F580CFA0F12DE9B0051D689 /* RenderLayerCompositor.cpp */; };

		0F580CFF0F12DE9B0051D689 /* RenderLayerBacking.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F580CFB0F12DE9B0051D689 /* RenderLayerBacking.h */; };

		0F580D000F12DE9B0051D689 /* RenderLayerBacking.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F580CFC0F12DE9B0051D689 /* RenderLayerBacking.cpp */; };

		0F580CF90F12DE9B0051D689 /* RenderLayerCompositor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderLayerCompositor.h; sourceTree = "<group>"; };

		0F580CFA0F12DE9B0051D689 /* RenderLayerCompositor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderLayerCompositor.cpp; sourceTree = "<group>"; };

		0F580CFB0F12DE9B0051D689 /* RenderLayerBacking.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderLayerBacking.h; sourceTree = "<group>"; };

		0F580CFC0F12DE9B0051D689 /* RenderLayerBacking.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderLayerBacking.cpp; sourceTree = "<group>"; };

				0F580CFB0F12DE9B0051D689 /* RenderLayerBacking.h */,

				0F580CFC0F12DE9B0051D689 /* RenderLayerBacking.cpp */,

				0F580CF90F12DE9B0051D689 /* RenderLayerCompositor.h */,

				0F580CFA0F12DE9B0051D689 /* RenderLayerCompositor.cpp */,

				0F580CFD0F12DE9B0051D689 /* RenderLayerCompositor.h in Headers */,

				0F580CFF0F12DE9B0051D689 /* RenderLayerBacking.h in Headers */,

				0F580CFE0F12DE9B0051D689 /* RenderLayerCompositor.cpp in Sources */,

				0F580D000F12DE9B0051D689 /* RenderLayerBacking.cpp in Sources */,

/*

 * Copyright (C) 2009 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. 

 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 "AnimationController.h"

#include "CSSStyleSelector.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "GraphicsLayer.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "HTMLNames.h"

#include "RenderImage.h"

#include "RenderLayerCompositor.h"

#include "RenderVideo.h"

#include "RenderView.h"

#include "RenderLayerBacking.h"

using namespace std;

namespace WebCore {

struct LayerHitTestData {

    LayerHitTestData(RenderLayer* inRootLayer, const HitTestRequest& inRequest, HitTestResult& inResult, const IntRect& hitTestRect)

    : m_rootLayer(inRootLayer)

    , m_request(inRequest)

    , m_hitTestRect(hitTestRect)

    , m_result(inResult)

    {

    }

    RenderLayer* m_rootLayer;

    const HitTestRequest& m_request;

    const IntRect& m_hitTestRect;

    HitTestResult& m_result;

};

RenderLayerBacking::RenderLayerBacking(RenderLayer* layer)

    : m_owningLayer(layer)

    , m_ancestorClippingLayer(0)

    , m_graphicsLayer(0)

    , m_contentsLayer(0)

    , m_clippingLayer(0)

    , m_forceCompositingLayer(false)

    , m_isSimpleContainerCompositingLayer(false)

    , m_simpleCompositingLayerStatusDirty(true)

    , m_compositingContentOffsetDirty(true)

{

    createGraphicsLayer();

}

RenderLayerBacking::~RenderLayerBacking()

{

    updateClippingLayers(false, false);

    updateContentsLayer(false);

    destroyGraphicsLayer();

}

void RenderLayerBacking::createGraphicsLayer()

{

    m_graphicsLayer = GraphicsLayer::createGraphicsLayer(this);

#ifndef NDEBUG

    if (renderer()->node()->isDocumentNode())

        m_graphicsLayer->setName("Document Node");

    else {

        if (renderer()->node()->isHTMLElement() && renderer()->node()->hasID())

            m_graphicsLayer->setName(renderer()->renderName() + String(" ") + ((HTMLElement*)renderer()->node())->id());

        else

            m_graphicsLayer->setName(renderer()->renderName());

    }

#endif  // NDEBUG

    updateLayerOpacity();

    updateLayerTransform();

}

void RenderLayerBacking::destroyGraphicsLayer()

{

    if (m_graphicsLayer)

        m_graphicsLayer->removeFromParent();

    delete m_graphicsLayer;

    m_graphicsLayer = 0;

    delete m_contentsLayer;

    m_contentsLayer = 0;

    delete m_clippingLayer;

    m_clippingLayer = 0;

}

void RenderLayerBacking::updateLayerOpacity()

{

    m_graphicsLayer->setOpacity(compositingOpacity(renderer()->opacity()), 0, 0);

}

void RenderLayerBacking::updateLayerTransform()

{

    RenderStyle* style = renderer()->style();

    const IntRect borderBox = renderer()->borderBox();

    // FIXME: This should use m_owningLayer->transform(), but that currently has transform-origin

    // baked into it, and we don't want that.

    TransformationMatrix t;

    style->applyTransform(t, borderBox.size(), false);

    m_graphicsLayer->setTransform(t);

}

void RenderLayerBacking::updateAfterLayout()

{

    invalidateDrawingOptimizations();

    detectDrawingOptimizations();

    updateGraphicsLayerGeometry();

}

bool RenderLayerBacking::updateGraphicsLayers(bool needsContentsLayer, bool needsUpperClippingLayer, bool needsLowerClippingLayer, bool needsRepaint)

{

    bool layerConfigChanged = false;

    if (updateContentsLayer(needsContentsLayer))

        layerConfigChanged = true;

    if (updateClippingLayers(needsUpperClippingLayer, needsLowerClippingLayer))

        layerConfigChanged = true;

    // See if we can now use any drawing optimizations.

    bool didDrawContent = graphicsLayer()->drawsContent();

    invalidateDrawingOptimizations();

    detectDrawingOptimizations();

    if (!didDrawContent && graphicsLayer()->drawsContent())

        needsRepaint = true;

    // Set opacity, if it is not animating.

    if (!renderer()->animation()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyOpacity))

        updateLayerOpacity();

    // Set transform property, if it is not animating.

    if (!renderer()->animation()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyWebkitTransform))

        updateLayerTransform();

    updateGraphicsLayerGeometry();

    m_graphicsLayer->updateContentsRect();

    if (needsRepaint) {

        m_graphicsLayer->setNeedsDisplay();

        if (m_contentsLayer)

            m_contentsLayer->setNeedsDisplay();

    }

    return layerConfigChanged;

}

void RenderLayerBacking::updateGraphicsLayerGeometry()

{

    // If we haven't built z-order lists yet, wait until later.

    if (m_owningLayer->isStackingContext() && m_owningLayer->m_zOrderListsDirty)

        return;

    m_compositingContentOffsetDirty = true;

    RenderLayer* compAncestor = compositor()->enclosingCompositingLayer(m_owningLayer, false);

    IntRect ancestorCompositingBounds;

    const RenderLayer* rootLayer = m_owningLayer->root();

    // FIXME: optimize calculateCompositedBounds calls. Too many coord conversions in this code.

    if (compAncestor)

        ancestorCompositingBounds = compositor()->calculateCompositedBounds(compAncestor, rootLayer);

    IntRect compositingBounds = compositor()->calculateCompositedBounds(m_owningLayer, rootLayer);

    if (compAncestor && m_ancestorClippingLayer) {

        IntRect clippingLayerContentBox;

        // Call calculateRects to get the backgroundRect which is what is used to clip the contents of this

        // layer. Note that we call it with temporaryClipRects=true because normally when computing clip rects

        // for a compositing layer, rootLayer is the layer itself.

        IntRect infiniteRect(INT_MIN/2, INT_MIN/2, INT_MAX, INT_MAX);

        IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;

        m_owningLayer->calculateRects(compAncestor, infiniteRect, layerBounds, backgroundRect, foregroundRect, outlineRect, true);

        // FIXME: if the layer that is clipping has a transform, this does not work correctly.

        clippingLayerContentBox = backgroundRect;

        int absX = 0, absY = 0;

        compAncestor->convertToLayerCoords(rootLayer, absX, absY);

        clippingLayerContentBox.move(absX, absY);

        // Position relative to the compAncestor

        if (compAncestor->backing()->hasClippingLayer()) {

            IntRect parentClippingBox = compAncestor->renderer()->getOverflowClipRect(absX, absY);

            m_ancestorClippingLayer->setPosition(FloatPoint() + (clippingLayerContentBox.location() - parentClippingBox.location()));

        } else

            m_ancestorClippingLayer->setPosition(FloatPoint() + (clippingLayerContentBox.location() - ancestorCompositingBounds.location()));

        m_ancestorClippingLayer->setSize(clippingLayerContentBox.size());

        m_graphicsLayer->setPosition(FloatPoint() + (compositingBounds.location() - clippingLayerContentBox.location()));

    } else if (compAncestor && compAncestor->backing()->hasClippingLayer()) {

        // The clipping layer is the size of the ancestor's overflowClipRect, so account for

        // its offset in its containing layer.

        int absX = 0, absY = 0;

        compAncestor->convertToLayerCoords(rootLayer, absX, absY);

        IntRect clippingLayerContentBox = compAncestor->renderer()->getOverflowClipRect(absX, absY);

        m_graphicsLayer->setPosition(FloatPoint() + (compositingBounds.location() - clippingLayerContentBox.location()));

    } else

        m_graphicsLayer->setPosition(FloatPoint() + (compositingBounds.location() - ancestorCompositingBounds.location()));

    FloatSize oldSize = m_graphicsLayer->size();

    FloatSize newSize(compositingBounds.size());

    if (oldSize != newSize) {

        m_graphicsLayer->setSize(newSize);

        // A bounds change will almost always require redisplay. Usually that redisplay

        // will happen because of a repaint elsewhere, but not always:

        // e.g. see RenderView::setMaximalOutlineSize()

        m_graphicsLayer->setNeedsDisplay();

    }

    // If we have a layer that clips children, position it.

    if (m_clippingLayer) {

        int absX = 0, absY = 0;

        m_owningLayer->convertToLayerCoords(rootLayer, absX, absY);

        IntRect clippingLayerContentBox = renderer()->getOverflowClipRect(absX, absY);

        m_clippingLayer->setPosition(FloatPoint() + (clippingLayerContentBox.location() - compositingBounds.location()));

        m_clippingLayer->setSize(clippingLayerContentBox.size());

    }

    IntRect layerBounds = IntRect(m_owningLayer->xPos(), m_owningLayer->yPos(), renderer()->width(), renderer()->height());

    // Convert to absolute coords to match bbox.

    int absX = 0, absY = 0;

    m_owningLayer->convertToLayerCoords(rootLayer, absX, absY);

    layerBounds.move(absX - m_owningLayer->xPos(), absY - m_owningLayer->yPos());

    // Update properties that depend on layer dimensions

    const IntRect borderBox = renderer()->borderBox();

    FloatPoint3D transformOrigin = computeTransformOrigin(borderBox);

    // Compute the anchor point, which is in the center of the renderer box unless transform-origin is set.

    FloatPoint  anchor(compositingBounds.width()  != 0.0f ? ((layerBounds.x() - compositingBounds.x()) + transformOrigin.x()) / compositingBounds.width()  : 0.5f,

                       compositingBounds.height() != 0.0f ? ((layerBounds.y() - compositingBounds.y()) + transformOrigin.y()) / compositingBounds.height() : 0.5f);

    m_graphicsLayer->setAnchorPoint(anchor, transformOrigin.z());

    if (m_contentsLayer) {

        m_contentsLayer->setPosition(IntPoint(0, 0));

        m_contentsLayer->setSize(newSize);

    }

    m_graphicsLayer->updateContentsRect();

}

void RenderLayerBacking::updateInternalHierarchy()

{

    // m_contentsLayer has to be inserted in the correct order with child layers,

    // so it's not inserted here.

    if (m_ancestorClippingLayer) {

        m_ancestorClippingLayer->removeAllChildren();

        m_graphicsLayer->removeFromParent();

        m_ancestorClippingLayer->addChild(m_graphicsLayer);

    }

    if (m_clippingLayer) {

        m_clippingLayer->removeFromParent();

        m_graphicsLayer->addChild(m_clippingLayer);

    }

}

// Return true if the layers changed.

bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip)

{

    bool layersChanged = false;

    if (needsAncestorClip) {

        if (!m_ancestorClippingLayer) {

            m_ancestorClippingLayer = GraphicsLayer::createGraphicsLayer(0);

#ifndef NDEBUG

            m_ancestorClippingLayer->setName("Ancestor clipping Layer");

#endif

            m_ancestorClippingLayer->setMasksToBounds(true);

            layersChanged = true;

        }

    } else if (m_ancestorClippingLayer) {

        m_ancestorClippingLayer->removeFromParent();

        delete m_ancestorClippingLayer;

        m_ancestorClippingLayer = 0;

        layersChanged = true;

    }

    if (needsDescendantClip) {

        if (!m_clippingLayer) {

            m_clippingLayer = GraphicsLayer::createGraphicsLayer(0);

#ifndef NDEBUG

            m_clippingLayer->setName("Child clipping Layer");

#endif

            m_clippingLayer->setMasksToBounds(true);

            layersChanged = true;

        }

    } else if (m_clippingLayer) {

        m_clippingLayer->removeFromParent();

        delete m_clippingLayer;

        m_clippingLayer = 0;

        layersChanged = true;

    }

    if (layersChanged)

        updateInternalHierarchy();

    return layersChanged;

}

bool RenderLayerBacking::updateContentsLayer(bool needsContentsLayer)

{

    bool layerChanged = false;

    if (needsContentsLayer) {

        if (!m_contentsLayer) {

            m_contentsLayer = GraphicsLayer::createGraphicsLayer(this);

#ifndef NDEBUG

            m_contentsLayer->setName("Contents");

#endif

            m_contentsLayer->setDrawsContent(true);

            m_contentsLayer->setDrawingPhase(GraphicsLayerPaintForegroundMask);

            m_graphicsLayer->setDrawingPhase(GraphicsLayerPaintBackgroundMask);

            layerChanged = true;

        }

    } else if (m_contentsLayer) {

        m_contentsLayer->removeFromParent();

        delete m_contentsLayer;

        m_contentsLayer = 0;

        m_graphicsLayer->setDrawingPhase(GraphicsLayerPaintAllMask);

        layerChanged = true;

    }

    return layerChanged;

}

float RenderLayerBacking::compositingOpacity(float rendererOpacity) const

{

    float finalOpacity = rendererOpacity;

    for (RenderLayer* curr = m_owningLayer->parent(); curr != 0; curr = curr->parent()) {

        // We only care about parents that are stacking contexts.

        // Recall that opacity creates stacking context.

        if (!curr->isStackingContext())

            continue;

        // If we found a compositing layer, we want to compute opacity

        // relative to it. So we can break here.

        if (curr->isComposited())

            break;

        finalOpacity *= curr->renderer()->opacity();

    }

    return finalOpacity;

}

// A simple background is either none or a solid color.

static bool hasSimpleBackground(RenderStyle* inStyle)

{

    return !inStyle->hasBackgroundImage();

}

static bool hasBorderOutlineOrShadow(RenderStyle* inStyle)

{

    return (inStyle->hasBorder() || inStyle->hasBorderRadius() || inStyle->hasOutline() || (inStyle->boxShadow() != 0));

}

bool RenderLayerBacking::rendererHasBackground() const

{

    // FIXME: share more code here

    if (renderer()->node()->isDocumentNode()) {

        RenderObject* htmlObject = renderer()->firstChild();

        if (!htmlObject)

            return false;

        RenderStyle* style = htmlObject->style();

        if (style->hasBackground())

            return true;

        RenderObject* bodyObject = htmlObject->firstChild();

        if (!bodyObject)

            return false;

        style = bodyObject->style();

        return style->hasBackground();

    }

    return renderer()->style()->hasBackground();

}

const Color& RenderLayerBacking::rendererBackgroundColor() const

{

    // FIXME: share more code here

    if (renderer()->node()->isDocumentNode()) {

        RenderObject* htmlObject = renderer()->firstChild();

        RenderStyle* style = htmlObject->style();

        if (style->hasBackground())

            return style->backgroundColor();

        RenderObject* bodyObject = htmlObject->firstChild();

        style = bodyObject->style();

        return style->backgroundColor();

    }

    return renderer()->style()->backgroundColor();

}

bool RenderLayerBacking::canBeSimpleContainerCompositingLayer() const

{

    RenderObject* renderObject = renderer();

    if (renderObject->isReplaced() ||       // replaced objects are not containers

        renderObject->hasMask())            // masks require special treatment

        return false;

    RenderStyle* style = renderObject->style();

    // Reject anything that has a border, a border-radius or outline,

    // or any background (color or image).

    // FIXME: we could optimize layers for simple backgrounds.

    if (hasBorderOutlineOrShadow(style) ||

        style->hasBackground())

        return false;

    // If we have got this far and the renderer has no children, then we're ok.

    if (!renderObject->firstChild())

        return true;

    if (renderObject->node()->isDocumentNode()) {

        // Look to see if the root object has a non-simple backgound

        RenderObject* rootObject = renderObject->document()->documentElement()->renderer();

        if (!rootObject)

            return false;

        style = rootObject->style();

        // Reject anything that has a border, a border-radius or outline,

        // or is not a simple background (no background, or solid color).

        if (hasBorderOutlineOrShadow(style) ||

            !hasSimpleBackground(style))

            return false;

        // Now look at the body's renderer.

        HTMLElement* body = renderObject->document()->body();

        RenderObject* bodyObject = (body && body->hasLocalName(HTMLNames::bodyTag)) ? body->renderer() : 0;

        if (!bodyObject)

            return false;

        style = bodyObject->style();

        if (hasBorderOutlineOrShadow(style) ||

            !hasSimpleBackground(style))

            return false;

        // Ceck to see if all the body's children are compositing layers.

        if (hasNonCompositingContent())

            return false;

        return true;

    }

    // Check to see if all the renderer's children are compositing layers.

    if (hasNonCompositingContent())

        return false;

    return true;

}

bool RenderLayerBacking::hasNonCompositingContent() const

{

    // Conservative test for having no rendered children.

    // Some HTML can cause whitespace text nodes to have renderers, like:

    // <div>

    // <img src=...>

    // </div>

    // so test for 0x0 RenderTexts here

    for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {

        if (!child->hasLayer() && (child->width() > 0 || child->height() > 0))

            return true;

    }

    // FIXME: test for overflow controls.

    if (m_owningLayer->isStackingContext()) {

        // Use the m_hasCompositingDescendant bit to optimize?

        Vector<RenderLayer*>* negZOrderList = m_owningLayer->negZOrderList();

        if (negZOrderList && negZOrderList->size() > 0) {

            for (Vector<RenderLayer*>::const_iterator it = negZOrderList->begin(); it != negZOrderList->end(); ++it) {

                RenderLayer* curLayer = (*it);

                if (!curLayer->isComposited())

                    return true;

            }

        }

        Vector<RenderLayer*>* posZOrderList = m_owningLayer->posZOrderList();

        if (posZOrderList && posZOrderList->size() > 0)

            for (Vector<RenderLayer*>::const_iterator it = posZOrderList->begin(); it != posZOrderList->end(); ++it) {

                RenderLayer* curLayer = (*it);

                if (!curLayer->isComposited())

                    return true;

            }

    }

    Vector<RenderLayer*>* overflowList = m_owningLayer->overflowList();

    if (overflowList && overflowList->size() > 0)

        for (Vector<RenderLayer*>::const_iterator it = overflowList->begin(); it != overflowList->end(); ++it) {

            RenderLayer* curLayer = (*it);

            if (!curLayer->isComposited())

                return true;

        }

    return false;

}

// A "simple container layer" is a RenderLayer which has no visible content to render.

// It may have no children, or all its children may be themselves composited.

// This is a useful optimization, because it allows us to avoid allocating backing store.

bool RenderLayerBacking::isSimpleContainerCompositingLayer()

{

    if (m_simpleCompositingLayerStatusDirty) {

        m_isSimpleContainerCompositingLayer = canBeSimpleContainerCompositingLayer();

        m_simpleCompositingLayerStatusDirty = false;

    }

    return m_isSimpleContainerCompositingLayer;

}

void RenderLayerBacking::detectDrawingOptimizations()

{

    bool drawsContent = true;

    if (isSimpleContainerCompositingLayer() || paintingGoesToWindow())

        drawsContent = false;

    m_graphicsLayer->setDrawsContent(drawsContent);

}

void RenderLayerBacking::invalidateDrawingOptimizations()

{

    m_simpleCompositingLayerStatusDirty = true;

}

void RenderLayerBacking::forceCompositingLayer(bool force)

{

    m_forceCompositingLayer = force;

}

FloatPoint RenderLayerBacking::computeTransformOrigin(const IntRect& borderBox) const

{

    RenderStyle* style = renderer()->style();

    FloatPoint origin;

    origin.setX(style->transformOriginX().calcFloatValue(borderBox.width()));

    origin.setY(style->transformOriginY().calcFloatValue(borderBox.height()));

    return origin;

}

// Return the offset from the top-left of this compositing layer at which the renderer's contents are painted.

IntSize RenderLayerBacking::contentOffsetInCompostingLayer()

{

    if (!m_compositingContentOffsetDirty)

        return m_compositingContentOffset;

    IntRect relativeCompositingBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);

    m_compositingContentOffset = IntSize(-relativeCompositingBounds.x(), -relativeCompositingBounds.y());

    m_compositingContentOffsetDirty = false;

    return m_compositingContentOffset;

}

IntRect RenderLayerBacking::contentsBox(const GraphicsLayer*)

{

    IntRect contentsRect;

    contentsRect = renderer()->contentBox();

    IntSize  contentOffset = contentOffsetInCompostingLayer();

    contentsRect.move(contentOffset);

    return contentsRect;

}

// Map the given point from coordinates in the GraphicsLayer to RenderLayer coordinates.

FloatPoint RenderLayerBacking::graphicsLayerToContentsCoordinates(const FloatPoint& point)

{

    IntSize contentOffset = contentOffsetInCompostingLayer();

    return FloatPoint(point.x() - contentOffset.width(), point.y() - contentOffset.height());

}

// Map the given point from coordinates in the RenderLayer to GraphicsLayer coordinates.

FloatPoint RenderLayerBacking::contentsToGraphicsLayerCoordinates(const FloatPoint& point)

{

    IntSize contentOffset = contentOffsetInCompostingLayer();

    return FloatPoint(point.x() + contentOffset.width(), point.y() + contentOffset.height());

}

bool RenderLayerBacking::paintingGoesToWindow() const

{

    return m_owningLayer->isDocumentLayer()

#ifndef NDEBUG

        && !GraphicsLayer::showLayerHierarchy()

#endif

        ;

}

void RenderLayerBacking::setContentsNeedDisplay()

{

    if (m_graphicsLayer)

        m_graphicsLayer->setNeedsDisplay();

    if (m_contentsLayer)

        m_contentsLayer->setNeedsDisplay();

}

// r is in the coordinate space of the layer's render object

void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r)

{

    if (m_graphicsLayer) {

        FloatPoint dirtyOrigin = contentsToGraphicsLayerCoordinates(FloatPoint(r.x(), r.y()));

        FloatRect dirtyRect(dirtyOrigin, r.size());

        FloatRect bounds(FloatPoint(), m_graphicsLayer->size());

        if (bounds.intersects(dirtyRect))

            m_graphicsLayer->setNeedsDisplayInRect(dirtyRect);

    }

    if (m_contentsLayer) {

        // FIXME: do incremental repaint

        m_contentsLayer->setNeedsDisplay();

    }

}

static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)

{

    if (paintDirtyRect == clipRect)

        return;

    p->save();

    p->clip(clipRect);

}

static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)

{

    if (paintDirtyRect == clipRect)

        return;

    p->restore();

}

// Share this with RenderLayer::paintLayer, which would have to be educated about GraphicsLayerPaintingPhase?

void RenderLayerBacking::paintIntoLayer(RenderLayer* rootLayer, GraphicsContext* context,

                    const IntRect& paintDirtyRect,      // in the coords of rootLayer

                    bool haveTransparency, PaintRestriction paintRestriction, GraphicsLayerPaintingPhase paintingPhase,

                    RenderObject* paintingRoot)

{

    if (paintingGoesToWindow()) {

        ASSERT_NOT_REACHED();

        return;

    }

    if (m_owningLayer->isStackingContext() && (m_owningLayer->m_zOrderListsDirty || m_owningLayer->m_overflowListDirty))

        compositor()->updateCompositingLayers(m_owningLayer);

    // Calculate the clip rects we should use.

    IntRect layerBounds, damageRect, clipRectToApply, outlineRect;

    m_owningLayer->calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);

    int x = layerBounds.x();        // layerBounds is computed relative to rootLayer

    int y = layerBounds.y();

    int tx = x - renderer()->xPos();

    int ty = y - renderer()->yPos() + renderer()->borderTopExtra();

    // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which

    // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).

    // Else, our renderer tree may or may not contain the painting root, so we pass that root along

    // so it will be tested against as we decend through the renderers.

    RenderObject *paintingRootForRenderer = 0;

    if (paintingRoot && !renderer()->isDescendantOf(paintingRoot))

        paintingRootForRenderer = paintingRoot;

    if (paintingPhase & GraphicsLayerPaintBackgroundMask) {

        // If this is the root then we need to send in a bigger bounding box

        // because we'll be painting the background as well (see RenderBox::paintRootBoxDecorations()).

        IntRect paintBox = clipRectToApply;

        if (renderer()->node()->isDocumentNode() && renderer()->document()->isHTMLDocument()) {

            int w = renderer()->width();

            int h = renderer()->height();

            int rw;

            int rh;

            if (renderer()->view()->frameView()) {

                rw = renderer()->view()->frameView()->contentsWidth();

                rh = renderer()->view()->frameView()->contentsHeight();

            } else {

                rw = renderer()->view()->width();

                rh = renderer()->view()->height();

            }

            int bx = tx - renderer()->marginLeft();

            int by = ty - renderer()->marginTop();

            int bw = max(w + renderer()->marginLeft() + renderer()->marginRight() + renderer()->borderLeft() + renderer()->borderRight(), rw);

            int bh = max(h + renderer()->marginTop() + renderer()->marginBottom() + renderer()->borderTop() + renderer()->borderBottom(), rh);

            paintBox = IntRect(bx, by, bw, bh);

        }

        // Paint our background first, before painting any child layers.

        // Establish the clip used to paint our background.

        setClip(context, paintDirtyRect, damageRect);

        RenderObject::PaintInfo info(context, paintBox, PaintPhaseBlockBackground, false, paintingRootForRenderer, 0);

        renderer()->paint(info, tx, ty);

        // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with

        // z-index.  We paint after we painted the background/border, so that the scrollbars will

        // sit above the background/border.

        m_owningLayer->paintOverflowControls(context, x, y, damageRect);

        // Restore the clip.

        restoreClip(context, paintDirtyRect, damageRect);

    }

    if (paintingPhase & GraphicsLayerPaintForegroundMask) {

        // Now walk the sorted list of children with negative z-indices. Only RenderLayers without compositing layers will paint.

        // FIXME: should these be painted as background?

        Vector<RenderLayer*>* negZOrderList = m_owningLayer->negZOrderList();

        if (negZOrderList)

            for (Vector<RenderLayer*>::iterator it = negZOrderList->begin(); it != negZOrderList->end(); ++it)

                it[0]->paintLayer(rootLayer, context, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);

        bool forceBlackText = paintRestriction == PaintRestrictionSelectionOnlyBlackText;

        bool selectionOnly  = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyBlackText;

        // Set up the clip used when painting our children.

        setClip(context, paintDirtyRect, clipRectToApply);

        RenderObject::PaintInfo paintInfo(context, clipRectToApply, 

                                          selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds,

                                          forceBlackText, paintingRootForRenderer, 0);

        renderer()->paint(paintInfo, tx, ty);

        if (!selectionOnly) {

            paintInfo.phase = PaintPhaseFloat;

            renderer()->paint(paintInfo, tx, ty);

            paintInfo.phase = PaintPhaseForeground;

            renderer()->paint(paintInfo, tx, ty);

            paintInfo.phase = PaintPhaseChildOutlines;

            renderer()->paint(paintInfo, tx, ty);

        }

        // Now restore our clip.

        restoreClip(context, paintDirtyRect, clipRectToApply);

        if (!outlineRect.isEmpty()) {

            // Paint our own outline

            RenderObject::PaintInfo paintInfo(context, outlineRect, PaintPhaseSelfOutline, false, paintingRootForRenderer, 0);

            setClip(context, paintDirtyRect, outlineRect);

            renderer()->paint(paintInfo, tx, ty);

            restoreClip(context, paintDirtyRect, outlineRect);

        }

        // Paint any child layers that have overflow.

        Vector<RenderLayer*>* overflowList = m_owningLayer->overflowList();

        if (overflowList)

            for (Vector<RenderLayer*>::iterator it = overflowList->begin(); it != overflowList->end(); ++it)

                it[0]->paintLayer(rootLayer, context, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);

        // Now walk the sorted list of children with positive z-indices.

        Vector<RenderLayer*>* posZOrderList = m_owningLayer->posZOrderList();

        if (posZOrderList)

            for (Vector<RenderLayer*>::iterator it = posZOrderList->begin(); it != posZOrderList->end(); ++it)

                it[0]->paintLayer(rootLayer, context, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);

        if (renderer()->hasMask() && !selectionOnly && !damageRect.isEmpty()) {

            setClip(context, paintDirtyRect, damageRect);

            // Paint the mask.

            RenderObject::PaintInfo paintInfo(context, damageRect, PaintPhaseMask, false, paintingRootForRenderer, 0);

            renderer()->paint(paintInfo, tx, ty);

            // Restore the clip.

            restoreClip(context, paintDirtyRect, damageRect);

        }

    }

    ASSERT(!m_owningLayer->m_usedTransparency);

}

// Up-call from compositing layer drawing callback.

void RenderLayerBacking::paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase drawingPhase, const IntRect& clip)

{

    // We have to use the same root as for hit testing, because both methods

    // can compute and cache clipRects.

    IntRect enclosingBBox = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);

    IntRect clipRect(clip);

    // Set up the coordinate space to be in the layer's rendering coordinates.

    context.translate(-enclosingBBox.x(), -enclosingBBox.y());

    // Offset the clip.

    clipRect.move(enclosingBBox.x(), enclosingBBox.y());

    // The dirtyRect is in the coords of the painting root.

    IntRect dirtyRect = enclosingBBox;

    dirtyRect.intersect(clipRect);

    paintIntoLayer(m_owningLayer, &context, dirtyRect, false, PaintRestrictionNone, drawingPhase, renderer());

}

FloatPoint RenderLayerBacking::convertToContentsCoordinates(const GraphicsLayer*, const FloatPoint& point)

{

    return graphicsLayerToContentsCoordinates(point);

}

// Compositing layer hit testing works like this:

//  * hitTestLayer() is called on the root.

//  * in compositing mode, that calls hitTestRootLayer()

//  * it calls findHitCompositingLayer().

//  * findHitCompositingLayer does hitTesting via GraphicsLayers, which involves

//      calling back via contentsContainPoint() to find out

//      if the given point should be considered to be "inside" the layer based on

//      HTML hit testing rules.

//  * Once we've found a hit compositing layer, hitTestRootLayer() then goes on to

//      do a final hitTestLayer() in order to fill in result.

//

// FIXME: move to RenderLayerCompositor?

RenderLayer* RenderLayerBacking::hitTestRootLayer(RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,

                                           const IntRect& hitTestRect, const IntPoint& hitTestPoint)

{

    RenderLayer* hitCompositingLayer = findHitCompositingLayer(rootLayer, request, result, hitTestRect, hitTestPoint);

    if (!hitCompositingLayer) {

        // We didn't hit any layer. If we are the root layer and the mouse is -- or just was -- down, 

        // return ourselves. We do this so mouse events continue getting delivered after a drag has 

        // exited the WebView, and so hit testing over a scrollbar hits the content document.

        if ((request.active || request.mouseUp) && renderer()->isRenderView()) {

            m_owningLayer->renderer()->updateHitTestResult(result, hitTestPoint);

            return m_owningLayer;

        }

        return 0;

    }

    // if we hit the root layer, we're done

    if (hitCompositingLayer == m_owningLayer) {

        m_owningLayer->renderer()->updateHitTestResult(result, hitTestPoint);

        return m_owningLayer;

    }

    // convert hitTestPoint to coords of the hit layer

    FloatPoint hitPoint = convertPointToLayer(hitTestPoint, hitCompositingLayer);

    IntPoint destHitTestPoint(roundf(hitPoint.x()), roundf(hitPoint.y()));

    // convert hitTestRect to the hit layer by mapping a quad, then getting its

    // bounding box

    IntRect destHitTestRect;

    {

        // FIXME: move into a helper function

        FloatQuad   hitTestQuad(hitTestRect);

        GraphicsLayer* destCompositingLayer = hitCompositingLayer->backing()->graphicsLayer();

        IntSize contentOffset = contentOffsetInCompostingLayer();

        hitTestQuad.move(contentOffset.width(), contentOffset.height());

        graphicsLayer()->convertQuadToLayer(hitTestQuad, destCompositingLayer);

        IntSize destContentOffset = hitCompositingLayer->backing()->contentOffsetInCompostingLayer();

        hitTestQuad.move(-destContentOffset.width(), -destContentOffset.height());

        destHitTestRect = enclosingIntRect(hitTestQuad.boundingBox());

    }

    // clear out the state in result that we may have set in contentsContainPoint(),

    // and run hit testing on the hit compositing layer

    result.setInnerNode(0);

    result.setInnerNonSharedNode(0);

    return hitCompositingLayer->hitTestLayer(hitCompositingLayer, request, result, destHitTestRect, destHitTestPoint);

}

// hitTestPoint and hitTestRect are in the coordinate system of rootLayer

RenderLayer* RenderLayerBacking::findHitCompositingLayer(RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result, const IntRect& hitTestRect, const IntPoint& hitTestPoint)

{

    LayerHitTestData hitTestData(rootLayer, request, result, hitTestRect);

    // Calculate the clip rects we should use.

    IntRect layerBounds;

    IntRect bgRect;

    IntRect fgRect;

    IntRect outlineRect;

    m_owningLayer->calculateRects(rootLayer, hitTestRect, layerBounds, bgRect, fgRect, outlineRect);

    // Check our lists are up-to-date.

    ASSERT(!m_owningLayer->isStackingContext() || !m_owningLayer->m_zOrderListsDirty);

    ASSERT(!m_owningLayer->isStackingContext() || !m_owningLayer->m_overflowListDirty);

    GraphicsLayer* rootGraphicsLayer = compositor()->rootPlatformLayer();

    // convert hitTestPoint to the coordinate system of the compositing layer

    FloatPoint hitPoint = contentsToGraphicsLayerCoordinates(hitTestPoint);

    // We assume here that the result.point() is in the coordinate system of m_graphicsLayer, so we

    // convert to the root layer, since we need to pass superlayer-relative coordinates into

    // the hitTest.

    hitPoint = m_graphicsLayer->convertPointToLayer(hitPoint, rootGraphicsLayer);

    // as hitTest is called on LCLayers, contentsContainPoint() is called for each compositing layer

    GraphicsLayer* hitLayer = m_graphicsLayer->hitTest(hitPoint, &hitTestData);

    if (!hitLayer)

        return 0;

    // note that hitLayer may be a m_contentsLayer, but we should not need to do anything special

    // Convert the point to the coords of the hit GraphicsLayer, which takes

    // layer transforms into account

    hitPoint = rootGraphicsLayer->convertPointToLayer(hitPoint, hitLayer);

    // Then convert it back to the coords of the root layer. We do all

    // the hit testing in root-relative coords, because all the clip rects

    // are root-relative (just like painting).

    RenderLayerBacking* hitLayerBacking = static_cast<RenderLayerBacking*>(hitLayer->client());

    RenderLayer* hitRenderLayer = hitLayerBacking ? hitLayerBacking->owningLayer() : 0;

    ASSERT(hitRenderLayer);

    return hitRenderLayer;

}

// up-call from compositing layer hit testing machinery. inPoint is in this layer coordinates.

bool RenderLayerBacking::contentsContainPoint(const GraphicsLayer*, const IntPoint& point, GraphicsLayerPaintingPhase compositePhase, struct LayerHitTestData* hitTestData)

{

    RenderLayer* rootLayer = hitTestData->m_rootLayer;

    const HitTestRequest& request = hitTestData->m_request;

    HitTestResult& result = hitTestData->m_result;

    IntRect hitTestRect = hitTestData->m_hitTestRect;

    // map hitTestRect to this layer

    FloatQuad hitTestQuad(hitTestRect);

    GraphicsLayer* rootCompositingLayer = rootLayer->backing()->graphicsLayer();

    IntSize rootContentOffset = rootLayer->backing()->contentOffsetInCompostingLayer();

    hitTestQuad.move(rootContentOffset.width(), rootContentOffset.height());

    rootCompositingLayer->convertQuadToLayer(hitTestQuad, graphicsLayer());

    IntSize contentOffset = contentOffsetInCompostingLayer();

    hitTestQuad.move(-contentOffset.width(), -contentOffset.height());

    IntRect destHitTestRect = enclosingIntRect(hitTestQuad.boundingBox());

    hitTestRect = destHitTestRect;

    // use this layer as the hit testing root

    rootLayer = m_owningLayer;

    // inPoint is already in the coords of this layer

    IntPoint hitTestPoint = point;

    // Calculate the clip rects we should use.

    IntRect layerBounds;

    IntRect bgRect;

    IntRect fgRect;

    IntRect outlineRect;

    m_owningLayer->calculateRects(rootLayer, hitTestRect, layerBounds, bgRect, fgRect, outlineRect);

    RenderLayer* insideLayer = 0;

    ASSERT(m_owningLayer->isStackingContext() || (!m_owningLayer->m_posZOrderList || m_owningLayer->m_posZOrderList->size() == 0));

    // FIXME: share this code with hitTestLayer above

    if (compositePhase & GraphicsLayerPaintForegroundMask) {

        // Begin by walking our list of positive layers from highest z-index down to the lowest

        // z-index. Only test non-compositing layers, since the first hitTestLayer will have found

        // any hit compositing layers.

        Vector<RenderLayer*>* posZOrderList = m_owningLayer->posZOrderList();

        if (posZOrderList) {

            for (int i = posZOrderList->size() - 1; i >= 0; --i) {

                RenderLayer* curLayer = posZOrderList->at(i);

                if (!curLayer->isComposited()) {

                    insideLayer = curLayer->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);

                    if (insideLayer)

                        return true;

                }

            }

        }

        // Now check our overflow objects.

        Vector<RenderLayer*>* overflowList = m_owningLayer->overflowList();

        if (overflowList) {

            for (int i = overflowList->size() - 1; i >= 0; --i) {

                RenderLayer* curLayer = overflowList->at(i);

                if (!curLayer->isComposited()) {

                    insideLayer = curLayer->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);

                    if (insideLayer)

                        return true;

                }

            }

        }

        // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.

        if (fgRect.contains(hitTestPoint) && 

            renderer()->hitTest(request, result, hitTestPoint,

                                layerBounds.x() - renderer()->xPos(),

                                layerBounds.y() - renderer()->yPos() + renderer()->borderTopExtra(), 

                                HitTestDescendants)) {

            // For positioned generated content, we might still not have a

            // node by the time we get to the layer level, since none of

            // the content in the layer has an element. So just walk up

            // the tree.

            if (!result.innerNode() || !result.innerNonSharedNode()) {

                Node* e = m_owningLayer->enclosingElement();

                if (!result.innerNode())

                    result.setInnerNode(e);

                if (!result.innerNonSharedNode())

                    result.setInnerNonSharedNode(e);

            }

            return true;

        }

        // Now check our negative z-index children.

        Vector<RenderLayer*>* negZOrderList = m_owningLayer->negZOrderList();

        if (negZOrderList) {

            for (int i = negZOrderList->size() - 1; i >= 0; --i) {

                RenderLayer* curLayer = negZOrderList->at(i);

                if (!curLayer->isComposited()) {

                    insideLayer = negZOrderList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);

                    if (insideLayer)

                        return true;

                }

            }

        }

    }

    if (compositePhase & GraphicsLayerPaintBackgroundMask) {

        if (bgRect.contains(hitTestPoint) &&

            renderer()->hitTest(request, result, hitTestPoint,

                                layerBounds.x() - renderer()->xPos(),

                                layerBounds.y() - renderer()->yPos() + renderer()->borderTopExtra(),

                                HitTestSelf)) {

            if (!result.innerNode() || !result.innerNonSharedNode()) {

                Node* e = m_owningLayer->enclosingElement();

                if (!result.innerNode())

                    result.setInnerNode(e);

                if (!result.innerNonSharedNode())

                    result.setInnerNonSharedNode(e);

            }

            return true;

        }

    }

    return false;

}

bool RenderLayerBacking::startAnimation(double beginTime, const Animation* anim, const KeyframeList& keyframes)

{

    bool hasOpacity = keyframes.containsProperty(CSSPropertyOpacity);

    bool hasTransform = keyframes.containsProperty(CSSPropertyWebkitTransform);

    if (!hasOpacity && !hasTransform)

        return false;

    GraphicsLayer::TransformValueList transformVector;

    GraphicsLayer::FloatValueList opacityVector;

    for (Vector<KeyframeValue>::const_iterator it = keyframes.beginKeyframes(); it != keyframes.endKeyframes(); ++it) {

        const RenderStyle* keyframeStyle = it->style();

        float key = it->key();

        if (!keyframeStyle)

            continue;

        // get timing function

        const TimingFunction* tf = keyframeStyle->hasAnimations() ? &((*keyframeStyle->animations()).animation(0)->timingFunction()) : 0;

        if (hasTransform)

            transformVector.insert(key, &(keyframeStyle->transform()), tf);

        if (hasOpacity)

            opacityVector.insert(key, keyframeStyle->opacity(), tf);

    }

    bool didAnimateTransform = !hasTransform;

    bool didAnimateOpacity = !hasOpacity;

    if (hasTransform && m_graphicsLayer->animateTransform(transformVector, renderer()->borderBox().size(), anim, beginTime, false))

        didAnimateTransform = true;

    if (hasOpacity && m_graphicsLayer->animateFloat(AnimatedPropertyOpacity, opacityVector, anim, beginTime))

        didAnimateOpacity = true;

    return didAnimateTransform && didAnimateOpacity;

}

bool RenderLayerBacking::startTransition(double beginTime, int property, const RenderStyle* fromStyle, const RenderStyle* toStyle)

{

    bool didAnimate = false;

    if (property == cAnimateAll || property == (int)CSSPropertyOpacity) {

        const Animation* opacityAnim = toStyle->transitionForProperty(CSSPropertyOpacity);

        if (opacityAnim && !opacityAnim->isEmptyOrZeroDuration()) {

            // If beginTime is not 0, we are restarting this transition, so first set the from value

            // in case it was smashed by a previous animation.

            if (beginTime > 0)

                m_graphicsLayer->setOpacity(compositingOpacity(fromStyle->opacity()), 0, 0);

            if (m_graphicsLayer->setOpacity(compositingOpacity(toStyle->opacity()), opacityAnim, beginTime))

                didAnimate = true;

        }

    }

    if (property == cAnimateAll || property == (int)CSSPropertyWebkitTransform) {

        // We get a TransformOperation, which is a linked list of primitive operations and their arguments.

        // Arguments can be floats or Length values, which need to be converted to numbers using

        // val.calcFloatValue(renderer()->width()) (or height()).

        const Animation* transformAnim = toStyle->transitionForProperty(CSSPropertyWebkitTransform);

        if (transformAnim && !transformAnim->isEmptyOrZeroDuration()) {

            GraphicsLayer::TransformValueList transformVector;

            transformVector.insert(0, &fromStyle->transform(), 0);        

            transformVector.insert(1, &toStyle->transform(), 0);        

            if (m_graphicsLayer->animateTransform(transformVector, renderer()->borderBox().size(), transformAnim, beginTime, true))

                didAnimate = true;

        }

    }

    return didAnimate;

}

void RenderLayerBacking::notifyTransitionStarted(const GraphicsLayer*, AnimatedPropertyID property, double time)

{

    int cssProperty = CSSPropertyInvalid;

    switch (property) {

        case AnimatedPropertyInvalid:

            break;

        case AnimatedPropertyWebkitTransform:

            cssProperty = CSSPropertyWebkitTransform;

            break;

        case AnimatedPropertyOpacity:

            cssProperty = CSSPropertyOpacity;

            break;

        case AnimatedPropertyBackgroundColor:

            cssProperty = CSSPropertyBackgroundColor;

            break;

    }

    renderer()->notifyTransitionStarted(cssProperty, time);

}

void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, double time)

{

    renderer()->notifyAnimationStarted(time);

}

void RenderLayerBacking::animationFinished(const String& name, int index, bool reset)

{

    m_graphicsLayer->removeFinishedAnimations(name, index, reset);

}

void RenderLayerBacking::transitionFinished(int property)

{

    m_graphicsLayer->removeFinishedTransitions(property);

}

void RenderLayerBacking::suspendAnimations()

{

    m_graphicsLayer->suspendAnimations();

}

void RenderLayerBacking::resumeAnimations()

{

    m_graphicsLayer->resumeAnimations();

}

FloatPoint RenderLayerBacking::convertPointToLayer(const FloatPoint& point, RenderLayer* targetLayer)

{

    RenderLayer* srcCompLayer = compositor()->enclosingCompositingLayer(m_owningLayer);

    RenderLayer* destCompLayer = compositor()->enclosingCompositingLayer(targetLayer);

    FloatPoint srcPoint(point);

    // EnclosingCompositingLayer doesn't guarantee that a compositing layer has been created yet

    // FIXME: this should never happen

    if (!srcCompLayer->isComposited() || !destCompLayer->isComposited()) {

#ifndef NDEBUG

        fprintf(stderr, "convertPointToLayer bailing because source or target doesn't have compositing layer");

#endif

        // FIXME: sucky absolute logic

        FloatPoint srcPos = renderer()->localToAbsolute();

        FloatPoint dstPos = targetLayer->renderer()->localToAbsolute();

        srcPoint += (dstPos - srcPos);

        return srcPoint;

    }

    if (srcCompLayer != m_owningLayer) {

        int x = 0, y = 0;

        m_owningLayer->convertToLayerCoords(srcCompLayer, x, y);

        srcPoint.move(x, y);

    }

    // convert from RenderLayer to GraphicsLayer coords

    srcPoint = contentsToGraphicsLayerCoordinates(srcPoint);

    // map to the dest layer

    GraphicsLayer* srcPlatformLayer = srcCompLayer->backing()->graphicsLayer();

    GraphicsLayer* dstPlatformLayer = destCompLayer->backing()->graphicsLayer();

    FloatPoint destPoint = srcPlatformLayer->convertPointToLayer(srcPoint, dstPlatformLayer);

    // convert back from GraphicsLayer to RenderLayer coords

    destPoint = destCompLayer->backing()->graphicsLayerToContentsCoordinates(destPoint);

    if (destCompLayer != targetLayer) {

        int x = 0, y = 0;

        targetLayer->convertToLayerCoords(destCompLayer, x, y);

        destPoint.move(-x, -y);

    }

    return destPoint;

}

// inPoint is relative to our renderer()

FloatPoint RenderLayerBacking::convertToPageUsingCompositingLayer(const FloatPoint& inPoint)

{

    RenderLayer* docLayer = m_owningLayer->enclosingDocumentLayer();

    return convertPointToLayer(inPoint, docLayer);

}

// inPoint is relative to the document

FloatPoint RenderLayerBacking::convertFromPageUsingCompositingLayer(const FloatPoint& inPoint)

{

    RenderLayer* docLayer = m_owningLayer->enclosingDocumentLayer();

    return docLayer->backing()->convertPointToLayer(inPoint, m_owningLayer);

}

void RenderLayerBacking::convertQuadToPageUsingCompositingLayer(FloatQuad& quad)

{

    RenderLayer* docLayer = m_owningLayer->enclosingDocumentLayer();

    GraphicsLayer* docCompLayer = docLayer ? docLayer->backing()->graphicsLayer() : 0;

    ASSERT(docCompLayer);

    if (!docCompLayer)

        return;

    // do the math that contentsToGraphicsLayerCoordinates does

    IntSize contentOffset = contentOffsetInCompostingLayer();

    quad.move(contentOffset.width(), contentOffset.height());

    m_graphicsLayer->convertQuadToLayer(quad, docCompLayer);

    IntSize docContentOffset = docLayer->backing()->contentOffsetInCompostingLayer();

    quad.move(-docContentOffset.width(), -docContentOffset.height());

}

} // namespace WebCore

#endif // USE(ACCELERATED_COMPOSITING)

/*

 * Copyright (C) 2009 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. 

 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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.

 */

#ifndef RenderLayerBacking_h

#define RenderLayerBacking_h

#if USE(ACCELERATED_COMPOSITING)

#include "FloatPoint.h"

#include "FloatPoint3D.h"

#include "GraphicsLayer.h";

#include "GraphicsLayerClient.h";

#include "RenderLayer.h"

#include "TransformationMatrix.h"

namespace WebCore {

class RenderLayerCompositor;

// RenderLayerBacking controls the compositing behavior for a single RenderLayer.

// It holds the various GraphicsLayers, and makes decisions about intra-layer rendering

// optimizations.

// 

// There is one RenderLayerBacking for each RenderLayer that is composited.

class RenderLayerBacking : public GraphicsLayerClient {

public:

    RenderLayerBacking(RenderLayer*);

    ~RenderLayerBacking();

    RenderLayer* owningLayer() const { return m_owningLayer; }

    void updateAfterLayout();

    // Returns true if layer configuration changed.

    bool updateGraphicsLayers(bool needsContentsLayer, bool needsUpperClippingLayer, bool needsLowerClippingLayer, bool needsRepaint);

    void updateGraphicsLayerGeometry();

    void updateInternalHierarchy();

    GraphicsLayer* graphicsLayer() const { return m_graphicsLayer; }

    // Layer to clip children

    bool hasClippingLayer() const   { return m_clippingLayer != 0; }

    GraphicsLayer* clippingLayer() const  { return m_clippingLayer; }

    // Layer to get clipped by ancestor

    bool hasAncestorClippingLayer() const   { return m_ancestorClippingLayer != 0; }

    GraphicsLayer* ancestorClippingLayer() const  { return m_ancestorClippingLayer; }

    bool hasContentsLayer() const   { return m_contentsLayer != 0; }

    GraphicsLayer* contentsLayer() const   { return m_contentsLayer; }

    GraphicsLayer* parentForSublayers() const { return m_clippingLayer ? m_clippingLayer : m_graphicsLayer; }

    GraphicsLayer* childForSuperlayers() const { return m_ancestorClippingLayer ? m_ancestorClippingLayer : m_graphicsLayer; }

    // RenderLayers with backing normally short-circuit paintLayer() because

    // their content is rendered via callbacks from GraphicsLayer. However, the document

    // layer is special, because it has a GraphicsLayer to act as a container for the GraphicsLayers

    // for descendants, but its contents usually render into the window (in which case this returns true).

    // This returns false for other layers, and when the document layer actually needs to paint into its backing store

    // for some reason.

    bool paintingGoesToWindow() const;

    void setContentsNeedDisplay();

    // r is in the coordinate space of the layer's render object

    void setContentsNeedDisplayInRect(const IntRect& r);

    // Interface to start, finish, suspend and resume animations and transitions

    bool startAnimation(double beginTime, const Animation* anim, const KeyframeList& keyframes);

    bool startTransition(double beginTime, int property, const RenderStyle* fromStyle, const RenderStyle* toStyle);

    void animationFinished(const String& name, int index, bool reset);

    void transitionFinished(int property);

    void suspendAnimations();

    void resumeAnimations();

    FloatPoint graphicsLayerToContentsCoordinates(const FloatPoint&);

    FloatPoint contentsToGraphicsLayerCoordinates(const FloatPoint&);

    // convert points, taking transforms into account

    FloatPoint convertPointToLayer(const FloatPoint&, RenderLayer* targetLayer);

    FloatPoint convertToPageUsingCompositingLayer(const FloatPoint&);

    FloatPoint convertFromPageUsingCompositingLayer(const FloatPoint&);

    void convertQuadToPageUsingCompositingLayer(FloatQuad&);

    void forceCompositingLayer(bool force = true);

    bool forcedCompositingLayer() const { return m_forceCompositingLayer; }

    void detectDrawingOptimizations();

    void invalidateDrawingOptimizations();

    // Up-calls from GraphicsLayer

    RenderLayer* hitTestRootLayer(RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&, const IntRect& hitTestRect, const IntPoint& hitTestPoint);

    // GraphicsLayerClient interface

    virtual void notifyTransitionStarted(const GraphicsLayer*, AnimatedPropertyID, double startTime);

    virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime);

    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip);

    virtual bool contentsContainPoint(const GraphicsLayer*, const IntPoint& point, GraphicsLayerPaintingPhase , struct LayerHitTestData*);

    virtual FloatPoint convertToContentsCoordinates(const GraphicsLayer*, const FloatPoint&);

    virtual IntRect contentsBox(const GraphicsLayer*);

private:

    void createGraphicsLayer();

    void destroyGraphicsLayer();

    RenderObject* renderer() const { return m_owningLayer->renderer(); }

    RenderLayerCompositor* compositor() const { return m_owningLayer->compositor(); }

    bool updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip);

    bool updateContentsLayer(bool needsContentsLayer);

    IntSize contentOffsetInCompostingLayer();

    // Result is transform origin in pixels.

    FloatPoint computeTransformOrigin(const IntRect& borderBox) const;

    void updateLayerOpacity();

    void updateLayerTransform();

    // Return the opacity value that this layer should use for compositing.

    float compositingOpacity(float rendererOpacity) const;

    // Returns true if this RenderLayer only has content that can be rendered directly

    // by the compositing layer, without drawing (e.g. solid background color).

    bool isSimpleContainerCompositingLayer();

    bool rendererHasBackground() const;

    const Color& rendererBackgroundColor() const;

    bool canBeSimpleContainerCompositingLayer() const;

    bool hasNonCompositingContent() const;

    void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,

                    bool haveTransparency, PaintRestriction paintRestriction, GraphicsLayerPaintingPhase, RenderObject* paintingRoot);

    RenderLayer* findHitCompositingLayer(RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&, const IntRect& hitTestRect, const IntPoint& hitTestPoint);

private:

    RenderLayer* m_owningLayer;

    GraphicsLayer* m_ancestorClippingLayer; // only used if we are clipped by an ancestor which is not a stacking context

    GraphicsLayer* m_graphicsLayer;

    GraphicsLayer* m_contentsLayer;         // only used in cases where we need to draw the foreground separately

    GraphicsLayer* m_clippingLayer;         // only used if we have clipping on a stacking context, with compositing children

    IntSize m_compositingContentOffset;

    bool m_forceCompositingLayer : 1;   // set if we need a compositing layer because of some external requirement

    bool m_isSimpleContainerCompositingLayer : 1;  // is this compositing layer able to be simplified

    bool m_simpleCompositingLayerStatusDirty : 1; // set if the test for simple layers needs to be redone

    bool m_compositingContentOffsetDirty: 1;

};

} // namespace WebCore

#endif // USE(ACCELERATED_COMPOSITING)

#endif // RenderLayerBacking_h

/*

 * Copyright (C) 2009 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. 

 * 3.  Neither the name of Apple Inc. ("Apple") nor the names of

 *     its contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission. 

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 ENABLE(3D_TRANSFORMS)

// This symbol is used to determine from a script whether 3D transforms are enabled (via 'nm').

bool WebCoreHas3DTransforms = true;

#endif

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.h"

#include "AnimationController.h"

#include "ChromeClient.h"

#include "FrameView.h"

#include "GraphicsLayer.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "Page.h"

#include "RenderLayerBacking.h"

#include "RenderView.h"

#include "SystemTime.h"

#ifndef NDEBUG

#include "CString.h"

#include "RenderTreeAsText.h"

#endif

namespace WebCore {

struct CompositingState {

    CompositingState(RenderLayer* inCompAncestor)

    : m_subtreeIsCompositing(false)

    , m_compositingAncestor(inCompAncestor)

    , m_depth(0)

    {

    }

    bool m_subtreeIsCompositing;

    RenderLayer* m_compositingAncestor;

    int m_depth;        // just used for debugging

};

static TransformationMatrix flipTransform()

{

    TransformationMatrix flipper;

    flipper.flipY();

    return flipper;

}

RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView)

    : m_renderView(renderView)

    , m_rootPlatformLayer(0)

    , m_compositing(false)

    , m_rootLayerAttached(false)

    , m_compositingLayersNeedUpdate(false)

#if PROFILE_LAYER_REBUILD

    , m_rootLayerUpdateCount(0)

#endif // PROFILE_LAYER_REBUILD

{

}

RenderLayerCompositor::~RenderLayerCompositor()

{

    ASSERT(!m_rootLayerAttached);

    delete m_rootPlatformLayer;

}

void RenderLayerCompositor::enableCompositingMode(bool enable /* = true */)

{

    if (enable != m_compositing) {

        m_compositing = enable;

        // We never go out of compositing mode for a given page,

        // but if all the layers disappear, we'll just be left with

        // the empty root layer, which has minimal overhead.

        if (m_compositing)

            ensureRootPlatformLayer();

    }

}

void RenderLayerCompositor::setCompositingLayersNeedUpdate(bool needUpdate)

{

    if (inCompositingMode())

        m_compositingLayersNeedUpdate = needUpdate;

}

void RenderLayerCompositor::updateCompositingLayers(RenderLayer* updateRoot)

{

    if (!m_compositingLayersNeedUpdate)

        return;

    m_compositingLayersNeedUpdate = false;

    ASSERT(inCompositingMode());

    if (!updateRoot)

        updateRoot = rootRenderLayer();

#if PROFILE_LAYER_REBUILD

    ++m_rootLayerUpdateCount;

    double startTime = currentTime();

#endif        

    // Go through the layers in presentation order, so that we can compute which

    // RLs need compositing layers.

    // FIXME: we could maybe do this in one pass, but the parenting logic would be more

    // complex.

    {

        CompositingState compState(updateRoot);

        computeCompositingRequirements(updateRoot, compState);

    }

    // Now create and parent the compositing layers.

    {

        CompositingState compState(updateRoot);

        rebuildCompositingLayerTree(updateRoot, compState);

    }

    {

        // If you uncomment this, be sure to comment the layout() and updateCompositingLayers() lines in

        // RenderTreeAsText.cpp, externalRepresentation(), to avoid recursion.

        //String dump = externalRepresentation(m_renderView);

        //fprintf(stderr, "%s", dump.utf8().data());

    }

#if PROFILE_LAYER_REBUILD

    double endTime = currentTime();

    if (!updateRoot)

        fprintf(stderr, "Update %d: computeCompositingRequirements for the world took %fms\n"

                    m_rootLayerUpdateCount, 1000.0 * (endTime - startTime));

#endif

    ASSERT(!m_compositingLayersNeedUpdate);

}

bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, RenderStyle::Diff diff)

{

    bool needsLayer = needsToBeComposited(layer);

    bool layerChanged = false;

    if (needsLayer) {

        enableCompositingMode();

        if (!layer->backing()) {

            layer->ensureBacking();

            layerChanged = true;

        }

    } else {

        if (layer->backing()) {

            layer->clearBacking();

            layerChanged = true;

        }

    }

    if (layerChanged) {

        // invalidate the parent in this region

        RenderLayer* compLayer = enclosingCompositingLayer(layer, false);

        if (compLayer) {

            // We can't reliably compute a dirty rect, because style may have changed already, 

            // so just dirty the whole parent layer

            compLayer->setNeedsRepaint();

        }

        layer->renderer()->compositingStateChanged();

    }

    if (!needsLayer)

        return layerChanged;

    if (layer->backing()->updateGraphicsLayers(needsContentsCompositingLayer(layer),

                                               clippedByAncestor(layer),

                                               clipsCompositingDescendants(layer),

                                               diff >= RenderStyle::Repaint))

        layerChanged = true;

    return layerChanged;

}

// 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, IntRect* layerBoundingBox)

{

    IntRect boundingBoxRect, unionBounds;

    boundingBoxRect = unionBounds = layer->boundingBox(layer);

    ASSERT(layer->isStackingContext() || (!layer->m_posZOrderList || layer->m_posZOrderList->size() == 0));

    Vector<RenderLayer*>* negZOrderList = layer->negZOrderList();

    if (negZOrderList)

        for (Vector<RenderLayer*>::iterator it = negZOrderList->begin(); it != negZOrderList->end(); ++it) {

            RenderLayer* curLayer = (*it);

            if (!curLayer->isComposited()) {

                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(childUnionBounds);

            }

        }

    Vector<RenderLayer*>* posZOrderList = layer->posZOrderList();

    if (posZOrderList)

        for (Vector<RenderLayer*>::iterator it = posZOrderList->begin(); it != posZOrderList->end(); ++it) {

            RenderLayer* curLayer = (*it);

            if (!curLayer->isComposited()) {

                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(childUnionBounds);

            }

        }

    Vector<RenderLayer*>* overflowList = layer->overflowList();

    if (overflowList)

        for (Vector<RenderLayer*>::iterator it = overflowList->begin(); it != overflowList->end(); ++it) {

            RenderLayer* curLayer = (*it);

            if (!curLayer->isComposited()) {

                IntRect curAbsBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(curAbsBounds);

            }

        }

    if (!layer->isComposited() && layer->transform()) {

        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);

    if (layerBoundingBox) {

        boundingBoxRect.move(ancestorRelX, ancestorRelY);

        *layerBoundingBox = boundingBoxRect;

    }

    return unionBounds;

}

void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer* /*child*/)

{

    setCompositingLayersNeedUpdate();

}

void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child)

{

    if (child->isComposited())

        setCompositingParent(child, 0);

    RenderLayer* compLayer = enclosingCompositingLayer(parent, false);

    if (compLayer) {

        IntRect ancestorRect = calculateCompositedBounds(child, compLayer);

        compLayer->setNeedsRepaintInRect(ancestorRect);

    }

    setCompositingLayersNeedUpdate();

}

RenderLayer* RenderLayerCompositor::enclosingCompositingLayer(RenderLayer* layer, bool includeSelf) const

{

    if (includeSelf && layer->isComposited())

        return layer;

    bool childOverflowOnly = layer->isOverflowOnly();

    RenderLayer* curr = layer->parent();

    for ( ; curr != 0; curr = curr->parent()) {

        // Compositing layers are parented according to stacking order and overflow list,

        // so we have to check whether the parent is a stacking context, or whether 

        // the child is overflow-only.

        if (curr->isComposited() && (childOverflowOnly || curr->isStackingContext()))

            return curr;

        childOverflowOnly = curr->isOverflowOnly();

    }

    return 0;

}

RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer* layer) const

{

    RenderLayer* curr = layer->parent();

    for ( ; curr != 0; curr = curr->parent()) {

        if (curr->isStackingContext())

            return 0;

        if (curr->renderer()->hasOverflowClip())

            return curr;

    }

    return 0;

}

//  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, struct CompositingState& ioCompState)

{

    // Make sure this layer's z-order and overflow lists are up to date

    layer->updateThisLayer();

    // Clear the flag

    layer->setHasCompositingDescendant(false);

    setForcedCompositingLayer(layer, ioCompState.m_subtreeIsCompositing);

    const bool isCompositingLayer = needsToBeComposited(layer);

    ioCompState.m_subtreeIsCompositing = isCompositingLayer;

    CompositingState childState = ioCompState;

    if (isCompositingLayer)

        childState.m_compositingAncestor = layer;

    // 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;

    ++childState.m_depth;

    if (layer->isStackingContext()) {

        ASSERT(!layer->m_zOrderListsDirty);

        Vector<RenderLayer*>* negZOrderList = layer->negZOrderList();

        if (negZOrderList && negZOrderList->size() > 0) {

            for (Vector<RenderLayer*>::const_iterator it = negZOrderList->begin(); it != negZOrderList->end(); ++it) {

                RenderLayer* curLayer = (*it);

                computeCompositingRequirements(curLayer, childState);

                // 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)

                if (childState.m_subtreeIsCompositing) {

                    // make |this| compositing

                    setForcedCompositingLayer(layer, true);

                    childState.m_compositingAncestor = layer;

                }

            }

        }

    }

    ASSERT(!layer->m_overflowListDirty);

    Vector<RenderLayer*>* overflowList = layer->overflowList();

    if (overflowList && overflowList->size() > 0)

        for (Vector<RenderLayer*>::const_iterator it = overflowList->begin(); it != overflowList->end(); ++it) {

            RenderLayer* curLayer = (*it);

            computeCompositingRequirements(curLayer, childState);

        }

    if (layer->isStackingContext()) {

        Vector<RenderLayer*>* posZOrderList = layer->posZOrderList();

        if (posZOrderList && posZOrderList->size() > 0)

            for (Vector<RenderLayer*>::const_iterator it = posZOrderList->begin(); it != posZOrderList->end(); ++it) {

                RenderLayer* curLayer = (*it);

                computeCompositingRequirements(curLayer, childState);

            }

    }

    // 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 (childState.m_subtreeIsCompositing &&

        (layer->renderer()->style()->hasTransform() || layer->renderer()->style()->opacity() < 1))

        setForcedCompositingLayer(layer, true);

    // Subsequent layers in the parent stacking context also need to composite.

    if (childState.m_subtreeIsCompositing)

        ioCompState.m_subtreeIsCompositing = true;

    // Set the flag to say that this SC has compositing children.

    // this can affect the answer to needsToBeComposited() when clipping,

    // but that's ok here.

    layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing);

}

void RenderLayerCompositor::setForcedCompositingLayer(RenderLayer* layer, bool force)

{

    if (force) {

        layer->ensureBacking();

        layer->backing()->forceCompositingLayer();

    } else {

        if (layer->backing())

            layer->backing()->forceCompositingLayer(false);

    }

}