/*

 * 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.

 *

 * 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 "AnimationController.h"

#if ENABLE(3D_CANVAS)    

#include "WebGLRenderingContext.h"

#endif

#include "CSSPropertyNames.h"

#include "CSSStyleSelector.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "GraphicsLayer.h"

#include "HTMLCanvasElement.h"

#include "HTMLElement.h"

#include "HTMLIFrameElement.h"

#include "HTMLMediaElement.h"

#include "HTMLNames.h"

#include "InspectorTimelineAgent.h"

#include "KeyframeList.h"

#include "PluginViewBase.h"

#include "RenderBox.h"

#include "RenderIFrame.h"

#include "RenderImage.h"

#include "RenderLayerCompositor.h"

#include "RenderEmbeddedObject.h"

#include "RenderVideo.h"

#include "RenderView.h"

#include "Settings.h"

#include "RenderLayerBacking.h"

using namespace std;

namespace WebCore {

using namespace HTMLNames;

static bool hasBorderOutlineOrShadow(const RenderStyle*);

static bool hasBoxDecorationsOrBackground(const RenderObject*);

static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*);

static IntRect clipBox(RenderBox* renderer);

static inline bool is3DCanvas(RenderObject* renderer)

{

#if ENABLE(3D_CANVAS)    

    if (renderer->isCanvas())

        return static_cast<HTMLCanvasElement*>(renderer->node())->is3D();

#else

    UNUSED_PARAM(renderer);

#endif

    return false;

}

RenderLayerBacking::RenderLayerBacking(RenderLayer* layer)

    : m_owningLayer(layer)

    , m_artificiallyInflatedBounds(false)

{

    createGraphicsLayer();

}

RenderLayerBacking::~RenderLayerBacking()

{

    updateClippingLayers(false, false);

    updateForegroundLayer(false);

    updateMaskLayer(false);

    destroyGraphicsLayer();

}

void RenderLayerBacking::createGraphicsLayer()

{

    m_graphicsLayer = GraphicsLayer::create(this);

#ifndef NDEBUG

    m_graphicsLayer->setName(nameForLayer());

#endif  // NDEBUG

    updateLayerOpacity(renderer()->style());

    updateLayerTransform(renderer()->style());

}

void RenderLayerBacking::destroyGraphicsLayer()

{

    if (m_graphicsLayer)

        m_graphicsLayer->removeFromParent();

    m_graphicsLayer = 0;

    m_foregroundLayer = 0;

    m_clippingLayer = 0;

    m_maskLayer = 0;

}

void RenderLayerBacking::updateLayerOpacity(const RenderStyle* style)

{

    m_graphicsLayer->setOpacity(compositingOpacity(style->opacity()));

}

void RenderLayerBacking::updateLayerTransform(const RenderStyle* style)

{

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

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

    TransformationMatrix t;

    if (m_owningLayer->hasTransform()) {

        style->applyTransform(t, toRenderBox(renderer())->borderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);

        makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());

    }

    m_graphicsLayer->setTransform(t);

}

static bool hasNonZeroTransformOrigin(const RenderObject* renderer)

{

    RenderStyle* style = renderer->style();

    return (style->transformOriginX().type() == Fixed && style->transformOriginX().value())

        || (style->transformOriginY().type() == Fixed && style->transformOriginY().value());

}

static RenderLayer* enclosingOverflowClipAncestor(RenderLayer* layer, bool& crossesTransform)

{

    crossesTransform = false;

    for (RenderLayer* curr = layer->parent(); curr; curr = curr->parent()) {

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

            return curr;

        if (curr->hasTransform())

            crossesTransform = true;

    }

    return 0;

}

void RenderLayerBacking::updateCompositedBounds()

{

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

    // Clip to the size of the document or enclosing overflow-scroll layer.

    if (compositor()->compositingConsultsOverlap() && !m_owningLayer->hasTransform()) {

        bool crossesTransform;

        RenderLayer* overflowAncestor = enclosingOverflowClipAncestor(m_owningLayer, crossesTransform);

        // If an ancestor is transformed, we can't currently compute the correct rect to intersect with.

        // We'd need RenderObject::convertContainerToLocalQuad(), which doesn't yet exist.

        if (!crossesTransform) {

            IntRect clippingBounds;

            RenderLayer* boundsRelativeLayer;

            if (overflowAncestor) {

                RenderBox* overflowBox = toRenderBox(overflowAncestor->renderer());

                // If scrollbars are visible, then constrain the layer to the scrollable area, so we can avoid redraws

                // on scrolling. Otherwise just clip to the visible area (it can still be scrolled via JS, but we'll come

                // back through this code when the scroll offset changes).

                if (overflowBox->scrollsOverflow())

                    clippingBounds = IntRect(-overflowAncestor->scrollXOffset(), -overflowAncestor->scrollYOffset(), overflowBox->scrollWidth(), overflowBox->scrollHeight());

                else

                    clippingBounds = clipBox(overflowBox);

                boundsRelativeLayer = overflowAncestor;

            } else {

                RenderView* view = m_owningLayer->renderer()->view();

                clippingBounds = view->layoutOverflowRect();

                boundsRelativeLayer = view->layer();

            }

            int deltaX = 0;

            int deltaY = 0;

            m_owningLayer->convertToLayerCoords(boundsRelativeLayer, deltaX, deltaY);

            clippingBounds.move(-deltaX, -deltaY);

            layerBounds.intersect(clippingBounds);

        }

    }

    // If the element has a transform-origin that has fixed lengths, and the renderer has zero size,

    // then we need to ensure that the compositing layer has non-zero size so that we can apply

    // the transform-origin via the GraphicsLayer anchorPoint (which is expressed as a fractional value).

    if (layerBounds.isEmpty() && hasNonZeroTransformOrigin(renderer())) {

        layerBounds.setWidth(1);

        layerBounds.setHeight(1);

        m_artificiallyInflatedBounds = true;

    } else

        m_artificiallyInflatedBounds = false;

    setCompositedBounds(layerBounds);

}

void RenderLayerBacking::updateAfterWidgetResize()

{

    if (renderer()->isRenderIFrame()) {

        if (RenderLayerCompositor* innerCompositor = RenderLayerCompositor::iframeContentsCompositor(toRenderIFrame(renderer())))

            innerCompositor->updateContentLayerOffset(contentsBox().location());

    }

}

void RenderLayerBacking::updateAfterLayout(UpdateDepth updateDepth, bool isUpdateRoot)

{

    RenderLayerCompositor* layerCompositor = compositor();

    if (!layerCompositor->compositingLayersNeedRebuild()) {

        // Calling updateGraphicsLayerGeometry() here gives incorrect results, because the

        // position of this layer's GraphicsLayer depends on the position of our compositing

        // ancestor's GraphicsLayer. That cannot be determined until all the descendant 

        // RenderLayers of that ancestor have been processed via updateLayerPositions().

        //

        // The solution is to update compositing children of this layer here,

        // via updateCompositingChildrenGeometry().

        updateCompositedBounds();

        layerCompositor->updateCompositingDescendantGeometry(m_owningLayer, m_owningLayer, updateDepth);

        if (isUpdateRoot) {

            updateGraphicsLayerGeometry();

            layerCompositor->updateRootLayerPosition();

        }

    }

}

bool RenderLayerBacking::updateGraphicsLayerConfiguration()

{

    RenderLayerCompositor* compositor = this->compositor();

    bool layerConfigChanged = false;

    if (updateForegroundLayer(compositor->needsContentsCompositingLayer(m_owningLayer)))

        layerConfigChanged = true;

    if (updateClippingLayers(compositor->clippedByAncestor(m_owningLayer), compositor->clipsCompositingDescendants(m_owningLayer)))

        layerConfigChanged = true;

    if (updateMaskLayer(m_owningLayer->renderer()->hasMask()))

        m_graphicsLayer->setMaskLayer(m_maskLayer.get());

    if (m_owningLayer->hasReflection()) {

        if (m_owningLayer->reflectionLayer()->backing()) {

            GraphicsLayer* reflectionLayer = m_owningLayer->reflectionLayer()->backing()->graphicsLayer();

            m_graphicsLayer->setReplicatedByLayer(reflectionLayer);

        }

    } else

        m_graphicsLayer->setReplicatedByLayer(0);

    if (isDirectlyCompositedImage())

        updateImageContents();

    if (renderer()->isEmbeddedObject() && toRenderEmbeddedObject(renderer())->allowsAcceleratedCompositing()) {

        PluginViewBase* pluginViewBase = static_cast<PluginViewBase*>(toRenderEmbeddedObject(renderer())->widget());

        m_graphicsLayer->setContentsToMedia(pluginViewBase->platformLayer());

    }

#if ENABLE(VIDEO)

    else if (renderer()->isVideo()) {

        HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(renderer()->node());

        m_graphicsLayer->setContentsToMedia(mediaElement->platformLayer());

    }

#endif

#if ENABLE(3D_CANVAS)    

    else if (is3DCanvas(renderer())) {

        HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer()->node());

        WebGLRenderingContext* context = static_cast<WebGLRenderingContext*>(canvas->renderingContext());

        if (context->graphicsContext3D()->platformLayer())

            m_graphicsLayer->setContentsToWebGL(context->graphicsContext3D()->platformLayer());

    }

#endif

    if (renderer()->isRenderIFrame())

        layerConfigChanged = RenderLayerCompositor::parentIFrameContentLayers(toRenderIFrame(renderer()));

    return layerConfigChanged;

}

static IntRect clipBox(RenderBox* renderer)

{

    IntRect result = ClipRects::infiniteRect();

    if (renderer->hasOverflowClip())

        result = renderer->overflowClipRect(0, 0);

    if (renderer->hasClip())

        result.intersect(renderer->clipRect(0, 0));

    return result;

}

void RenderLayerBacking::updateGraphicsLayerGeometry()

{

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

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

        return;

    // Set transform property, if it is not animating. We have to do this here because the transform

    // is affected by the layer dimensions.

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

        updateLayerTransform(renderer()->style());

    // Set opacity, if it is not animating.

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

        updateLayerOpacity(renderer()->style());

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

    m_graphicsLayer->setPreserves3D(style->transformStyle3D() == TransformStyle3DPreserve3D && !renderer()->hasReflection());

    m_graphicsLayer->setBackfaceVisibility(style->backfaceVisibility() == BackfaceVisibilityVisible);

    RenderLayer* compAncestor = m_owningLayer->ancestorCompositingLayer();

    // We compute everything relative to the enclosing compositing layer.

    IntRect ancestorCompositingBounds;

    if (compAncestor) {

        ASSERT(compAncestor->backing());

        ancestorCompositingBounds = compAncestor->backing()->compositedBounds();

    }

    IntRect localCompositingBounds = compositedBounds();

    IntRect relativeCompositingBounds(localCompositingBounds);

    int deltaX = 0, deltaY = 0;

    m_owningLayer->convertToLayerCoords(compAncestor, deltaX, deltaY);

    relativeCompositingBounds.move(deltaX, deltaY);

    IntPoint graphicsLayerParentLocation;

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

        // If the compositing ancestor has a layer to clip children, we parent in that, and therefore

        // position relative to it.

        IntRect clippingBox = clipBox(toRenderBox(compAncestor->renderer()));

        graphicsLayerParentLocation = clippingBox.location();

    } else

        graphicsLayerParentLocation = ancestorCompositingBounds.location();

    if (compAncestor && m_ancestorClippingLayer) {

        // 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 parentClipRect = m_owningLayer->backgroundClipRect(compAncestor, true);

        m_ancestorClippingLayer->setPosition(FloatPoint() + (parentClipRect.location() - graphicsLayerParentLocation));

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

        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.

        IntSize rendererOffset(parentClipRect.location().x() - deltaX, parentClipRect.location().y() - deltaY);

        m_ancestorClippingLayer->setOffsetFromRenderer(rendererOffset);

        // The primary layer is then parented in, and positioned relative to this clipping layer.

        graphicsLayerParentLocation = parentClipRect.location();

    }

    m_graphicsLayer->setPosition(FloatPoint() + (relativeCompositingBounds.location() - graphicsLayerParentLocation));

    IntSize oldOffsetFromRenderer = m_graphicsLayer->offsetFromRenderer();

    m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - IntPoint());

    // If the compositing layer offset changes, we need to repaint.

    if (oldOffsetFromRenderer != m_graphicsLayer->offsetFromRenderer())

        m_graphicsLayer->setNeedsDisplay();

    FloatSize oldSize = m_graphicsLayer->size();

    FloatSize newSize = relativeCompositingBounds.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.

    IntRect clippingBox;

    if (m_clippingLayer) {

        clippingBox = clipBox(toRenderBox(renderer()));

        m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));

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

        m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());

    }

    if (m_maskLayer) {

        m_maskLayer->setSize(m_graphicsLayer->size());

        m_maskLayer->setPosition(FloatPoint());

    }

    if (m_owningLayer->hasTransform()) {

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

        // Get layout bounds in the coords of compAncestor to match relativeCompositingBounds.

        IntRect layerBounds = IntRect(deltaX, deltaY, borderBox.width(), borderBox.height());

        // Update properties that depend on layer dimensions

        FloatPoint3D transformOrigin = computeTransformOrigin(borderBox);

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

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

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

                            transformOrigin.z());

        m_graphicsLayer->setAnchorPoint(anchor);

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

        if (style->hasPerspective()) {

            TransformationMatrix t = owningLayer()->perspectiveTransform();

            if (m_clippingLayer) {

                m_clippingLayer->setChildrenTransform(t);

                m_graphicsLayer->setChildrenTransform(TransformationMatrix());

            }

            else

                m_graphicsLayer->setChildrenTransform(t);

        } else {

            if (m_clippingLayer)

                m_clippingLayer->setChildrenTransform(TransformationMatrix());

            else

                m_graphicsLayer->setChildrenTransform(TransformationMatrix());

        }

    } else {

        m_graphicsLayer->setAnchorPoint(FloatPoint3D(0.5f, 0.5f, 0));

    }

    if (m_foregroundLayer) {

        FloatPoint foregroundPosition;

        FloatSize foregroundSize = newSize;

        IntSize foregroundOffset = m_graphicsLayer->offsetFromRenderer();

        // If we have a clipping layer (which clips descendants), then the foreground layer is a child of it,

        // so that it gets correctly sorted with children. In that case, position relative to the clipping layer.

        if (m_clippingLayer) {

            foregroundPosition = FloatPoint() + (localCompositingBounds.location() - clippingBox.location());

            foregroundSize = FloatSize(clippingBox.size());

            foregroundOffset = clippingBox.location() - IntPoint();

        }

        m_foregroundLayer->setPosition(foregroundPosition);

        m_foregroundLayer->setSize(foregroundSize);

        m_foregroundLayer->setOffsetFromRenderer(foregroundOffset);

    }

    if (m_owningLayer->reflectionLayer() && m_owningLayer->reflectionLayer()->isComposited()) {

        RenderLayerBacking* reflectionBacking = m_owningLayer->reflectionLayer()->backing();

        reflectionBacking->updateGraphicsLayerGeometry();

        // The reflection layer has the bounds of m_owningLayer->reflectionLayer(),

        // but the reflected layer is the bounds of this layer, so we need to position it appropriately.

        FloatRect layerBounds = compositedBounds();

        FloatRect reflectionLayerBounds = reflectionBacking->compositedBounds();

        reflectionBacking->graphicsLayer()->setReplicatedLayerPosition(FloatPoint() + (layerBounds.location() - reflectionLayerBounds.location()));

    }

    m_graphicsLayer->setContentsRect(contentsBox());

    updateDrawsContent();

    updateAfterWidgetResize();

}

void RenderLayerBacking::updateInternalHierarchy()

{

    // m_foregroundLayer 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.get());

    }

    if (m_clippingLayer) {

        m_clippingLayer->removeFromParent();

        m_graphicsLayer->addChild(m_clippingLayer.get());

    }

}

void RenderLayerBacking::updateDrawsContent()

{

    m_graphicsLayer->setDrawsContent(containsPaintedContent());

}

// Return true if the layers changed.

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

{

    bool layersChanged = false;

    if (needsAncestorClip) {

        if (!m_ancestorClippingLayer) {

            m_ancestorClippingLayer = GraphicsLayer::create(this);

#ifndef NDEBUG

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

#endif

            m_ancestorClippingLayer->setMasksToBounds(true);

            layersChanged = true;

        }

    } else if (m_ancestorClippingLayer) {

        m_ancestorClippingLayer->removeFromParent();

        m_ancestorClippingLayer = 0;

        layersChanged = true;

    }

    if (needsDescendantClip) {

        if (!m_clippingLayer) {

            m_clippingLayer = GraphicsLayer::create(this);

#ifndef NDEBUG

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

#endif

            m_clippingLayer->setMasksToBounds(true);

            layersChanged = true;

        }

    } else if (m_clippingLayer) {

        m_clippingLayer->removeFromParent();

        m_clippingLayer = 0;

        layersChanged = true;

    }

    if (layersChanged)

        updateInternalHierarchy();

    return layersChanged;

}

bool RenderLayerBacking::updateForegroundLayer(bool needsForegroundLayer)

{

    bool layerChanged = false;

    if (needsForegroundLayer) {

        if (!m_foregroundLayer) {

            m_foregroundLayer = GraphicsLayer::create(this);

#ifndef NDEBUG