 * 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

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

 */

#include "config.h"

#if USE(ACCELERATED_COMPOSITING)

30#include "RenderLayerBacking.h"

31

3032#include "AnimationController.h"

31 #if ENABLE(3D_CANVAS)

33#if ENABLE(3D_CANVAS)

#include "WebGLRenderingContext.h"

#endif

#include "CSSPropertyNames.h"

#include "KeyframeList.h"

#include "PluginWidget.h"

#include "RenderBox.h"

49#include "RenderEmbeddedObject.h"

4750#include "RenderImage.h"

4851#include "RenderLayerCompositor.h"

49 #include "RenderEmbeddedObject.h"

#include "RenderVideo.h"

#include "RenderView.h"

#include "Settings.h"

54 #include "RenderLayerBacking.h"

using namespace std;

@@static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*);

static inline bool is3DCanvas(RenderObject* renderer)

{

68 #if ENABLE(3D_CANVAS)

69#if ENABLE(3D_CANVAS)

    if (renderer->isCanvas())

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

#else

@@RenderLayerBacking::~RenderLayerBacking()

void RenderLayerBacking::createGraphicsLayer()

{

    m_graphicsLayer = GraphicsLayer::create(this);

95

96

#ifndef NDEBUG

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

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

@@void RenderLayerBacking::createGraphicsLayer()

        m_graphicsLayer->setName("Reflection");

    else

        m_graphicsLayer->setName("Anonymous Node");

110 #endif // NDEBUG

111#endif // NDEBUG

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

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

@@void RenderLayerBacking::updateLayerTransform(const RenderStyle* style)

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

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

    }

141

142

    m_graphicsLayer->setTransform(t);

}

