Changeset 86276 in webkit

Timestamp:

May 11, 2011 3:11:13 PM (13 years ago)

Author:

noam.rosenthal@nokia.com

Message:

2011-05-11 Noam Rosenthal <​noam.rosenthal@nokia.com>

Reviewed by Kenneth Rohde Christiansen.

[Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
​https://bugs.webkit.org/show_bug.cgi?id=60439

Patch 10/12: Glue the TextureMapper refactoring into Webkit(1).

1. Pass a GraphicsLayer* instead of a PlatformLayer* to the QWebPageClient.
2. Set parameters in TextureMapper/TextureMapperNode instead of passing them in an options argument.
3. Rename PlatformLayerProxyQt to TextureMapperNodeClient

• Api/qwebframe.cpp: (QWebFramePrivate::renderCompositedLayers):
• Api/qwebframe.h:
• Api/qwebframe_p.h: (QWebFramePrivate::QWebFramePrivate):
• WebCoreSupport/ChromeClientQt.cpp: (WebCore::ChromeClientQt::attachRootGraphicsLayer):
• WebCoreSupport/PageClientQt.cpp: (WebCore::TextureMapperNodeClientQt::TextureMapperNodeClientQt): (WebCore::TextureMapperNodeClientQt::scroll): (WebCore::TextureMapperNodeClientQt::setTextureMapper): (WebCore::TextureMapperNodeClientQt::~TextureMapperNodeClientQt): (WebCore::TextureMapperNodeClientQt::computeLastModifiedRect): (WebCore::TextureMapperNodeClientQt::syncRootLayer): (WebCore::TextureMapperNodeClientQt::rootNode): (WebCore::PageClientQWidget::setRootGraphicsLayer): (WebCore::PageClientQWidget::syncLayers): (WebCore::PageClientQWidget::~PageClientQWidget): (WebCore::PageClientQGraphicsWidget::~PageClientQGraphicsWidget): (WebCore::PageClientQGraphicsWidget::update): (WebCore::PageClientQGraphicsWidget::syncLayers): (WebCore::PageClientQGraphicsWidget::setRootGraphicsLayer): (WebCore::PageClientQGraphicsWidget::markForSync):
• WebCoreSupport/PageClientQt.h: (WebCore::PageClientQWidget::PageClientQWidget): (WebCore::PageClientQGraphicsWidget::PageClientQGraphicsWidget): (WebCore::PageClientQGraphicsWidget::syncLayersTimeout):

2011-05-11 Noam Rosenthal <​noam.rosenthal@nokia.com>

Reviewed by Kenneth Rohde Christiansen.

[Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
​https://bugs.webkit.org/show_bug.cgi?id=60439

Patch 12/12: Enable accelerated animations in texture-mapper. The entire interpolation
mechanism happens inside TextureMapper, and we interpolate right before we paint.

No new tests. Tests in LayoutTests/compositing cover this.

• platform/graphics/texmap/GraphicsLayerTextureMapper.cpp: (WebCore::GraphicsLayerTextureMapper::GraphicsLayerTextureMapper): (WebCore::GraphicsLayerTextureMapper::syncCompositingState): (WebCore::GraphicsLayerTextureMapper::addAnimation): (WebCore::GraphicsLayerTextureMapper::pauseAnimation): (WebCore::GraphicsLayerTextureMapper::removeAnimation): (WebCore::GraphicsLayerTextureMapper::animationStartedTimerFired):
• platform/graphics/texmap/TextureMapperNode.cpp: (WebCore::TextureMapperNode::descendantsOrSelfHaveRunningAnimations): (WebCore::normalizedAnimationValue): (WebCore::TextureMapperNode::applyOpacityAnimation): (WebCore::solveEpsilon): (WebCore::solveCubicBezierFunction): (WebCore::solveStepsFunction): (WebCore::applyTimingFunction): (WebCore::TextureMapperNode::applyTransformAnimation): (WebCore::TextureMapperNode::applyAnimationFrame): (WebCore::TextureMapperNode::applyAnimation): (WebCore::TextureMapperNode::hasRunningOpacityAnimation): (WebCore::TextureMapperNode::hasRunningTransformAnimation): (WebCore::TextureMapperNode::syncAnimations): (WebCore::copyTimingFunction): (WebCore::copyAnimationValue): (WebCore::TextureMapperAnimation::TextureMapperAnimation):
• platform/graphics/texmap/TextureMapperNode.h: (WebCore::TextureMapperAnimation::create):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/graphics/opengl/TextureMapperGL.cpp (modified) (25 diffs)
• WebCore/platform/graphics/opengl/TextureMapperGL.h (modified) (3 diffs)
• WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp (modified) (6 diffs)
• WebCore/platform/graphics/qt/MediaPlayerPrivateQt.cpp (modified) (3 diffs)
• WebCore/platform/graphics/qt/MediaPlayerPrivateQt.h (modified) (3 diffs)
• WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp (modified) (7 diffs)
• WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h (modified) (4 diffs)
• WebCore/platform/graphics/texmap/TextureMapperNode.cpp (modified) (7 diffs)
• WebCore/platform/graphics/texmap/TextureMapperNode.h (modified) (9 diffs)
• WebCore/platform/qt/QWebPageClient.h (modified) (1 diff)
• WebCore/plugins/PluginView.h (modified) (1 diff)
• WebKit/qt/Api/qwebframe.cpp (modified) (3 diffs)
• WebKit/qt/Api/qwebframe.h (modified) (2 diffs)
• WebKit/qt/Api/qwebframe_p.h (modified) (3 diffs)
• WebKit/qt/ChangeLog (modified) (1 diff)
• WebKit/qt/WebCoreSupport/ChromeClientQt.cpp (modified) (1 diff)
• WebKit/qt/WebCoreSupport/PageClientQt.cpp (modified) (10 diffs)
• WebKit/qt/WebCoreSupport/PageClientQt.h (modified) (8 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 12/12: Enable accelerated animations in texture-mapper. The entire interpolation
+        mechanism happens inside TextureMapper, and we interpolate right before we paint.
+
+        No new tests. Tests in LayoutTests/compositing cover this.
+
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
+        (WebCore::GraphicsLayerTextureMapper::GraphicsLayerTextureMapper):
+        (WebCore::GraphicsLayerTextureMapper::syncCompositingState):
+        (WebCore::GraphicsLayerTextureMapper::addAnimation):
+        (WebCore::GraphicsLayerTextureMapper::pauseAnimation):
+        (WebCore::GraphicsLayerTextureMapper::removeAnimation):
+        (WebCore::GraphicsLayerTextureMapper::animationStartedTimerFired):
+        * platform/graphics/texmap/TextureMapperNode.cpp:
+        (WebCore::TextureMapperNode::descendantsOrSelfHaveRunningAnimations):
+        (WebCore::normalizedAnimationValue):
+        (WebCore::TextureMapperNode::applyOpacityAnimation):
+        (WebCore::solveEpsilon):
+        (WebCore::solveCubicBezierFunction):
+        (WebCore::solveStepsFunction):
+        (WebCore::applyTimingFunction):
+        (WebCore::TextureMapperNode::applyTransformAnimation):
+        (WebCore::TextureMapperNode::applyAnimationFrame):
+        (WebCore::TextureMapperNode::applyAnimation):
+        (WebCore::TextureMapperNode::hasRunningOpacityAnimation):
+        (WebCore::TextureMapperNode::hasRunningTransformAnimation):
+        (WebCore::TextureMapperNode::syncAnimations):
+        (WebCore::copyTimingFunction):
+        (WebCore::copyAnimationValue):
+        (WebCore::TextureMapperAnimation::TextureMapperAnimation):
+        * platform/graphics/texmap/TextureMapperNode.h:
+        (WebCore::TextureMapperAnimation::create):
+
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 11/12: Patch PluginView to build with TextureMapper on Linux.
+
+        No new tests. This is a build fix.
+
+        * platform/qt/QWebPageClient.h:
+        (QWebPageClient::setRootGraphicsLayer):
+
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 10/12: Glue the TextureMapper refactoring into Webkit(1).
+        Pass a GraphicsLayer* instead of a PlatformLayer* to the QWebPageClient.
+
+        No new tests. Tests in LayoutTests/compositing cover this.
+
+        * platform/qt/QWebPageClient.h:
+        (QWebPageClient::setRootGraphicsLayer):
+
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 9/12: Refactor TextureMapperNode for performance, readability and accuracy.
+        Changes include:
+        1. Support the new TextureMapperPlatformLayer for media & WebGL.
+        2. Use a pool for intermediate surfaces, to avoid constant allocating/freeing of textures.
+        3. Divide computation operations to different smaller functions.
+        4. Get rid of scissor/clip layers, use transformed clip instead.
+        5. Allow tiling for big layers.
+
+        No new tests. Tests in LayoutTests/compositing cover this.
+
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
+        (WebCore::GraphicsLayerTextureMapper::GraphicsLayerTextureMapper):
+        (WebCore::GraphicsLayerTextureMapper::setNeedsDisplayInRect):
+        (WebCore::GraphicsLayerTextureMapper::setContentsToMedia):
+        (WebCore::GraphicsLayerTextureMapper::platformLayer):
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:
+        (WebCore::GraphicsLayerTextureMapper::setContentsNeedsDisplay):
+        (WebCore::GraphicsLayerTextureMapper::setContentsToCanvas):
+        (WebCore::GraphicsLayerTextureMapper::node):
+        * platform/graphics/texmap/TextureMapperNode.cpp:
+        (WebCore::TextureMapperSurfaceManager::getIntermediateSurface):
+        (WebCore::TextureMapperSurfaceManager::releaseIntermediateSurface):
+        (WebCore::toTextureMapperNode):
+        (WebCore::TextureMapperNode::rootLayer):
+        (WebCore::TextureMapperNode::setTransform):
+        (WebCore::TextureMapperNode::computePerspectiveTransformIfNeeded):
+        (WebCore::TextureMapperNode::countDescendantsWithContent):
+        (WebCore::TextureMapperNode::computeOverlapsIfNeeded):
+        (WebCore::TextureMapperNode::computeReplicaTransformIfNeeded):
+        (WebCore::TextureMapperNode::computeLocalTransformIfNeeded):
+        (WebCore::TextureMapperNode::needsToComputeBoundingRect):
+        (WebCore::TextureMapperNode::computeAllTransforms):
+        (WebCore::TextureMapperNode::computeBoundingRectFromRootIfNeeded):
+        (WebCore::TextureMapperNode::computeTiles):
+        (WebCore::TextureMapperNode::computeVisibleRectIfNeeded):
+        (WebCore::TextureMapperNode::renderContent):
+        (WebCore::TextureMapperNode::paint):
+        (WebCore::TextureMapperNode::targetRectForTileRect):
+        (WebCore::TextureMapperNode::paintSelf):
+        (WebCore::TextureMapperNode::compareGraphicsLayersZValue):
+        (WebCore::TextureMapperNode::sortByZOrder):
+        (WebCore::TextureMapperNode::paintSelfAndChildren):
+        (WebCore::TextureMapperNode::paintReflection):
+        (WebCore::TextureMapperNode::paintRecursive):
+        (WebCore::TextureMapperNode::~TextureMapperNode):
+        (WebCore::TextureMapperNode::resetDescendants):
+        (WebCore::TextureMapperNode::setContentScale):
+        (WebCore::TextureMapperNode::setVisibleRect):
+        (WebCore::TextureMapperNode::syncCompositingState):
+        (WebCore::TextureMapperNode::invalidateOverlaps):
+        (WebCore::TextureMapperNode::syncCompositingStateSelf):
+        (WebCore::TextureMapperNode::descendantsOrSelfHaveRunningAnimations):
+        * platform/graphics/texmap/TextureMapperNode.h:
+        (WebCore::TextureMapperPaintOptions::TextureMapperPaintOptions):
+        (WebCore::TextureMapperAnimation::create):
+        (WebCore::TextureMapperNode::TextureMapperNode):
+        (WebCore::TextureMapperNode::size):
+        (WebCore::TextureMapperNode::setOpacity):
+        (WebCore::TextureMapperNode::setTextureMapper):
+        (WebCore::TextureMapperNode::media):
+        (WebCore::TextureMapperNode::texture):
+        (WebCore::TextureMapperNode::targetRect):
+        (WebCore::TextureMapperNode::entireRect):
+        (WebCore::TextureMapperNode::contentSize):
+        (WebCore::TextureMapperNode::State::State):
+        (WebCore::deleteOwnedPtr):
+
+2011-05-07  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 8/12: Changes to the GL backend of TextureMapper. The code for these changes is intertwined so it was hard to separate
+        them to different patches. This is the summary of what the changes do:
+
+        1. Use stencil for clipping instead of scissors, refactor beginClip/endClip functions to accomodate that.
+        2. Get rid of the "Target" program which forced an intermediate framebuffer for any content. Instead,
+           we upload the texture with BGRA from the start. Ports other than Qt can optimize this for their needs.
+        3. Use glGetAttribLocation instead of glBindAttribLocation; On some platforms we might be polluting the
+           GL context otherwise.
+        4. Use image UIDs (cache-key in Qt) instead of image pointers. This is important for images that change their
+           internal content.
+        5. Allow packing and unpacking. This is currently a stub, for future memory optimizations.
+        6. Put some of the initialization code here (beginPainting/endPainting).
+        7. Allow painting a texture via an ID instead of a BitmapTexture data type.
+        8. Get rid of makeContextCurrent / obtainCurrentContext. We only use texture-mapper when the context is current.
+
+        No new tests. Tests in LayoutTests/compositing test this.
+
+        * platform/graphics/opengl/TextureMapperGL.cpp:
+        (WebCore::debugGLCommand):
+        (WebCore::TextureMapperGLData::GlobalGLData::createShaderProgram):
+        (WebCore::TextureMapperGLData::GlobalGLData::GlobalGLData):
+        (WebCore::TextureMapperGLData::DirectlyCompositedImageRepository::findOrCreate):
+        (WebCore::TextureMapperGLData::DirectlyCompositedImageRepository::deref):
+        (WebCore::TextureMapperGLData::DirectlyCompositedImageRepository::~DirectlyCompositedImageRepository):
+        (WebCore::TextureMapperGLData::TextureMapperGLData):
+        (WebCore::BitmapTextureGL::id):
+        (WebCore::BitmapTextureGL::isOpaque):
+        (WebCore::BitmapTextureGL::relativeSize):
+        (WebCore::BitmapTextureGL::setTextureMapper):
+        (WebCore::BitmapTextureGL::pack):
+        (WebCore::BitmapTextureGL::unpack):
+        (WebCore::BitmapTextureGL::isPacked):
+        (WebCore::BitmapTextureGL::BitmapTextureGL):
+        (WebCore::TextureMapperGL::TextureMapperGL):
+        (WebCore::TextureMapperGL::initializeShaders):
+        (WebCore::TextureMapperGL::beginPainting):
+        (WebCore::TextureMapperGL::endPainting):
+        (WebCore::TextureMapperGL::drawTexture):
+        (WebCore::BitmapTextureGL::reset):
+        (WebCore::BitmapTextureGL::endPaint):
+        (WebCore::BitmapTextureGL::setContentsToImage):
+        (WebCore::createProjectionMatrix):
+        (WebCore::BitmapTextureGL::bind):
+        (WebCore::BitmapTextureGL::destroy):
+        (WebCore::TextureMapperGL::~TextureMapperGL):
+        (WebCore::TextureMapperGL::bindSurface):
+        (WebCore::TextureMapperGL::beginClip):
+        (WebCore::TextureMapperGL::endClip):
+        (WebCore::TextureMapperGL::createTexture):
+        * platform/graphics/opengl/TextureMapperGL.h:
+        (WebCore::TextureMapperGL::allowSurfaceForRoot):
+        (WebCore::TextureMapperGL::create):
+        (WebCore::TextureMapperGL::setGraphicsContext):
+        (WebCore::TextureMapperGL::graphicsContext):
+        (WebCore::TextureMapperGL::isOpenGLBacked):
+        * platform/graphics/qt/GraphicsContext3DQt.cpp:
+        (WebCore::GraphicsContext3DInternal::paintToTextureMapper):
+        (WebCore::GraphicsContext3DInternal::boundingRect):
+        (WebCore::GraphicsContext3DInternal::paint):
+        * platform/graphics/qt/MediaPlayerPrivateQt.cpp:
+        (WebCore::MediaPlayerPrivateQt::repaint):
+        (WebCore::MediaPlayerPrivateQt::paintToTextureMapper):
+        * platform/graphics/qt/MediaPlayerPrivateQt.h:
+        (WebCore::MediaPlayerPrivateQt::acceleratedRenderingStateChanged):
+        (WebCore::MediaPlayerPrivateQt::platformLayer):
+
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 7/12: Allow a 3D-context (WebGL) to paint itself into a TextureMapper.
+        This allows using a WebGL canvas with CSS.
+
+        No new tests. Tests in LayoutTests/compositing/webgl cover this.
+
+        * platform/graphics/qt/GraphicsContext3DQt.cpp:
+        (WebCore::GraphicsContext3DInternal::paintToTextureMapper):
+        (WebCore::GraphicsContext3DInternal::boundingRect):
+        (WebCore::GraphicsContext3DInternal::paint):
+        * platform/graphics/qt/MediaPlayerPrivateQt.cpp:
+        (WebCore::MediaPlayerPrivateQt::repaint):
+        (WebCore::MediaPlayerPrivateQt::paintToTextureMapper):
+        * platform/graphics/qt/MediaPlayerPrivateQt.h:
+        (WebCore::MediaPlayerPrivateQt::acceleratedRenderingStateChanged):
+        (WebCore::MediaPlayerPrivateQt::platformLayer):
+
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 6/12: Allow the Qt media player implementation to paint into a TextureMapper,
+        to allow videos to be composited.
+
+        No new tests. Tests in LayoutTests/compositing cover this.
+
+        * platform/graphics/qt/MediaPlayerPrivateQt.cpp:
+        (WebCore::MediaPlayerPrivateQt::repaint):
+        (WebCore::MediaPlayerPrivateQt::paintToTextureMapper):
+        * platform/graphics/qt/MediaPlayerPrivateQt.h:
+        (WebCore::MediaPlayerPrivateQt::acceleratedRenderingStateChanged):
+        (WebCore::MediaPlayerPrivateQt::platformLayer):
+
 2011-05-11  John Bauman  <jbauman@chromium.org>
 

trunk/Source/WebCore/platform/graphics/opengl/TextureMapperGL.cpp

@@ -19 +19 @@
 
 #include "config.h"
+
 #include "TextureMapperGL.h"
 
@@ -30 +31 @@
 #if defined(TEXMAP_OPENGL_ES_2)
 #include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
 #elif OS(MAC_OS_X)
-#include <AGL/agl.h>
 #include <gl.h>
 #else
-#if OS(UNIX)
-#include <GL/glx.h>
-#endif
 #include <GL/gl.h>
 #endif
@@ -68 +66 @@
     void glBufferData(GLenum, GLsizeiptr, const GLvoid*, GLenum);
     void glBufferSubData(GLenum, GLsizeiptr, GLsizeiptr, const GLvoid*);
-    void glGetProgramInfoLog(GLuint program, GLsizei, GLsizei*, GLchar*);
-
+    void glGetProgramInfoLog(GLuint, GLsizei, GLsizei*, GLchar*);
+    void glGetShaderInfoLog(GLuint, GLsizei, GLsizei*, GLchar*);
+    void glGenRenderbuffers(GLsizei n, GLuint* ids);
+    void glDeleteRenderbuffers(GLsizei n, const GLuint* ids);
+    void glBindRenderbuffer(GLenum target, GLuint id);
+    void glRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height);
+    void glFramebufferRenderbuffer(GLenum target, GLenum attachmentPoint, GLenum renderbufferTarget, GLuint renderbufferId);
+    GLenum glCheckFramebufferStatus(GLenum target);
+    GLint glGetAttribLocation(GLuint program, const GLchar* name);
 #if !OS(MAC_OS_X)
     GLint glGetUniformLocation(GLuint, const GLchar*);
@@ -85 +90 @@
         return;
     WTFReportError(__FILE__, line, WTF_PRETTY_FUNCTION, "[TextureMapper GL] Command failed: %s (%x)\n", command, err);
+    ASSERT_NOT_REACHED();
 }
 
@@ -95 +101 @@
 #endif
 
-static const GLuint gInVertexAttributeIndex = 0;
-
 struct TextureMapperGLData {
-    static struct ShaderInfo {
+    static struct GlobalGLData {
         enum ShaderProgramIndex {
+            NoProgram = -1,
             SimpleProgram,
             OpacityAndMaskProgram,
-            TargetProgram,
+            ClipProgram,
 
             ProgramCount
@@ -120 +125 @@
         struct ProgramInfo {
             GLuint id;
+            GLuint vertexAttrib;
             GLint vars[VariableCount];
         };
@@ -139 +145 @@
             GL_CMD(glAttachShader(programID, vertexShader))
             GL_CMD(glAttachShader(programID, fragmentShader))
-            GL_CMD(glBindAttribLocation(programID, gInVertexAttributeIndex, "InVertex"))
             GL_CMD(glLinkProgram(programID))
+            programs[index].vertexAttrib = glGetAttribLocation(programID, "InVertex");
             programs[index].id = programID;
-#ifdef PRINT_PROGRAM_INFO_LOG
-            char infoLog[1024];
-            int len;
-            GL_CMD(glGetProgramInfoLog(programID, 1024, &len, infoLog));
-            LOG(Graphics, "Compiled program for texture mapper. Log: %s\n", infoLog);
-#endif
         }
 
         ProgramInfo programs[ProgramCount];
 
-    } shaderInfo;
+        int stencilIndex;
+
+        GlobalGLData()
+            : stencilIndex(1)
+        { }
+    } globalGLData;
 
     struct DirectlyCompositedImageRepository {
@@ -159 +164 @@
             int refCount;
         };
-        HashMap<NativeImagePtr, Entry> imageToTexture;
-
-        GLuint findOrCreate(NativeImagePtr image, bool& found)
+        typedef HashMap<ImageUID, Entry> ImageTextureMap;
+        ImageTextureMap imageToTexture;
+
+        GLuint findOrCreate(ImageUID image, bool& found)
         {
-            HashMap<NativeImagePtr, Entry>::iterator it = imageToTexture.find(image);
+            ImageTextureMap::iterator it = imageToTexture.find(image);
             found = false;
             if (it != imageToTexture.end()) {
@@ -177 +183 @@
         }
 
-        bool deref(NativeImagePtr image)
+        bool deref(ImageUID image)
         {
-            HashMap<NativeImagePtr, Entry>::iterator it = imageToTexture.find(image);
+            HashMap<ImageUID, Entry>::iterator it = imageToTexture.find(image);
             if (it != imageToTexture.end()) {
                 if (it->second.refCount < 2) {
@@ -195 +201 @@
         ~DirectlyCompositedImageRepository()
         {
-            for (HashMap<NativeImagePtr, Entry>::iterator it = imageToTexture.begin(); it != imageToTexture.end(); ++it) {
+            for (ImageTextureMap::iterator it = imageToTexture.begin(); it != imageToTexture.end(); ++it) {
                 GLuint texture = it->second.texture;
                 if (texture)
@@ -205 +211 @@
 
     TextureMapperGLData()
-        : currentProgram(TextureMapperGLData::ShaderInfo::TargetProgram)
+        : currentProgram(TextureMapperGLData::GlobalGLData::NoProgram)
     { }
 
     TransformationMatrix projectionMatrix;
     int currentProgram;
-
-#if OS(MAC_OS_X)
-    AGLContext aglContext;
-#elif OS(UNIX)
-    Drawable glxDrawable;
-    GLXContext glxContext;
-#endif
+    int previousProgram;
 };
 
-TextureMapperGLData::ShaderInfo TextureMapperGLData::shaderInfo;
+TextureMapperGLData::GlobalGLData TextureMapperGLData::globalGLData;
 
 class BitmapTextureGL : public BitmapTexture {
@@ -227 +227 @@
     virtual bool isValid() const;
     virtual void reset(const IntSize&, bool opaque);
+    void bind();
     virtual PlatformGraphicsContext* beginPaint(const IntRect& dirtyRect);
     virtual void endPaint();
     virtual void setContentsToImage(Image*);
     ~BitmapTextureGL() { destroy(); }
+    virtual uint32_t id() const { return m_id; }
+    inline bool isOpaque() const { return m_opaque; }
+    inline FloatSize relativeSize() const { return m_relativeSize; }
+    void setTextureMapper(TextureMapperGL* texmap) { m_textureMapper = texmap; }
+
+    void pack()
+    {
+        // This is currently a stub.
+        if (isPacked())
+            return;
+        m_isPacked = true;
+    }
+
+    void unpack()
+    {
+        // This is currently a stub.
+        if (!isPacked())
+            return;
+        m_isPacked = false;
+    }
+
+    bool isPacked() const
+    {
+        return m_isPacked;
+    }
 
 private:
     GLuint m_id;
-    NativeImagePtr m_image;
+    ImageUID m_imageUID;
     FloatSize m_relativeSize;
     bool m_opaque;
@@ -241 +267 @@
     IntRect m_dirtyRect;
     GLuint m_fbo;
+    GLuint m_rbo;
     IntSize m_actualSize;
     bool m_surfaceNeedsReset;
+    bool m_isPacked;
     TextureMapperGL* m_textureMapper;
     BitmapTextureGL()
         : m_id(0)
-        , m_image(0)
+        , m_imageUID(0)
         , m_opaque(false)
         , m_fbo(0)
+        , m_rbo(0)
         , m_surfaceNeedsReset(true)
         , m_textureMapper(0)
@@ -258 +287 @@
 
 #define TEXMAP_GET_SHADER_VAR_LOCATION(prog, var) \
-    if (TextureMapperGLData::shaderInfo.getUniformLocation(TextureMapperGLData::shaderInfo.prog##Program, TextureMapperGLData::shaderInfo.var##Variable, #var) < 0) \
+    if (TextureMapperGLData::globalGLData.getUniformLocation(TextureMapperGLData::globalGLData.prog##Program, TextureMapperGLData::globalGLData.var##Variable, #var) < 0) \
             LOG_ERROR("Couldn't find variable "#var" in program "#prog"\n");
 
 #define TEXMAP_BUILD_SHADER(program) \
-    TextureMapperGLData::shaderInfo.createShaderProgram(vertexShaderSource##program, fragmentShaderSource##program, TextureMapperGLData::shaderInfo.program##Program);
+    TextureMapperGLData::globalGLData.createShaderProgram(vertexShaderSource##program, fragmentShaderSource##program, TextureMapperGLData::globalGLData.program##Program);
 
 TextureMapperGL::TextureMapperGL()
     : m_data(new TextureMapperGLData)
 {
+}
+
+void TextureMapperGL::initializeShaders()
+{
     static bool shadersCompiled = false;
-    obtainCurrentContext();
     if (shadersCompiled)
         return;
@@ -326 +358 @@
 "               }                                                           \n";
 
-    const char* fragmentShaderSourceTarget =
-            OES2_PRECISION_DEFINITIONS
-"               uniform sampler2D SourceTexture;                                            \n"
-"               uniform lowp float Opacity;                                                 \n"
-"               varying highp vec2 OutTexCoordSource;                                       \n"
-"               void main(void)                                                             \n"
-"               {                                                                           \n"
-"                   lowp vec4 color = texture2D(SourceTexture, OutTexCoordSource);          \n"
-"                   gl_FragColor = vec4(color.bgr * Opacity, color.a * Opacity);            \n"
-"               }                                                                           \n";
-
-    const char* vertexShaderSourceTarget = vertexShaderSourceSimple;
+    const char* fragmentShaderSourceClip =
+"               void main(void) { gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0); }                                ";
+
+    const char* vertexShaderSourceClip =
+"               uniform mat4 InMatrix;                                      \n"
+"               attribute vec4 InVertex;                                    \n"
+"               void main(void) { gl_Position = InMatrix * InVertex; }      ";
+
 
     TEXMAP_BUILD_SHADER(Simple)
     TEXMAP_BUILD_SHADER(OpacityAndMask)
-    TEXMAP_BUILD_SHADER(Target)
+    TEXMAP_BUILD_SHADER(Clip)
 
     TEXMAP_GET_SHADER_VAR_LOCATION(OpacityAndMask, InMatrix)
@@ -355 +383 @@
     TEXMAP_GET_SHADER_VAR_LOCATION(Simple, Opacity)
 
-    TEXMAP_GET_SHADER_VAR_LOCATION(Target, InSourceMatrix)
-    TEXMAP_GET_SHADER_VAR_LOCATION(Target, InMatrix)
-    TEXMAP_GET_SHADER_VAR_LOCATION(Target, SourceTexture)
-    TEXMAP_GET_SHADER_VAR_LOCATION(Target, Opacity)
-}
-
-void TextureMapperGL::drawTexture(const BitmapTexture& texture, const IntRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture)
+    TEXMAP_GET_SHADER_VAR_LOCATION(Clip, InMatrix)
+}
+
+void TextureMapperGL::beginPainting()
+{
+#if PLATFORM(QT)
+    glGetIntegerv(GL_CURRENT_PROGRAM, &m_data->previousProgram);
+    QPainter* painter = m_context->platformContext();
+    painter->save();
+    painter->beginNativePainting();
+    glClearStencil(0);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    bindSurface(0);
+#endif
+    initializeShaders();
+}
+
+void TextureMapperGL::endPainting()
+{
+#if PLATFORM(QT)
+    glClearStencil(1);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    QPainter* painter = m_context->platformContext();
+    glUseProgram(m_data->previousProgram);
+    painter->endNativePainting();
+    painter->restore();
+#endif
+}
+
+
+void TextureMapperGL::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, const BitmapTexture* mask)
 {
     if (!texture.isValid())
         return;
-
     const BitmapTextureGL& textureGL = static_cast<const BitmapTextureGL&>(texture);
-
-    TextureMapperGLData::ShaderInfo::ShaderProgramIndex program;
+    drawTexture(textureGL.id(), textureGL.isOpaque(), textureGL.relativeSize(), targetRect, matrix, opacity, mask, false);
+}
+
+void TextureMapperGL::drawTexture(uint32_t texture, bool opaque, const FloatSize& relativeSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture, bool flip)
+{
+    TextureMapperGLData::GlobalGLData::ShaderProgramIndex program;
     if (maskTexture)
-        program = TextureMapperGLData::ShaderInfo::OpacityAndMaskProgram;
+        program = TextureMapperGLData::GlobalGLData::OpacityAndMaskProgram;
     else
-        program = TextureMapperGLData::ShaderInfo::SimpleProgram;
-
-    const TextureMapperGLData::ShaderInfo::ProgramInfo& programInfo = data().shaderInfo.programs[program];
-    if (data().currentProgram != program) {
-        GL_CMD(glUseProgram(programInfo.id))
-        GL_CMD(glDisableVertexAttribArray(gInVertexAttributeIndex))
-        data().currentProgram = program;
-        GL_CMD(glEnableVertexAttribArray(gInVertexAttributeIndex))
-    }
-
-    GL_CMD(glDisable(GL_DEPTH_TEST))
-    GL_CMD(glDisable(GL_STENCIL_TEST))
-
+        program = TextureMapperGLData::GlobalGLData::SimpleProgram;
+
+    const TextureMapperGLData::GlobalGLData::ProgramInfo& programInfo = data().globalGLData.programs[program];
+    GL_CMD(glUseProgram(programInfo.id))
+    data().currentProgram = program;
+    GL_CMD(glEnableVertexAttribArray(programInfo.vertexAttrib))
     GL_CMD(glActiveTexture(GL_TEXTURE0))
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, textureGL.m_id))
+    GL_CMD(glBindTexture(GL_TEXTURE_2D, texture))
     GL_CMD(glBindBuffer(GL_ARRAY_BUFFER, 0))
     const GLfloat unitRect[] = {0, 0, 1, 0, 1, 1, 0, 1};
-    GL_CMD(glVertexAttribPointer(gInVertexAttributeIndex, 2, GL_FLOAT, GL_FALSE, 0, unitRect))
+    GL_CMD(glVertexAttribPointer(programInfo.vertexAttrib, 2, GL_FLOAT, GL_FALSE, 0, unitRect))
 
     TransformationMatrix matrix = TransformationMatrix(data().projectionMatrix).multiply(modelViewMatrix).multiply(TransformationMatrix(
@@ -403 +451 @@
         matrix.m41(), matrix.m42(), matrix.m43(), matrix.m44()
     };
-    const GLfloat m4src[] = {textureGL.m_relativeSize.width(), 0, 0, 0,
-                                     0, textureGL.m_relativeSize.height(), 0, 0,
+    const GLfloat m4src[] = {relativeSize.width(), 0, 0, 0,
+                                     0, relativeSize.height() * (flip ? -1 : 1), 0, 0,
                                      0, 0, 1, 0,
-                                     0, 0, 0, 1};
-    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::ShaderInfo::InMatrixVariable], 1, GL_FALSE, m4))
-    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::ShaderInfo::InSourceMatrixVariable], 1, GL_FALSE, m4src))
-    GL_CMD(glUniform1i(programInfo.vars[TextureMapperGLData::ShaderInfo::SourceTextureVariable], 0))
-    GL_CMD(glUniform1f(programInfo.vars[TextureMapperGLData::ShaderInfo::OpacityVariable], opacity))
+                                     0, flip ? relativeSize.height() : 0, 0, 1};
+
+    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::GlobalGLData::InMatrixVariable], 1, GL_FALSE, m4))
+    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::GlobalGLData::InSourceMatrixVariable], 1, GL_FALSE, m4src))
+    GL_CMD(glUniform1i(programInfo.vars[TextureMapperGLData::GlobalGLData::SourceTextureVariable], 0))
+    GL_CMD(glUniform1f(programInfo.vars[TextureMapperGLData::GlobalGLData::OpacityVariable], opacity))
 
     if (maskTexture && maskTexture->isValid()) {
         const BitmapTextureGL* maskTextureGL = static_cast<const BitmapTextureGL*>(maskTexture);
         GL_CMD(glActiveTexture(GL_TEXTURE1))
-        GL_CMD(glBindTexture(GL_TEXTURE_2D, maskTextureGL->m_id))
-        const GLfloat m4mask[] = {maskTextureGL->m_relativeSize.width(), 0, 0, 0,
-                                         0, maskTextureGL->m_relativeSize.height(), 0, 0,
+        GL_CMD(glBindTexture(GL_TEXTURE_2D, maskTextureGL->id()))
+        const GLfloat m4mask[] = {maskTextureGL->relativeSize().width(), 0, 0, 0,
+                                         0, maskTextureGL->relativeSize().height(), 0, 0,
                                          0, 0, 1, 0,
                                          0, 0, 0, 1};
-        GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::ShaderInfo::InMaskMatrixVariable], 1, GL_FALSE, m4mask));
-        GL_CMD(glUniform1i(programInfo.vars[TextureMapperGLData::ShaderInfo::MaskTextureVariable], 1))
+        GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::GlobalGLData::InMaskMatrixVariable], 1, GL_FALSE, m4mask));
+        GL_CMD(glUniform1i(programInfo.vars[TextureMapperGLData::GlobalGLData::MaskTextureVariable], 1))
         GL_CMD(glActiveTexture(GL_TEXTURE0))
     }
 
