Changeset 137481 in webkit

Timestamp:

Dec 12, 2012 10:32:01 AM (11 years ago)

Author:

allan.jensen@digia.com

Message:

[Qt] Animation fails on large layers
​https://bugs.webkit.org/show_bug.cgi?id=104538

Reviewed by Noam Rosenthal.

The backing tiles had no upper limit defined for the non-GL backend, which could cause them
to allocate pixmaps widier or higher than what the underlying graphics systems can handle.

On top of that GraphicsLayerTextureMapper::prepareBackingStore() would allocate an intermediate
pixmap the size of the dirty rect, which would at least on the first paint be the size of the
entire layer, again causing allocation of pixmaps with dimensions outside of platform bounds.

This patch introduces a limit to the size of image buffer tiles, and adds an alternative path
for painting where the GraphicsLayer paints directly to the tile instead of over an intermediate
pixmap. This alternative path can also be useful later to minimize the amount of pixel copying
happening in full repaints.

• platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:

(WebCore::GraphicsLayerTextureMapper::prepareBackingStore):

• platform/graphics/texmap/GraphicsLayerTextureMapper.h:

(GraphicsLayerTextureMapper):

• platform/graphics/texmap/TextureMapper.cpp:

(WebCore::BitmapTexture::updateContents):

• platform/graphics/texmap/TextureMapper.h:

(BitmapTexture):
(TextureMapper):

• platform/graphics/texmap/TextureMapperBackingStore.cpp:

(WebCore::TextureMapperTile::updateContents):
(WebCore::TextureMapperTiledBackingStore::updateContents):

• platform/graphics/texmap/TextureMapperBackingStore.h:

(TextureMapperTile):
(TextureMapperTiledBackingStore):

• platform/graphics/texmap/TextureMapperImageBuffer.cpp:

(WebCore::BitmapTextureImageBuffer::updateContents):
(WebCore::TextureMapperImageBuffer::maxTextureSize):

• platform/graphics/texmap/TextureMapperImageBuffer.h:

(BitmapTextureImageBuffer):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/texmap/GraphicsLayerTextureMapper.cpp (modified) (1 diff)
• platform/graphics/texmap/GraphicsLayerTextureMapper.h (modified) (2 diffs)
• platform/graphics/texmap/TextureMapper.cpp (modified) (2 diffs)
• platform/graphics/texmap/TextureMapper.h (modified) (3 diffs)
• platform/graphics/texmap/TextureMapperBackingStore.cpp (modified) (2 diffs)
• platform/graphics/texmap/TextureMapperBackingStore.h (modified) (2 diffs)
• platform/graphics/texmap/TextureMapperImageBuffer.cpp (modified) (4 diffs)
• platform/graphics/texmap/TextureMapperImageBuffer.h (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-12-12  Allan Sandfeld Jensen  <allan.jensen@digia.com>
+
+        [Qt] Animation fails on large layers
+        https://bugs.webkit.org/show_bug.cgi?id=104538
+
+        Reviewed by Noam Rosenthal.
+
+        The backing tiles had no upper limit defined for the non-GL backend, which could cause them
+        to allocate pixmaps widier or higher than what the underlying graphics systems can handle.
+
+        On top of that GraphicsLayerTextureMapper::prepareBackingStore() would allocate an intermediate
+        pixmap the size of the dirty rect, which would at least on the first paint be the size of the
+        entire layer, again causing allocation of pixmaps with dimensions outside of platform bounds.
+
+        This patch introduces a limit to the size of image buffer tiles, and adds an alternative path
+        for painting where the GraphicsLayer paints directly to the tile instead of over an intermediate
+        pixmap. This alternative path can also be useful later to minimize the amount of pixel copying
+        happening in full repaints.
+
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
+        (WebCore::GraphicsLayerTextureMapper::prepareBackingStore):
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:
+        (GraphicsLayerTextureMapper):
+        * platform/graphics/texmap/TextureMapper.cpp:
+        (WebCore::BitmapTexture::updateContents):
+        * platform/graphics/texmap/TextureMapper.h:
+        (BitmapTexture):
+        (TextureMapper):
+        * platform/graphics/texmap/TextureMapperBackingStore.cpp:
+        (WebCore::TextureMapperTile::updateContents):
+        (WebCore::TextureMapperTiledBackingStore::updateContents):
+        * platform/graphics/texmap/TextureMapperBackingStore.h:
+        (TextureMapperTile):
+        (TextureMapperTiledBackingStore):
+        * platform/graphics/texmap/TextureMapperImageBuffer.cpp:
+        (WebCore::BitmapTextureImageBuffer::updateContents):
+        (WebCore::TextureMapperImageBuffer::maxTextureSize):
+        * platform/graphics/texmap/TextureMapperImageBuffer.h:
+        (BitmapTextureImageBuffer):
+
 2012-12-12  Aaron Colwell  <acolwell@chromium.org>
 

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

@@ -467 +467 @@
         m_backingStore = TextureMapperTiledBackingStore::create();
 
-    // Paint the entire dirty rect into an image buffer. This ensures we only paint once.
-    OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(dirtyRect.size());
-    GraphicsContext* context = imageBuffer->context();
-    context->setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
-    context->setTextDrawingMode(textureMapper->textDrawingMode());
-    context->translate(-dirtyRect.x(), -dirtyRect.y());
-    paintGraphicsLayerContents(*context, dirtyRect);
-
-    if (isShowingRepaintCounter()) {
+    ASSERT(dynamic_cast<TextureMapperTiledBackingStore*>(m_backingStore.get()));
+    TextureMapperTiledBackingStore* backingStore = static_cast<TextureMapperTiledBackingStore*>(m_backingStore.get());
+
+    if (isShowingRepaintCounter())
         incrementRepaintCount();
-        drawRepaintCounter(context);
-    }
-
-    RefPtr<Image> image = imageBuffer->copyImage(DontCopyBackingStore);
-#if PLATFORM(QT)
-    ASSERT(dynamic_cast<TextureMapperTiledBackingStore*>(m_backingStore.get()));
-#endif
-    TextureMapperTiledBackingStore* backingStore = static_cast<TextureMapperTiledBackingStore*>(m_backingStore.get());
-    backingStore->updateContents(textureMapper, image.get(), m_size, dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
+
+    // Paint into an intermediate buffer to avoid painting content more than once.
+    bool paintOnce = true;
+    const IntSize maxTextureSize = textureMapper->maxTextureSize();
+    // We need to paint directly if the dirty rect exceeds one of the maximum dimensions.
+    if (dirtyRect.width() > maxTextureSize.width() || dirtyRect.height() > maxTextureSize.height())
+        paintOnce = false;
+
+    if (paintOnce) {
+        OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(dirtyRect.size());
+        GraphicsContext* context = imageBuffer->context();
+        context->setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
+        context->setTextDrawingMode(textureMapper->textDrawingMode());
+        context->translate(-dirtyRect.x(), -dirtyRect.y());
+        paintGraphicsLayerContents(*context, dirtyRect);
+
+        if (isShowingRepaintCounter())
+            drawRepaintCounter(context);
+
+        RefPtr<Image> image = imageBuffer->copyImage(DontCopyBackingStore);
+        backingStore->updateContents(textureMapper, image.get(), m_size, dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
+    } else
+        backingStore->updateContents(textureMapper, this, m_size, dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
 
     backingStore->setShowDebugBorders(isShowingDebugBorder());

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

@@ -98 +98 @@
     bool fixedToViewport() const { return m_fixedToViewport; }
 
+    void drawRepaintCounter(GraphicsContext*);
 private:
     virtual void willBeDestroyed();
@@ -105 +106 @@
     void prepareBackingStore();
     bool shouldHaveBackingStore() const;
-    void drawRepaintCounter(GraphicsContext*);
     void animationStartedTimerFired(Timer<GraphicsLayerTextureMapper>*);
 

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

@@ -21 +21 @@
 #include "TextureMapper.h"
 
+#include "GraphicsLayer.h"
 #include "TextureMapperImageBuffer.h"
 #include "Timer.h"
@@ -146 +147 @@
 { }
 
+void BitmapTexture::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
+{
+    OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(targetRect.size());
+    GraphicsContext* context = imageBuffer->context();
+    context->setImageInterpolationQuality(textureMapper->imageInterpolationQuality());
+    context->setTextDrawingMode(textureMapper->textDrawingMode());
+
+    IntRect sourceRect(targetRect);
+    sourceRect.setLocation(offset);
+    context->translate(-offset.x(), -offset.y());
+    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
+
+    RefPtr<Image> image = imageBuffer->copyImage(DontCopyBackingStore);
+
+    updateContents(image.get(), targetRect, IntPoint(), updateContentsFlag);
 }
+
+} // namespace
+
 #endif

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

@@ -50 +50 @@
 class BitmapTexturePool;
 class CustomFilterProgram;
+class GraphicsLayer;
 class TextureMapper;
 
 // A 2D texture that can be the target of software or GL rendering.
-class BitmapTexture  : public RefCounted<BitmapTexture> {
+class BitmapTexture : public RefCounted<BitmapTexture> {
 public:
     enum Flag {
@@ -76 +77 @@
     virtual IntSize size() const = 0;
     virtual void updateContents(Image*, const IntRect&, const IntPoint& offset, UpdateContentsFlag) = 0;
+    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
     virtual void updateContents(const void*, const IntRect& target, const IntPoint& offset, int bytesPerLine, UpdateContentsFlag) = 0;
     virtual bool isValid() const = 0;
@@ -152 +154 @@
     virtual void endPainting() { }
 
-    virtual IntSize maxTextureSize() const { return IntSize(INT_MAX, INT_MAX); }
+    virtual IntSize maxTextureSize() const = 0;
 
     virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&);

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

@@ -79 +79 @@
 
     m_texture->updateContents(image, targetRect, sourceOffset, updateContentsFlag);
+}
+
+void TextureMapperTile::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
+{
+    IntRect targetRect = enclosingIntRect(m_rect);
+    targetRect.intersect(dirtyRect);
+    if (targetRect.isEmpty())
+        return;
+    IntPoint sourceOffset = targetRect.location();
+
+    // Normalize targetRect to the texture's coordinates.
+    targetRect.move(-m_rect.x(), -m_rect.y());
+
+    if (!m_texture) {
+        m_texture = textureMapper->createTexture();
+        m_texture->reset(targetRect.size(), BitmapTexture::SupportsAlpha);
+    }
+
+    m_texture->updateContents(textureMapper, sourceLayer, targetRect, sourceOffset, updateContentsFlag);
 }
 
@@ -198 +217 @@
 }
 
+void TextureMapperTiledBackingStore::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const FloatSize& totalSize, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
+{
+    createOrDestroyTilesIfNeeded(totalSize, textureMapper->maxTextureSize(), true);
+    for (size_t i = 0; i < m_tiles.size(); ++i)
+        m_tiles[i].updateContents(textureMapper, sourceLayer, dirtyRect, updateContentsFlag);
+}
+
 PassRefPtr<BitmapTexture> TextureMapperTiledBackingStore::texture() const
 {

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

@@ -74 +74 @@
 
     void updateContents(TextureMapper*, Image*, const IntRect&, BitmapTexture::UpdateContentsFlag UpdateCanModifyOriginalImageData);
+    void updateContents(TextureMapper*, GraphicsLayer*, const IntRect&, BitmapTexture::UpdateContentsFlag UpdateCanModifyOriginalImageData);
     virtual void paint(TextureMapper*, const TransformationMatrix&, float, BitmapTexture*, const unsigned exposedEdges);
     virtual ~TextureMapperTile() { }
@@ -95 +96 @@
     virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*) OVERRIDE;
     void updateContents(TextureMapper*, Image*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
+    void updateContents(TextureMapper*, GraphicsLayer*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
 
     void setContentsToImage(Image* image) { m_image = image; }

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

@@ -22 +22 @@
 
 #include "FilterEffectRenderer.h"
+#include "GraphicsLayer.h"
 #if PLATFORM(QT)
 #include "NativeImageQt.h"
@@ -29 +30 @@
 #if USE(TEXTURE_MAPPER)
 namespace WebCore {
+
+static const int s_maximumAllowedImageBufferDimension = 4096;
 
 void BitmapTextureImageBuffer::updateContents(const void* data, const IntRect& targetRect, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag)
@@ -55 +58 @@
 }
 
+void BitmapTextureImageBuffer::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& sourceOffset, UpdateContentsFlag)
+{
+    GraphicsContext* context = m_image->context();
+
+    context->clearRect(targetRect);
+
+    IntRect sourceRect(targetRect);
+    sourceRect.setLocation(sourceOffset);
+    context->save();
+    context->translate(targetRect.x() - sourceOffset.x(), targetRect.y() - sourceOffset.y());
+    sourceLayer->paintGraphicsLayerContents(*context, sourceRect);
+    context->restore();
+}
+
 void BitmapTextureImageBuffer::didReset()
 {
@@ -63 +80 @@
 {
     m_image->context()->drawImage(image, ColorSpaceDeviceRGB, targetRect, IntRect(offset, targetRect.size()), CompositeCopy);
+}
+
+IntSize TextureMapperImageBuffer::maxTextureSize() const
+{
+    return IntSize(s_maximumAllowedImageBufferDimension, s_maximumAllowedImageBufferDimension);
 }
 

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

@@ -36 +36 @@
     inline GraphicsContext* graphicsContext() { return m_image ? m_image->context() : 0; }
     virtual void updateContents(Image*, const IntRect&, const IntPoint&, UpdateContentsFlag);
+    virtual void updateContents(TextureMapper*, GraphicsLayer*, const IntRect& target, const IntPoint& offset, UpdateContentsFlag);
     virtual void updateContents(const void*, const IntRect& target, const IntPoint& sourceOffset, int bytesPerLine, UpdateContentsFlag);
 #if ENABLE(CSS_FILTERS)
@@ -66 +67 @@
     virtual void bindSurface(BitmapTexture* surface) OVERRIDE { m_currentSurface = surface;}
     virtual void endClip() OVERRIDE { graphicsContext()->restore(); }
+    virtual IntSize maxTextureSize() const;
     virtual PassRefPtr<BitmapTexture> createTexture() OVERRIDE { return BitmapTextureImageBuffer::create(); }