@@void RenderLayerBacking::updateAfterLayout(UpdateDepth updateDepth, bool isUpdat

    if (!layerCompositor->compositingLayersNeedRebuild()) {

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

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

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

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

182

183

        if (isUpdateRoot) {

            updateGraphicsLayerGeometry();

            layerCompositor->updateRootLayerPosition();

@@bool RenderLayerBacking::updateGraphicsLayerConfiguration()

    bool layerConfigChanged = false;

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

        layerConfigChanged = true;

197

198

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

        layerConfigChanged = true;

@@bool RenderLayerBacking::updateGraphicsLayerConfiguration()

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

    }

#endif

225 #if ENABLE(3D_CANVAS)

226#if ENABLE(3D_CANVAS)

    else if (is3DCanvas(renderer())) {

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

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

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

    // Set opacity, if it is not animating.

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

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

251

252

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

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

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

    RenderLayer* compAncestor = m_owningLayer->ancestorCompositingLayer();

257

258

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

    IntRect ancestorCompositingBounds;

    if (compAncestor) {

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

        graphicsLayerParentLocation = toRenderBox(compAncestor->renderer())->overflowClipRect(0, 0).location();

    } else

        graphicsLayerParentLocation = ancestorCompositingBounds.location();

279

        if ( rendererHasBackground() ) {

                const Color &bgColor = rendererBackgroundColor();

                m_graphicsLayer->setBackgroundColor(bgColor);

        } else

                m_graphicsLayer->clearBackgroundColor();

    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

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

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

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

298

305

    FloatSize oldSize = m_graphicsLayer->size();

    FloatSize newSize = relativeCompositingBounds.size();

    if (oldSize != newSize) {

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

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

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

    }

317

324

    if (m_maskLayer) {

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

        m_maskLayer->setPosition(FloatPoint());

    }

322

329

    if (m_owningLayer->hasTransform()) {

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

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

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

        if (style->hasPerspective()) {

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

340

347

            if (m_clippingLayer) {

                m_clippingLayer->setChildrenTransform(t);

                m_graphicsLayer->setChildrenTransform(TransformationMatrix());

344 }

345 else

351 } else

                m_graphicsLayer->setChildrenTransform(t);

        } else {

            if (m_clippingLayer)

@@void RenderLayerBacking::updateGraphicsLayerGeometry()

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

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

        reflectionBacking->updateGraphicsLayerGeometry();

377

383

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

@@bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needs

        m_ancestorClippingLayer = 0;

        layersChanged = true;

    }

424

430

    if (needsDescendantClip) {

        if (!m_clippingLayer) {

            m_clippingLayer = GraphicsLayer::create(this);

@@bool RenderLayerBacking::updateClippingLayers(bool needsAncestorClip, bool needs

        m_clippingLayer = 0;

        layersChanged = true;

    }

439

445

    if (layersChanged)

        updateInternalHierarchy();

@@GraphicsLayerPaintingPhase RenderLayerBacking::paintingPhaseForPrimaryLayer() co

float RenderLayerBacking::compositingOpacity(float rendererOpacity) const

{

    float finalOpacity = rendererOpacity;

509

515

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

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

        // Recall that opacity creates stacking context.

        if (!curr->isStackingContext())

            continue;

515

521

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

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

        if (curr->isComposited())

            break;

520

526

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

    }

@@bool RenderLayerBacking::rendererHasBackground() const

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

        if (!htmlObject)

            return false;

549

555

        RenderStyle* style = htmlObject->style();

        if (style->hasBackground())

            return true;

553

559

        RenderObject* bodyObject = htmlObject->firstChild();

        if (!bodyObject)

            return false;

557

563

        style = bodyObject->style();

        return style->hasBackground();

    }

561

567

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

}

@@const Color& RenderLayerBacking::rendererBackgroundColor() const

bool RenderLayerBacking::isSimpleContainerCompositingLayer() const

{

    RenderObject* renderObject = renderer();

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

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

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

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

        return false;

    RenderStyle* style = renderObject->style();

@@bool RenderLayerBacking::isSimpleContainerCompositingLayer() const

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

    if (!renderObject->firstChild())

        return true;

603

609

    if (renderObject->node() && 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;

609

615

610616 style = rootObject->style();

611

617

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

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

        if (hasBoxDecorationsOrBackgroundImage(style))

            return false;

616

622

        // Now look at the body's renderer.

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

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

        if (!bodyObject)

            return false;

622

628

623629 style = bodyObject->style();

624

630

        if (hasBoxDecorationsOrBackgroundImage(style))

            return false;

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

        if (hasNonCompositingContent())

            return false;

631

637

        return true;

    }

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

    if (hasNonCompositingContent())

        return false;

638

644

    return true;

}

@@bool RenderLayerBacking::hasNonCompositingContent() const

{

    if (m_owningLayer->hasOverflowControls())

        return true;

647

653

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

    // <div>

    // <img src=...>

@@bool RenderLayerBacking::hasNonCompositingContent() const

        if (!child->hasLayer()) {

            if (child->isRenderInline() || !child->isBox())

                return true;

657

663

            if (toRenderBox(child)->width() > 0 || toRenderBox(child)->height() > 0)

                return true;

        }

@@void RenderLayerBacking::rendererContentChanged()

        return;

    }

727 #if ENABLE(3D_CANVAS)

733#if ENABLE(3D_CANVAS)

    if (is3DCanvas(renderer())) {

        m_graphicsLayer->setGraphicsContext3DNeedsDisplay();

        return;

@@void RenderLayerBacking::updateImageContents()

    // This is a no-op if the layer doesn't have an inner layer for the image.

    m_graphicsLayer->setContentsToImage(image);

754

760

    // Image animation is "lazy", in that it automatically stops unless someone is drawing

    // the image. So we have to kick the animation each time; this has the downside that the

    // image will keep animating, even if its layer is not visible.

@@void RenderLayerBacking::setContentsNeedDisplay()

{

    if (m_graphicsLayer && m_graphicsLayer->drawsContent())

        m_graphicsLayer->setNeedsDisplay();

833

839

    if (m_foregroundLayer && m_foregroundLayer->drawsContent())

        m_foregroundLayer->setNeedsDisplay();

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

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

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

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

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

                    PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase,

                    RenderObject* paintingRoot)

{

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

        ASSERT_NOT_REACHED();

        return;

    }

888

894

889895 m_owningLayer->updateLayerListsIfNeeded();

890

896

    // Calculate the clip rects we should use.

    IntRect layerBounds, damageRect, clipRectToApply, outlineRect;

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

894

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

900

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

    int y = layerBounds.y();

    int tx = x - m_owningLayer->renderBoxX();

    int ty = y - m_owningLayer->renderBoxY();

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

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

904 RenderObject *paintingRootForRenderer = 0;

910 RenderObject* paintingRootForRenderer = 0;

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

        paintingRootForRenderer = paintingRoot;

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

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

914

920

        // FIXME: do we need this code?

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

            RenderBox* box = toRenderBox(renderer());

            int w = box->width();

            int h = box->height();

920

926

            int rw;

            int rh;

            if (FrameView* frameView = box->view()->frameView()) {

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

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

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

            }

930

936

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

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

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

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

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

        // Establish the clip used to paint our background.

        setClip(context, paintDirtyRect, damageRect);

941

947

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

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

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

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

949

955

        // Restore the clip.

        restoreClip(context, paintDirtyRect, damageRect);

    }

953

959

    bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText;

    bool selectionOnly  = paintBehavior & PaintBehaviorSelectionOnly;

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

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

        setClip(context, paintDirtyRect, clipRectToApply);

968 RenderObject::PaintInfo paintInfo(context, clipRectToApply,

974 RenderObject::PaintInfo paintInfo(context, clipRectToApply,

                                          selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds,

                                          forceBlackText, paintingRootForRenderer, 0);

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

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

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

        }

    }

1009

1015

    if (shouldPaint && (paintingPhase & GraphicsLayerPaintMask)) {

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

            setClip(context, paintDirtyRect, damageRect);

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

            // Paint the mask.

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

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

1017

1023

            // Restore the clip.

            restoreClip(context, paintDirtyRect, damageRect);

        }

@@void RenderLayerBacking::paintContents(const GraphicsLayer*, GraphicsContext& co

    IntRect enclosingBBox = compositedBounds();

    IntRect clipRect(clip);

1052

1058

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

1058

1064

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

    IntRect dirtyRect = enclosingBBox;

    dirtyRect.intersect(clipRect);

@@bool RenderLayerBacking::startAnimation(double timeOffset, const Animation* anim

{

    bool hasOpacity = keyframes.containsProperty(CSSPropertyOpacity);

    bool hasTransform = keyframes.containsProperty(CSSPropertyWebkitTransform);

1085

1091

10861092 if (!hasOpacity && !hasTransform)

10871093 return false;

1088

1094

    KeyframeValueList transformVector(AnimatedPropertyWebkitTransform);

    KeyframeValueList opacityVector(AnimatedPropertyOpacity);

@@bool RenderLayerBacking::startAnimation(double timeOffset, const Animation* anim

        if (!keyframeStyle)

            continue;

1098

1104

10991105 // get timing function

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

1101

1107

11021108 if (hasTransform)

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

1104

1110

        if (hasOpacity)

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

    }

    bool didAnimateTransform = !hasTransform;

    bool didAnimateOpacity = !hasOpacity;

1111

1117

    if (hasTransform && m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->borderBoxRect().size(), anim, keyframes.animationName(), timeOffset))

        didAnimateTransform = true;

    if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), anim, keyframes.animationName(), timeOffset))

        didAnimateOpacity = true;

1117

1123

    bool runningAcceleratedAnimation = didAnimateTransform && didAnimateOpacity;

    if (runningAcceleratedAnimation)

        compositor()->didStartAcceleratedAnimation();

@@bool RenderLayerBacking::startTransition(double timeOffset, int property, const

    if (didAnimate)

        compositor()->didStartAcceleratedAnimation();

1161

1167

    return didAnimate;

}

@@int RenderLayerBacking::graphicsLayerToCSSProperty(AnimatedPropertyID property)

{

    int cssProperty = CSSPropertyInvalid;

    switch (property) {

        case AnimatedPropertyWebkitTransform:

            cssProperty = CSSPropertyWebkitTransform;

            break;

        case AnimatedPropertyOpacity:

            cssProperty = CSSPropertyOpacity;

            break;

        case AnimatedPropertyBackgroundColor:

            cssProperty = CSSPropertyBackgroundColor;

            break;

        case AnimatedPropertyInvalid:

            ASSERT_NOT_REACHED();

    case AnimatedPropertyWebkitTransform:

        cssProperty = CSSPropertyWebkitTransform;

        break;

    case AnimatedPropertyOpacity:

        cssProperty = CSSPropertyOpacity;

        break;

    case AnimatedPropertyBackgroundColor:

        cssProperty = CSSPropertyBackgroundColor;

        break;

    case AnimatedPropertyInvalid:

        ASSERT_NOT_REACHED();

    }

    return cssProperty;

}

@@int RenderLayerBacking::graphicsLayerToCSSProperty(AnimatedPropertyID property)

AnimatedPropertyID RenderLayerBacking::cssToGraphicsLayerProperty(int cssProperty)

{

    switch (cssProperty) {

        case CSSPropertyWebkitTransform:

            return AnimatedPropertyWebkitTransform;

        case CSSPropertyOpacity:

            return AnimatedPropertyOpacity;

        case CSSPropertyBackgroundColor:

            return AnimatedPropertyBackgroundColor;

    case CSSPropertyWebkitTransform:

        return AnimatedPropertyWebkitTransform;

    case CSSPropertyOpacity:

        return AnimatedPropertyOpacity;

    case CSSPropertyBackgroundColor:

        return AnimatedPropertyBackgroundColor;

        // It's fine if we see other css properties here; they are just not accelerated.

    }

    return AnimatedPropertyInvalid;

COMMIT_MESSAGE

WebCore/ChangeLog

WebCore/platform/graphics/qt/GraphicsLayerQt.cpp

WebCore/rendering/RenderLayerBacking.cpp