-    if (textureGL.m_opaque && opacity > 0.99 && !maskTexture)
+    if (opaque && opacity > 0.99 && !maskTexture)
         GL_CMD(glDisable(GL_BLEND))
     else {
@@ -432 +481 @@
     }
 
+    GL_CMD(glDisable(GL_DEPTH_TEST))
     GL_CMD(glDrawArrays(GL_TRIANGLE_FAN, 0, 4))
+    GL_CMD(glDisableVertexAttribArray(programInfo.vertexAttrib))
 }
 
@@ -443 +494 @@
 {
     BitmapTexture::reset(newSize, opaque);
-    m_image = 0;
+    m_imageUID = 0;
     IntSize newTextureSize = nextPowerOfTwo(newSize);
     bool justCreated = false;
@@ -479 +530 @@
     m_buffer->endPaint();
     GL_CMD(glBindTexture(GL_TEXTURE_2D, m_id))
-    GL_CMD(glTexSubImage2D(GL_TEXTURE_2D, 0, m_dirtyRect.x(), m_dirtyRect.y(), m_dirtyRect.width(), m_dirtyRect.height(), GL_RGBA, GL_UNSIGNED_BYTE, m_buffer->data()))
+    GL_CMD(glTexSubImage2D(GL_TEXTURE_2D, 0, m_dirtyRect.x(), m_dirtyRect.y(), m_dirtyRect.width(), m_dirtyRect.height(), GL_BGRA, GL_UNSIGNED_BYTE, m_buffer->data()))
     m_buffer.clear();
 }
@@ -485 +536 @@
 void BitmapTextureGL::setContentsToImage(Image* image)
 {
-    NativeImagePtr nativeImage = image ? image->nativeImageForCurrentFrame() : 0;
-    if (!image || !nativeImage) {
-        if (m_image)
+    ImageUID uid = image ? uidForImage(image) : 0;
+    if (!image || !uid) {
+        if (m_imageUID)
             destroy();
         return;
     }
 
-    if (nativeImage == m_image)
+    if (uid == m_imageUID)
         return;
     bool found = false;
-    GLuint newTextureID = m_textureMapper->data().directlyCompositedImages.findOrCreate(nativeImage, found);
+    GLuint newTextureID = m_textureMapper->data().directlyCompositedImages.findOrCreate(uid, found);
     if (newTextureID != m_id) {
+        m_imageUID = uid;
         destroy();
         m_id = newTextureID;
         reset(image->size(), false);
-        m_image = nativeImage;
         if (!found) {
             GraphicsContext context(beginPaint(IntRect(0, 0, m_textureSize.width(), m_textureSize.height())));
@@ -509 +560 @@
 }
 
+static inline TransformationMatrix createProjectionMatrix(const IntSize& size, bool flip)
+{
+    const float near = 9999999;
+    const float far = -99999;
+
+    return TransformationMatrix(2.0 / float(size.width()), 0, 0, 0,
+                                0, (flip ? -2.0 : 2.0) / float(size.height()), 0, 0,
+                                0, 0, -2.f / (far - near), 0,
+                                -1, flip ? 1 : -1, -(far + near) / (far - near), 1);
+}
+
+void BitmapTextureGL::bind()
+{
+    int& stencilIndex = TextureMapperGLData::globalGLData.stencilIndex;
+    if (m_surfaceNeedsReset || !m_fbo) {
+        if (!m_fbo)
+            GL_CMD(glGenFramebuffers(1, &m_fbo))
+        if (!m_rbo)
+            GL_CMD(glGenRenderbuffers(1, &m_rbo));
+        GL_CMD(glBindRenderbuffer(GL_RENDERBUFFER, m_rbo))
+#ifdef TEXMAP_OPENGL_ES_2
+        GL_CMD(glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, m_textureSize.width(), m_textureSize.height()))
+#else
+        GL_CMD(glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, m_textureSize.width(), m_textureSize.height()))
+#endif
+        GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo))
+        GL_CMD(glBindTexture(GL_TEXTURE_2D, 0))
+        GL_CMD(glBindRenderbuffer(GL_RENDERBUFFER, 0))
+        GL_CMD(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id(), 0))
+        GL_CMD(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_rbo))
+#if CPU(X86)
+        GL_CMD(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_rbo));
+#endif
+        GL_CMD(glClearColor(0, 0, 0, 0))
+        GL_CMD(glClearStencil(stencilIndex - 1))
+        GL_CMD(glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT))
+        m_surfaceNeedsReset = false;
+    } else
+        GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo))
+
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+    glStencilFunc(stencilIndex > 1 ? GL_GEQUAL : GL_ALWAYS, stencilIndex - 1, stencilIndex - 1);
+    GL_CMD(glViewport(0, 0, size().width(), size().height()))
+    m_textureMapper->data().projectionMatrix = createProjectionMatrix(size(), false);
+    glDisable(GL_SCISSOR_TEST);
+}
+
 void BitmapTextureGL::destroy()
 {
-    if (m_id && (!m_image || !m_textureMapper->data().directlyCompositedImages.deref(m_image)))
+    if (m_id && (!m_imageUID || !m_textureMapper->data().directlyCompositedImages.deref(m_imageUID)))
         GL_CMD(glDeleteTextures(1, &m_id))
+
     if (m_fbo)
         GL_CMD(glDeleteFramebuffers(1, &m_fbo))
+
+    if (m_rbo)
+        GL_CMD(glDeleteRenderbuffers(1, &m_rbo))
 
     m_fbo = 0;
@@ -532 +634 @@
 }
 
-static inline TransformationMatrix createProjectionMatrix(const IntSize& size, bool flip)
-{
-    return TransformationMatrix(2.0 / float(size.width()), 0, 0, 0,
-                                0, (flip ? -2.0 : 2.0) / float(size.height()), 0, 0,
-                                0, 0, -0.000001, 0,
-                                -1, flip ? 1 : -1, 0, 1);
-}
-
 TextureMapperGL::~TextureMapperGL()
 {
-    makeContextCurrent();
     delete m_data;
 }
 
-bool TextureMapperGL::makeContextCurrent()
-{
-#if OS(MAC_OS_X)
-    return aglSetCurrentContext(data().aglContext);
-#elif OS(UNIX)
-    Display* display = XOpenDisplay(0);
-    if (!display)
-        return false;
-    return glXMakeCurrent(display, data().glxDrawable, data().glxContext);
-#endif
-}
-
-void TextureMapperGL::obtainCurrentContext()
-{
-#if OS(MAC_OS_X)
-    data().aglContext = aglGetCurrentContext();
-#elif OS(UNIX)
-    data().glxDrawable = glXGetCurrentDrawable();
-    data().glxContext = glXGetCurrentContext();
-#endif
-}
-
 void TextureMapperGL::bindSurface(BitmapTexture *surfacePointer)
 {
     BitmapTextureGL* surface = static_cast<BitmapTextureGL*>(surfacePointer);
 
-    if (!surface)
+    if (!surface) {
+        GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, 0))
+        data().projectionMatrix = createProjectionMatrix(viewportSize(), true).multiply(transform());
+        GL_CMD(glStencilFunc(data().globalGLData.stencilIndex > 1 ? GL_EQUAL : GL_ALWAYS, data().globalGLData.stencilIndex - 1, data().globalGLData.stencilIndex - 1))
+        GL_CMD(glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP))
+        GL_CMD(glViewport(0, 0, viewportSize().width(), viewportSize().height()))
         return;
