Revert the merge. Mac build is mysteriously broken.

third_party/WebKit/WebCore/rendering/RenderLayerBacking.cpp

Index: third_party/WebKit/WebCore/rendering/RenderLayerBacking.cpp
===================================================================
--- third_party/WebKit/WebCore/rendering/RenderLayerBacking.cpp	(revision 9383)
+++ third_party/WebKit/WebCore/rendering/RenderLayerBacking.cpp	(working copy)
@@ -1,966 +1,966 @@
-/*
- * 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"
-#include "CSSPropertyNames.h"
-#include "CSSStyleSelector.h"
-#include "FrameView.h"
-#include "GraphicsContext.h"
-#include "GraphicsLayer.h"
-#include "HitTestRequest.h"
-#include "HitTestResult.h"
-#include "HTMLNames.h"
-#include "RenderBox.h"
-#include "RenderImage.h"
-#include "RenderLayerCompositor.h"
-#include "RenderVideo.h"
-#include "RenderView.h"
-
-#include "RenderLayerBacking.h"
-
-using namespace std;
-
-namespace WebCore {
-
-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(" ") + static_cast<HTMLElement*>(renderer()->element())->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();
-
-    // 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);
-    
-    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();
-    
-    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;
-
-    // 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()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyWebkitTransform))
-        updateLayerTransform();
-
-    m_compositingContentOffsetDirty = true;
-    
-    RenderLayer* compAncestor = compositor()->ancestorCompositingLayer(m_owningLayer);
-    
-    // We compute everything relative to the enclosing compositing layer.
-    IntRect ancestorCompositingBounds;
-    if (compAncestor)
-        ancestorCompositingBounds = compositor()->calculateCompositedBounds(compAncestor, compAncestor);
-    
-    IntRect localCompositingBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
-
-    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.
-        graphicsLayerParentLocation = compAncestor->renderer()->getOverflowClipRect(0, 0).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 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);
-        
-        m_ancestorClippingLayer->setPosition(FloatPoint() + (backgroundRect.location() - graphicsLayerParentLocation));
-        m_ancestorClippingLayer->setSize(backgroundRect.size());
-
-        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.
-        IntSize rendererOffset(backgroundRect.location().x() - deltaX, backgroundRect.location().y() - deltaY);
-        m_ancestorClippingLayer->setOffsetFromRenderer(rendererOffset);
-
-        // The primary layer is then parented in, and positioned relative to this clipping layer.
-        graphicsLayerParentLocation = backgroundRect.location();
-    }
-
-    m_graphicsLayer->setPosition(FloatPoint() + (relativeCompositingBounds.location() - graphicsLayerParentLocation));
-    m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - IntPoint());
-    
-    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.
-    if (m_clippingLayer) {
-        IntRect clippingBox = renderer()->getOverflowClipRect(0, 0);
-        m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));
-        m_clippingLayer->setSize(clippingBox.size());
-        m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());
-    }
-    
-    if (m_owningLayer->hasTransform()) {
-        const IntRect borderBox = toRenderBox(renderer())->borderBoxRect();
-
-        IntRect layerBounds = IntRect(m_owningLayer->xPos(), m_owningLayer->yPos(), borderBox.width(), borderBox.height());
-        // Convert to absolute coords to match bbox.
-        int x = 0, y = 0;
-        m_owningLayer->convertToLayerCoords(compAncestor, x, y);
-        layerBounds.move(x - m_owningLayer->xPos(), y - m_owningLayer->yPos());
-
-        // 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);
-    } else {
-        m_graphicsLayer->setAnchorPoint(FloatPoint3D(0.5f, 0.5f, 0));
-    }
-
-    if (m_contentsLayer) {
-        // The contents layer is always coincidental with the graphicsLayer for now.
-        m_contentsLayer->setPosition(IntPoint(0, 0));
-        m_contentsLayer->setSize(newSize);
-        m_contentsLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
-    }
-
-    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(this);
-#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; 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* style)
-{
-    return !style->hasBackgroundImage();
-}
-
-static bool hasBorderOutlineOrShadow(RenderStyle* style)
-{
-    return (style->hasBorder() || style->hasBorderRadius() || style->hasOutline() || (style->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()) {
-            if (child->isRenderInline() || !child->isBox())
-                return true;
-            
-            if (toRenderBox(child)->width() > 0 || toRenderBox(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*)
-{
-    if (!renderer()->isBox())
-        return IntRect();
-
-    IntRect contentsRect = toRenderBox(renderer())->contentBoxRect();
-    IntSize contentOffset = contentOffsetInCompostingLayer();
-    contentsRect.move(contentOffset);
-    return contentsRect;
-}
-
-// Map the given point from coordinates in the GraphicsLayer to RenderLayer coordinates.
-FloatPoint RenderLayerBacking::graphicsLayerToContentsCoordinates(const GraphicsLayer* graphicsLayer, const FloatPoint& point)
-{
-    return point + FloatSize(graphicsLayer->offsetFromRenderer());
-}
-
-// Map the given point from coordinates in the RenderLayer to GraphicsLayer coordinates.
-FloatPoint RenderLayerBacking::contentsToGraphicsLayerCoordinates(const GraphicsLayer* graphicsLayer, const FloatPoint& point)
-{
-    return point - FloatSize(graphicsLayer->offsetFromRenderer());
-}
-
-bool RenderLayerBacking::paintingGoesToWindow() const
-{
-    return m_owningLayer->isDocumentLayer();
-}
-
-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(m_graphicsLayer, 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;
-    }
-    
-    m_owningLayer->updateLayerListsIfNeeded();
-    
-    // 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 - toRenderBox(renderer())->x();
-    int ty = y - toRenderBox(renderer())->y();
-
-    // 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;
-        
-        // FIXME: do we need this code?
-        if (renderer()->node()->isDocumentNode() && renderer()->document()->isHTMLDocument()) {
-            RenderBox* box = toRenderBox(renderer());
-            int w = box->width();
-            int h = box->height();
-            
-            int rw;
-            int rh;
-            if (box->view()->frameView()) {
-                rw = box->view()->frameView()->contentsWidth();
-                rh = box->view()->frameView()->contentsHeight();
-            } else {
-                rw = box->view()->width();
-                rh = box->view()->height();
-            }
-            
-            int bx = tx - box->marginLeft();
-            int by = ty - box->marginTop();
-            int bw = max(w + box->marginLeft() + box->marginRight() + box->borderLeft() + box->borderRight(), rw);
-            int bh = max(h + box->marginTop() + box->marginBottom() + box->borderTop() + box->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());
-}
-
-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, toRenderBox(renderer())->borderBoxRect().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;
-    ASSERT(property != cAnimateAll);
-
-    if (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 == (int)CSSPropertyWebkitTransform && m_owningLayer->hasTransform()) {
-        // 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, toRenderBox(renderer())->borderBoxRect().size(), transformAnim, beginTime, true))
-                didAnimate = true;
-        }
-    }
-    
-    return didAnimate;
-}
-
-void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, double time)
-{
-    renderer()->animation()->notifyAnimationStarted(renderer(), time);
-}
-
-void RenderLayerBacking::animationFinished(const String& name, int index, bool reset)
-{
-    m_graphicsLayer->removeFinishedAnimations(name, index, reset);
-}
-
-void RenderLayerBacking::transitionFinished(int property)
-{
-    AnimatedPropertyID animatedProperty = cssToGraphicsLayerProperty(property);
-    if (animatedProperty != AnimatedPropertyInvalid)
-        m_graphicsLayer->removeFinishedTransitions(animatedProperty);
-}
-
-void RenderLayerBacking::suspendAnimations()
-{
-    m_graphicsLayer->suspendAnimations();
-}
-
-void RenderLayerBacking::resumeAnimations()
-{
-    m_graphicsLayer->resumeAnimations();
-}
-
-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();
-    }
-    return cssProperty;
-}
-
-AnimatedPropertyID RenderLayerBacking::cssToGraphicsLayerProperty(int cssProperty)
-{
-    switch (cssProperty) {
-        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;
-}
-
-} // 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.
+ *
+ * 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"
+#include "CSSPropertyNames.h"
+#include "CSSStyleSelector.h"
+#include "FrameView.h"
+#include "GraphicsContext.h"
+#include "GraphicsLayer.h"
+#include "HitTestRequest.h"
+#include "HitTestResult.h"
+#include "HTMLNames.h"
+#include "RenderBox.h"
+#include "RenderImage.h"
+#include "RenderLayerCompositor.h"
+#include "RenderVideo.h"
+#include "RenderView.h"
+
+#include "RenderLayerBacking.h"
+
+using namespace std;
+
+namespace WebCore {
+
+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(" ") + static_cast<HTMLElement*>(renderer()->element())->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();
+
+    // 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, renderer()->borderBoxRect().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();
+    
+    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;
+
+    // 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()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyWebkitTransform))
+        updateLayerTransform();
+
+    m_compositingContentOffsetDirty = true;
+    
+    RenderLayer* compAncestor = compositor()->ancestorCompositingLayer(m_owningLayer);
+    
+    // We compute everything relative to the enclosing compositing layer.
+    IntRect ancestorCompositingBounds;
+    if (compAncestor)
+        ancestorCompositingBounds = compositor()->calculateCompositedBounds(compAncestor, compAncestor);
+    
+    IntRect localCompositingBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
+
+    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.
+        graphicsLayerParentLocation = compAncestor->renderer()->getOverflowClipRect(0, 0).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 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);
+        
+        m_ancestorClippingLayer->setPosition(FloatPoint() + (backgroundRect.location() - graphicsLayerParentLocation));
+        m_ancestorClippingLayer->setSize(backgroundRect.size());
+
+        // backgroundRect is relative to compAncestor, so subtract deltaX/deltaY to get back to local coords.
+        IntSize rendererOffset(backgroundRect.location().x() - deltaX, backgroundRect.location().y() - deltaY);
+        m_ancestorClippingLayer->setOffsetFromRenderer(rendererOffset);
+
+        // The primary layer is then parented in, and positioned relative to this clipping layer.
+        graphicsLayerParentLocation = backgroundRect.location();
+    }
+
+    m_graphicsLayer->setPosition(FloatPoint() + (relativeCompositingBounds.location() - graphicsLayerParentLocation));
+    m_graphicsLayer->setOffsetFromRenderer(localCompositingBounds.location() - IntPoint());
+    
+    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.
+    if (m_clippingLayer) {
+        IntRect clippingBox = renderer()->getOverflowClipRect(0, 0);
+        m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));
+        m_clippingLayer->setSize(clippingBox.size());
+        m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());
+    }
+    
+    if (m_owningLayer->hasTransform()) {
+        const IntRect borderBox = renderer()->borderBoxRect();
+
+        IntRect layerBounds = IntRect(m_owningLayer->xPos(), m_owningLayer->yPos(), borderBox.width(), borderBox.height());
+        // Convert to absolute coords to match bbox.
+        int x = 0, y = 0;
+        m_owningLayer->convertToLayerCoords(compAncestor, x, y);
+        layerBounds.move(x - m_owningLayer->xPos(), y - m_owningLayer->yPos());
+
+        // 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);
+    } else {
+        m_graphicsLayer->setAnchorPoint(FloatPoint3D(0.5f, 0.5f, 0));
+    }
+
+    if (m_contentsLayer) {
+        // The contents layer is always coincidental with the graphicsLayer for now.
+        m_contentsLayer->setPosition(IntPoint(0, 0));
+        m_contentsLayer->setSize(newSize);
+        m_contentsLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
+    }
+
+    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(this);
+#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; 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* style)
+{
+    return !style->hasBackgroundImage();
+}
+
+static bool hasBorderOutlineOrShadow(RenderStyle* style)
+{
+    return (style->hasBorder() || style->hasBorderRadius() || style->hasOutline() || (style->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()) {
+            if (child->isRenderInline() || !child->isBox())
+                return true;
+            
+            if (toRenderBox(child)->width() > 0 || toRenderBox(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 = renderer()->contentBoxRect();
+    IntSize contentOffset = contentOffsetInCompostingLayer();
+    contentsRect.move(contentOffset);
+    return contentsRect;
+}
+
+// Map the given point from coordinates in the GraphicsLayer to RenderLayer coordinates.
+FloatPoint RenderLayerBacking::graphicsLayerToContentsCoordinates(const GraphicsLayer* graphicsLayer, const FloatPoint& point)
+{
+    return point + FloatSize(graphicsLayer->offsetFromRenderer());
+}
+
+// Map the given point from coordinates in the RenderLayer to GraphicsLayer coordinates.
+FloatPoint RenderLayerBacking::contentsToGraphicsLayerCoordinates(const GraphicsLayer* graphicsLayer, const FloatPoint& point)
+{
+    return point - FloatSize(graphicsLayer->offsetFromRenderer());
+}
+
+bool RenderLayerBacking::paintingGoesToWindow() const
+{
+    return m_owningLayer->isDocumentLayer();
+}
+
+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(m_graphicsLayer, 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;
+    }
+    
+    m_owningLayer->updateLayerListsIfNeeded();
+    
+    // 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()->x();
+    int ty = y - renderer()->y();
+
+    // 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());
+}
+
+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()->borderBoxRect().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;
+    ASSERT(property != cAnimateAll);
+
+    if (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 == (int)CSSPropertyWebkitTransform && m_owningLayer->hasTransform()) {
+        // 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()->borderBoxRect().size(), transformAnim, beginTime, true))
+                didAnimate = true;
+        }
+    }
+    
+    return didAnimate;
+}
+
+void RenderLayerBacking::notifyTransitionStarted(const GraphicsLayer*, AnimatedPropertyID property, double time)
+{
+    renderer()->animation()->notifyTransitionStarted(renderer(), graphicsLayerToCSSProperty(property), time);
+}
+
+void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, double time)
+{
+    renderer()->animation()->notifyAnimationStarted(renderer(), time);
+}
+
+void RenderLayerBacking::animationFinished(const String& name, int index, bool reset)
+{
+    m_graphicsLayer->removeFinishedAnimations(name, index, reset);
+}
+
+void RenderLayerBacking::transitionFinished(int property)
+{
+    AnimatedPropertyID animatedProperty = cssToGraphicsLayerProperty(property);
+    if (animatedProperty != AnimatedPropertyInvalid)
+        m_graphicsLayer->removeFinishedTransitions(animatedProperty);
+}
+
+void RenderLayerBacking::suspendAnimations()
+{
+    m_graphicsLayer->suspendAnimations();
+}
+
+void RenderLayerBacking::resumeAnimations()
+{
+    m_graphicsLayer->resumeAnimations();
+}
+
+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();
+    }
+    return cssProperty;
+}
+
+AnimatedPropertyID RenderLayerBacking::cssToGraphicsLayerProperty(int cssProperty)
+{
+    switch (cssProperty) {
+        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;
+}
+
+} // namespace WebCore
+
+#endif // USE(ACCELERATED_COMPOSITING)