/*

 * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.h"

#include "AnimationController.h"

#include "CSSPropertyNames.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsLayer.h"

#include "HTMLCanvasElement.h"

#include "HTMLIFrameElement.h"

#include "HTMLNames.h"

#include "HitTestResult.h"

#include "NodeList.h"

#include "Page.h"

#include "RenderEmbeddedObject.h"

#include "RenderIFrame.h"

#include "RenderLayerBacking.h"

#include "RenderReplica.h"

#include "RenderVideo.h"

#include "RenderView.h"

#include "Settings.h"

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

#include "HTMLMediaElement.h"

#endif

#if PROFILE_LAYER_REBUILD

#include <wtf/CurrentTime.h>

#endif

#ifndef NDEBUG

#include "RenderTreeAsText.h"

#endif

#if ENABLE(3D_RENDERING)

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

bool WebCoreHas3DRendering = true;

#endif

namespace WebCore {

using namespace HTMLNames;

struct CompositingState {

    CompositingState(RenderLayer* compAncestor)

        : m_compositingAncestor(compAncestor)

        , m_subtreeIsCompositing(false)

#ifndef NDEBUG

        , m_depth(0)

#endif

    {

    }

    RenderLayer* m_compositingAncestor;

    bool m_subtreeIsCompositing;

#ifndef NDEBUG

    int m_depth;

#endif

};

RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView)

    : m_renderView(renderView)

    , m_rootPlatformLayer(0)

    , m_hasAcceleratedCompositing(true)

    , m_showDebugBorders(false)

    , m_showRepaintCounter(false)

    , m_compositingConsultsOverlap(true)

    , m_compositingDependsOnGeometry(false)

    , m_compositing(false)

    , m_compositingLayersNeedRebuild(false)

    , m_rootLayerAttachment(RootLayerUnattached)

#if PROFILE_LAYER_REBUILD

    , m_rootLayerUpdateCount(0)

#endif // PROFILE_LAYER_REBUILD

{

}

RenderLayerCompositor::~RenderLayerCompositor()

{

    ASSERT(m_rootLayerAttachment == RootLayerUnattached);

}

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

{

    if (enable != m_compositing) {

        m_compositing = enable;

        if (m_compositing) {

            ensureRootPlatformLayer();

            notifyIFramesOfCompositingChange();

        } else

            destroyRootPlatformLayer();

    }

}

void RenderLayerCompositor::cacheAcceleratedCompositingFlags()

{

    bool hasAcceleratedCompositing = false;

    bool showDebugBorders = false;

    bool showRepaintCounter = false;

    if (Settings* settings = m_renderView->document()->settings()) {

        hasAcceleratedCompositing = settings->acceleratedCompositingEnabled();

        showDebugBorders = settings->showDebugBorders();

        showRepaintCounter = settings->showRepaintCounter();

    }

    // We allow the chrome to override the settings, in case the page is rendered

    // on a chrome that doesn't allow accelerated compositing.

    if (hasAcceleratedCompositing) {

        Frame* frame = m_renderView->frameView()->frame();

        Page* page = frame ? frame->page() : 0;

        if (page)

            hasAcceleratedCompositing = page->chrome()->client()->allowsAcceleratedCompositing();

    }

    if (hasAcceleratedCompositing != m_hasAcceleratedCompositing || showDebugBorders != m_showDebugBorders || showRepaintCounter != m_showRepaintCounter)

        setCompositingLayersNeedRebuild();

    m_hasAcceleratedCompositing = hasAcceleratedCompositing;

    m_showDebugBorders = showDebugBorders;

    m_showRepaintCounter = showRepaintCounter;

}

void RenderLayerCompositor::setCompositingLayersNeedRebuild(bool needRebuild)

{

    if (inCompositingMode())

        m_compositingLayersNeedRebuild = needRebuild;

}

void RenderLayerCompositor::scheduleSync()

{

    Frame* frame = m_renderView->frameView()->frame();

    Page* page = frame ? frame->page() : 0;

    if (!page)

        return;

    page->chrome()->client()->scheduleCompositingLayerSync();

}

void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType updateType, RenderLayer* updateRoot)

{

    if (!m_compositingDependsOnGeometry && !m_compositing)

        return;

    bool checkForHierarchyUpdate = m_compositingDependsOnGeometry;

    bool needGeometryUpdate = false;

    switch (updateType) {

    case CompositingUpdateAfterLayoutOrStyleChange:

    case CompositingUpdateOnPaitingOrHitTest:

        checkForHierarchyUpdate = true;

        break;

    case CompositingUpdateOnScroll:

        if (m_compositingConsultsOverlap)

            checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates.

        needGeometryUpdate = true;

        break;

    }

    if (!checkForHierarchyUpdate && !needGeometryUpdate)

        return;

    bool needHierarchyUpdate = m_compositingLayersNeedRebuild;

    if (!updateRoot) {

        // Only clear the flag if we're updating the entire hierarchy.

        m_compositingLayersNeedRebuild = false;

        updateRoot = rootRenderLayer();

    }

#if PROFILE_LAYER_REBUILD

    ++m_rootLayerUpdateCount;

    double startTime = WTF::currentTime();

#endif        

    if (checkForHierarchyUpdate) {

        // Go through the layers in presentation order, so that we can compute which RenderLayers need compositing layers.

        // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex.

        CompositingState compState(updateRoot);

        bool layersChanged = false;

        if (m_compositingConsultsOverlap) {

            OverlapMap overlapTestRequestMap;

            computeCompositingRequirements(updateRoot, &overlapTestRequestMap, compState, layersChanged);

        } else

            computeCompositingRequirements(updateRoot, 0, compState, layersChanged);

        needHierarchyUpdate |= layersChanged;

    }

    if (needHierarchyUpdate) {

        // Update the hierarchy of the compositing layers.

        CompositingState compState(updateRoot);

        Vector<GraphicsLayer*> childList;

        rebuildCompositingLayerTree(updateRoot, compState, childList);

        // Host the document layer in the RenderView's root layer.

        if (updateRoot == rootRenderLayer()) {

            if (childList.isEmpty())

                destroyRootPlatformLayer();

            else

                m_rootPlatformLayer->setChildren(childList);

        }

    } else if (needGeometryUpdate) {

        // We just need to do a geometry update. This is only used for position:fixed scrolling;

        // most of the time, geometry is updated via RenderLayer::styleChanged().

        updateLayerTreeGeometry(updateRoot);

    }

#if PROFILE_LAYER_REBUILD

    double endTime = WTF::currentTime();

    if (updateRoot == rootRenderLayer())

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

                    m_rootLayerUpdateCount, 1000.0 * (endTime - startTime));

#endif

    ASSERT(updateRoot || !m_compositingLayersNeedRebuild);

    if (!hasAcceleratedCompositing())

        enableCompositingMode(false);

}

bool RenderLayerCompositor::updateBacking(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)

{

    bool layerChanged = false;

    if (needsToBeComposited(layer)) {

        enableCompositingMode();

        // 3D transforms turn off the testing of overlap.

        if (requiresCompositingForTransform(layer->renderer()))

            setCompositingConsultsOverlap(false);

        if (!layer->backing()) {

            // If we need to repaint, do so before making backing

            if (shouldRepaint == CompositingChangeRepaintNow)

                repaintOnCompositingChange(layer);

            layer->ensureBacking();

            layerChanged = true;

        }

    } else {

        if (layer->backing()) {

            // If we're removing backing on a reflection, clear the source GraphicsLayer's pointer to

            // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection 

            // are both either composited, or not composited.

            if (layer->isReflection()) {

                RenderLayer* sourceLayer = toRenderBoxModelObject(layer->renderer()->parent())->layer();

                if (RenderLayerBacking* backing = sourceLayer->backing()) {

                    ASSERT(backing->graphicsLayer()->replicaLayer() == layer->backing()->graphicsLayer());

                    backing->graphicsLayer()->setReplicatedByLayer(0);

                }

            }

            layer->clearBacking();

            layerChanged = true;

            // The layer's cached repaints rects are relative to the repaint container, so change when

            // compositing changes; we need to update them here.

            layer->computeRepaintRects();

            // If we need to repaint, do so now that we've removed the backing

            if (shouldRepaint == CompositingChangeRepaintNow)

                repaintOnCompositingChange(layer);

        }

    }

#if ENABLE(VIDEO)

    if (layerChanged && layer->renderer()->isVideo()) {

        // If it's a video, give the media player a chance to hook up to the layer.

        RenderVideo* video = toRenderVideo(layer->renderer());

        video->acceleratedRenderingStateChanged();

    }

#endif

    if (layerChanged && layer->renderer()->isRenderIFrame()) {

        RenderLayerCompositor* innerCompositor = iframeContentsCompositor(toRenderIFrame(layer->renderer()));

        if (innerCompositor && innerCompositor->inCompositingMode())

            innerCompositor->updateRootLayerAttachment();

    }

    return layerChanged;

}

bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)

{

    bool layerChanged = updateBacking(layer, shouldRepaint);

    // See if we need content or clipping layers. Methods called here should assume

    // that the compositing state of descendant layers has not been updated yet.

    if (layer->backing() && layer->backing()->updateGraphicsLayerConfiguration())

        layerChanged = true;

    return layerChanged;

}

void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)

{

    // If the renderer is not attached yet, no need to repaint.

    if (layer->renderer() != m_renderView && !layer->renderer()->parent())

        return;

    RenderBoxModelObject* repaintContainer = layer->renderer()->containerForRepaint();

    if (!repaintContainer)

        repaintContainer = m_renderView;

    layer->repaintIncludingNonCompositingDescendants(repaintContainer);

    if (repaintContainer == m_renderView) {

        // The contents of this layer may be moving between the window

        // and a GraphicsLayer, so we need to make sure the window system

        // synchronizes those changes on the screen.

        m_renderView->frameView()->setNeedsOneShotDrawingSynchronization();

    }

}

// The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant

// RenderLayers that are rendered by the composited RenderLayer.

IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)

{

    if (!canBeComposited(layer))

        return IntRect();

    IntRect boundingBoxRect = layer->localBoundingBox();

    if (layer->renderer()->isRoot()) {

        // If the root layer becomes composited (e.g. because some descendant with negative z-index is composited),

        // then it has to be big enough to cover the viewport in order to display the background. This is akin

        // to the code in RenderBox::paintRootBoxDecorations().

        if (m_renderView->frameView()) {

            int rw = m_renderView->frameView()->contentsWidth();

            int rh = m_renderView->frameView()->contentsHeight();

            boundingBoxRect.setWidth(max(boundingBoxRect.width(), rw - boundingBoxRect.x()));

            boundingBoxRect.setHeight(max(boundingBoxRect.height(), rh - boundingBoxRect.y()));

        }

    }

    IntRect unionBounds = boundingBoxRect;

    if (layer->renderer()->hasOverflowClip() || layer->renderer()->hasMask()) {

        int ancestorRelX = 0, ancestorRelY = 0;

        layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);

        boundingBoxRect.move(ancestorRelX, ancestorRelY);

        return boundingBoxRect;

    }

    if (RenderLayer* reflection = layer->reflectionLayer()) {

        if (!reflection->isComposited()) {

            IntRect childUnionBounds = calculateCompositedBounds(reflection, layer);

            unionBounds.unite(childUnionBounds);

        }

    }

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

    if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {

        size_t listSize = negZOrderList->size();

        for (size_t i = 0; i < listSize; ++i) {

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

            if (!curLayer->isComposited()) {

                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(childUnionBounds);

            }

        }

    }

    if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {

        size_t listSize = posZOrderList->size();

        for (size_t i = 0; i < listSize; ++i) {

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

            if (!curLayer->isComposited()) {

                IntRect childUnionBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(childUnionBounds);

            }

        }

    }

    if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {

        size_t listSize = normalFlowList->size();

        for (size_t i = 0; i < listSize; ++i) {

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

            if (!curLayer->isComposited()) {

                IntRect curAbsBounds = calculateCompositedBounds(curLayer, layer);

                unionBounds.unite(curAbsBounds);

            }

        }

    }

    if (layer->paintsWithTransform(PaintBehaviorNormal)) {

        TransformationMatrix* affineTrans = layer->transform();

        boundingBoxRect = affineTrans->mapRect(boundingBoxRect);

        unionBounds = affineTrans->mapRect(unionBounds);

    }

    int ancestorRelX = 0, ancestorRelY = 0;

    layer->convertToLayerCoords(ancestorLayer, ancestorRelX, ancestorRelY);

    unionBounds.move(ancestorRelX, ancestorRelY);

    return unionBounds;

}

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

{

    setCompositingLayersNeedRebuild();

}

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

{

    if (!child->isComposited() || parent->renderer()->documentBeingDestroyed())

        return;

    setCompositingParent(child, 0);

    RenderLayer* compLayer = parent->enclosingCompositingLayer();

    if (compLayer) {

        ASSERT(compLayer->backing());

        IntRect compBounds = child->backing()->compositedBounds();

        int offsetX = 0, offsetY = 0;

        child->convertToLayerCoords(compLayer, offsetX, offsetY);

        compBounds.move(offsetX, offsetY);

        compLayer->setBackingNeedsRepaintInRect(compBounds);

        // The contents of this layer may be moving from a GraphicsLayer to the window,

        // so we need to make sure the window system synchronizes those changes on the screen.

        m_renderView->frameView()->setNeedsOneShotDrawingSynchronization();

    }

    setCompositingLayersNeedRebuild();

}

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

{

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

        if (curr->isStackingContext())

            return 0;

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

            return curr;

    }

    return 0;

}

void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)

{

    if (layer->isRootLayer())

        return;

    if (!boundsComputed) {

        layerBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();

        // Empty rects never intersect, but we need them to for the purposes of overlap testing.

        if (layerBounds.isEmpty())

            layerBounds.setSize(IntSize(1, 1));

        boundsComputed = true;

    }

    overlapMap.add(layer, layerBounds);

}

bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const IntRect& layerBounds)

{

    RenderLayerCompositor::OverlapMap::const_iterator end = overlapMap.end();

    for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) {

        const IntRect& bounds = it->second;

        if (layerBounds.intersects(bounds))

            return true;

    }

    return false;

}

//  Recurse through the layers in z-index and overflow order (which is equivalent to painting order)

//  For the z-order children of a compositing layer:

//      If a child layers has a compositing layer, then all subsequent layers must

//      be compositing in order to render above that layer.

//

//      If a child in the negative z-order list is compositing, then the layer itself

//      must be compositing so that its contents render over that child.

//      This implies that its positive z-index children must also be compositing.

//

void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* layer, OverlapMap* overlapMap, struct CompositingState& compositingState, bool& layersChanged)

{

    layer->updateLayerPosition();

    layer->updateZOrderLists();

    layer->updateNormalFlowList();

    // Clear the flag

    layer->setHasCompositingDescendant(false);

    bool mustOverlapCompositedLayers = compositingState.m_subtreeIsCompositing;

    bool haveComputedBounds = false;

    IntRect absBounds;

    if (overlapMap && !overlapMap->isEmpty()) {

        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.

        absBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();

        // Empty rects never intersect, but we need them to for the purposes of overlap testing.

        if (absBounds.isEmpty())

            absBounds.setSize(IntSize(1, 1));