-
-    TransformationMatrix matrix = createProjectionMatrix(surface->size(), false);
-    matrix.translate(-surface->offset().x(), -surface->offset().y());
-
-    if (surface->m_surfaceNeedsReset || !surface->m_fbo) {
-        if (!surface->m_fbo)
-            GL_CMD(glGenFramebuffers(1, &surface->m_fbo))
-        GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, surface->m_fbo))
-        GL_CMD(glBindTexture(GL_TEXTURE_2D, 0))
-        GL_CMD(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, surface->m_id, 0))
-        GL_CMD(glClearColor(0, 0, 0, 0))
-        GL_CMD(glClear(GL_COLOR_BUFFER_BIT))
-        surface->m_surfaceNeedsReset = false;
-    } else {
-        GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, surface->m_fbo))
-    }
-
-    GL_CMD(glViewport(0, 0, surface->size().width(), surface->size().height()))
-    data().projectionMatrix = matrix;
-}
-
-void TextureMapperGL::setClip(const IntRect& rect)
-{
-    GL_CMD(glScissor(rect.x(), rect.y(), rect.width(), rect.height()))
-    GL_CMD(glEnable(GL_SCISSOR_TEST))
-}
-
-
-void TextureMapperGL::paintToTarget(const BitmapTexture& aSurface, const IntSize& surfaceSize, const TransformationMatrix& transform, float opacity, const IntRect& visibleRect)
-{
-    const BitmapTextureGL& surface = static_cast<const BitmapTextureGL&>(aSurface);
-
-    // Create the model-view-projection matrix to display on screen.
-    TransformationMatrix matrix = createProjectionMatrix(surfaceSize, true).multiply(transform).multiply(
-                TransformationMatrix(
-                        surface.m_actualSize.width(), 0, 0, 0,
-                        0, surface.m_actualSize.height(), 0, 0,
-                        0, 0, 1, 0,
-                        surface.offset().x(), surface.offset().y(), 0, 1)
-            );
+    }
+
+    surface->bind();
+}
+
+void TextureMapperGL::beginClip(const TransformationMatrix& modelViewMatrix, const FloatRect& targetRect)
+{
+    TextureMapperGLData::GlobalGLData::ShaderProgramIndex program = TextureMapperGLData::GlobalGLData::ClipProgram;
+    const TextureMapperGLData::GlobalGLData::ProgramInfo& programInfo = data().globalGLData.programs[program];
+    GL_CMD(glUseProgram(programInfo.id))
+    GL_CMD(glEnableVertexAttribArray(programInfo.vertexAttrib))
+    const GLfloat unitRect[] = {0, 0, 1, 0, 1, 1, 0, 1};
+    GL_CMD(glVertexAttribPointer(programInfo.vertexAttrib, 2, GL_FLOAT, GL_FALSE, 0, unitRect))
+
+    TransformationMatrix matrix = TransformationMatrix(data().projectionMatrix)
+            .multiply(modelViewMatrix)
+            .multiply(TransformationMatrix(targetRect.width(), 0, 0, 0,
+                0, targetRect.height(), 0, 0,
+                0, 0, 1, 0,
+                targetRect.x(), targetRect.y(), 0, 1));
 
     const GLfloat m4[] = {
@@ -622 +678 @@
     };
 
-    const GLfloat m4src[] = {surface.m_relativeSize.width(), 0, 0, 0,
-                                     0, surface.m_relativeSize.height(), 0, 0,
-                                     0, 0, 1, 0,
-                                     0, 0, 0, 1};
-
-    // We already blended the alpha in; the result is premultiplied.
-    GL_CMD(glUseProgram(data().shaderInfo.programs[TextureMapperGLData::ShaderInfo::TargetProgram].id))
-    GL_CMD(glBindFramebuffer(GL_FRAMEBUFFER, 0))
-    GL_CMD(glViewport(0, 0, surfaceSize.width(), surfaceSize.height()))
-    GL_CMD(glDisable(GL_STENCIL_TEST))
-    const TextureMapperGLData::ShaderInfo::ProgramInfo& programInfo = data().shaderInfo.programs[TextureMapperGLData::ShaderInfo::TargetProgram];
-    GL_CMD(glUniform1f(programInfo.vars[TextureMapperGLData::ShaderInfo::OpacityVariable], opacity))
-    GL_CMD(glActiveTexture(GL_TEXTURE0))
-    GL_CMD(glBindTexture(GL_TEXTURE_2D, surface.m_id))
-    GL_CMD(glUniform1i(programInfo.vars[TextureMapperGLData::ShaderInfo::SourceTextureVariable], 0))
-    GL_CMD(glEnableVertexAttribArray(gInVertexAttributeIndex))
-    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::ShaderInfo::InMatrixVariable], 1, GL_FALSE, m4))
-    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::ShaderInfo::InSourceMatrixVariable], 1, GL_FALSE, m4src))
-    GL_CMD(glBindBuffer(GL_ARRAY_BUFFER, 0))
-    const GLfloat unitRect[] = {0, 0, 1, 0, 1, 1, 0, 1};
-    GL_CMD(glVertexAttribPointer(gInVertexAttributeIndex, 2, GL_FLOAT, GL_FALSE, 0, unitRect))
-    GL_CMD(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA))
-    GL_CMD(glEnable(GL_BLEND))
-    setClip(visibleRect);
-
+    int& stencilIndex = data().globalGLData.stencilIndex;
+
+    GL_CMD(glUniformMatrix4fv(programInfo.vars[TextureMapperGLData::GlobalGLData::InMatrixVariable], 1, GL_FALSE, m4))
+    GL_CMD(glEnable(GL_STENCIL_TEST))
+    GL_CMD(glStencilFunc(GL_NEVER, stencilIndex, stencilIndex))
+    GL_CMD(glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE))
+    GL_CMD(glStencilMask(0xff & ~(stencilIndex - 1)))
     GL_CMD(glDrawArrays(GL_TRIANGLE_FAN, 0, 4))
-    GL_CMD(glDisableVertexAttribArray(0))
-    GL_CMD(glUseProgram(0))
-    GL_CMD(glBindBuffer(GL_ARRAY_BUFFER, 0))
-    data().currentProgram = TextureMapperGLData::ShaderInfo::TargetProgram;
+    GL_CMD(glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP))
+    stencilIndex <<= 1;
+    glStencilFunc(stencilIndex > 1 ? GL_EQUAL : GL_ALWAYS, stencilIndex - 1, stencilIndex - 1);
+}
+
+void TextureMapperGL::endClip()
+{
+    data().globalGLData.stencilIndex >>= 1;
+    glStencilFunc(data().globalGLData.stencilIndex > 1 ? GL_EQUAL : GL_ALWAYS, data().globalGLData.stencilIndex - 1, data().globalGLData.stencilIndex - 1);
 }
 
@@ -657 +700 @@
 {
     BitmapTextureGL* texture = new BitmapTextureGL();
-    texture->m_textureMapper = this;
+    texture->setTextureMapper(this);
     return adoptRef(texture);
 }

trunk/Source/WebCore/platform/graphics/opengl/TextureMapperGL.h

@@ -31 +31 @@
 
 class TextureMapperGLData;
+class GraphicsContext;
 
 // An OpenGL-ES2 implementation of TextureMapper.
@@ -39 +40 @@
 
     // reimps from TextureMapper
-    virtual void drawTexture(const BitmapTexture& texture, const IntRect&, const TransformationMatrix& transform, float opacity, const BitmapTexture* maskTexture);
+    virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, const BitmapTexture* maskTexture);
+    virtual void drawTexture(uint32_t texture, bool opaque, const FloatSize&, const FloatRect&, const TransformationMatrix&, float opacity, const BitmapTexture* maskTexture, bool flip);
     virtual void bindSurface(BitmapTexture* surface);
-    virtual void setClip(const IntRect&);
-    virtual void paintToTarget(const BitmapTexture&, const IntSize&, const TransformationMatrix&, float opacity, const IntRect& visibleRect);
-    virtual bool allowSurfaceForRoot() const { return true; }
+    virtual void beginClip(const TransformationMatrix&, const FloatRect&);
+    virtual void endClip();
+    virtual bool allowSurfaceForRoot() const { return false; }
     virtual PassRefPtr<BitmapTexture> createTexture();
     virtual const char* type() const;
-    void obtainCurrentContext();
-    bool makeContextCurrent();
-    static PassOwnPtr<TextureMapperGL> create()
-    {
-        return new TextureMapperGL;
-    }
+    static PassOwnPtr<TextureMapperGL> create() { return adoptPtr(new TextureMapperGL); }
+    void beginPainting();
+    void endPainting();
+    void setGraphicsContext(GraphicsContext* context) { m_context = context; }
+    GraphicsContext* graphicsContext() { return m_context; }
+    virtual bool isOpenGLBacked() const { return true; }
 
 private:
+    void initializeShaders();
     inline TextureMapperGLData& data() { return *m_data; }
     TextureMapperGLData* m_data;
+    GraphicsContext* m_context;
     friend class BitmapTextureGL;
 };
@@ -85 +89 @@
 }
 
+typedef uint64_t ImageUID;
+ImageUID uidForImage(Image*);
+
 };
 

trunk/Source/WebCore/platform/graphics/qt/GraphicsContext3DQt.cpp

@@ -39 +39 @@
 #include <wtf/UnusedParam.h>
 #include <wtf/text/CString.h>
+
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#include <opengl/TextureMapperGL.h>
+#endif
 
 #if ENABLE(WEBGL)
@@ -155 +159 @@
 typedef void (APIENTRY* glVertexAttribPointerType) (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid*);
 
-class GraphicsContext3DInternal : public QGraphicsObject {
+class GraphicsContext3DInternal
+#if USE(ACCELERATED_COMPOSITING)
+#if USE(TEXTURE_MAPPER)
+        : public TextureMapperPlatformLayer
+#else
+        : public QGraphicsObject
+#endif
+#endif
+{
 public:
     GraphicsContext3DInternal(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow);
@@ -164 +176 @@
     QGLWidget* getViewportGLWidget();
     void reshape(int width, int height);
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+    virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity, BitmapTexture* mask) const;
+#endif
+
     void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*);
     QRectF boundingRect() const;
@@ -534 +550 @@
 }
 
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+void GraphicsContext3DInternal::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, BitmapTexture* mask) const
+{
+    if (textureMapper->isOpenGLBacked()) {
+        TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);
+        texmapGL->drawTexture(m_texture, !m_attrs.alpha, FloatSize(1, 1), targetRect, matrix, opacity, mask, true /* flip */);
+        return;
+    }
+
+    GraphicsContext* context = textureMapper->graphicsContext();
+    QPainter* painter = context->platformContext();
+    painter->save();
+    painter->setTransform(matrix);
+    painter->setOpacity(opacity);
+
+    // Alternatively read pixels to a memory buffer.
+    QImage offscreenImage(m_boundingRect.width(), m_boundingRect.height(), QImage::Format_ARGB32);
+    quint32* imagePixels = reinterpret_cast<quint32*>(offscreenImage.bits());
+
+    m_glWidget->makeCurrent();
+    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_canvasFbo);
+    glReadPixels(/* x */ 0, /* y */ 0, m_boundingRect.width(), m_boundingRect.height(), GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, imagePixels);
+
+    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_currentFbo);
+
+    // OpenGL gives us ABGR on 32 bits, and with the origin at the bottom left
+    // We need RGB32 or ARGB32_PM, with the origin at the top left.
+    quint32* pixelsSrc = imagePixels;
+    const int height = static_cast<int>(m_boundingRect.height());
+    const int width = static_cast<int>(m_boundingRect.width());
+    const int halfHeight = height / 2;
+    for (int row = 0; row < halfHeight; ++row) {
+        const int targetIdx = (height - 1 - row) * width;
+        quint32* pixelsDst = imagePixels + targetIdx;
+        for (int column = 0; column < width; ++column) {
+            quint32 tempPixel = *pixelsSrc;
+            *pixelsSrc = swapBgrToRgb(*pixelsDst);
+            *pixelsDst = swapBgrToRgb(tempPixel);
+            ++pixelsSrc;
+            ++pixelsDst;
+        }
+    }
+    if (static_cast<int>(height) % 2) {
+        for (int column = 0; column < width; ++column) {
+            *pixelsSrc = swapBgrToRgb(*pixelsSrc);
+            ++pixelsSrc;
+        }
+    }
+
+    painter->drawImage(targetRect, offscreenImage);
+    painter->restore();
+}
+#endif // USE(ACCELERATED_COMPOSITING)
+
+QRectF GraphicsContext3DInternal::boundingRect() const
+{
+    return m_boundingRect;
+}
+
 void GraphicsContext3DInternal::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget)
 {
@@ -581 +656 @@
         }
     }
+
     painter->drawImage(/* x */ 0, /* y */ 0, offscreenImage);
-}
-
-QRectF GraphicsContext3DInternal::boundingRect() const
-{
-    return m_boundingRect;
 }
 
@@ -636 +707 @@
 }
 
+#if USE(ACCELERATED_COMPOSITING)
 PlatformLayer* GraphicsContext3D::platformLayer() const
 {
     return m_internal.get();
 }
+#endif
 
 void GraphicsContext3D::makeContextCurrent()

trunk/Source/WebCore/platform/graphics/qt/MediaPlayerPrivateQt.cpp

@@ -23 +23 @@
 #include "FrameView.h"
 #include "GraphicsContext.h"
+#include "GraphicsLayer.h"
 #include "HTMLMediaElement.h"
 #include "HTMLVideoElement.h"
@@ -51 +52 @@
 #include <wtf/text/CString.h>
 
-#if USE(ACCELERATED_COMPOSITING)
-#include "texmap/TextureMapperPlatformLayer.h"
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#include "texmap/TextureMapper.h"
 #endif
 
@@ -604 +605 @@
 {
     m_webCorePlayer->repaint();
+
 }
 
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-
-class TextureMapperVideoLayerQt : public virtual TextureMapperMediaLayer {
-public:
-    TextureMapperVideoLayerQt(QGraphicsVideoItem* videoItem)
-        : m_videoItem(videoItem)
-    {
-    }
-
-    virtual void setPlatformLayerClient(TextureMapperLayerClient* client)
-    {
-        m_client = client;
-    }
-
-    virtual void paint(GraphicsContext* context)
-    {
-        if (!m_videoItem)
-            return;
-
-        QStyleOptionGraphicsItem opt;
-        opt.exposedRect = m_videoItem.data()->sceneBoundingRect();
-        opt.rect = opt.exposedRect.toRect();
-        m_videoItem.data()->paint(context->platformContext(), &opt);
-    }
-
-    virtual IntSize size() const
-    {
-        return m_videoItem ? IntSize(m_videoItem.data()->size().width(), m_videoItem.data()->size().height()) : IntSize();
-    }
-
-    QWeakPointer<QGraphicsVideoItem> m_videoItem;
-    TextureMapperLayerClient* m_client;
-};
-
-
-void MediaPlayerPrivateQt::acceleratedRenderingStateChanged()
-{
-    MediaPlayerClient* client = m_webCorePlayer->mediaPlayerClient();
-    bool composited = client->mediaPlayerRenderingCanBeAccelerated(m_webCorePlayer);
-    if (composited == m_composited)
-        return;
-
-    m_composited = composited;
-    if (composited)
-        m_platformLayer = new TextureMapperVideoLayerQt(m_videoItem);
-}
-
-PlatformLayer* MediaPlayerPrivateQt::platformLayer() const
-{
-    return m_composited ? m_platformLayer.get() : 0;
+void MediaPlayerPrivateQt::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, BitmapTexture*) const
+{
+        GraphicsContext* context = textureMapper->graphicsContext();
+        QPainter* painter = context->platformContext();
+        painter->save();
+        painter->setTransform(matrix);
+        painter->setOpacity(opacity);
+        m_videoScene->render(painter, QRectF(targetRect), m_videoItem->sceneBoundingRect());
+        painter->restore();
 }
 #endif

trunk/Source/WebCore/platform/graphics/qt/MediaPlayerPrivateQt.h

@@ -32 +32 @@
 QT_END_NAMESPACE
 
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#include "TextureMapper.h"
+#endif
+
 namespace WebCore {
 
-class TextureMapperMediaLayer;
-
-class MediaPlayerPrivateQt : public QObject, public MediaPlayerPrivateInterface {
+class MediaPlayerPrivateQt : public QObject, public MediaPlayerPrivateInterface
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+        , public TextureMapperPlatformLayer
+#endif
+{
 
     Q_OBJECT
@@ -100 +106 @@
     virtual bool supportsAcceleratedRendering() const { return true; }
     // called when the rendering system flips the into or out of accelerated rendering mode.
-    virtual void acceleratedRenderingStateChanged();
-    // returns an object that can be directly composited via GraphicsLayerQt (essentially a QGraphicsItem*)
-    virtual PlatformLayer* platformLayer() const;
+    virtual void acceleratedRenderingStateChanged() { }
+    // Const-casting here is safe, since all of TextureMapperPlatformLayer's functions are const.g
+    virtual PlatformLayer* platformLayer() const { return const_cast<MediaPlayerPrivateQt*>(this); }
+    virtual void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity, BitmapTexture* mask) const;
 #else
     virtual bool supportsAcceleratedRendering() const { return false; }
@@ -139 +146 @@
     QGraphicsVideoItem* m_videoItem;
     QGraphicsScene* m_videoScene;
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-    OwnPtr<TextureMapperMediaLayer> m_platformLayer;
-#endif
 
     mutable MediaPlayer::NetworkState m_networkState;

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp

@@ -29 +29 @@
     , m_node(adoptPtr(new TextureMapperNode()))
     , m_changeMask(0)
+    , m_animationStartedTimer(this, &GraphicsLayerTextureMapper::animationStartedTimerFired)
 {
 }
@@ -71 +72 @@
     if (m_pendingContent.needsDisplay)
         return;
-    m_pendingContent.needsDisplayRect.unite(IntRect(rect));
+    m_pendingContent.needsDisplayRect.unite(rect);
     notifyChange(TextureMapperNode::DisplayChange);
 }
@@ -320 +321 @@
 }
 
-/* \reimp (GraphicsLayer.h)
-*/
-void GraphicsLayerTextureMapper::setContentsBackgroundColor(const Color& color)
-{
-    notifyChange(TextureMapperNode::ContentChange);
-    m_pendingContent.contentType = TextureMapperNode::ColorContentType;
-    m_pendingContent.backgroundColor = color;
-    GraphicsLayer::setContentsBackgroundColor(color);
-}
-
-
-void GraphicsLayerTextureMapper::setContentsToMedia(PlatformLayer* media)
+void GraphicsLayerTextureMapper::setContentsToMedia(TextureMapperPlatformLayer* media)
 {
     GraphicsLayer::setContentsToMedia(media);
     notifyChange(TextureMapperNode::ContentChange);
     m_pendingContent.contentType = media ? TextureMapperNode::MediaContentType : TextureMapperNode::HTMLContentType;
-    if (media)
-        m_pendingContent.media = static_cast<TextureMapperMediaLayer*>(media);
-    else
-        m_pendingContent.media = 0;
-}
-
-/* \reimp (GraphicsLayer.h)
-*/
-void GraphicsLayerTextureMapper::setContentsOrientation(CompositingCoordinatesOrientation orientation)
-{
-    if (contentsOrientation() == orientation)
-        return;
-    notifyChange(TextureMapperNode::ContentsOrientationChange);
-    GraphicsLayer::setContentsOrientation(orientation);
+    m_pendingContent.media = media;
 }
 
@@ -356 +333 @@
 void GraphicsLayerTextureMapper::syncCompositingStateForThisLayerOnly()
 {
-    m_node->syncCompositingState(this, false);
+    m_node->syncCompositingState(this);
 }
 
@@ -363 +340 @@
 void GraphicsLayerTextureMapper::syncCompositingState()
 {
-    m_node->syncCompositingState(this, true);
+    m_node->syncCompositingState(this, TextureMapperNode::TraverseDescendants);
 }
 
@@ -370 +347 @@
 PlatformLayer* GraphicsLayerTextureMapper::platformLayer() const
 {
-    return m_node.get();
+    return const_cast<TextureMapperPlatformLayer*>(node()->media());
 }
 
@@ -378 +355 @@
 }
 
-}
+bool GraphicsLayerTextureMapper::addAnimation(const KeyframeValueList& valueList, const IntSize& boxSize, const Animation* anim, const String& keyframesName, double timeOffset)
+{
+    ASSERT(!keyframesName.isEmpty());
+
+    if (!anim || anim->isEmptyOrZeroDuration() || valueList.size() < 2 || (valueList.property() != AnimatedPropertyWebkitTransform && valueList.property() != AnimatedPropertyOpacity))
+        return false;
+
+    for (size_t i = 0; i < m_animations.size(); ++i) {
+        // The same animation name can be used for two animations with different properties.
+        if (m_animations[i]->name != keyframesName || m_animations[i]->keyframes.property() != valueList.property())
+            continue;
+
+        // We already have a copy of this animation, that means that we're resuming it rather than adding it.
+        RefPtr<TextureMapperAnimation>& animation = m_animations[i];
+        animation->animation = Animation::create(anim);
+        animation->paused = false;
+        animation->startTime = WTF::currentTime() - timeOffset;
+        notifyChange(TextureMapperNode::AnimationChange);
+        m_animationStartedTimer.startOneShot(0);
+        return true;
+    }
+
+    RefPtr<TextureMapperAnimation> animation = TextureMapperAnimation::create(valueList);
+    animation->boxSize = boxSize;
+    animation->name = keyframesName;
+    animation->animation = Animation::create(anim);
+    animation->paused = false;
+    animation->startTime = WTF::currentTime() - timeOffset;
+
+    if (valueList.property() == AnimatedPropertyWebkitTransform) {
+        bool hasBigRotation; // Not used, but required as a pointer parameter for the function.
+        fetchTransformOperationList(valueList, animation->functionList, animation->listsMatch, hasBigRotation);
+    }
+
+    m_animations.append(animation);
+    notifyChange(TextureMapperNode::AnimationChange);
+    m_animationStartedTimer.startOneShot(0);
+
+    return true;
+}
+
+void GraphicsLayerTextureMapper::pauseAnimation(const String& animationName, double timeOffset)
+{
+    for (size_t i = 0; i < m_animations.size(); ++i) {
+        if (m_animations[i]->name != animationName)
+            continue;
+        m_animations[i]->paused = true;
+        notifyChange(TextureMapperNode::AnimationChange);
+    }
+}
+
+void GraphicsLayerTextureMapper::removeAnimation(const String& animationName)
+{
+    for (int i = m_animations.size() - 1; i >= 0; --i) {
+        // The same animation name can be used for two animations with different properties. We should remove both.
+        if (m_animations[i]->name != animationName)
+            continue;
+        m_animations.remove(i);
+        notifyChange(TextureMapperNode::AnimationChange);
+    }
+}
+
+void GraphicsLayerTextureMapper::animationStartedTimerFired(Timer<GraphicsLayerTextureMapper>*)
+{
+    client()->notifyAnimationStarted(this, /* DOM time */ WTF::currentTime());
+}
+
+}

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h

@@ -46 +46 @@
     // reimps from GraphicsLayer.h
     virtual void setNeedsDisplay();
+    virtual void setContentsNeedsDisplay() { setNeedsDisplay(); };
     virtual void setNeedsDisplayInRect(const FloatRect&);
     virtual void setParent(GraphicsLayer* layer);
@@ -73 +74 @@
     virtual void setContentsToImage(Image*);
     virtual void setContentsToMedia(PlatformLayer*);
-    virtual void setContentsBackgroundColor(const Color&);
-#if ENABLE(WEBGL)
-    virtual void setContentsToGraphicsContext3D(const GraphicsContext3D*);
-    virtual void setGraphicsContext3DNeedsDisplay();
-#endif
-    virtual void setContentsOrientation(CompositingCoordinatesOrientation orientation);
+    virtual void setContentsToCanvas(PlatformLayer* canvas) { setContentsToMedia(canvas); }
     virtual void syncCompositingState();
     virtual void syncCompositingStateForThisLayerOnly();
     virtual void setName(const String& name);
     virtual PlatformLayer* platformLayer() const;
-
-    virtual bool addAnimation(const KeyframeValueList&, const IntSize& /*boxSize*/, const Animation*, const String& /*keyframesName*/, double /*timeOffset*/) { return false; }
 
     void notifyChange(TextureMapperNode::ChangeMask changeMask);
@@ -91 +85 @@
     void didSynchronize();
 
+    virtual bool addAnimation(const KeyframeValueList&, const IntSize&, const Animation*, const String&, double);
+    virtual void pauseAnimation(const String&, double);
+    virtual void removeAnimation(const String&);
+
+    TextureMapperNode* node() const { return m_node.get(); }
+
 private:
     OwnPtr<TextureMapperNode> m_node;
@@ -96 +96 @@
     int m_changeMask;
     TextureMapperNode::ContentData m_pendingContent;
+    Vector<RefPtr<TextureMapperAnimation> > m_animations;
+    void animationStartedTimerFired(Timer<GraphicsLayerTextureMapper>*);
+    Timer<GraphicsLayerTextureMapper> m_animationStartedTimer;
 };
 

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperNode.cpp

@@ -21 +21 @@
 #include "TextureMapperNode.h"
 
+#if USE(ACCELERATED_COMPOSITING)
+
 #include "GraphicsLayerTextureMapper.h"
 
+namespace {
+    static const float gTileDimension = 1024.0;
+}
+
 namespace WebCore {
 
-class TextureMapperCache {
+class TextureMapperSurfaceManager {
 public:
-    void mark(BitmapTexture* texture);
-
-    class Entry {
-    public:
-        RefPtr<BitmapTexture> texture;
-        Entry() : previousCost(0) { }
-        inline int computeCost() const
-        {
-            if (!texture || !texture->isValid() || texture->isPacked())
-                return 0;
-            const IntSize textureSize = texture->size();
-            // An image's cost in bytes is width * height * bytes per pixel (4).
-            return textureSize.width() * textureSize.height() * 4;
-        }
-        Entry(BitmapTexture* newTexture)
-            : texture(newTexture)
-        {
-        }
-        bool operator==(const Entry& other) const { return texture == other.texture; }
-        int previousCost;
-    };
-
-    TextureMapperCache()
-        : m_totalCost(0)
+    TextureMapper* textureMapper;
+    Vector<RefPtr<BitmapTexture> > surfaces;
+    IntSize viewportSize;
+
+    PassRefPtr<BitmapTexture> getIntermediateSurface()
     {
-    }
-
-    void purge();
-    Vector<Entry> m_data;
-    int m_totalCost;
-#ifndef TEXMAP_TEXTURE_CACHE_KBS
-#define TEXMAP_TEXTURE_CACHE_KBS 24 * 1024
-#endif
-    static const int MaxCost = TEXMAP_TEXTURE_CACHE_KBS * 1024;
-    static const int PurgeAmount = MaxCost / 4;
+        IntSize newViewportSize = textureMapper->viewportSize();
+        if (newViewportSize != viewportSize) {
+            viewportSize = newViewportSize;
+            surfaces.clear();
+        }
+        if (surfaces.isEmpty()) {
+            RefPtr<BitmapTexture> newSurface = textureMapper->createTexture();
+            newSurface->reset(viewportSize, false);
+            return newSurface.get();
+        }
+        RefPtr<BitmapTexture> surface = surfaces.last();
+        surface->reset(viewportSize, false);
+        surfaces.removeLast();
+        surface->lock();
+        return surface.get();
+    }
+
+    void releaseIntermediateSurface(BitmapTexture* surface)
+    {
+        if (!surface)
+            return;
+        surfaces.append(surface);
+        surface->unlock();
+    }
 };
 
-
-void TextureMapperCache::purge()
-{
-    const int size = m_data.size();
-
-    if (m_totalCost <= TextureMapperCache::MaxCost)
-        return;
-
-    // Ensure that we have the right count. It might be inaccurate if content changed size.
-    // We only do this when we're actually ready to purge.
-    m_totalCost = 0;
-    for (int i = 0; i < size; ++i)
-        m_totalCost += m_data[i].computeCost();
-
-    for (int i = size-1; i >= 0 && m_totalCost > TextureMapperCache::MaxCost - TextureMapperCache::PurgeAmount; --i) {
-        Entry& entry = m_data[i];
-        if (entry.texture->isLocked() || !entry.texture->isValid() || entry.texture->isPacked())
-            continue;
-        m_totalCost -= entry.previousCost;
-        entry.texture->pack();
-        m_data.remove(i);
-    }
-}
-
-void TextureMapperCache::mark(BitmapTexture* texture)
-{
-    if (!texture || !texture->isValid())
-        return;
-
-    Entry entry(texture);
-    size_t index = m_data.find(entry);
-    if (!index)
-        return;
-
-    int previousCost = 0;
-
-    if (index < m_data.size()) {
-        previousCost = m_data[index].previousCost;
-        m_data.remove(index);
-    }
-    const int cost = entry.computeCost();
-    m_totalCost -= previousCost;
-    m_totalCost += (entry.previousCost = cost);
-    m_data.prepend(entry);
-}
-
-class TextureMapperCacheLock {
-public:
-    TextureMapperCacheLock(BitmapTexture* texture) : m_texture(texture)
-    {
-        if (m_texture)
-            m_texture->lock();
-    }
-    ~TextureMapperCacheLock()
-    {
-        if (m_texture)
-            m_texture->unlock();
-    }
-
-private:
-    RefPtr<BitmapTexture> m_texture;
-};
-
-
-TextureMapperCache* TextureMapperNode::cache()
-{
-    TextureMapperNode* root = rootLayer();
-    if (!root)
-        return 0;
-    if (!root->m_cache)
-        root->m_cache = new TextureMapperCache;
-    return root->m_cache;
-}
-
-void TextureMapperNode::setNeedsDisplayInRect(IntRect rect)
-{
-    if (m_platformClient) {
-        if (m_state.hasSurfaceDescendants) {
-            m_platformClient->setNeedsDisplay();
-            return;
-        }
-        rect.intersect(IntRect(0, 0, m_size.width(), m_size.height()));
-        if (rect.isEmpty())
-            return;
-        m_platformClient->setNeedsDisplayInRect(rect);
-        return;
-    }
-
-    if (!m_parent)
-        return;
-
-    m_parent->setNeedsDisplayInRect(rect);
-}
-
-void TextureMapperNode::setNeedsDisplay()
-{
-    if (m_effectTarget)
-        m_effectTarget->setNeedsDisplay();
-    if (m_transforms.targetBoundingRect.isEmpty())
-        return;
-    if (m_state.drawsContent || m_currentContent.contentType != HTMLContentType)
-        setNeedsDisplayInRect(m_transforms.targetBoundingRect);
-}
-
-void TextureMapperNode::setPlatformLayerClient(TextureMapperLayerClient* client)
-{
-    m_platformClient = client;
-}
-
-int TextureMapperNode::compareGraphicsLayersZValue(const void* a, const void* b)
-{
-    typedef const TextureMapperNode* NodePtr;
-    const NodePtr* nodeA = static_cast<const NodePtr*>(a);
-    const NodePtr* nodeB = static_cast<const NodePtr*>(b);
-    return int(((*nodeA)->m_transforms.centerZ - (*nodeB)->m_transforms.centerZ) * 1000);
-}
-
-void TextureMapperNode::sortByZOrder(Vector<TextureMapperNode* >& array, int first, int last)
-{
-    qsort(array.data(), array.size(), sizeof(TextureMapperNode*), TextureMapperNode::compareGraphicsLayersZValue);
-}
-
-bool TextureMapperNode::hasSurfaceDescendants() const
-{
-    if (m_layerType == ClipLayer || m_layerType == TransparencyLayer || m_state.replicaLayer)
-        return true;
-
-    const int size = m_children.size();
-    for (int i = 0; i < size; ++i) {
-        if (TextureMapperNode* child = m_children[i]) {
-            if (child->hasSurfaceDescendants())
-                return true;
-        }
-    }
-    return false;
-}
-
-int TextureMapperNode::countDescendantsWithContent() const
-{
-    if (!m_state.visible || m_state.opacity < 0.001)
-        return 0;
-
-    int descendantsWithContent = (m_state.drawsContent || m_currentContent.contentType != HTMLContentType) ? 1 : 0;
-
-    const int size = m_children.size();
-    for (int i = 0; i < size; ++i) {
-        if (TextureMapperNode* child = m_children[i])
-            descendantsWithContent += child->countDescendantsWithContent();
-    }
-
-    return descendantsWithContent;
-}
-
-TextureMapperNode* TextureMapperNode::toTextureMapperNode(GraphicsLayer* layer)
-{
-    return layer ? static_cast<TextureMapperNode*>(layer->platformLayer()) : 0;
-}
-
-void TextureMapperNode::computeLayerType()
-{
-    const bool selfHasContent = m_state.drawsContent || (m_currentContent.contentType != HTMLContentType);
-    const bool hasDescendantsWithContent = m_state.descendantsWithContent - (selfHasContent ? 1 : 0);
-    const bool hasTransparency = m_state.opacity < 0.99 || m_state.maskLayer;
-    const bool hasReplica = m_state.replicaLayer;
-
-    //  DefaultLayer: draws itself and its children directly to the current framebuffer.
-    //                any layer that doesn't conform to the other rules is a DefaultLayer.
-    m_layerType = DefaultLayer;
-
-    //  RootLayer: the top level. Draws to a framebuffer, and the target texture draws into the viewport.
-    //            only one layer is the root layer.
-    if (!m_parent && !m_effectTarget) {
-        m_layerType = RootLayer;
-        return;
-    }
-
-    // A layer with no contents is always a default layer.
-    if (!m_state.descendantsWithContent)
-        return;
-
-    //  ClipLayer: creates a new framebuffer, the size of the layer, and then paints it to the enclosing BitmapTexture with the layer's transform/opacity.
-    //              A clip layer is a layer that masks to bounds, doesn't preserve 3D, has children, and has a transparency/mask or a non-rectangular transform.
-    if (hasDescendantsWithContent && m_state.maskLayer) {
-        m_layerType = ClipLayer;
-        return;
-    }
-
-    //  ScissorLayer: draws to the current framebuffer, and applies an extra scissor before drawing its children.
-    //                A scissor layer is a layer with children that masks to bounds, is not a transparency layer, and has a rectangular clip.
-    if (m_state.masksToBounds && hasDescendantsWithContent) {
-        if (hasTransparency || !m_state.transform.isIdentityOrTranslation() || m_parent->m_state.preserves3D)
-            m_layerType = ClipLayer;
-        else
-            m_layerType = ScissorLayer;
-        return;
-    }
-
-    //  TransparencyLayer: creates a new framebuffer idetical in size to the current framebuffer. Then draws the fb's texture to the current framebuffer with identity transform.
-    //                     Used for layers with children and transparency/mask that preserve 3D or don't mask to bounds.
-    if ((hasReplica && hasDescendantsWithContent) || (hasReplica && hasTransparency) || (hasTransparency && m_state.descendantsWithContent > 1))
-        m_layerType = TransparencyLayer;
-}
-
-void TextureMapperNode::initializeTextureMapper(TextureMapper* textureMapper)
-{
-    if (m_texture)
-        return;
-    m_surface = textureMapper->createTexture();
-    m_replicaSurface = textureMapper->createTexture();
-    m_texture = textureMapper->createTexture();
-    cache()->mark(m_texture.get());
-}
-
-TextureMapperNode::TextureMapperNode()
-    : m_layerType(DefaultLayer)
-    , m_surface(0)
-    , m_parent(0)
-    , m_effectTarget(0)
-    , m_platformClient(0)
-    , m_cache(0)
-{
+TextureMapperNode* toTextureMapperNode(GraphicsLayer* layer)
+{
+    return layer ? toGraphicsLayerTextureMapper(layer)->node() : 0;
 }
 
@@ -296 +79 @@
 }
 
-void TextureMapperNode::invalidateTransform()
-{
-    m_transforms.dirty = true;
-    if (m_layerType != ClipLayer)
-        m_state.dirty = true;
-    if (m_state.replicaLayer)
-        m_state.replicaLayer->invalidateTransform();
-    const int size = m_children.size();
-    for (int i = 0; i < size; ++i) {
-        if (TextureMapperNode* layer = m_children[i])
-            layer->invalidateTransform();
-    }
-}
-
-void TextureMapperNode::computeLocalTransform()
-{
-    if (!m_transforms.localDirty)
-        return;
-    const float originX = m_state.anchorPoint.x() * m_size.width();
-    const float originY = m_state.anchorPoint.y() * m_size.height();
-    m_transforms.local =
-        TransformationMatrix()
-        .translate3d(originX + m_state.pos.x(), originY + m_state.pos.y(), m_state.anchorPoint.z())
-        .multiply(m_state.transform)
-        .translate3d(-originX, -originY, -m_state.anchorPoint.z());
-    m_transforms.localDirty = false;
-}
-
-void TextureMapperNode::flattenTo2DSpaceIfNecessary()
-{
-    if (m_state.preserves3D)
-        return;
-
-    m_transforms.forDescendants.setM13(0);
-    m_transforms.forDescendants.setM23(0);
-    m_transforms.forDescendants.setM31(0);
-    m_transforms.forDescendants.setM32(0);
-    m_transforms.forDescendants.setM33(1);
-    m_transforms.forDescendants.setM34(0);
-    m_transforms.forDescendants.setM43(0);
-}
-
-IntSize TextureMapperNode::nearestSurfaceSize() const
-{
-    if (m_layerType == ClipLayer || m_layerType == RootLayer)
-        return m_surface && !m_surface->size().isEmpty() ? m_surface->size() : m_size;
-    return m_parent->nearestSurfaceSize();
-}
-
-void TextureMapperNode::computeReplicaTransform()
-{
-    if (!m_state.replicaLayer)
-        return;
-
-    m_nearestSurfaceSize = nearestSurfaceSize();
-
-    if (m_layerType != TransparencyLayer) {
-        m_transforms.replica = TransformationMatrix(m_transforms.target).multiply(m_state.replicaLayer->m_transforms.local);
-        return;
-    }
-
-    const float originX = m_transforms.target.m41();
-    const float originY = m_transforms.target.m42();
-    m_transforms.replica =
-            TransformationMatrix()
-                .translate(originX, originY)
-                .multiply(m_state.replicaLayer->m_transforms.local)
-                .translate(-originX, -originY);
-}
-
-void TextureMapperNode::computeTransformations()
-{
-    if (!m_transforms.dirty)
-        return;
-
-    m_transforms.dirty = false;
-    if ((m_size.isEmpty() && m_state.masksToBounds))
-        return;
-
-    TextureMapperNode* parent = m_parent;
-    computeLocalTransform();
-
-    m_transforms.target = TransformationMatrix(parent ? parent->m_transforms.forDescendants : TransformationMatrix()).multiply(m_transforms.local);
-    m_transforms.forDescendants = (m_layerType == ClipLayer ? TransformationMatrix() : m_transforms.target);
-
-    if (m_effectTarget)
-        return;
-
-    m_transforms.targetBoundingRect = IntRect(m_transforms.target.mapRect(entireRect()));
-    if (m_state.replicaLayer)
-        m_state.replicaLayer->computeTransformations();
-
-    flattenTo2DSpaceIfNecessary();
-
-    if (!m_state.backfaceVisibility && m_transforms.target.inverse().m33() < 0) {
-        m_state.visible = false;
-        return;
-    }
-    m_state.visible = true;
-
-    if (parent && parent->m_state.preserves3D)
-        m_transforms.centerZ = m_transforms.target.mapPoint(FloatPoint3D(m_size.width() / 2, m_size.height() / 2, 0)).z();
-
-    if (!m_children.size())
-        return;
-
-    if (m_state.childrenTransform.isIdentity())
+void TextureMapperNode::setTransform(const TransformationMatrix& matrix)
+{
+    if (m_transforms.base == matrix)
+        return;
+
+    m_transforms.base = matrix;
+}
+
+void TextureMapperNode::computePerspectiveTransformIfNeeded()
+{
+    if (m_children.isEmpty() || m_state.childrenTransform.isIdentity())
         return;
 
     const FloatPoint centerPoint = FloatPoint(m_size.width() / 2, m_size.height() / 2);
-    if (m_transforms.perspectiveDirty)
-        m_transforms.perspective = TransformationMatrix()
+    m_transforms.perspective = TransformationMatrix()
             .translate(centerPoint.x(), centerPoint.y())
             .multiply(m_state.childrenTransform)
             .translate(-centerPoint.x(), -centerPoint.y());
-    m_transforms.perspectiveDirty = false;
+}
+
+int TextureMapperNode::countDescendantsWithContent() const
+{
+    if (!m_state.visible || m_opacity < 0.01 || (!m_size.width() && !m_size.height() && m_state.masksToBounds))
+        return 0;
+    int count = (m_size.width() && m_size.height() && (m_state.drawsContent || m_currentContent.contentType != HTMLContentType)) ? 1 : 0;
+    for (size_t i = 0; i < m_children.size(); ++i)
+        count += m_children[i]->countDescendantsWithContent();
+
+    return count;
+}
+
+void TextureMapperNode::computeOverlapsIfNeeded()
+{
+    m_state.mightHaveOverlaps = countDescendantsWithContent() > 1;
+}
+
+void TextureMapperNode::computeReplicaTransformIfNeeded()
+{
+    if (!m_state.replicaLayer)
+        return;
+
+    m_transforms.replica =
+        TransformationMatrix(m_transforms.target)
+            .multiply(m_state.replicaLayer->m_transforms.local)
+            .multiply(TransformationMatrix(m_transforms.target).inverse());
+}
+
+void TextureMapperNode::computeLocalTransformIfNeeded()
+{
+    float originX = m_state.anchorPoint.x() * m_size.width();
+    float originY = m_state.anchorPoint.y() * m_size.height();
+    m_transforms.local =
+        TransformationMatrix()
+        .translate3d(originX + m_state.pos.x(), originY + m_state.pos.y(), m_state.anchorPoint.z() )
+        .multiply(m_transforms.base)
+        .translate3d(-originX, -originY, -m_state.anchorPoint.z());
+}
+
+bool TextureMapperNode::needsToComputeBoundingRect() const
+{
+    if (m_size.width() > gTileDimension || m_size.height() > gTileDimension)
+        return true;
+    if (!m_state.masksToBounds)
+        return false;
+
+    for (size_t i = 0; i < m_children.size(); ++i)
+        if (m_children[i]->needsToComputeBoundingRect())
+            return true;
+
+    return false;
+}
+
+void TextureMapperNode::computeAllTransforms()
+{
+    if (m_size.isEmpty() && m_state.masksToBounds)
+        return;
+
+    computeLocalTransformIfNeeded();
+    computeReplicaTransformIfNeeded();
+    computePerspectiveTransformIfNeeded();
+
+    m_transforms.target = TransformationMatrix(m_parent ? m_parent->m_transforms.forDescendants : TransformationMatrix()).multiply(m_transforms.local);
+    m_transforms.targetBoundingRect = FloatRect(m_transforms.target.mapRect(targetRect()));
+
+    m_state.visible = m_state.backfaceVisibility || m_transforms.target.inverse().m33() >= 0;
+    if (!m_state.visible)
+        return;
+
+    // This transform is only applied if using a two-pass for the replica, because the transform needs to be adjusted to the size of the intermediate surface, insteaf of the size of the content layer.
+    if (m_parent && m_parent->m_state.preserves3D)
+        m_transforms.centerZ = m_transforms.target.mapPoint(FloatPoint3D(m_size.width() / 2, m_size.height() / 2, 0)).z();
+
+    if (!m_children.size())
+        return;
+
+    m_transforms.forDescendants = m_transforms.target;
+
+    if (!m_state.preserves3D) {
+        m_transforms.forDescendants = TransformationMatrix(
+                    m_transforms.forDescendants.m11(), m_transforms.forDescendants.m12(), 0, m_transforms.forDescendants.m14(),
+                    m_transforms.forDescendants.m21(), m_transforms.forDescendants.m22(), 0, m_transforms.forDescendants.m24(),
+                    0, 0, 1, 0,
+                    m_transforms.forDescendants.m41(), m_transforms.forDescendants.m42(), 0, m_transforms.forDescendants.m44());
+    }
+
     m_transforms.forDescendants.multiply(m_transforms.perspective);
 }
 
-void TextureMapperNode::uploadTextureFromContent(TextureMapper* textureMapper, const IntRect& visibleRect, GraphicsLayer* layer)
-{
-    if (m_size.isEmpty() || !layer) {
-        m_texture->destroy();
-        return;
-    }
-
-    if (m_currentContent.contentType == DirectImageContentType) {
-        if (m_currentContent.image)
-            m_texture->setContentsToImage(m_currentContent.image.get());
-        return;
-    }
-
-    if (m_currentContent.contentType == MediaContentType) {
-        if (!m_currentContent.media)
-            return;
-        m_texture->reset(m_size, true);
-        PlatformGraphicsContext* platformContext = m_texture->beginPaintMedia();
-        GraphicsContext context(platformContext);
-        m_currentContent.media->paint(&context);
-        m_texture->endPaint();
-        return;
-    }
-
-    const bool needsReset = (m_texture->contentSize() != m_size) || !m_texture->isValid();
-    if ((m_currentContent.contentType != HTMLContentType)
-        || (!m_currentContent.needsDisplay && m_currentContent.needsDisplayRect.isEmpty() && !needsReset))
-        return;
-
-    IntRect dirtyRect = IntRect(0, 0, m_size.width(), m_size.height());
-    if (!needsReset && !m_currentContent.needsDisplay)
-        dirtyRect.intersect(m_currentContent.needsDisplayRect);
-
-    if (needsReset)
-        m_texture->reset(m_size, m_state.contentsOpaque);
-
-    {
-        GraphicsContext context(m_texture->beginPaint(dirtyRect));
-        if (textureMapper) {
+void TextureMapperNode::computeBoundingRectFromRootIfNeeded()
+{
+    if (!needsToComputeBoundingRect())
+        return;
+    if (!m_parent) {
+        m_transforms.boundingRectFromRoot = m_transforms.boundingRectFromRootForDescendants = IntRect(0, 0, -1, -1);
+        return;
+    }
+
+    const FloatRect targetRectInRootCoordinates = m_transforms.target.mapRect(targetRect());
+
+    const FloatRect parentBoundingRect = m_parent->m_transforms.boundingRectFromRootForDescendants;
+    if (parentBoundingRect.width() < 0)
+        m_transforms.boundingRectFromRoot = targetRectInRootCoordinates;
+    else {
+        m_transforms.boundingRectFromRootForDescendants = m_transforms.boundingRectFromRoot = parentBoundingRect;
+        m_transforms.boundingRectFromRoot.intersect(targetRectInRootCoordinates);
+    }
+    if (m_state.masksToBounds)
+        m_transforms.boundingRectFromRootForDescendants.intersect(m_transforms.boundingRectFromRoot);
+}
+
+void TextureMapperNode::computeTiles()
+{
+    if (m_currentContent.contentType == HTMLContentType && !m_state.drawsContent) {
+        m_tiles.clear();
+        return;
+    }
+    Vector<FloatRect> tilesToAdd;
+    Vector<int> tilesToRemove;
+    const int TileEraseThreshold = 6;
+    FloatSize size = contentSize();
+    FloatRect contentRect(0, 0, size.width() * m_state.contentScale, size.height() * m_state.contentScale);
+
+    for (float y = 0; y < contentRect.height(); y += gTileDimension) {
+        for (float x = 0; x < contentRect.width(); x += gTileDimension) {
+            FloatRect tileRect(x, y, gTileDimension, gTileDimension);
+            tileRect.intersect(contentRect);
+            FloatRect tileRectInRootCoordinates = tileRect;
+            tileRectInRootCoordinates.scale(1.0 / m_state.contentScale);
+            tileRectInRootCoordinates = m_transforms.target.mapRect(tileRectInRootCoordinates);
+            static bool sDiscardHiddenTiles = false;
+            // FIXME: discard hidden tiles.
+            if (!sDiscardHiddenTiles || !needsToComputeBoundingRect() || tileRectInRootCoordinates.intersects(m_state.visibleRect))
+                tilesToAdd.append(tileRect);
+        }
+    }
+
+    for (int i = m_tiles.size() - 1; i >= 0; --i) {
+        const FloatRect oldTile = m_tiles[i].rect;
+        bool found = false;
+
+        for (int j = tilesToAdd.size() - 1; j >= 0; --j) {
+            const FloatRect newTile = tilesToAdd[j];
+            if (oldTile != newTile)
+                continue;
+
+            found = true;
+            tilesToAdd.remove(j);
+            break;
+        }
+
+        if (!found)
+            tilesToRemove.append(i);
+    }
+
+    for (size_t i = 0; i < tilesToAdd.size(); ++i) {
+        if (!tilesToRemove.isEmpty()) {
+            Tile& tile = m_tiles[tilesToRemove[0]];
+            tilesToRemove.remove(0);
+            tile.rect = tilesToAdd[i];
+            tile.needsReset = true;
+            continue;
+        }
+
+        Tile tile;
+        tile.rect = tilesToAdd[i];
+        tile.needsReset = true;
+        m_tiles.append(tile);
+    }
+
+    for (size_t i = 0; i < tilesToRemove.size() && m_tiles.size() > TileEraseThreshold; ++i)
+        m_tiles.remove(tilesToRemove[i]);
+}
+
+void TextureMapperNode::computeVisibleRectIfNeeded()
+{
+    if (!needsToComputeBoundingRect())
+        return;
+    FloatRect rootVisibleRect;
+    if (!m_parent)
+        rootVisibleRect = m_state.rootVisibleRect;
+    else if (m_parent)
+        rootVisibleRect = m_parent->m_state.rootVisibleRect;
+
+    m_state.rootVisibleRect = rootVisibleRect;
+    m_state.visibleRect = m_state.rootVisibleRect;
+    m_state.visibleRect.intersect(m_transforms.boundingRectFromRoot);
+}
+
+void TextureMapperNode::renderContent(TextureMapper* textureMapper, GraphicsLayer* layer)
+{
+    if (m_size.isEmpty() || !layer || (!m_state.drawsContent && m_currentContent.contentType == HTMLContentType)) {
+        m_tiles.clear();
+        return;
+    }
+
+    if (!textureMapper)
+        return;
+
+    if (m_currentContent.contentType == MediaContentType)
+        return;
+
+    // FIXME: Add directly composited images.
+    FloatRect dirtyRect = m_currentContent.needsDisplay ? entireRect() : m_currentContent.needsDisplayRect;
+    dirtyRect.scale(m_state.contentScale);
+
+    for (size_t tileIndex = 0; tileIndex < m_tiles.size(); ++tileIndex) {
+        Tile& tile = m_tiles[tileIndex];
+        FloatRect rect = dirtyRect;
+        if (!tile.texture)
+            tile.texture = textureMapper->createTexture();
+        RefPtr<BitmapTexture>& texture = tile.texture;
+        IntSize tileSize = enclosingIntRect(tile.rect).size();
+
+        if (tile.needsReset || texture->contentSize() != tileSize || !texture->isValid()) {
+            tile.needsReset = false;
+            texture->reset(tileSize, m_currentContent.contentType == DirectImageContentType ? false : m_state.contentsOpaque);
+            rect = tile.rect;
+        }
+
+        IntRect contentRect = enclosingIntRect(tile.rect);
+        contentRect.intersect(enclosingIntRect(rect));
+        if (contentRect.isEmpty())
+            continue;
+
+        FloatRect contentRectInTileCoordinates = contentRect;
+        FloatPoint offset(-tile.rect.x(), -tile.rect.y());
+        contentRectInTileCoordinates.move(offset.x(), offset.y());
+
+        {
+            GraphicsContext context(texture->beginPaint(enclosingIntRect(contentRectInTileCoordinates)));
             context.setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
             context.setTextDrawingMode(textureMapper->textDrawingMode());
-        }
-        layer->paintGraphicsLayerContents(context, dirtyRect);
-    }
-    m_texture->endPaint();
+            context.translate(offset.x(), offset.y());
+            context.scale(FloatSize(m_state.contentScale, m_state.contentScale));
+            FloatRect scaledContentRect(contentRect);
+            scaledContentRect.scale(1.0 / m_state.contentScale);
+            if (m_currentContent.contentType == DirectImageContentType)
+                context.drawImage(m_currentContent.image.get(), ColorSpaceDeviceRGB, IntPoint(0, 0));
+            else
+                layer->paintGraphicsLayerContents(context, enclosingIntRect(scaledContentRect));
+            texture->endPaint();
+        }
+    }
+
     m_currentContent.needsDisplay = false;
-}
-
-
-void TextureMapperNode::paint(TextureMapper* textureMapper, const TextureMapperContentLayer::PaintOptions& options)
-{
-    ASSERT(m_layerType == RootLayer);
+    m_currentContent.needsDisplayRect = IntRect();
+}
+
+void TextureMapperNode::paint()
+{
     if (m_size.isEmpty())
         return;
 
-    TexmapPaintOptions opt;
-    opt.opacity = 1;
-    opt.rootLayer = this;
-    opt.scissorRect = options.targetRect;
-    opt.visibleRect = options.visibleRect;
-    opt.textureMapper = textureMapper;
-    opt.surface = 0;
-    opt.cache = m_cache;
+    if (!m_surfaceManager)
+        m_surfaceManager = new TextureMapperSurfaceManager;
+    m_surfaceManager->textureMapper = m_textureMapper;
+    TextureMapperPaintOptions opt;
+    opt.surfaceManager = m_surfaceManager;
+    opt.textureMapper = m_textureMapper;
+    opt.textureMapper->bindSurface(0);
     paintRecursive(opt);
-
-    if (textureMapper->allowSurfaceForRoot() || m_state.hasSurfaceDescendants) {
-        textureMapper->bindSurface(0);
-        textureMapper->paintToTarget(*m_surface.get(), options.viewportSize, options.transform, options.opacity * m_state.opacity, options.targetRect);
-    }
-    m_cache->purge();
-}
-
-void TextureMapperNode::paintSelf(const TexmapPaintOptions& options)
+}
+
+FloatRect TextureMapperNode::targetRectForTileRect(const FloatRect& targetRect, const FloatRect& tileRect) const
+{
+    return FloatRect(
+                targetRect.x() + (tileRect.x() - targetRect.x()) / m_state.contentScale,
+                targetRect.y() + (tileRect.y() - targetRect.y()) / m_state.contentScale,
+                tileRect.width() / m_state.contentScale,
+                tileRect.height() / m_state.contentScale);
+}
+
+void TextureMapperNode::paintSelf(const TextureMapperPaintOptions& options)
 {
     if (m_size.isEmpty() || (!m_state.drawsContent && m_currentContent.contentType == HTMLContentType))
         return;
 
+    RefPtr<BitmapTexture> maskTexture;
     RefPtr<BitmapTexture> replicaMaskTexture;
-    m_texture->unpack();
-
-    RefPtr<BitmapTexture> maskTexture = m_state.maskLayer ? m_state.maskLayer->m_texture : 0;
+
+    if (m_state.maskLayer)
+        maskTexture = m_state.maskLayer->texture();
     if (m_state.replicaLayer && m_state.replicaLayer->m_state.maskLayer)
-        replicaMaskTexture = m_state.replicaLayer->m_state.maskLayer->m_texture;
-
-    if (maskTexture)
-        maskTexture->unpack();
-
-    if (replicaMaskTexture)
-        replicaMaskTexture->unpack();
+        replicaMaskTexture = m_state.replicaLayer->m_state.maskLayer->texture();
 
     const float opacity = options.isSurface ? 1 : options.opacity;
 
-    if (m_state.replicaLayer && !options.isSurface)
-        options.textureMapper->drawTexture(*m_texture.get(), replicaRect(), m_transforms.replica,
-                         opacity * m_state.replicaLayer->m_state.opacity,
-                         replicaMaskTexture ? replicaMaskTexture.get() : maskTexture.get());
-
-    const IntRect rect = m_layerType == ClipLayer ? entireRect() : targetRect();
-    const TransformationMatrix transform = m_layerType == ClipLayer ? TransformationMatrix() : m_transforms.target;
-    options.textureMapper->drawTexture(*m_texture.get(), rect, transform, opacity, options.isSurface ? 0 : maskTexture.get());
-    options.cache->mark(m_texture.get());
-}
-
-bool TextureMapperNode::paintReplica(const TexmapPaintOptions& options)
-{
-    BitmapTexture& texture = *m_surface.get();
-    TextureMapperNode* replica = m_state.replicaLayer;
+    const FloatRect targetRect = this->targetRect();
+
+    if (m_currentContent.contentType == MediaContentType && m_currentContent.media) {
+        if (m_state.replicaLayer && !options.isSurface)
+            m_currentContent.media->paintToTextureMapper(options.textureMapper, targetRect,
+                                                         TransformationMatrix(m_transforms.target).multiply(m_state.replicaLayer->m_transforms.local),
+                                                         opacity * m_state.replicaLayer->m_opacity,
+                                                         replicaMaskTexture ? replicaMaskTexture.get() : maskTexture.get());
+        m_currentContent.media->paintToTextureMapper(options.textureMapper, targetRect, m_transforms.target, opacity, options.isSurface ? 0 : maskTexture.get());
+        return;
+    }
+
+    for (size_t i = 0; i < m_tiles.size(); ++i) {
+        BitmapTexture* texture = m_tiles[i].texture.get();
+        if (m_state.replicaLayer && !options.isSurface) {
+            options.textureMapper->drawTexture(*texture, targetRectForTileRect(targetRect, m_tiles[i].rect),
+                             TransformationMatrix(m_transforms.target).multiply(m_state.replicaLayer->m_transforms.local),
+                             opacity * m_state.replicaLayer->m_opacity,
+                             replicaMaskTexture ? replicaMaskTexture.get() : maskTexture.get());
+        }
+
+        const FloatRect rect = targetRectForTileRect(targetRect, m_tiles[i].rect);
+        options.textureMapper->drawTexture(*texture, rect, m_transforms.target, opacity, options.isSurface ? 0 : maskTexture.get());
+    }
+}
+
+int TextureMapperNode::compareGraphicsLayersZValue(const void* a, const void* b)
+{
+    TextureMapperNode* const* nodeA = static_cast<TextureMapperNode* const*>(a);
+    TextureMapperNode* const* nodeB = static_cast<TextureMapperNode* const*>(b);
+    return int(((*nodeA)->m_transforms.centerZ - (*nodeB)->m_transforms.centerZ) * 1000);
+}
+
+void TextureMapperNode::sortByZOrder(Vector<TextureMapperNode* >& array, int first, int last)
+{
+    qsort(array.data(), array.size(), sizeof(TextureMapperNode*), compareGraphicsLayersZValue);
+}
+
+void TextureMapperNode::paintSelfAndChildren(const TextureMapperPaintOptions& options, TextureMapperPaintOptions& optionsForDescendants)
+{
+    bool hasClip = m_state.masksToBounds && !m_children.isEmpty();
+    if (hasClip)
+        options.textureMapper->beginClip(m_transforms.forDescendants, FloatRect(0, 0, m_size.width(), m_size.height()));
+
+    paintSelf(options);
+
+    for (int i = 0; i < m_children.size(); ++i)
+        m_children[i]->paintRecursive(optionsForDescendants);
+
+    if (hasClip)
+        options.textureMapper->endClip();
+}
+
+bool TextureMapperNode::paintReflection(const TextureMapperPaintOptions& options, BitmapTexture* contentSurface)
+{
+    if (!m_state.replicaLayer)
+        return false;
+
+    RefPtr<BitmapTexture> surface(contentSurface);
+    RefPtr<BitmapTexture> maskSurface;
+    RefPtr<BitmapTexture> replicaMaskSurface;
+    RefPtr<BitmapTexture> replicaMaskTexture;
+
+    if (TextureMapperNode* replicaMask = m_state.replicaLayer->m_state.maskLayer)
+        replicaMaskTexture = replicaMask->texture();
+
     RefPtr<BitmapTexture> maskTexture;
     if (TextureMapperNode* mask = m_state.maskLayer)
-        maskTexture = mask->m_texture;
-    RefPtr<BitmapTexture> replicaMaskTexture;
-    if (!replica)
-        return false;
-
-    if (replica && replica->m_state.maskLayer)
-        replicaMaskTexture = replica->m_state.maskLayer->m_texture;
-
-    if (replicaMaskTexture)
-        replicaMaskTexture->unpack();
-    ASSERT(m_replicaSurface);
-    m_replicaSurface->reset(options.surface->size());
-    m_replicaSurface->setOffset(options.surface->offset());
-    options.cache->mark(m_replicaSurface.get());
-    options.textureMapper->bindSurface(m_replicaSurface.get());
-    options.textureMapper->drawTexture(texture, replicaRect(), m_transforms.replica, replica->m_state.opacity, replicaMaskTexture ? replicaMaskTexture.get() : maskTexture.get());
-    options.textureMapper->drawTexture(texture, IntRect(IntPoint(0, 0), options.surface->size()), TransformationMatrix(), 1.0f, maskTexture.get());
+        maskTexture = mask->texture();
+
+    const IntSize viewportSize = options.textureMapper->viewportSize();
+    const bool useIntermediateBufferForReplica = m_state.replicaLayer && options.opacity < 0.99;
+    const bool useIntermediateBufferForMask = maskTexture && replicaMaskTexture;
+    const FloatRect viewportRect(0, 0, viewportSize.width(), viewportSize.height());
+
+    // The mask has to be adjusted to target coordinates.
+    if (maskTexture) {
+        maskSurface = options.surfaceManager->getIntermediateSurface();
+        options.textureMapper->bindSurface(maskSurface.get());
+        options.textureMapper->drawTexture(*maskTexture.get(), entireRect(), m_transforms.target, 1, 0);
+        maskTexture = maskSurface;
+    }
+
+    // The replica's mask has to be adjusted to target coordinates.
+    if (replicaMaskTexture) {
+        replicaMaskSurface = options.surfaceManager->getIntermediateSurface();
+        options.textureMapper->bindSurface(replicaMaskSurface.get());
+        options.textureMapper->drawTexture(*replicaMaskTexture.get(), entireRect(), m_transforms.target, 1, 0);
+        replicaMaskTexture = replicaMaskSurface;
+    }
+
+    // We might need to apply the mask of the content layer before we draw the reflection, as there might be yet another mask for the reflection itself.
+    if (useIntermediateBufferForMask) {
+        RefPtr<BitmapTexture> maskSurface = options.surfaceManager->getIntermediateSurface();
+        options.textureMapper->bindSurface(maskSurface.get());
+        options.textureMapper->drawTexture(*surface.get(), viewportRect, TransformationMatrix(), 1, maskTexture.get());
+        options.surfaceManager->releaseIntermediateSurface(surface.get());
+        surface = maskSurface;
+        maskTexture.clear();
+    }
+
+    // We blend the layer and its replica in an intermediate buffer before blending into the target surface.
+    if (useIntermediateBufferForReplica) {
+        RefPtr<BitmapTexture> replicaSurface = options.surfaceManager->getIntermediateSurface();
+        options.textureMapper->bindSurface(replicaSurface.get());
+        options.textureMapper->drawTexture(*surface.get(), viewportRect, m_transforms.replica, m_state.replicaLayer->m_opacity, replicaMaskTexture.get());
+        options.textureMapper->drawTexture(*surface.get(), viewportRect, TransformationMatrix(), 1, maskTexture.get());
+        options.surfaceManager->releaseIntermediateSurface(surface.get());
+        surface = replicaSurface;
+    }
+
     options.textureMapper->bindSurface(options.surface);
-    options.cache->mark(options.surface);
-    options.textureMapper->drawTexture(*m_replicaSurface.get(), IntRect(IntPoint(0, 0), options.surface->size()), TransformationMatrix(), options.opacity, 0);
+
+    // Draw the reflection.
+    if (!useIntermediateBufferForReplica)
+        options.textureMapper->drawTexture(*surface.get(), viewportRect, m_transforms.replica, m_state.replicaLayer->m_opacity, replicaMaskTexture.get());
+
+    // Draw the original.
+    options.textureMapper->drawTexture(*surface.get(), viewportRect, TransformationMatrix(), options.opacity, maskTexture.get());
+
+    options.surfaceManager->releaseIntermediateSurface(maskSurface.get());
+    options.surfaceManager->releaseIntermediateSurface(replicaMaskSurface.get());
+
     return true;
 }
 
-void TextureMapperNode::paintSurface(const TexmapPaintOptions& options)
-{
-    if (m_layerType == RootLayer || m_layerType == DefaultLayer || m_layerType == ScissorLayer)
-        return;
-
-    RefPtr<BitmapTexture> maskTexture;
-    if (TextureMapperNode* mask = m_state.maskLayer)
-        maskTexture = mask->m_texture;
-
-    ASSERT(m_surface);
-    BitmapTexture& texture = *m_surface.get();
-    if (maskTexture)
-        maskTexture->unpack();
-    texture.unpack();
-
-    if (paintReplica(options))
-        return;
-
-    options.textureMapper->bindSurface(options.surface);
-    options.textureMapper->drawTexture(texture,
-                             m_layerType == TransparencyLayer ? IntRect(IntPoint(0, 0), options.surface->size()) :
-                             targetRect(),
-                             m_layerType == TransparencyLayer ? TransformationMatrix() : m_transforms.target,
-                             options.opacity, maskTexture.get());
-    options.cache->mark(&texture);
-}
-
-void TextureMapperNode::paintSelfAndChildren(const TexmapPaintOptions& options, TexmapPaintOptions& optionsForDescendants)
-{
-    bool didPaintSelf = false;
-    if (!m_state.preserves3D || m_children.isEmpty()) {
-        paintSelf(options);
-        didPaintSelf = true;
-    }
-
-    if (m_children.isEmpty() && !options.isSurface)
-        return;
-
-    if (m_layerType == ScissorLayer)
-        optionsForDescendants.scissorRect.intersect(m_transforms.target.mapRect(IntRect(0, 0, m_size.width(), m_size.height())));
-
-    for (int i = 0; i < m_children.size(); ++i) {
-        TextureMapperNode* layer = m_children[i];
-        if (!layer)
-            continue;
-
-        if (!didPaintSelf && layer->m_transforms.centerZ >= 0) {
-            paintSelf(options);
-            didPaintSelf = true;
-        }
-        layer->paintRecursive(optionsForDescendants);
-        if (options.isSurface) {
-            ASSERT(m_surface);
-            options.cache->mark(m_surface.get());
-            options.textureMapper->bindSurface(m_surface.get());
-        }
-    }
-    if (!didPaintSelf) {
-        paintSelf(options);
-        didPaintSelf = true;
-    }
-}
-
-void TextureMapperNode::paintRecursive(TexmapPaintOptions options)
-{
-    bool isDirty = m_state.dirty;
-    m_state.dirty = false;
-
+void TextureMapperNode::paintRecursive(TextureMapperPaintOptions options)
+{
     if ((m_size.isEmpty() && (m_state.masksToBounds
-        || m_children.isEmpty())) || !m_state.visible || options.opacity < 0.01 || m_state.opacity < 0.01)
-        return;
-
-    computeReplicaTransform();
-
-    if (m_state.maskLayer)
-        m_state.maskLayer->m_state.dirty = false;
-
-    if (m_state.replicaLayer) {
-        m_state.replicaLayer->m_state.dirty = false;
-        if (m_state.replicaLayer->m_state.maskLayer)
-            m_state.replicaLayer->m_state.maskLayer->m_state.dirty = false;
-    }
-
-    const bool isSurface = (m_layerType == ClipLayer
-                            || m_layerType == TransparencyLayer
-                            || (m_layerType == RootLayer
-                                && (options.textureMapper->allowSurfaceForRoot() || m_state.hasSurfaceDescendants)
-                                ));
-
-    const IntRect boundingRectfromNearestSurface = m_transforms.targetBoundingRect;
-
-    options.opacity *= m_state.opacity;
-
-    TexmapPaintOptions optionsForDescendants(options);
-    optionsForDescendants.opacity = isSurface ? 1 : options.opacity;
-    options.isSurface = isSurface;
-
-    if (m_layerType == ClipLayer) {
-        optionsForDescendants.visibleRect = TransformationMatrix().translate(-boundingRectfromNearestSurface.x(), -boundingRectfromNearestSurface.y()).mapRect(options.visibleRect);
-        optionsForDescendants.scissorRect = IntRect(0, 0, m_size.width(), m_size.height());
-    }
-
-    if (m_layerType == ScissorLayer)
-        optionsForDescendants.scissorRect.intersect(m_transforms.targetBoundingRect);
-    options.textureMapper->setClip(optionsForDescendants.scissorRect);
-
-    TextureMapperCacheLock(m_texture.get());
-    TextureMapperCacheLock(m_surface.get());
-    TextureMapperCacheLock(m_replicaSurface.get());
-
-    options.cache->purge();
-
-    if (isSurface) {
-        ASSERT(m_surface);
-        if (!m_surface->isValid())
-            isDirty = true;
-        if (m_state.tiled) {
-            m_surface->reset(options.visibleRect.size());
-            m_surface->setOffset(options.visibleRect.location());
-        } else if (isDirty)
-            m_surface->reset(m_layerType == TransparencyLayer ? options.surface->size() : m_size);
-        options.cache->mark(m_surface.get());
-        options.textureMapper->bindSurface(m_surface.get());
-        optionsForDescendants.surface = m_surface.get();
-    } else if (m_surface)
-        m_surface->destroy();
-
-    if (isDirty || !isSurface || m_state.tiled || !m_surface->isValid())
+        || m_children.isEmpty())) || !m_state.visible || options.opacity < 0.01 || m_opacity < 0.01)
+        return;
+
+    options.opacity *= m_opacity;
+    RefPtr<BitmapTexture> surface;
+    const bool needsTwoPass = ((m_state.replicaLayer || m_state.maskLayer) && !m_children.isEmpty()) || (m_opacity < 0.99 && m_state.mightHaveOverlaps) || (m_opacity < 0.99 && m_state.replicaLayer);
+    const IntSize viewportSize = options.textureMapper->viewportSize();
+    options.isSurface = false;
+
+    TextureMapperPaintOptions optionsForDescendants(options);
+
+    if (!needsTwoPass) {
         paintSelfAndChildren(options, optionsForDescendants);
-
-    paintSurface(options);
+        return;
+    }
+
+    FloatRect viewportRect(0, 0, viewportSize.width(), viewportSize.height());
+
+    RefPtr<BitmapTexture> maskSurface;
+
+    // The mask has to be adjusted to target coordinates.
+    if (m_state.maskLayer) {
+        maskSurface = options.surfaceManager->getIntermediateSurface();
+        options.textureMapper->bindSurface(maskSurface.get());
+        options.textureMapper->drawTexture(*m_state.maskLayer->texture(), entireRect(), m_transforms.target, 1.0, 0);
+    }
+
+    surface = options.surfaceManager->getIntermediateSurface();
+    optionsForDescendants.surface = surface.get();
+    options.isSurface = true;
+    optionsForDescendants.opacity = 1;
+    options.textureMapper->bindSurface(surface.get());
+
+    paintSelfAndChildren(options, optionsForDescendants);
+
+    if (!paintReflection(options, surface.get())) {
+        options.textureMapper->bindSurface(options.surface);
+        options.textureMapper->drawTexture(*surface.get(), viewportRect, TransformationMatrix(), options.opacity, 0);
+    }
+
+    options.surfaceManager->releaseIntermediateSurface(surface.get());
+    options.surfaceManager->releaseIntermediateSurface(maskSurface.get());
 }
 
 TextureMapperNode::~TextureMapperNode()
 {
-    setNeedsDisplay();
-    {
-        const int childrenSize = m_children.size();
-        for (int i = childrenSize-1; i >= 0; --i) {
-            ASSERT(m_children[i]->m_parent == this);
-            m_children[i]->m_parent = 0;
-        }
-    }
+    for (int i = m_children.size() - 1; i >= 0; --i)
+        m_children[i]->m_parent = 0;
+
     if (m_parent)
         m_parent->m_children.remove(m_parent->m_children.find(this));
-    if (m_cache)
-        delete m_cache;
-}
-
-void TextureMapperNode::performPostSyncOperations()
-{
-    const LayerType prevLayerType = m_layerType;
-    computeLayerType();
-    if (prevLayerType != m_layerType)
-        m_state.dirty = true;
-    if (m_transforms.dirty)
-        setNeedsDisplay();
-
-    computeTransformations();
-    if (m_state.maskLayer && !m_state.dirty)
-        m_state.dirty = m_state.maskLayer->m_state.dirty;
-    if (m_state.replicaLayer && !m_state.dirty)
-        m_state.dirty = m_state.replicaLayer->m_state.dirty;
-
-    const int size = m_children.size();
-
-    for (int i = size - 1; i >= 0; --i) {
-        TextureMapperNode* layer = m_children[i];
-
-        layer->performPostSyncOperations();
-        if (!m_state.dirty)
-            m_state.dirty = layer->m_state.dirty;
-    }
-    m_state.hasSurfaceDescendants = hasSurfaceDescendants();
-    if (m_state.dirty)
-        m_state.descendantsWithContent = countDescendantsWithContent();
-
-    if (m_state.preserves3D)
-        sortByZOrder(m_children, 0, size);
-    if (m_state.dirty)
-        setNeedsDisplay();
-}
-
-void TextureMapperNode::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, bool recurse)
-{
-    TextureMapper* textureMapper = rootLayer()->m_platformClient->textureMapper();
-    syncCompositingStateInternal(graphicsLayer, recurse, textureMapper);
-    performPostSyncOperations();
+}
+
+void TextureMapperNode::setVisibleRect(const IntRect& rect)
+{
+    m_state.rootVisibleRect = m_state.visibleRect = rect;
+}
+
+void TextureMapperNode::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, int options)
+{
+    syncCompositingState(graphicsLayer, rootLayer()->m_textureMapper, options);
 }
 
 void TextureMapperNode::syncCompositingStateSelf(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper)
 {
-    const int changeMask = graphicsLayer->changeMask();
-    initializeTextureMapper(textureMapper);
+    int changeMask = graphicsLayer->changeMask();
     const TextureMapperNode::ContentData& pendingContent = graphicsLayer->pendingContent();
-    if (changeMask == NoChanges && pendingContent.needsDisplayRect.isEmpty() && !pendingContent.needsDisplay)
-        return;
-
-    setNeedsDisplay();
-    if (m_parent)
-        m_parent->m_state.dirty = true;
+    if (changeMask == NoChanges && graphicsLayer->m_animations.isEmpty() && pendingContent.needsDisplayRect.isEmpty() && !pendingContent.needsDisplay)
+        return;
 
     if (m_currentContent.contentType == HTMLContentType && (changeMask & ParentChange)) {
-        // The WebCore compositor manages item ownership. We have to make sure graphicsview doesn't
-        // try to snatch that ownership.
-
-        if (!graphicsLayer->parent())
-            m_parent = 0;
-        else
-            m_parent = toTextureMapperNode(graphicsLayer->parent());
+        m_parent = toTextureMapperNode(graphicsLayer->parent());
 
         if (!graphicsLayer->parent() && m_parent) {
@@ -767 +597 @@
         m_children.clear();
         for (size_t i = 0; i < graphicsLayer->children().size(); ++i) {
-            if (TextureMapperNode* child = toTextureMapperNode(graphicsLayer->children()[i])) {
-                if (!child)
-                    continue;
-                m_children.append(child);
-                child->m_parent = this;
-            }
-        }
-        m_state.dirty = true;
+            TextureMapperNode* child = toTextureMapperNode(graphicsLayer->children()[i]);
+            if (!child)
+                continue;
+            m_children.append(child);
+            child->m_parent = this;
+        }
     }
 
     if (changeMask & (SizeChange | ContentsRectChange)) {
-        IntSize wantedSize = IntSize(graphicsLayer->size().width(), graphicsLayer->size().height());
+        FloatSize wantedSize(graphicsLayer->size().width(), graphicsLayer->size().height());
         if (wantedSize.isEmpty() && pendingContent.contentType == HTMLContentType)
-            wantedSize = IntSize(graphicsLayer->contentsRect().width(), graphicsLayer->contentsRect().height());
-
-        if (wantedSize != m_size) {
-            m_size = IntSize(wantedSize.width(), wantedSize.height());
-            if (m_platformClient)
-                m_platformClient->setSizeChanged(m_size);
-            const bool needsTiling = m_size.width() > 2000 || m_size.height() > 2000;
-            if (m_state.tiled != needsTiling)
-                m_state.tiled = needsTiling;
-            m_state.dirty = true;
-        }
+            wantedSize = FloatSize(graphicsLayer->contentsRect().width(), graphicsLayer->contentsRect().height());
+
+        if (wantedSize != m_size)
+            m_tiles.clear();
+
+        m_size = wantedSize;
     }
 
@@ -803 +626 @@
     }
 
-    if (changeMask & (TransformChange | SizeChange | AnchorPointChange | PositionChange))
-        m_transforms.localDirty = true;
-
-    if (changeMask & (ChildrenTransformChange | SizeChange))
-        m_transforms.perspectiveDirty = true;
-
-    if (changeMask & (ChildrenTransformChange | Preserves3DChange | TransformChange | AnchorPointChange | SizeChange | ContentsRectChange | BackfaceVisibilityChange | PositionChange | MaskLayerChange | DrawsContentChange | ContentChange | ReplicaLayerChange))    {
-        // Due to the differences between the way WebCore handles transforms and the way Qt handles transforms,
-        // all these elements affect the transforms of all the descendants.
-        invalidateTransform();
-    }
-
-    if (changeMask & DisplayChange)
-        m_state.dirty = true;
+    if (changeMask & AnimationChange) {
+        m_animations.clear();
+        for (size_t i = 0; i < graphicsLayer->m_animations.size(); ++i)
+            m_animations.append(graphicsLayer->m_animations[i]);
+    }
 
     m_state.maskLayer = toTextureMapperNode(graphicsLayer->maskLayer());
@@ -823 +637 @@
     m_state.anchorPoint = graphicsLayer->anchorPoint();
     m_state.size = graphicsLayer->size();
+    m_state.contentsRect = graphicsLayer->contentsRect();
     m_state.transform = graphicsLayer->transform();
-    m_state.contentsRect = graphicsLayer->contentsRect();
-    m_state.opacity = graphicsLayer->opacity();
     m_state.contentsRect = graphicsLayer->contentsRect();
     m_state.preserves3D = graphicsLayer->preserves3D();
@@ -833 +646 @@
     m_state.backfaceVisibility = graphicsLayer->backfaceVisibility();
     m_state.childrenTransform = graphicsLayer->childrenTransform();
+    m_state.opacity = graphicsLayer->opacity();
     m_currentContent.contentType = pendingContent.contentType;
     m_currentContent.image = pendingContent.image;
     m_currentContent.media = pendingContent.media;
-    m_currentContent.backgroundColor = pendingContent.backgroundColor;
     m_currentContent.needsDisplay = m_currentContent.needsDisplay || pendingContent.needsDisplay;
-    m_currentContent.needsDisplayRect.unite(pendingContent.needsDisplayRect);
-
-}
-
-void TextureMapperNode::syncCompositingStateInternal(GraphicsLayerTextureMapper* graphicsLayer, bool recurse, TextureMapper* textureMapper)
-{
-    syncCompositingStateSelf(graphicsLayer, textureMapper);
-
-    graphicsLayer->didSynchronize();
-
-    if (m_state.maskLayer) {
-        m_state.maskLayer->syncCompositingStateInternal(toGraphicsLayerTextureMapper(graphicsLayer->maskLayer()), false, textureMapper);
+    if (!m_currentContent.needsDisplay)
+        m_currentContent.needsDisplayRect.unite(pendingContent.needsDisplayRect);
+
+    if (!hasRunningOpacityAnimation())
+        m_opacity = m_state.opacity;
+    if (!hasRunningTransformAnimation())
+        m_transforms.base = m_state.transform;
+}
+
+bool TextureMapperNode::descendantsOrSelfHaveRunningAnimations() const
+{
+    for (size_t i = 0; i < m_animations.size(); ++i) {
+        if (!m_animations[i]->paused)
+            return true;
+    }
+
+    for (size_t i = 0; i < m_children.size(); ++i) {
+        if (m_children[i]->descendantsOrSelfHaveRunningAnimations())
+            return true;
+    }
+
+    return false;
+}
+
+static double normalizedAnimationValue(double runningTime, double duration, bool alternate)
+{
+    if (!duration)
+        return 0;
+    const int loopCount = runningTime / duration;
+    const double lastFullLoop = duration * double(loopCount);
+    const double remainder = runningTime - lastFullLoop;
+    const double normalized = remainder / duration;
+    return (loopCount % 2 && alternate) ? (1 - normalized) : normalized;
+}
+
+void TextureMapperNode::applyOpacityAnimation(float fromOpacity, float toOpacity, double progress)
+{
+    // Optimization: special case the edge values (0 and 1).
+    if (progress == 1.0)
+        setOpacity(toOpacity);
+    else if (!progress)
+        setOpacity(fromOpacity);
+    else
+        setOpacity(fromOpacity + progress * (toOpacity - fromOpacity));
+}
+
+static inline double solveEpsilon(double duration)
+{
+    return 1.0 / (200.0 * duration);
+}
+
+static inline double solveCubicBezierFunction(qreal p1x, qreal p1y, qreal p2x, qreal p2y, double t, double duration)
+{
+    UnitBezier bezier(p1x, p1y, p2x, p2y);
+    return bezier.solve(t, solveEpsilon(duration));
+}
+
+static inline double solveStepsFunction(int numSteps, bool stepAtStart, double t)
+{
+    if (stepAtStart)
+        return qMin(1.0, (floor(numSteps * t) + 1) / numSteps);
+    return floor(numSteps * t) / numSteps;
+}
+
+static inline float applyTimingFunction(const TimingFunction* timingFunction, float progress, double duration)
+{
+    if (!timingFunction)
+        return progress;
+
+    if (timingFunction->isCubicBezierTimingFunction()) {
+        const CubicBezierTimingFunction* ctf = static_cast<const CubicBezierTimingFunction*>(timingFunction);
+        return solveCubicBezierFunction(ctf->x1(),
+                                        ctf->y1(),
+                                        ctf->x2(),
+                                        ctf->y2(),
+                                        progress, duration);
+    }
+
+    if (timingFunction->isStepsTimingFunction()) {
+        const StepsTimingFunction* stf = static_cast<const StepsTimingFunction*>(timingFunction);
+        return solveStepsFunction(stf->numberOfSteps(), stf->stepAtStart(), double(progress));
+    }
+
+    return progress;
+}
+
+void TextureMapperNode::applyTransformAnimation(const TextureMapperAnimation& animation, const TransformOperations* from, const TransformOperations* to, double progress)
+{
+    // Optimization: special case the edge values (0 and 1).
+    if (progress == 1.0 || !progress) {
+        TransformationMatrix matrix;
+        const TransformOperations* ops = progress ? to : from;
+        ops->apply(animation.boxSize, matrix);
+        setTransform(matrix);
+    }
+
+    if (!animation.listsMatch) {
+        TransformationMatrix toMatrix, fromMatrix;
+        to->apply(animation.boxSize, toMatrix);
+        from->apply(animation.boxSize, fromMatrix);
+        toMatrix.blend(fromMatrix, progress);
+        setTransform(toMatrix);
+        return;
+    }
+
+    TransformationMatrix matrix;
+
+    if (!to->size()) {
+        const TransformOperations* swap = to;
+        to = from;
+        from = swap;
+    } else if (!from->size())
+        progress = 1.0 - progress;
+
+    TransformOperations blended(*to);
+    for (size_t i = 0; i < animation.functionList.size(); ++i)
+        blended.operations()[i]->blend(from->at(i), progress, !from->at(i))->apply(matrix, animation.boxSize);
+
+    setTransform(matrix);
+}
+
+void TextureMapperNode::applyAnimationFrame(const TextureMapperAnimation& animation, const AnimationValue* from, const AnimationValue* to, float progress)
+{
+    switch (animation.keyframes.property()) {
+    case AnimatedPropertyOpacity:
+        applyOpacityAnimation((static_cast<const FloatAnimationValue*>(from)->value()), (static_cast<const FloatAnimationValue*>(to)->value()), progress);
+        return;
+    case AnimatedPropertyWebkitTransform:
+        applyTransformAnimation(animation, static_cast<const TransformAnimationValue*>(from)->value(), static_cast<const TransformAnimationValue*>(to)->value(), progress);
+        return;
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
+
+void TextureMapperNode::applyAnimation(const TextureMapperAnimation& animation, double normalizedValue)
+{
+    // Optimization: special case the edge values (0 and 1).
+    if (!normalizedValue) {
+        applyAnimationFrame(animation, animation.keyframes.at(0), animation.keyframes.at(1), 0);
+        return;
+    }
+    if (normalizedValue == 1.0) {
+        applyAnimationFrame(animation, animation.keyframes.at(animation.keyframes.size() - 2), animation.keyframes.at(animation.keyframes.size() - 1), 1);
+        return;
+    }
+    if (animation.keyframes.size() == 2) {
+        normalizedValue = applyTimingFunction(animation.animation->timingFunction().get(), normalizedValue, animation.animation->duration());
+        applyAnimationFrame(animation, animation.keyframes.at(0), animation.keyframes.at(1), normalizedValue);
+        return;
+    }
+
+    for (size_t i = 0; i < animation.keyframes.size() - 1; ++i) {
+        const AnimationValue* from = animation.keyframes.at(i);
+        const AnimationValue* to = animation.keyframes.at(i + 1);
+        if (from->keyTime() > normalizedValue || to->keyTime() < normalizedValue)
+            continue;
+
+        normalizedValue = (normalizedValue - from->keyTime()) / (to->keyTime() - from->keyTime());
+        normalizedValue = applyTimingFunction(from->timingFunction(), normalizedValue, animation.animation->duration());
+        applyAnimationFrame(animation, from, to, normalizedValue);
+        break;
+    }
+}
+
+bool TextureMapperNode::hasRunningOpacityAnimation() const
+{
+    for (size_t i = 0; i < m_animations.size(); ++i) {
+        const TextureMapperAnimation& animation = *m_animations[i].get();
+        if (!animation.paused && animation.keyframes.property() == AnimatedPropertyOpacity)
+            return true;
+    }
+    return false;
+}
+
+bool TextureMapperNode::hasRunningTransformAnimation() const
+{
+    for (size_t i = 0; i < m_animations.size(); ++i) {
+        const TextureMapperAnimation& animation = *m_animations[i].get();
+        if (!animation.paused && animation.keyframes.property() == AnimatedPropertyWebkitTransform)
+            return true;
+    }
+    return false;
+}
+
+void TextureMapperNode::syncAnimations(GraphicsLayerTextureMapper* layer)
+{
+    for (int i = m_animations.size() - 1; i >= 0; --i) {
+        RefPtr<TextureMapperAnimation> animation = m_animations[i];
+
+        double totalRunningTime = WTF::currentTime() - animation->startTime;
+        RefPtr<Animation> anim = animation->animation;
+        double normalizedValue = normalizedAnimationValue(totalRunningTime, anim->duration(), true);
+
+        if (anim->iterationCount() != Animation::IterationCountInfinite && totalRunningTime >= anim->duration() * anim->iterationCount()) {
+            // We apply an animation that very close to the edge, so that the final frame is applied, oterwise we might get, for example, an opacity of 0.01 which is still visible.
+            if (anim->fillsForwards()) {
+                if (animation->keyframes.property() == AnimatedPropertyWebkitTransform)
+                    m_state.transform = m_transforms.base;
+                else if (animation->keyframes.property() == AnimatedPropertyOpacity)
+                    m_opacity = m_state.opacity;
+            }
+
+            m_animations.remove(i);
+            continue;
+        }
+
+        if (!animation->paused)
+            applyAnimation(*animation.get(), normalizedValue);
+    }
+}
+
+void TextureMapperNode::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper, int options)
+{
+    if (graphicsLayer) {
+        syncCompositingStateSelf(graphicsLayer, textureMapper);
+        graphicsLayer->didSynchronize();
+    }
+
+    if (graphicsLayer && m_state.maskLayer) {
+        m_state.maskLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->maskLayer()), textureMapper);
+
+        // A mask layer has its parent's size by default, in case it's not set specifically.
         if (m_state.maskLayer->m_size.isEmpty())
             m_state.maskLayer->m_size = m_size;
@@ -855 +879 @@
 
     if (m_state.replicaLayer)
-        m_state.replicaLayer->syncCompositingStateInternal(toGraphicsLayerTextureMapper(graphicsLayer->replicaLayer()), false, textureMapper);
-
-    if (m_state.dirty)
-        uploadTextureFromContent(textureMapper, m_state.visibleRect, graphicsLayer);
-
-    m_currentContent.needsDisplayRect = IntRect();
-    m_currentContent.needsDisplay = false;
-
-    if (!recurse)
-        return;
-
-    Vector<GraphicsLayer*> children = graphicsLayer->children();
-    for (int i = children.size() - 1; i >= 0; --i) {
-        TextureMapperNode* node = toTextureMapperNode(children[i]);
-        if (!node)
-            continue;
-        node->syncCompositingStateInternal(toGraphicsLayerTextureMapper(children[i]), true, textureMapper);
-    }
-}
-
-}
+        m_state.replicaLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->replicaLayer()), textureMapper);
+
+    syncAnimations(graphicsLayer);
+
+    computeAllTransforms();
+    computeBoundingRectFromRootIfNeeded();
+    computePerspectiveTransformIfNeeded();
+    computeTiles();
+    computeOverlapsIfNeeded();
+
+    if (graphicsLayer)
+        renderContent(textureMapper, graphicsLayer);
+
+    if (!(options & TraverseDescendants))
+        return;
+
+    if (graphicsLayer) {
+        Vector<GraphicsLayer*> children = graphicsLayer->children();
+        for (int i = children.size() - 1; i >= 0; --i) {
+            TextureMapperNode* node = toTextureMapperNode(children[i]);
+            if (!node)
+                continue;
+            node->syncCompositingState(toGraphicsLayerTextureMapper(children[i]), textureMapper, options);
+        }
+    } else {
+        for (int i = m_children.size() - 1; i >= 0; --i)
+            m_children[i]->syncCompositingState(0, textureMapper, options);
+    }
+
+    if (m_state.preserves3D)
+        sortByZOrder(m_children, 0, m_children.size());
+}
+
+static PassRefPtr<TimingFunction> copyTimingFunction(const TimingFunction* tfunc)
+{
+    if (!tfunc)
+        return 0;
+
+    if (tfunc->isLinearTimingFunction())
+        return LinearTimingFunction::create();
+
+    if (tfunc->isCubicBezierTimingFunction()) {
+        const CubicBezierTimingFunction* btfunc = static_cast<const CubicBezierTimingFunction*>(tfunc);
+        return CubicBezierTimingFunction::create(btfunc->x1(), btfunc->y1(), btfunc->x2(), btfunc->y2());
+    }
+
+    if (tfunc->isStepsTimingFunction()) {
+        const StepsTimingFunction* stfunc = static_cast<const StepsTimingFunction*>(tfunc);
+        return StepsTimingFunction::create(stfunc->numberOfSteps(), stfunc->stepAtStart());
+    }
+
+    return 0;
+}
+
+static const AnimationValue* copyAnimationValue(AnimatedPropertyID property, const AnimationValue* value)
+{
+    switch (property) {
+    case AnimatedPropertyWebkitTransform: {
+        const TransformAnimationValue* transformValue = static_cast<const TransformAnimationValue*>(value);
+        return new TransformAnimationValue(transformValue->keyTime(), transformValue->value(), copyTimingFunction(transformValue->timingFunction()));
+    }
+    case AnimatedPropertyOpacity: {
+        const FloatAnimationValue* floatValue = static_cast<const FloatAnimationValue*>(value);
+        return new FloatAnimationValue(floatValue->keyTime(), floatValue->value(), copyTimingFunction(floatValue->timingFunction()));
+    }
+    default:
+        ASSERT_NOT_REACHED();
+    }
+
+    return 0;
+}
+
+TextureMapperAnimation::TextureMapperAnimation(const KeyframeValueList& values)
+    : keyframes(values.property())
+{
+    for (size_t i = 0; i < values.size(); ++i)
+        keyframes.insert(copyAnimationValue(values.property(), values.at(i)));
+}
+
+}
+
+#endif

trunk/Source/WebCore/platform/graphics/texmap/TextureMapperNode.h

@@ -26 +26 @@
 #include "Image.h"
 #include "TextureMapper.h"
-#include "TextureMapperPlatformLayer.h"
 #include "Timer.h"
 #include "TransformOperations.h"
@@ -37 +36 @@
 namespace WebCore {
 
+class TextureMapperPlatformLayer;
 class TextureMapperNode;
-class TextureMapperCache;
 class GraphicsLayerTextureMapper;
-
-struct TexmapPaintOptions {
+class TextureMapperSurfaceManager;
+
+class TextureMapperPaintOptions {
+public:
     BitmapTexture* surface;
     TextureMapper* textureMapper;
-    TextureMapperNode* rootLayer;
+    TextureMapperSurfaceManager* surfaceManager;
+
     float opacity;
-    IntRect scissorRect;
-    IntRect visibleRect;
     bool isSurface;
-    TextureMapperCache* cache;
+    TextureMapperPaintOptions() : surface(0), textureMapper(0), opacity(1.0), isSurface(false) { }
 };
 
-class TextureMapperNode : public TextureMapperContentLayer {
+class TextureMapperAnimation : public RefCounted<TextureMapperAnimation> {
+public:
+    String name;
+    KeyframeValueList keyframes;
+    IntSize boxSize;
+    RefPtr<Animation> animation;
+    bool paused;
+    Vector<TransformOperation::OperationType> functionList;
+    bool listsMatch;
+    bool hasBigRotation;
+    double startTime;
+    TextureMapperAnimation(const KeyframeValueList&);
+    static PassRefPtr<TextureMapperAnimation> create(const KeyframeValueList& values) { return adoptRef(new TextureMapperAnimation(values)); }
+};
+
+class TextureMapperNode {
 
 public:
@@ -84 +99 @@
         BackgroundColorChange =     (1L << 19),
 
-        ReplicaLayerChange =        (1L << 20)
-    };
+        ReplicaLayerChange =        (1L << 20),
+        AnimationChange =           (1L << 21)
+    };
+
+    enum SyncOptions {
+        TraverseDescendants = 1
+    };
+
     // The compositor lets us special-case images and colors, so we try to do so.
     enum ContentType { HTMLContentType, DirectImageContentType, ColorContentType, MediaContentType, Canvas3DContentType};
     struct ContentData {
-        IntRect needsDisplayRect;
+        FloatRect needsDisplayRect;
         bool needsDisplay;
         Color backgroundColor;
@@ -95 +116 @@
         ContentType contentType;
         RefPtr<Image> image;
-        TextureMapperMediaLayer* media;
-
+        const TextureMapperPlatformLayer* media;
         ContentData()
             : needsDisplay(false)
@@ -106 +126 @@
     };
 
-
-    TextureMapperNode();
+    TextureMapperNode()
+        : m_parent(0), m_effectTarget(0), m_opacity(1.0), m_surfaceManager(0), m_textureMapper(0) { }
+
     virtual ~TextureMapperNode();
 
-    void syncCompositingState(GraphicsLayerTextureMapper*, bool recursive);
-
-protected:
-    // Reimps from TextureMapperContentLayer
-    virtual IntSize size() const { return m_size; }
-    virtual void setPlatformLayerClient(TextureMapperLayerClient*);
-    virtual void paint(TextureMapper*, const TextureMapperContentLayer::PaintOptions&);
+    void syncCompositingState(GraphicsLayerTextureMapper*, int syncOptions = 0);
+    void syncCompositingState(GraphicsLayerTextureMapper*, TextureMapper*, int syncOptions = 0);
+    IntSize size() const { return IntSize(m_size.width() + .5, m_size.height() + .5); }
+    void setTransform(const TransformationMatrix&);
+    void setOpacity(float value) { m_opacity = value; }
+    void setVisibleRect(const IntRect&);
+    void setTextureMapper(TextureMapper* texmap) { m_textureMapper = texmap; }
+    bool descendantsOrSelfHaveRunningAnimations() const;
+
+    void paint();
+
+    bool needsToComputeBoundingRect() const;
+
+    const TextureMapperPlatformLayer* media() const { return m_currentContent.media; }
 
 private:
     TextureMapperNode* rootLayer();
-    void clearDirectImage();
-    void computeTransformations();
-    IntSize nearestSurfaceSize() const;
-    void computeReplicaTransform();
-    void computeLayerType();
-    void computeLocalTransform();
-    void flattenTo2DSpaceIfNecessary();
-    void initializeTextureMapper(TextureMapper*);
-    void invalidateTransform();
+    void computeAllTransforms();
+    void computeVisibleRectIfNeeded();
+    void computePerspectiveTransformIfNeeded();
+    void computeReplicaTransformIfNeeded();
+    void computeOverlapsIfNeeded();
+    void computeLocalTransformIfNeeded();
+    void computeBoundingRectFromRootIfNeeded();
+    void computeTiles();
+    int countDescendantsWithContent() const;
+    FloatRect targetRectForTileRect(const FloatRect& totalTargetRect, const FloatRect& tileRect) const;
+    void invalidateViewport(const FloatRect&);
     void notifyChange(ChangeMask);
-    void setNeedsDisplay();
-    void setNeedsDisplayInRect(IntRect);
-    void performPostSyncOperations();
-    void syncCompositingStateInternal(GraphicsLayerTextureMapper*, bool recursive, TextureMapper*);
     void syncCompositingStateSelf(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper);
-    TextureMapperCache* cache();
-
-    void paintRecursive(TexmapPaintOptions options);
-    bool paintReplica(const TexmapPaintOptions& options);
-    void paintSurface(const TexmapPaintOptions& options);
-    void paintSelf(const TexmapPaintOptions& options);
-    void paintSelfAndChildren(const TexmapPaintOptions& options, TexmapPaintOptions& optionsForDescendants);
-    void uploadTextureFromContent(TextureMapper* textureMapper, const IntRect& visibleRect, GraphicsLayer* layer);
-
-    int countDescendantsWithContent() const;
-    bool hasSurfaceDescendants() const;
-
-    TextureMapper* textureMapper();
-
-
-    static TextureMapperNode* toTextureMapperNode(GraphicsLayer*);
+
     static int compareGraphicsLayersZValue(const void* a, const void* b);
     static void sortByZOrder(Vector<TextureMapperNode* >& array, int first, int last);
+
+    BitmapTexture* texture() { return m_tiles.isEmpty() ? 0 : m_tiles[0].texture.get(); }
+
+    void paintRecursive(TextureMapperPaintOptions);
+    bool paintReflection(const TextureMapperPaintOptions&, BitmapTexture* surface);
+    void paintSelf(const TextureMapperPaintOptions&);
+    void paintSelfAndChildren(const TextureMapperPaintOptions&, TextureMapperPaintOptions& optionsForDescendants);
+    void renderContent(TextureMapper*, GraphicsLayer*);
+
+    void syncAnimations(GraphicsLayerTextureMapper*);
+    void applyAnimation(const TextureMapperAnimation&, double runningTime);
+    void applyAnimationFrame(const TextureMapperAnimation&, const AnimationValue* from, const AnimationValue* to, float progress);
+    void applyOpacityAnimation(float fromOpacity, float toOpacity, double);
+    void applyTransformAnimation(const TextureMapperAnimation&, const TransformOperations* start, const TransformOperations* end, double);
+    bool hasRunningOpacityAnimation() const;
+    bool hasRunningTransformAnimation() const;
+
     struct TransformData {
-        TransformationMatrix base, target, replica, forDescendants, perspective, local;
-        IntRect targetBoundingRect;
+        TransformationMatrix target;
+        TransformationMatrix replica;
+        TransformationMatrix forDescendants;
+        TransformationMatrix local;
+        TransformationMatrix base;
+        TransformationMatrix perspective;
+        FloatRect targetBoundingRect;
         float centerZ;
-        bool dirty, localDirty, perspectiveDirty;
-        IntRect boundingRectFromRoot;
-        TransformData() : dirty(true), localDirty(true), perspectiveDirty(true) { }
+        FloatRect boundingRectFromRoot;
+        FloatRect boundingRectFromRootForDescendants;
+        TransformData() { }
     };
 
     TransformData m_transforms;
 
-    enum LayerType {
-        DefaultLayer,
-        RootLayer,
-        ScissorLayer,
-        ClipLayer,
-        TransparencyLayer
-    };
-
-    LayerType m_layerType;
-
-    inline IntRect targetRect() const
+    inline FloatRect targetRect() const
     {
         return m_currentContent.contentType == HTMLContentType ? entireRect() : m_state.contentsRect;
     }
 
-    inline IntRect entireRect() const
+    inline FloatRect entireRect() const
     {
-        return IntRect(0, 0, m_size.width(), m_size.height());
+        return FloatRect(0, 0, m_size.width(), m_size.height());
     }
 
-    inline IntRect replicaRect() const
+    FloatSize contentSize() const
     {
-        return m_layerType == TransparencyLayer ? IntRect(0, 0, m_nearestSurfaceSize.width(), m_nearestSurfaceSize.height()) : entireRect();
+        return m_currentContent.contentType == DirectImageContentType && m_currentContent.image ? m_currentContent.image->size() : m_size;
     }
-
-    RefPtr<BitmapTexture> m_texture;
-    RefPtr<BitmapTexture> m_surface, m_replicaSurface;
+    struct Tile {
+        FloatRect rect;
+        RefPtr<BitmapTexture> texture;
+        bool needsReset;
+    };
+
+    Vector<Tile> m_tiles;
 
     ContentData m_currentContent;
@@ -197 +224 @@
     TextureMapperNode* m_parent;
     TextureMapperNode* m_effectTarget;
-    IntSize m_size, m_nearestSurfaceSize;
+    FloatSize m_size;
+    float m_opacity;
     String m_name;
-    TextureMapperLayerClient* m_platformClient;
 
     struct State {
@@ -207 +234 @@
         TransformationMatrix transform;
         TransformationMatrix childrenTransform;
-        Color backgroundColor;
-        Color currentColor;
-        GraphicsLayer::CompositingCoordinatesOrientation geoOrientation;
-        GraphicsLayer::CompositingCoordinatesOrientation contentsOrientation;
         float opacity;
-        IntRect contentsRect;
+        FloatRect contentsRect;
         int descendantsWithContent;
         TextureMapperNode* maskLayer;
         TextureMapperNode* replicaLayer;
-        bool preserves3D;
-        bool masksToBounds;
-        bool drawsContent;
-        bool contentsOpaque;
-        bool backfaceVisibility;
-        bool visible;
-        bool dirty;
-        bool tiled;
-        bool hasSurfaceDescendants;
-        IntRect visibleRect;
+        bool preserves3D : 1;
+        bool masksToBounds : 1;
+        bool drawsContent : 1;
+        bool contentsOpaque : 1;
+        bool backfaceVisibility : 1;
+        bool visible : 1;
+        bool needsReset: 1;
+        bool mightHaveOverlaps : 1;
+        bool needsRepaint;
+        FloatRect visibleRect;
+        FloatRect rootVisibleRect;
+        float contentScale;
 
         State()
             : opacity(1.f)
-            , descendantsWithContent(0)
             , maskLayer(0)
             , replicaLayer(0)
@@ -238 +262 @@
             , backfaceVisibility(false)
             , visible(true)
-            , dirty(true)
-            , tiled(false)
-            , hasSurfaceDescendants(false)
+            , needsReset(false)
+            , mightHaveOverlaps(false)
+            , contentScale(1.0f)
         {
         }
@@ -246 +270 @@
 
     State m_state;
-    TextureMapperCache* m_cache;
+    TextureMapperSurfaceManager* m_surfaceManager;
+    TextureMapper* m_textureMapper;
+
+    Vector<RefPtr<TextureMapperAnimation> > m_animations;
 };
+
+
+TextureMapperNode* toTextureMapperNode(GraphicsLayer*);
 
 }

trunk/Source/WebCore/platform/qt/QWebPageClient.h

@@ -53 +53 @@
     virtual bool inputMethodEnabled() const = 0;
 #if USE(ACCELERATED_COMPOSITING)
-    virtual void setRootGraphicsLayer(WebCore::PlatformLayer* layer) { }
+    virtual void setRootGraphicsLayer(WebCore::GraphicsLayer* layer) { }
 
     // this gets called when the compositor wants us to sync the layers

trunk/Source/WebCore/plugins/PluginView.h

@@ -59 +59 @@
 #endif
 #if PLATFORM(QT)
+#if USE(TEXTURE_MAPPER)
+#include "TextureMapperPlatformLayer.h"
+#endif
+
 #include <QGraphicsItem>
 #include <QImage>

trunk/Source/WebKit/qt/Api/qwebframe.cpp

@@ -99 +99 @@
 #if USE(TEXTURE_MAPPER)
 #include "texmap/TextureMapper.h"
-#include "texmap/TextureMapperPlatformLayer.h"
+#include "texmap/TextureMapperNode.h"
 #endif
 #include "wtf/HashMap.h"
@@ -322 +322 @@
 void QWebFramePrivate::renderCompositedLayers(GraphicsContext* context, const IntRect& clip)
 {
-    if (!rootGraphicsLayer)
+    if (!rootTextureMapperNode || !textureMapper)
         return;
 
@@ -328 +328 @@
     textureMapper->setImageInterpolationQuality(context->imageInterpolationQuality());
     textureMapper->setTextDrawingMode(context->textDrawingMode());
+    textureMapper->setViewportSize(frame->view()->frameRect().size());
     QPainter* painter = context->platformContext();
-    FrameView* view = frame->view();
-    painter->save();
-    painter->beginNativePainting();
-    TextureMapperContentLayer::PaintOptions options;
-    options.visibleRect = clip;
-    options.targetRect = view->frameRect();
-    options.viewportSize = view->size();
-    options.opacity = painter->opacity();
-    rootGraphicsLayer->paint(textureMapper.get(), options);
-    painter->endNativePainting();
-    painter->restore();
+    const QTransform transform = painter->worldTransform();
+    const TransformationMatrix matrix(
+                transform.m11(), transform.m12(), 0, transform.m13(),
+                transform.m21(), transform.m22(), 0, transform.m23(),
+                0, 0, 1, 0,
+                transform.m31(), transform.m32(), 0, transform.m33()
+                );
+    rootTextureMapperNode->setTransform(matrix);
+    rootTextureMapperNode->setOpacity(painter->opacity());
+    textureMapper->beginPainting();
+    textureMapper->beginClip(matrix, clip);
+    rootTextureMapperNode->paint();
+    textureMapper->endClip();
+    textureMapper->endPainting();
 }
 #endif

trunk/Source/WebKit/qt/Api/qwebframe.h

@@ -57 +57 @@
     class FrameLoaderClientQt;
     class ChromeClientQt;
-    class PlatformLayerProxyQt;
+    class TextureMapperNodeClientQt;
 }
 class QWebFrameData;
@@ -233 +233 @@
     friend class WebCore::FrameLoaderClientQt;
     friend class WebCore::ChromeClientQt;
-    friend class WebCore::PlatformLayerProxyQt;
+    friend class WebCore::TextureMapperNodeClientQt;
     QWebFramePrivate *d;
     Q_PRIVATE_SLOT(d, void _q_orientationChanged())

trunk/Source/WebKit/qt/Api/qwebframe_p.h

@@ -47 +47 @@
     class HTMLFrameOwnerElement;
     class Scrollbar;
-    class TextureMapperContentLayer;
+    class TextureMapperNode;
 }
 class QWebPage;
@@ -83 +83 @@
         , marginHeight(-1)
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-        , rootGraphicsLayer(0)
+        , rootTextureMapperNode(0)
 #endif
         {}
@@ -121 +121 @@
     int marginHeight;
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-    WebCore::TextureMapperContentLayer* rootGraphicsLayer;
+    WebCore::TextureMapperNode* rootTextureMapperNode;
     OwnPtr<WebCore::TextureMapper> textureMapper;
 #endif

trunk/Source/WebKit/qt/ChangeLog

@@ +1 @@
+2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
+
+        Reviewed by Kenneth Rohde Christiansen.
+
+        [Texmap][Qt] Upstream texture-mapper changes from Qt's WebKit2 branch
+        https://bugs.webkit.org/show_bug.cgi?id=60439
+
+        Patch 10/12: Glue the TextureMapper refactoring into Webkit(1).
+        1. Pass a GraphicsLayer* instead of a PlatformLayer* to the QWebPageClient.
+        2. Set parameters in TextureMapper/TextureMapperNode instead of passing them in an options argument.
+        3. Rename PlatformLayerProxyQt to TextureMapperNodeClient
+
+        * Api/qwebframe.cpp:
+        (QWebFramePrivate::renderCompositedLayers):
+        * Api/qwebframe.h:
+        * Api/qwebframe_p.h:
+        (QWebFramePrivate::QWebFramePrivate):
+        * WebCoreSupport/ChromeClientQt.cpp:
+        (WebCore::ChromeClientQt::attachRootGraphicsLayer):
+        * WebCoreSupport/PageClientQt.cpp:
+        (WebCore::TextureMapperNodeClientQt::TextureMapperNodeClientQt):
+        (WebCore::TextureMapperNodeClientQt::scroll):
+        (WebCore::TextureMapperNodeClientQt::setTextureMapper):
+        (WebCore::TextureMapperNodeClientQt::~TextureMapperNodeClientQt):
+        (WebCore::TextureMapperNodeClientQt::computeLastModifiedRect):
+        (WebCore::TextureMapperNodeClientQt::syncRootLayer):
+        (WebCore::TextureMapperNodeClientQt::rootNode):
+        (WebCore::PageClientQWidget::setRootGraphicsLayer):
+        (WebCore::PageClientQWidget::syncLayers):
+        (WebCore::PageClientQWidget::~PageClientQWidget):
+        (WebCore::PageClientQGraphicsWidget::~PageClientQGraphicsWidget):
+        (WebCore::PageClientQGraphicsWidget::update):
+        (WebCore::PageClientQGraphicsWidget::syncLayers):
+        (WebCore::PageClientQGraphicsWidget::setRootGraphicsLayer):
+        (WebCore::PageClientQGraphicsWidget::markForSync):
+        * WebCoreSupport/PageClientQt.h:
+        (WebCore::PageClientQWidget::PageClientQWidget):
+        (WebCore::PageClientQGraphicsWidget::PageClientQGraphicsWidget):
+        (WebCore::PageClientQGraphicsWidget::syncLayersTimeout):
+
+
 2011-05-11  Noam Rosenthal  <noam.rosenthal@nokia.com>
 

trunk/Source/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp

@@ -622 +622 @@
 {
     if (platformPageClient())
-        platformPageClient()->setRootGraphicsLayer(graphicsLayer ? graphicsLayer->platformLayer() : 0);
+        platformPageClient()->setRootGraphicsLayer(graphicsLayer);
 }
 

trunk/Source/WebKit/qt/WebCoreSupport/PageClientQt.cpp

@@ -20 +20 @@
 
 #include "config.h"
-
 #include "PageClientQt.h"
-#include "TextureMapperQt.h"
-#include "texmap/TextureMapperPlatformLayer.h"
+
 #include <QGraphicsScene>
 #include <QGraphicsView>
@@ -30 +28 @@
 #endif
 
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+#include "TextureMapperQt.h"
+#include "texmap/TextureMapperNode.h"
+
 #ifdef QT_OPENGL_LIB
 #include "opengl/TextureMapperGL.h"
-#include <QGLWidget>
+#endif
 #endif
 
 namespace WebCore {
 
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)    
-class PlatformLayerProxyQt : public QObject, public virtual TextureMapperLayerClient {
-public:
-    PlatformLayerProxyQt(QWebFrame* frame, TextureMapperContentLayer* layer, QObject* object)
-        : QObject(object)
-        , m_frame(frame)
-        , m_layer(layer)
-    {
-        if (m_layer)
-            m_layer->setPlatformLayerClient(this);
-        m_frame->d->rootGraphicsLayer = m_layer;
-    }
-
-    void setTextureMapper(PassOwnPtr<TextureMapper> textureMapper)
-    {
-        m_frame->d->textureMapper = textureMapper;
-    }
-
-    virtual ~PlatformLayerProxyQt()
-    {
-        if (m_layer)
-            m_layer->setPlatformLayerClient(0);
-        if (m_frame->d)
-            m_frame->d->rootGraphicsLayer = 0;
-    }
-
-    virtual TextureMapper* textureMapper()
-    {
-        return m_frame->d->textureMapper.get();
-    }
-
-    // Since we just paint the composited tree and never create a special item for it, we don't have to handle its size changes.
-    void setSizeChanged(const IntSize&) { }
-
-private:
-    QWebFrame* m_frame;
-    TextureMapperContentLayer* m_layer;
-};
-
-class PlatformLayerProxyQWidget : public PlatformLayerProxyQt {
-public:
-    PlatformLayerProxyQWidget(QWebFrame* frame, TextureMapperContentLayer* layer, QWidget* widget)
-        : PlatformLayerProxyQt(frame, layer, widget)
-        , m_widget(widget)
-    {
-        if (m_widget)
-            m_widget->installEventFilter(this);
-
-        if (textureMapper())
-            return;
-
-        setTextureMapper(TextureMapperQt::create());
-    }
-
-    // We don't want a huge region-clip on the compositing layers; instead we unite the rectangles together
-    // and clear them when the paint actually occurs.
-    bool eventFilter(QObject* object, QEvent* event)
-    {
-        if (object == m_widget && event->type() == QEvent::Paint)
-            m_dirtyRect = QRect();
-        return QObject::eventFilter(object, event);
-    }
-
-    void setNeedsDisplay()
-    {
-        if (m_widget)
-            m_widget->update();
-    }
-
-    void setNeedsDisplayInRect(const IntRect& rect)
-    {
-        m_dirtyRect |= rect;
-        m_widget->update(m_dirtyRect);
-    }
-
-private:
-    QRect m_dirtyRect;
-    QWidget* m_widget;
-};
-
-#if !defined(QT_NO_GRAPHICSVIEW)
-class PlatformLayerProxyQGraphicsObject : public PlatformLayerProxyQt {
-public:
-    PlatformLayerProxyQGraphicsObject(QWebFrame* frame, TextureMapperContentLayer* layer, QGraphicsObject* object)
-        : PlatformLayerProxyQt(frame, layer, object)
-        , m_graphicsItem(object)
-    {
-        if (textureMapper())
-            return;
-
-#ifdef QT_OPENGL_LIB
-        QGraphicsView* view = object->scene()->views()[0];
-        if (view && view->viewport() && view->viewport()->inherits("QGLWidget")) {
-            setTextureMapper(TextureMapperGL::create());
-            return;
-        }
-#endif
-        setTextureMapper(TextureMapperQt::create());
-    }
-
-    void setNeedsDisplay()
-    {
-        if (m_graphicsItem)
-            m_graphicsItem->update();
-    }
-
-    void setNeedsDisplayInRect(const IntRect& rect)
-    {
-        if (m_graphicsItem)
-            m_graphicsItem->update(QRectF(rect));
-    }
-
-private:
-    QGraphicsItem* m_graphicsItem;
-};
-#endif // QT_NO_GRAPHICSVIEW
-
-void PageClientQWidget::setRootGraphicsLayer(TextureMapperPlatformLayer* layer)
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+TextureMapperNodeClientQt::TextureMapperNodeClientQt(QWebFrame* frame, GraphicsLayer* layer)
+    : m_frame(frame)
+    , m_rootGraphicsLayer(GraphicsLayer::create(0))
+{
+    m_frame->d->rootTextureMapperNode = rootNode();
+    m_rootGraphicsLayer->addChild(layer);
+    m_rootGraphicsLayer->setDrawsContent(false);
+    m_rootGraphicsLayer->setMasksToBounds(false);
+    m_rootGraphicsLayer->setSize(IntSize(1, 1));
+}
+
+void TextureMapperNodeClientQt::setTextureMapper(const PassOwnPtr<TextureMapper>& textureMapper)
+{
+    m_frame->d->textureMapper = textureMapper;
+    m_frame->d->rootTextureMapperNode->setTextureMapper(m_frame->d->textureMapper.get());
+}
+
+TextureMapperNodeClientQt::~TextureMapperNodeClientQt()
+{
+    m_frame->d->rootTextureMapperNode = 0;
+}
+
+void TextureMapperNodeClientQt::syncRootLayer()
+{
+    m_rootGraphicsLayer->syncCompositingStateForThisLayerOnly();
+}
+
+TextureMapperNode* TextureMapperNodeClientQt::rootNode()
+{
+    return toTextureMapperNode(m_rootGraphicsLayer.get());
+}
+
+
+void PageClientQWidget::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     if (layer) {
-        platformLayerProxy = new PlatformLayerProxyQWidget(page->mainFrame(), static_cast<TextureMapperContentLayer*>(layer), view);
-        return;
-    }
-    delete platformLayerProxy;
-    platformLayerProxy = 0;
+        textureMapperNodeClient = adoptPtr(new TextureMapperNodeClientQt(page->mainFrame(), layer));
+        textureMapperNodeClient->setTextureMapper(new TextureMapperQt);
+        textureMapperNodeClient->syncRootLayer();
+        return;
+    }
+    textureMapperNodeClient.clear();
 }
 
@@ -171 +91 @@
 void PageClientQWidget::syncLayers(Timer<PageClientQWidget>*)
 {
+    if (textureMapperNodeClient)
+        textureMapperNodeClient->syncRootLayer();
     QWebFramePrivate::core(page->mainFrame())->view()->syncCompositingStateIncludingSubframes();
+    if (!textureMapperNodeClient)
+        return;
+    if (textureMapperNodeClient->rootNode()->descendantsOrSelfHaveRunningAnimations())
+        syncTimer.startOneShot(1.0 / 60.0);
+    update(view->rect());
 }
 #endif
@@ -202 +129 @@
 PageClientQWidget::~PageClientQWidget()
 {
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-    delete platformLayerProxy;
-#endif
 }
 
@@ -261 +185 @@
 {
     delete overlay;
-#if USE(ACCELERATED_COMPOSITING)
-#if USE(TEXTURE_MAPPER)
-    delete platformLayerProxy;
-#else
+#if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
     if (!rootGraphicsLayer)
         return;
@@ -271 +192 @@
     view->scene()->removeItem(rootGraphicsLayer.data());
 #endif
-#endif
 }
 
@@ -286 +206 @@
     if (overlay)
         overlay->update(QRectF(dirtyRect));
-#if USE(ACCELERATED_COMPOSITING)
+#if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
     syncLayers();
 #endif
@@ -321 +241 @@
 void PageClientQGraphicsWidget::syncLayers()
 {
-    if (shouldSync) {
-        QWebFramePrivate::core(page->mainFrame())->view()->syncCompositingStateIncludingSubframes();
-        shouldSync = false;
-    }
-}
-
 #if USE(TEXTURE_MAPPER)
-void PageClientQGraphicsWidget::setRootGraphicsLayer(TextureMapperPlatformLayer* layer)
+    if (textureMapperNodeClient)
+        textureMapperNodeClient->syncRootLayer();
+#endif
+
+    QWebFramePrivate::core(page->mainFrame())->view()->syncCompositingStateIncludingSubframes();
+
+#if USE(TEXTURE_MAPPER)
+    if (!textureMapperNodeClient)
+        return;
+
+    if (textureMapperNodeClient->rootNode()->descendantsOrSelfHaveRunningAnimations())
+        syncTimer.startOneShot(1.0 / 60.0);
+    update(view->boundingRect().toAlignedRect());
+    if (!shouldSync)
+        return;
+    shouldSync = false;
+#endif
+}
+
+#if USE(TEXTURE_MAPPER)
+void PageClientQGraphicsWidget::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     if (layer) {
-        platformLayerProxy = new PlatformLayerProxyQGraphicsObject(page->mainFrame(), static_cast<TextureMapperContentLayer*>(layer), view);
-        return;
-    }
-    delete platformLayerProxy;
-    platformLayerProxy = 0;
+        textureMapperNodeClient = adoptPtr(new TextureMapperNodeClientQt(page->mainFrame(), layer));
+#ifdef QT_OPENGL_LIB
+        QGraphicsView* graphicsView = view->scene()->views()[0];
+        if (graphicsView && graphicsView->viewport() && graphicsView->viewport()->inherits("QGLWidget")) {
+            textureMapperNodeClient->setTextureMapper(TextureMapperGL::create());
+            return;
+        }
+#endif
+        textureMapperNodeClient->setTextureMapper(TextureMapperQt::create());
+        return;
+    }
+    textureMapperNodeClient.clear();
 }
 #else
-void PageClientQGraphicsWidget::setRootGraphicsLayer(QGraphicsObject* layer)
+void PageClientQGraphicsWidget::setRootGraphicsLayer(GraphicsLayer* layer)
 {
     if (rootGraphicsLayer) {
@@ -346 +287 @@
     }
 
-    rootGraphicsLayer = layer;
-
-    if (layer) {
-        layer->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
-        layer->setParentItem(view);
-        layer->setZValue(RootGraphicsLayerZValue);
+    rootGraphicsLayer = layer ? layer->platformLayer() : 0;
+
+    if (rootGraphicsLayer) {
+        rootGraphicsLayer.data()->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+        rootGraphicsLayer.data()->setParentItem(view);
+        rootGraphicsLayer.data()->setZValue(RootGraphicsLayerZValue);
     }
     createOrDeleteOverlay();
@@ -360 +301 @@
 {
     shouldSync = true;
-    if (scheduleSync)
-        syncMetaMethod.invoke(view, Qt::QueuedConnection);
+    syncTimer.startOneShot(0);
 }
 

trunk/Source/WebKit/qt/WebCoreSupport/PageClientQt.h

@@ -42 +42 @@
 #include <Settings.h>
 
-#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-#include "texmap/TextureMapperPlatformLayer.h"
-#endif
-
 namespace WebCore {
+
+#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
+class TextureMapperNodeClientQt {
+public:
+    TextureMapperNodeClientQt(QWebFrame*, GraphicsLayer*);
+    virtual ~TextureMapperNodeClientQt();
+    void setTextureMapper(const PassOwnPtr<TextureMapper>&);
+    void syncRootLayer();
+    TextureMapperNode* rootNode();
+
+private:
+    QWebFrame* m_frame;
+    OwnPtr<GraphicsLayer> m_rootGraphicsLayer;
+};
+#endif
 
 class PageClientQWidget : public QWebPageClient {
@@ -55 +66 @@
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
         , syncTimer(this, &PageClientQWidget::syncLayers)
-        , platformLayerProxy(0)
 #endif
     {
@@ -92 +102 @@
 
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
-    virtual void setRootGraphicsLayer(TextureMapperPlatformLayer* layer);
+    virtual void setRootGraphicsLayer(GraphicsLayer*);
     virtual void markForSync(bool scheduleSync);
     void syncLayers(Timer<PageClientQWidget>*);
@@ -105 +115 @@
 #if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)
     Timer<PageClientQWidget> syncTimer;
-    PlatformLayerProxyQt* platformLayerProxy;
+    OwnPtr<TextureMapperNodeClientQt> textureMapperNodeClient;
 #endif
 };
@@ -151 +161 @@
         , viewResizesToContents(false)
 #if USE(ACCELERATED_COMPOSITING)
-#if USE(TEXTURE_MAPPER)
-        , platformLayerProxy(0)
-#endif
+        , syncTimer(this, &PageClientQGraphicsWidget::syncLayersTimeout)
         , shouldSync(false)
 #endif
@@ -163 +171 @@
         // this QGraphicsWebView as the scrollbars are needed when there's no compositing
         view->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
-        syncMetaMethod = view->metaObject()->method(view->metaObject()->indexOfMethod("syncLayers()"));
 #endif
     }
@@ -201 +208 @@
 
 #if USE(ACCELERATED_COMPOSITING)
-    virtual void setRootGraphicsLayer(PlatformLayer* layer);
+    virtual void setRootGraphicsLayer(GraphicsLayer*);
     virtual void markForSync(bool scheduleSync);
     void syncLayers();
+    void syncLayersTimeout(Timer<PageClientQGraphicsWidget>*) { syncLayers(); }
 
     // QGraphicsWebView can render composited layers
@@ -217 +225 @@
 #if USE(ACCELERATED_COMPOSITING)
 #if USE(TEXTURE_MAPPER)
-    PlatformLayerProxyQt* platformLayerProxy;
+    OwnPtr<TextureMapperNodeClientQt> textureMapperNodeClient;
 #else
     QWeakPointer<QGraphicsObject> rootGraphicsLayer;
 #endif
     // we have to flush quite often, so we use a meta-method instead of QTimer::singleShot for putting the event in the queue
-    QMetaMethod syncMetaMethod;
+    Timer<PageClientQGraphicsWidget> syncTimer;
 
     // we need to sync the layers if we get a special call from the WebCore