ChangeLog

2013-02-25  No'am Rosenthal  <noam@webkit.org>

        [Texmap] TextureMapper is too eager to use intermediate surfaces.

        https://bugs.webkit.org/show_bug.cgi?id=110762

        Reviewed by NOBODY (OOPS!).

        Refactor the way intermediate surfaces are handled in TextureMapperLayer.

        Beforehand, we would create an intermediate surface whenever there is a chance of overlap, and

        the intermediate surface would be the largest possible. The result would then be drawn to the

        target surface with the layer's opacity and mask.

        This would make it so that (1) surfaces are created even when they're not needed, i.e. when there

        is no actual overlap, and (2) mask wouldn't be applied correctly.

        In this patch the behavior is changed so that the area to be painted is divided to "overlapping"

        and "non overlapping" regions. The non-overlapping regions are painted directly, while the overlapping

        regions are tiled to smaller rectangles painted using an intermediate surface.

        Masks are applied to those intermediate surfaces based on the transform of the actual mask, not drawn

        together with the content texture like before.

        This optimizes for the more common case of opacity animations on a large tree, while making the quite

        rare case of composited masks slightly less optimized but always correct.

        Tests: compositing/overlap-blending/children-opacity-huge.html

               compositing/overlap-blending/reflection-opacity-huge.html

               compositing/overlap-blending/children-opacity-no-overlap.html

        * platform/graphics/cairo/GraphicsContext3DPrivate.cpp:

        (WebCore::GraphicsContext3DPrivate::paintToTextureMapper):

        * platform/graphics/cairo/GraphicsContext3DPrivate.h:

        (GraphicsContext3DPrivate):

        * platform/graphics/efl/GraphicsContext3DPrivate.cpp:

        (WebCore::GraphicsContext3DPrivate::paintToTextureMapper):

        * platform/graphics/efl/GraphicsContext3DPrivate.h:

        (GraphicsContext3DPrivate):

        * platform/graphics/qt/GraphicsContext3DQt.cpp:

        (GraphicsContext3DPrivate):

        (WebCore::GraphicsContext3DPrivate::paintToTextureMapper):

        * platform/graphics/qt/MediaPlayerPrivateQt.cpp:

        (WebCore::MediaPlayerPrivateQt::paintToTextureMapper):

        * platform/graphics/qt/MediaPlayerPrivateQt.h:

        (MediaPlayerPrivateQt):

        * platform/graphics/surfaces/GraphicsSurface.cpp:

        (WebCore::GraphicsSurface::paintToTextureMapper):

        * platform/graphics/surfaces/GraphicsSurface.h:

        (GraphicsSurface):

        * platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp:

        (WebCore::GraphicsSurface::platformPaintToTextureMapper):

        * platform/graphics/surfaces/mac/GraphicsSurfaceMac.cpp:

        (WebCore::GraphicsSurface::platformPaintToTextureMapper):

        * platform/graphics/surfaces/win/GraphicsSurfaceWin.cpp:

        (WebCore::GraphicsSurface::platformPaintToTextureMapper):

        * platform/graphics/texmap/TextureMapperBackingStore.h:

        (TextureMapperBackingStore):

        * platform/graphics/texmap/TextureMapperPlatformLayer.h:

        (TextureMapperPlatformLayer):

        * platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp:

        (WebCore::TextureMapperSurfaceBackingStore::paintToTextureMapper):

        * platform/graphics/texmap/TextureMapperSurfaceBackingStore.h:

        (TextureMapperSurfaceBackingStore):

        * platform/graphics/texmap/TextureMapperTile.cpp:

        (WebCore::TextureMapperTile::paint):

        * platform/graphics/texmap/TextureMapperTile.h:

        (TextureMapperTile):

        * platform/graphics/texmap/TextureMapperTiledBackingStore.cpp:

        (WebCore::TextureMapperTiledBackingStore::paintToTextureMapper):

        * platform/graphics/texmap/TextureMapperTiledBackingStore.h:

        (TextureMapperTiledBackingStore):

        * platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp:

        (WebCore::CoordinatedBackingStore::paintTilesToTextureMapper):

        (WebCore::CoordinatedBackingStore::paintToTextureMapper):

        * platform/graphics/texmap/coordinated/CoordinatedBackingStore.h:

        (CoordinatedBackingStore):

                Removed the "mask" parameter from TextureMapperPlatformLayer and overrides.

        * platform/graphics/texmap/TextureMapper.cpp:

        (WebCore::TextureMapper::TextureMapper):

        * platform/graphics/texmap/TextureMapper.h:

        (WebCore::TextureMapper::setMaskMode):

        (TextureMapper):

        (WebCore::TextureMapper::isInMaskMode):

        * platform/graphics/texmap/TextureMapperGL.cpp:

        (WebCore::TextureMapperGL::drawNumber):

        (WebCore::TextureMapperGL::drawTexture):

        (WebCore::TextureMapperGL::draw):

        (WebCore):

        (WebCore::TextureMapperGL::drawTexturedQuadWithProgram):

        (WebCore::TextureMapperGL::drawFiltered):

        * platform/graphics/texmap/TextureMapperGL.h:

        (TextureMapperGL):

        * platform/graphics/texmap/TextureMapperImageBuffer.cpp:

        (WebCore::TextureMapperImageBuffer::drawTexture):

        (WebCore::TextureMapperImageBuffer::drawSolidColor):

        * platform/graphics/texmap/TextureMapperImageBuffer.h:

        (TextureMapperImageBuffer):

                Instead of painting the mask together with the texture/color, paint the mask

                by drawing with DestinationIn to an existing surface.

        * platform/graphics/texmap/TextureMapperLayer.cpp:

        (TextureMapperPaintOptions):

        (WebCore::TextureMapperLayer::paintSelf):

        (WebCore::TextureMapperLayer::shouldBlend):

        (WebCore::TextureMapperLayer::paintSelfAndChildrenWithReplica):

        (WebCore::TextureMapperLayer::replicaTransform):

        (WebCore):

        (WebCore::applyFilters):

        (WebCore::resolveOverlaps):

        (WebCore::TextureMapperLayer::computeOverlapRegions):

        (WebCore::TextureMapperLayer::paintUsingOverlapRegions):

        (WebCore::TextureMapperLayer::applyMask):

        (WebCore::TextureMapperLayer::paintIntoSurface):

        (WebCore::commitSurface):

        (WebCore::TextureMapperLayer::paintWithIntermediateSurface):

        (WebCore::TextureMapperLayer::paintRecursive):

        * platform/graphics/texmap/TextureMapperLayer.h:

        (WebCore):

        (TextureMapperLayer):

        (WebCore::TextureMapperLayer::hasFilters):

        * platform/graphics/texmap/TextureMapperShaderProgram.cpp:

        (WebCore):

        (WebCore::TextureMapperShaderProgram::create):

        * platform/graphics/texmap/TextureMapperShaderProgram.h:

2013-02-23  No'am Rosenthal  <noam@webkit.org>

        [Texmap] LayoutTests/compositing/animation/state-at-end-event-transform-layer.html shows a red square where it shouldn't

Source/WebCore/platform/graphics/cairo/GraphicsContext3DPrivate.cpp

@@PlatformGraphicsContext3D GraphicsContext3DPrivate::platformContext()

}

#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)

81 void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity~~, BitmapTexture* mask~~)

81void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)

{

    if (!m_glContext)

        return;

@@void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper

    TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);

    TextureMapperGL::Flags flags = TextureMapperGL::ShouldFlipTexture | (m_context->m_attrs.alpha ? TextureMapperGL::ShouldBlend : 0);

    IntSize textureSize(m_context->m_currentWidth, m_context->m_currentHeight);

145 texmapGL->drawTexture(m_context->m_texture, flags, textureSize, targetRect, matrix, opacity~~, mask~~);

145 texmapGL->drawTexture(m_context->m_texture, flags, textureSize, targetRect, matrix, opacity);

#endif // USE(ACCELERATED_COMPOSITING_GL)

}

#endif // USE(ACCELERATED_COMPOSITING)

Source/WebCore/platform/graphics/cairo/GraphicsContext3DPrivate.h

@@public:

    GraphicsContext3D::RenderStyle renderStyle() { return m_renderStyle; }

#if USE(ACCELERATED_COMPOSITING) && USE(TEXTURE_MAPPER)

47 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity~~, BitmapTexture* mask~~);

47 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity);

#endif

private:

Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp

@@bool GraphicsContext3DPrivate::prepareBuffer() const

}

#if USE(TEXTURE_MAPPER_GL)

200 void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper*, const FloatRect& /* target */, const TransformationMatrix&, float /* opacity */~~, BitmapTexture* /* mask */~~)

200void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper*, const FloatRect& /* target */, const TransformationMatrix&, float /* opacity */)

{

    notImplemented();

}

Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.h

@@public:

    PlatformGraphicsContext3D platformGraphicsContext3D() const;

    void setContextLostCallback(PassOwnPtr<GraphicsContext3D::ContextLostCallback>);

#if USE(TEXTURE_MAPPER_GL)

51 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*) OVERRIDE;

51 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float) OVERRIDE;

#endif

#if USE(GRAPHICS_SURFACE)

    virtual IntSize platformLayerSize() const OVERRIDE;

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

@@public:

    ~GraphicsContext3DPrivate();

#if USE(ACCELERATED_COMPOSITING)

69 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity~~, BitmapTexture* mask~~);

69 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& target, const TransformationMatrix&, float opacity);

#endif

#if USE(GRAPHICS_SURFACE)

    virtual IntSize platformLayerSize() const;

@@static inline quint32 swapBgrToRgb(quint32 pixel)

}

#if USE(ACCELERATED_COMPOSITING)

212 void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity~~, BitmapTexture* mask~~)

212void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)

{

    m_context->markLayerComposited();

    blitMultisampleFramebufferAndRestoreContext();

@@void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper* textureMapper

        currentContext->makeCurrent(currentSurface);

        TextureMapperGL* texmapGL = static_cast<TextureMapperGL*>(textureMapper);

234 m_graphicsSurface->paintToTextureMapper(texmapGL, targetRect, matrix, opacity~~, mask~~);

234 m_graphicsSurface->paintToTextureMapper(texmapGL, targetRect, matrix, opacity);

#endif

        return;

    }

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

@@void MediaPlayerPrivateQt::paintCurrentFrameInContext(GraphicsContext* context,

}

#if USE(ACCELERATED_COMPOSITING)

648 void MediaPlayerPrivateQt::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, BitmapTexture*)

648void MediaPlayerPrivateQt::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)

{

}

#endif

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

@@public:

    virtual void acceleratedRenderingStateChanged() { }

    // Const-casting here is safe, since all of TextureMapperPlatformLayer's functions are const.g

    virtual PlatformLayer* platformLayer() const { return 0; }

112 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity~~, BitmapTexture* mask~~);

112 virtual void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity);

#endif

    virtual PlatformMedia platformMedia() const;

Source/WebCore/platform/graphics/surfaces/GraphicsSurface.cpp

@@void GraphicsSurface::copyFromTexture(uint32_t texture, const IntRect& sourceRec

    platformCopyFromTexture(texture, sourceRect);

}

66 void GraphicsSurface::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

66void GraphicsSurface::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

6767{

68 platformPaintToTextureMapper(textureMapper, targetRect, transform, opacity~~, mask~~);

68 platformPaintToTextureMapper(textureMapper, targetRect, transform, opacity);

}

uint32_t GraphicsSurface::frontBuffer()

Source/WebCore/platform/graphics/surfaces/GraphicsSurface.h

@@public:

    static PassRefPtr<GraphicsSurface> create(const IntSize&, Flags, const GraphicsSurfaceToken&);

    void copyToGLTexture(uint32_t target, uint32_t texture, const IntRect& targetRect, const IntPoint& sourceOffset);

    void copyFromTexture(uint32_t texture, const IntRect& sourceRect);

82 void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity~~, BitmapTexture* mask~~);

82 void paintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity);

    uint32_t frontBuffer();

    uint32_t swapBuffers();

    GraphicsSurfaceToken exportToken();

@@protected:

    void platformUnlock();

    void platformCopyToGLTexture(uint32_t target, uint32_t texture, const IntRect&, const IntPoint&);

    void platformCopyFromTexture(uint32_t texture, const IntRect& sourceRect);

102 void platformPaintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity~~, BitmapTexture* mask~~);

102 void platformPaintToTextureMapper(TextureMapper*, const FloatRect& targetRect, const TransformationMatrix&, float opacity);

    uint32_t platformFrontBuffer() const;

    uint32_t platformSwapBuffers();

    IntSize platformSize() const;

Source/WebCore/platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp

@@void GraphicsSurface::platformCopyFromTexture(uint32_t texture, const IntRect& s

    m_private->copyFromTexture(texture, sourceRect);

}

388 void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

388void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

{

    IntSize size = m_private->size();

    if (size.isEmpty())

@@void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper,

    FloatRect rectOnContents(FloatPoint::zero(), size);

    TransformationMatrix adjustedTransform = transform;

    adjustedTransform.multiply(TransformationMatrix::rectToRect(rectOnContents, targetRect));

400 static_cast<TextureMapperGL*>(textureMapper)->drawTexture(texture, m_private->flags(), size, rectOnContents, adjustedTransform, opacity~~, mask~~);

400 static_cast<TextureMapperGL*>(textureMapper)->drawTexture(texture, m_private->flags(), size, rectOnContents, adjustedTransform, opacity);

}

uint32_t GraphicsSurface::platformFrontBuffer() const

Source/WebCore/platform/graphics/surfaces/mac/GraphicsSurfaceMac.cpp

@@void GraphicsSurface::platformCopyFromTexture(uint32_t texture, const IntRect& s

    m_private->copyFromTexture(texture, sourceRect);

}

336 void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

336void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

{

    IntSize size = m_private->size();

    FloatRect rectOnContents(FloatPoint::zero(), size);

    TransformationMatrix adjustedTransform = transform;

    adjustedTransform.multiply(TransformationMatrix::rectToRect(rectOnContents, targetRect));

342 static_cast<TextureMapperGL*>(textureMapper)->drawTexture(m_private->frontBufferTextureID(), TextureMapperGL::ShouldBlend | TextureMapperGL::ShouldUseARBTextureRect, size, rectOnContents, adjustedTransform, opacity~~, mask~~);

342 static_cast<TextureMapperGL*>(textureMapper)->drawTexture(m_private->frontBufferTextureID(), TextureMapperGL::ShouldBlend | TextureMapperGL::ShouldUseARBTextureRect, size, rectOnContents, adjustedTransform, opacity);

}

uint32_t GraphicsSurface::platformFrontBuffer() const

Source/WebCore/platform/graphics/surfaces/win/GraphicsSurfaceWin.cpp

@@void GraphicsSurface::platformCopyFromTexture(uint32_t texture, const IntRect& s

    m_private->copyFromTexture(texture, sourceRect);

}

424 void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

424void GraphicsSurface::platformPaintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

{

    IntSize size = m_private->size();

    FloatRect rectOnContents(FloatPoint::zero(), size);

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

@@TextureMapper::TextureMapper(AccelerationMode accelerationMode)

    , m_textDrawingMode(TextModeFill)

    , m_texturePool(adoptPtr(new BitmapTexturePool()))

    , m_accelerationMode(accelerationMode)

144 , m_maskMode(false)

{ }

TextureMapper::~TextureMapper()

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

@@public:

    virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) = 0;

    virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) = 0;

135 virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, ~~const BitmapTexture* maskTexture = 0,~~ unsigned exposedEdges = AllEdges) = 0;

135 virtual void drawTexture(const BitmapTexture&, const FloatRect& target, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0f, unsigned exposedEdges = AllEdges) = 0;

    virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) = 0;

    // makes a surface the target for the following drawTexture calls.

@@public:

    virtual void beginPainting(PaintFlags = 0) { }

    virtual void endPainting() { }

156 void setMaskMode(bool m) { m_maskMode = m; }

157

    virtual IntSize maxTextureSize() const = 0;

    virtual PassRefPtr<BitmapTexture> acquireTextureFromPool(const IntSize&);

@@protected:

    GraphicsContext* m_context;

171 bool isInMaskMode() const { return m_maskMode; }

172

private:

#if USE(TEXTURE_MAPPER_GL)

    static PassOwnPtr<TextureMapper> platformCreateAccelerated();

@@private:

    TextDrawingModeFlags m_textDrawingMode;

    OwnPtr<BitmapTexturePool> m_texturePool;

    AccelerationMode m_accelerationMode;

186 bool m_maskMode;

};

}

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

@@class GraphicsLayer;

class TextureMapperBackingStore : public TextureMapperPlatformLayer, public RefCounted<TextureMapperBackingStore> {

public:

    virtual PassRefPtr<BitmapTexture> texture() const = 0;

42 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*) = 0;

42 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float) = 0;

    virtual void drawRepaintCounter(TextureMapper*, int /* repaintCount */, const Color&, const FloatRect&, const TransformationMatrix&) { }

    virtual ~TextureMapperBackingStore() { }

Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp

@@void TextureMapperGL::drawNumber(int number, const Color& color, const FloatPoin

    RefPtr<BitmapTexture> texture = acquireTextureFromPool(size);

    const uchar* bits = image.bits();

    static_cast<BitmapTextureGL*>(texture.get())->updateContentsNoSwizzle(bits, sourceRect, IntPoint::zero(), image.bytesPerLine());

352 drawTexture(*texture, targetRect, modelViewMatrix, 1.0f, 0, AllEdges);

352 drawTexture(*texture, targetRect, modelViewMatrix, 1.0f, AllEdges);

#elif USE(CAIRO)

    CString counterString = String::number(number).ascii();

@@void TextureMapperGL::drawNumber(int number, const Color& color, const FloatPoin

    const unsigned char* bits = cairo_image_surface_get_data(surface);

    int stride = cairo_image_surface_get_stride(surface);

    static_cast<BitmapTextureGL*>(texture.get())->updateContentsNoSwizzle(bits, sourceRect, IntPoint::zero(), stride);

383 drawTexture(*texture, targetRect, modelViewMatrix, 1.0f, 0, AllEdges);

383 drawTexture(*texture, targetRect, modelViewMatrix, 1.0f, AllEdges);

    cairo_surface_destroy(surface);

    cairo_destroy(cr);

@@void TextureMapperGL::drawNumber(int number, const Color& color, const FloatPoin

#endif

}

397 void TextureMapperGL::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, ~~const BitmapTexture* mask,~~ unsigned exposedEdges)

397void TextureMapperGL::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, unsigned exposedEdges)

{

    if (!texture.isValid())

        return;

@@void TextureMapperGL::drawTexture(const BitmapTexture& texture, const FloatRect&

        return;

    const BitmapTextureGL& textureGL = static_cast<const BitmapTextureGL&>(texture);

406 drawTexture(textureGL.id(), textureGL.isOpaque() ? 0 : ShouldBlend, textureGL.size(), targetRect, matrix, opacity, ~~mask,~~ exposedEdges);

406 drawTexture(textureGL.id(), textureGL.isOpaque() ? 0 : ShouldBlend, textureGL.size(), targetRect, matrix, opacity, exposedEdges);

407407}

408408

409 void TextureMapperGL::drawTexture(Platform3DObject texture, Flags flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, ~~const BitmapTexture* maskTexture,~~ unsigned exposedEdges)

409void TextureMapperGL::drawTexture(Platform3DObject texture, Flags flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges)

410410{

411411 bool useRect = flags & ShouldUseARBTextureRect;

412 bool masked = !!maskTexture;

    bool useAntialiasing = m_enableEdgeDistanceAntialiasing

        && exposedEdges == AllEdges

        && !modelViewMatrix.mapQuad(targetRect).isRectilinear();

    TextureMapperShaderProgram::Options options = TextureMapperShaderProgram::Texture;

418 if (masked)

419 options |= TextureMapperShaderProgram::Mask;

    if (useRect)

        options |= TextureMapperShaderProgram::Rect;

    if (opacity < 1)

@@void TextureMapperGL::drawTexture(Platform3DObject texture, Flags flags, const I

        flags |= ShouldAntialias;

    }

429 if (~~masked ||~~ useAntialiasing || opacity < 1)

426 if (useAntialiasing || opacity < 1)

        flags |= ShouldBlend;

    RefPtr<TextureMapperShaderProgram> program;

    program = data().sharedGLData().getShaderProgram(options);

434 drawTexturedQuadWithProgram(program.get(), texture, flags, textureSize, targetRect, modelViewMatrix, opacity~~, maskTexture~~);

431 drawTexturedQuadWithProgram(program.get(), texture, flags, textureSize, targetRect, modelViewMatrix, opacity);

}

void TextureMapperGL::drawSolidColor(const FloatRect& rect, const TransformationMatrix& matrix, const Color& color)

@@void TextureMapperGL::draw(const FloatRect& rect, const TransformationMatrix& mo

    shaderProgram->setMatrix(shaderProgram->modelViewMatrixLocation(), matrix);

    shaderProgram->setMatrix(shaderProgram->projectionMatrixLocation(), data().projectionMatrix);

507 if (flag~~s & ShouldBlend~~) {

508 m_context3D->blendFunc(GraphicsContext3D::~~ONE~~, GraphicsContext3D::~~ONE_MINUS_~~SRC_ALPHA);

504 if (isInMaskMode()) {

505 m_context3D->blendFunc(GraphicsContext3D::ZERO, GraphicsContext3D::SRC_ALPHA);

509506 m_context3D->enable(GraphicsContext3D::BLEND);

510 } else

511 m_context3D->disable(GraphicsContext3D::BLEND);

    } else {

        if (flags & ShouldBlend) {

            m_context3D->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA);

            m_context3D->enable(GraphicsContext3D::BLEND);

        } else

            m_context3D->disable(GraphicsContext3D::BLEND);

    }

    if (flags & ShouldAntialias)

        drawEdgeTriangles(shaderProgram);

@@void TextureMapperGL::draw(const FloatRect& rect, const TransformationMatrix& mo

        drawUnitRect(shaderProgram, drawingMode);

    m_context3D->disableVertexAttribArray(shaderProgram->vertexLocation());

521 m_context3D->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA);

522 m_context3D->enable(GraphicsContext3D::BLEND);

519523}

520 void TextureMapperGL::drawTexturedQuadWithProgram(TextureMapperShaderProgram* program, uint32_t texture, Flags flags, const IntSize& size, const FloatRect& rect, const TransformationMatrix& modelViewMatrix, float opacity, const BitmapTexture* maskTexture)

524

525void TextureMapperGL::drawTexturedQuadWithProgram(TextureMapperShaderProgram* program, uint32_t texture, Flags flags, const IntSize& size, const FloatRect& rect, const TransformationMatrix& modelViewMatrix, float opacity)

{

    m_context3D->useProgram(program->programID());

    m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);

@@void TextureMapperGL::drawTexturedQuadWithProgram(TextureMapperShaderProgram* pr

    if (flags & ShouldFlipTexture)

        patternTransform.translate(0, -1);

536

    program->setMatrix(program->textureSpaceMatrixLocation(), patternTransform);

    m_context3D->uniform1f(program->opacityLocation(), opacity);

    if (maskTexture && maskTexture->isValid()) {

        const BitmapTextureGL* maskTextureGL = static_cast<const BitmapTextureGL*>(maskTexture);

        m_context3D->activeTexture(GraphicsContext3D::TEXTURE1);

        m_context3D->bindTexture(GraphicsContext3D::TEXTURE_2D, maskTextureGL->id());

        m_context3D->uniform1i(program->maskLocation(), 1);

        m_context3D->activeTexture(GraphicsContext3D::TEXTURE0);

    }

    if (opacity < 1 || maskTexture)

544 if (opacity < 1)

        flags |= ShouldBlend;

    draw(rect, modelViewMatrix, program, GraphicsContext3D::TRIANGLE_FAN, flags);

@@void TextureMapperGL::drawFiltered(const BitmapTexture& sampler, const BitmapTex

    prepareFilterProgram(program.get(), filter, pass, sampler.contentSize(), static_cast<const BitmapTextureGL&>(contentTexture).id());

    FloatRect targetRect(IntPoint::zero(), sampler.contentSize());

946 drawTexturedQuadWithProgram(program.get(), static_cast<const BitmapTextureGL&>(sampler).id(), 0, IntSize(1, 1), targetRect, TransformationMatrix(), 1~~, 0~~);

942 drawTexturedQuadWithProgram(program.get(), static_cast<const BitmapTextureGL&>(sampler).id(), 0, IntSize(1, 1), targetRect, TransformationMatrix(), 1);

}

PassRefPtr<BitmapTexture> BitmapTextureGL::applyFilters(TextureMapper* textureMapper, const BitmapTexture& contentTexture, const FilterOperations& filters)

Source/WebCore/platform/graphics/texmap/TextureMapperGL.h

@@public:

    // TextureMapper implementation

    virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) OVERRIDE;

    virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) OVERRIDE;

57 virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, ~~const BitmapTexture* maskTexture,~~ unsigned exposedEdges) OVERRIDE;

58 virtual void drawTexture(Platform3DObject texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, ~~const BitmapTexture* maskTexture,~~ unsigned exposedEdges = AllEdges);

57 virtual void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, unsigned exposedEdges) OVERRIDE;

58 virtual void drawTexture(Platform3DObject texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);

    virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) OVERRIDE;

    virtual void bindSurface(BitmapTexture* surface) OVERRIDE;

@@private:

    TextureMapperGL();

105 void drawTexturedQuadWithProgram(TextureMapperShaderProgram*, uint32_t texture, Flags, const IntSize&, const FloatRect&, const TransformationMatrix& modelViewMatrix, float opacity~~, const BitmapTexture* maskTexture~~);

105 void drawTexturedQuadWithProgram(TextureMapperShaderProgram*, uint32_t texture, Flags, const IntSize&, const FloatRect&, const TransformationMatrix& modelViewMatrix, float opacity);

    void draw(const FloatRect&, const TransformationMatrix& modelViewMatrix, TextureMapperShaderProgram*, GC3Denum drawingMode, Flags);

    void drawUnitRect(TextureMapperShaderProgram*, GC3Denum drawingMode);

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

@@void TextureMapperImageBuffer::beginClip(const TransformationMatrix& matrix, con

#endif

}

117 void TextureMapperImageBuffer::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, ~~const BitmapTexture* maskTexture,~~ unsigned /* exposedEdges */)

117void TextureMapperImageBuffer::drawTexture(const BitmapTexture& texture, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity, unsigned /* exposedEdges */)

{

    GraphicsContext* context = currentContext();

    if (!context)

@@void TextureMapperImageBuffer::drawTexture(const BitmapTexture& texture, const F

    const BitmapTextureImageBuffer& textureImageBuffer = static_cast<const BitmapTextureImageBuffer&>(texture);

    ImageBuffer* image = textureImageBuffer.m_image.get();

    OwnPtr<ImageBuffer> maskedImage;

    if (maskTexture && maskTexture->isValid()) {

        const BitmapTextureImageBuffer* mask = static_cast<const BitmapTextureImageBuffer*>(maskTexture);

        maskedImage = ImageBuffer::create(maskTexture->contentSize());

        GraphicsContext* maskContext = maskedImage->context();

        maskContext->drawImageBuffer(image, ColorSpaceDeviceRGB, IntPoint::zero(), CompositeCopy);

        if (opacity < 1) {

            maskContext->setAlpha(opacity);

            opacity = 1;

        }

        maskContext->drawImageBuffer(mask->m_image.get(), ColorSpaceDeviceRGB, IntPoint::zero(), CompositeDestinationIn);

        image = maskedImage.get();

    }

140125 context->save();

126 context->setCompositeOperation(isInMaskMode() ? CompositeDestinationIn : CompositeSourceOver);

    context->setAlpha(opacity);

#if ENABLE(3D_RENDERING)

    context->concat3DTransform(matrix);

@@void TextureMapperImageBuffer::drawSolidColor(const FloatRect& rect, const Trans

        return;

    context->save();

144 context->setCompositeOperation(isInMaskMode() ? CompositeDestinationIn : CompositeSourceOver);

#if ENABLE(3D_RENDERING)

    context->concat3DTransform(matrix);

#else

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

@@public:

    // TextureMapper implementation

    virtual void drawBorder(const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) OVERRIDE;

    virtual void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) OVERRIDE;

58 virtual void drawTexture(const BitmapTexture&, const FloatRect& targetRect, const TransformationMatrix&, float opacity, ~~const BitmapTexture* maskTexture,~~ unsigned exposedEdges) OVERRIDE;

58 virtual void drawTexture(const BitmapTexture&, const FloatRect& targetRect, const TransformationMatrix&, float opacity, unsigned exposedEdges) OVERRIDE;

    virtual void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&) OVERRIDE;

    virtual void beginClip(const TransformationMatrix&, const FloatRect&) OVERRIDE;

    virtual void bindSurface(BitmapTexture* surface) OVERRIDE { m_currentSurface = surface;}

Source/WebCore/platform/graphics/texmap/TextureMapperLayer.cpp

#include "config.h"

#include "TextureMapperLayer.h"

23#include "Region.h"

24

#if USE(ACCELERATED_COMPOSITING)

namespace WebCore {

@@namespace WebCore {

class TextureMapperPaintOptions {

public:

    RefPtr<BitmapTexture> surface;

30 RefPtr<BitmapTexture> mask;

    float opacity;

    TransformationMatrix transform;

    IntSize offset;

@@void TextureMapperLayer::paintSelf(const TextureMapperPaintOptions& options)

    transform.multiply(m_currentTransform.combined());

    float opacity = options.opacity;

111 RefPtr<BitmapTexture> mask = options.mask;

112

    if (m_state.solidColor.isValid() && !m_state.contentsRect.isEmpty()) {

        options.textureMapper->drawSolidColor(m_state.contentsRect, transform, blendWithOpacity(m_state.solidColor, opacity));

        if (m_state.showDebugBorders)

@@void TextureMapperLayer::paintSelf(const TextureMapperPaintOptions& options)

    if (m_backingStore) {

        ASSERT(m_state.drawsContent && m_state.contentsVisible && !m_state.size.isEmpty());

        ASSERT(!layerRect().isEmpty());

123 m_backingStore->paintToTextureMapper(options.textureMapper, layerRect(), transform, opacity~~, mask.get()~~);

122 m_backingStore->paintToTextureMapper(options.textureMapper, layerRect(), transform, opacity);

        if (m_state.showDebugBorders)

            m_backingStore->drawBorder(options.textureMapper, m_state.debugBorderColor, m_state.debugBorderWidth, layerRect(), transform);

        // Only draw repaint count for the main backing store.

@@void TextureMapperLayer::paintSelf(const TextureMapperPaintOptions& options)

    if (m_contentsLayer) {

        ASSERT(!layerRect().isEmpty());

133 m_contentsLayer->paintToTextureMapper(options.textureMapper, m_state.contentsRect, transform, opacity~~, mask.get()~~);

132 m_contentsLayer->paintToTextureMapper(options.textureMapper, m_state.contentsRect, transform, opacity);

        if (m_state.showDebugBorders)

            m_contentsLayer->drawBorder(options.textureMapper, m_state.debugBorderColor, m_state.debugBorderWidth, m_state.contentsRect, transform);

    }

@@void TextureMapperLayer::paintSelfAndChildren(const TextureMapperPaintOptions& o

        options.textureMapper->endClip();

}

IntRect TextureMapperLayer::intermediateSurfaceRect()

{

    // FIXME: Add an inverse transform to LayerTransform.

    return intermediateSurfaceRect(m_currentTransform.combined().inverse());

}

IntRect TextureMapperLayer::intermediateSurfaceRect(const TransformationMatrix& matrix)

{

    IntRect rect;

    TransformationMatrix localTransform = TransformationMatrix(matrix).multiply(m_currentTransform.combined());

    rect = enclosingIntRect(localTransform.mapRect(layerRect()));

    if (!m_state.masksToBounds && !m_state.maskLayer) {

        for (size_t i = 0; i < m_children.size(); ++i)

            rect.unite(m_children[i]->intermediateSurfaceRect(matrix));

    }

#if ENABLE(CSS_FILTERS)

    if (m_currentFilters.hasOutsets()) {

        FilterOutsets outsets = m_currentFilters.outsets();

        IntRect unfilteredTargetRect(rect);

        rect.move(std::max(0, -outsets.left()), std::max(0, -outsets.top()));

        rect.expand(outsets.left() + outsets.right(), outsets.top() + outsets.bottom());

        rect.unite(unfilteredTargetRect);

    }

#endif

    if (m_state.replicaLayer)

        rect.unite(m_state.replicaLayer->intermediateSurfaceRect(matrix));

    return rect;

}

TextureMapperLayer::ContentsLayerCount TextureMapperLayer::countPotentialLayersWithContents() const

168bool TextureMapperLayer::shouldBlend() const

202169{

    int selfLayersWithContents = (m_state.drawsContent ? 1 : 0) + (m_contentsLayer ? 1 : 0);

    int potentialLayersWithContents = selfLayersWithContents + m_children.size();

    if (!potentialLayersWithContents)

        return NoLayersWithContent;

    if (potentialLayersWithContents > 1)

        return MultipleLayersWithContents;

    if (m_children.isEmpty())

        return SingleLayerWithContents;

    return m_children.first()->countPotentialLayersWithContents();

}

170 if (m_state.preserves3D)

171 return false;

217172

218 bool TextureMapperLayer::shouldPaintToIntermediateSurface() const

219 {

#if ENABLE(CSS_FILTERS)

    if (m_currentFilters.size())

        return true;

#endif

    bool hasOpacity = m_currentOpacity < 0.99;

    bool canHaveMultipleLayersWithContent = countPotentialLayersWithContents() == MultipleLayersWithContents;

    bool hasReplica = !!m_state.replicaLayer;

    bool hasMask = !!m_state.maskLayer;

    // We don't use two-pass blending for preserves-3d, that's in sync with Safari.

    if (m_state.preserves3D)

        return false;

    // We should use an intermediate surface when blending several items with an ancestor opacity.

    // Tested by compositing/reflections/reflection-opacity.html

    if (hasOpacity && (canHaveMultipleLayersWithContent || hasReplica))

        return true;

    // We should use an intermediate surface with a masked ancestor.

    // In the case of replicas the mask is applied before replicating.

    // Tested by compositing/masks/masked-ancestor.html

    if (hasMask && canHaveMultipleLayersWithContent && !hasReplica)

        return true;

    return false;

177 return m_currentOpacity < 1 || m_state.maskLayer || (m_state.replicaLayer && m_state.replicaLayer->m_state.maskLayer);

}

bool TextureMapperLayer::isVisible() const

@@void TextureMapperLayer::paintSelfAndChildrenWithReplica(const TextureMapperPain

{

    if (m_state.replicaLayer) {

        TextureMapperPaintOptions replicaOptions(options);

        // We choose either the content's mask or the replica's mask.

        // FIXME: blend the two if both exist.

        if (m_state.replicaLayer->m_state.maskLayer)

            replicaOptions.mask = m_state.replicaLayer->m_state.maskLayer->texture();

        replicaOptions.transform

            .multiply(m_state.replicaLayer->m_currentTransform.combined())

            .multiply(m_currentTransform.combined().inverse());

@@void TextureMapperLayer::setAnimatedOpacity(float opacity)

    m_currentOpacity = opacity;

}

TransformationMatrix TextureMapperLayer::replicaTransform()

{

    return TransformationMatrix(m_state.replicaLayer->m_currentTransform.combined()).multiply(m_currentTransform.combined().inverse());

}

#if ENABLE(CSS_FILTERS)

void TextureMapperLayer::setAnimatedFilters(const FilterOperations& filters)

{

@@static bool shouldKeepContentTexture(const FilterOperations& filters)

    return false;

}

310 static PassRefPtr<BitmapTexture> applyFilters(const FilterOperations& filters, TextureMapper* textureMapper, BitmapTexture* source~~, IntRect& targetRect~~)

243static PassRefPtr<BitmapTexture> applyFilters(const FilterOperations& filters, TextureMapper* textureMapper, BitmapTexture* source)

{

    if (!filters.size())

        return source;

@@static PassRefPtr<BitmapTexture> applyFilters(const FilterOperations& filters, T

}

#endif

320 void ~~TextureMapperLayer::paintRecursive(const TextureMapperPaintOpt~~ions& options)

253static void resolveOverlaps(Region& overlapRegion, Region& nonOverlapRegion, Region newRegion)

321254{

322 if (!isVisible())

    Region newOverlapRegion(newRegion);

    newOverlapRegion.intersect(nonOverlapRegion);

    nonOverlapRegion.subtract(newOverlapRegion);

    overlapRegion.unite(newOverlapRegion);

    newRegion.subtract(overlapRegion);

    nonOverlapRegion.unite(newRegion);

}

void TextureMapperLayer::computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, bool alwaysResolveSelfOverlap)

{

    if (!m_state.visible || !m_state.contentsVisible)

323266 return;

324267

325 float opacity = options.opacity * m_currentOpacity;

326 RefPtr<BitmapTexture> maskTexture = m_state.maskLayer ? m_state.maskLayer->texture() : 0;

    FloatRect boundingRect;

    if (m_backingStore || m_state.masksToBounds || m_state.maskLayer || hasFilters())

        boundingRect = layerRect();

    else if (m_contentsLayer || m_state.solidColor.alpha())

        boundingRect = m_state.contentsRect;

327273

328 TextureMapperPaintOptions paintOptions(options);

329 paintOptions.mask = maskTexture.get();

#if ENABLE(CSS_FILTERS)

    if (m_currentFilters.hasOutsets()) {

        FilterOutsets outsets = m_currentFilters.outsets();

        IntRect unfilteredTargetRect(boundingRect);

        boundingRect.move(std::max(0, -outsets.left()), std::max(0, -outsets.top()));

        boundingRect.expand(outsets.left() + outsets.right(), outsets.top() + outsets.bottom());

        boundingRect.unite(unfilteredTargetRect);

    }

#endif

    TransformationMatrix replicaMatrix;

    if (m_state.replicaLayer) {

        replicaMatrix = replicaTransform();

        boundingRect.unite(replicaMatrix.mapRect(boundingRect));

    }

330289

    if (!shouldPaintToIntermediateSurface()) {

        paintOptions.opacity = opacity;

        paintSelfAndChildrenWithReplica(paintOptions);

    boundingRect = m_currentTransform.combined().mapRect(boundingRect);

    // Count all masks and filters as overlap layers.

    if (hasFilters() || m_state.maskLayer || (m_state.replicaLayer && m_state.replicaLayer->m_state.maskLayer)) {

        Region newOverlapRegion(enclosingIntRect(boundingRect));

        nonOverlapRegion.subtract(newOverlapRegion);

        overlapRegion.unite(newOverlapRegion);

        return;

    }

    // Prepare a surface to paint into.

    // We paint into the surface ignoring the opacity/transform of the current layer.

    IntRect surfaceRect = intermediateSurfaceRect();

    RefPtr<BitmapTexture> surface = options.textureMapper->acquireTextureFromPool(surfaceRect.size());

    paintOptions.surface = surface;

    options.textureMapper->bindSurface(surface.get());

    paintOptions.opacity = 1;

    Region newOverlapRegion;

    Region newNonOverlapRegion(enclosingIntRect(boundingRect));

    if (!m_state.masksToBounds) {

        for (size_t i = 0; i < m_children.size(); ++i) {

            TextureMapperLayer* child = m_children[i];

            bool alwaysResolveSelfOverlapForChildren = false;

            child->computeOverlapRegions(newOverlapRegion, newNonOverlapRegion, alwaysResolveSelfOverlapForChildren);

        }

    }

    if (m_state.replicaLayer) {

        newOverlapRegion.unite(replicaMatrix.mapRect(newOverlapRegion.bounds()));

        Region replicaRegion(replicaMatrix.mapRect(newNonOverlapRegion.bounds()));

        resolveOverlaps(newOverlapRegion, newNonOverlapRegion, replicaRegion);

    }

344316

345 paintOptions.transform = m_currentTransform.combined().inverse();

346 paintOptions.offset = -IntSize(surfaceRect.x(), surfaceRect.y());

    if (!alwaysResolveSelfOverlap  && shouldBlend()) {

        newNonOverlapRegion.unite(newOverlapRegion);

        newOverlapRegion = Region();

    }

347321

348 paintSelfAndChildrenWithReplica(paintOptions);

    overlapRegion.unite(newOverlapRegion);

    resolveOverlaps(overlapRegion, nonOverlapRegion, newNonOverlapRegion);

}

349325

    // If we painted the replica, the mask is already applied so we don't need to paint it again.

    if (m_state.replicaLayer)

        maskTexture = 0;

void TextureMapperLayer::paintUsingOverlapRegions(const TextureMapperPaintOptions& options)

{

    Region overlapRegion;

    Region nonOverlapRegion;

    computeOverlapRegions(overlapRegion, nonOverlapRegion);

    if (overlapRegion.isEmpty()) {

        paintSelfAndChildrenWithReplica(options);

        return;

    }

    Vector<IntRect> rects = nonOverlapRegion.rects();

    for (size_t i = 0; i < rects.size(); ++i) {

        options.textureMapper->beginClip(TransformationMatrix(), rects[i]);

        paintSelfAndChildrenWithReplica(options);

        options.textureMapper->endClip();

    }

    rects = overlapRegion.rects();

    for (size_t i = 0; i < rects.size(); ++i) {

        IntRect rect = rects[i];

        const static int maxRectDimension = 2000;

        for (int x = rect.x(); x < rect.maxX(); x += maxRectDimension) {

            for (int y = rect.y(); y < rect.maxY(); y += maxRectDimension) {

                IntRect tileRect(x, y, maxRectDimension, maxRectDimension);

                tileRect.intersect(rect);

                paintWithIntermediateSurface(options, tileRect);

            }

        }

    }

}

353356

void TextureMapperLayer::applyMask(const TextureMapperPaintOptions& options)

{

    options.textureMapper->setMaskMode(true);

    paintSelf(options);

    options.textureMapper->setMaskMode(false);

}

PassRefPtr<BitmapTexture> TextureMapperLayer::paintIntoSurface(const TextureMapperPaintOptions& options, const IntSize& size)

{

    RefPtr<BitmapTexture> surface = options.textureMapper->acquireTextureFromPool(size);

    options.textureMapper->bindSurface(surface.get());

    paintSelfAndChildren(options);

    if (m_state.maskLayer)

        m_state.maskLayer->applyMask(options);

354371#if ENABLE(CSS_FILTERS)

355 surface = applyFilters(m_currentFilters, options.textureMapper, surface.get(), surfaceRect);

372 if (!m_currentFilters.isEmpty())

373 surface = applyFilters(m_currentFilters, options.textureMapper, surface.get());

356374#endif

    options.textureMapper->bindSurface(surface.get());

    return surface;

}

357378

379static PassRefPtr<BitmapTexture> commitSurface(const TextureMapperPaintOptions& options, PassRefPtr<BitmapTexture> surface, const IntRect& rect, float opacity)

380{

    options.textureMapper->bindSurface(options.surface.get());

    TransformationMatrix targetTransform;

    targetTransform.translate(options.offset.width(), options.offset.height());

    targetTransform.multiply(options.transform);

362 targetTransform.multiply(m_currentTransform.combined());

    options.textureMapper->drawTexture(*surface.get(), rect, targetTransform, opacity);

    return 0;

}

void TextureMapperLayer::paintWithIntermediateSurface(const TextureMapperPaintOptions& options, const IntRect& rect)

{

    RefPtr<BitmapTexture> replicaSurface;

    RefPtr<BitmapTexture> mainSurface;

    TextureMapperPaintOptions paintOptions(options);

    paintOptions.offset = -IntSize(rect.x(), rect.y());

    paintOptions.opacity = 1;

    paintOptions.transform = TransformationMatrix();

    if (m_state.replicaLayer) {

        paintOptions.transform = replicaTransform();

        replicaSurface = paintIntoSurface(paintOptions, rect.size());

        paintOptions.transform = TransformationMatrix();

        if (m_state.replicaLayer->m_state.maskLayer)

            m_state.replicaLayer->m_state.maskLayer->applyMask(paintOptions);

    }

363404

364 options.textureMapper->drawTexture(*surface.get(), surfaceRect, targetTransform, opacity, maskTexture.get());

    if (replicaSurface && options.opacity == 1)

        replicaSurface = commitSurface(options, replicaSurface, rect, 1);

    mainSurface = paintIntoSurface(paintOptions, rect.size());

    if (replicaSurface) {

        options.textureMapper->bindSurface(replicaSurface.get());

        options.textureMapper->drawTexture(*mainSurface.get(), FloatRect(FloatPoint::zero(), rect.size()));

        mainSurface = replicaSurface;

    }

    commitSurface(options, mainSurface, rect, options.opacity);

}

void TextureMapperLayer::paintRecursive(const TextureMapperPaintOptions& options)

{

    if (!isVisible())

        return;

    if (!shouldBlend()) {

        paintSelfAndChildrenWithReplica(options);

        return;

    }

    TextureMapperPaintOptions paintOptions(options);

    paintOptions.opacity = options.opacity * m_currentOpacity;

    paintUsingOverlapRegions(paintOptions);

}

TextureMapperLayer::~TextureMapperLayer()

Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h

namespace WebCore {

34class Region;

class TextureMapperPaintOptions;

class TextureMapperPlatformLayer;

@@public:

#if ENABLE(CSS_FILTERS)

    void setFilters(const FilterOperations&);

#endif

    bool hasFilters() const

    {

#if ENABLE(CSS_FILTERS)

        return !m_currentFilters.isEmpty();

#else

        return false;

#endif

    }

    void setDebugVisuals(bool showDebugBorders, const Color& debugBorderColor, float debugBorderWidth, bool showRepaintCounter);

    void setRepaintCount(int);

    void setContentsLayer(TextureMapperPlatformLayer*);

@@public:

private:

    const TextureMapperLayer* rootLayer() const;

    void computeTransformsRecursive();

95 IntRect intermediateSurfaceRect(const TransformationMatrix&);

96 IntRect intermediateSurfaceRect();

    static int compareGraphicsLayersZValue(const void* a, const void* b);

    static void sortByZOrder(Vector<TextureMapperLayer* >& array, int first, int last);

@@private:

    PassRefPtr<BitmapTexture> texture() { return m_backingStore ? m_backingStore->texture() : 0; }

    FloatPoint adjustedPosition() const { return m_state.pos + m_scrollPositionDelta; }

    bool isAncestorFixedToViewport() const;

104

113 TransformationMatrix replicaTransform();

    void addChild(TextureMapperLayer*);

    void removeFromParent();

    void removeAllChildren();

118 void computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, bool alwaysResolveSelfOverlap = true);

119

109120 void paintRecursive(const TextureMapperPaintOptions&);

    void paintUsingOverlapRegions(const TextureMapperPaintOptions&);

    PassRefPtr<BitmapTexture> paintIntoSurface(const TextureMapperPaintOptions&, const IntSize&);

    void paintWithIntermediateSurface(const TextureMapperPaintOptions&, const IntRect&);

    void paintSelf(const TextureMapperPaintOptions&);

    void paintSelfAndChildren(const TextureMapperPaintOptions&);

    void paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions&);

127 void applyMask(const TextureMapperPaintOptions&);

    // GraphicsLayerAnimation::Client

    virtual void setAnimatedTransform(const TransformationMatrix&) OVERRIDE;

@@private:

        MultipleLayersWithContents

    };

128 ContentsLayerCount countPotentialLayersWithContents() const;

129 bool shouldPaintToIntermediateSurface() const;

143 bool shouldBlend() const;

    inline FloatRect layerRect() const

    {

Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayer.h

@@namespace WebCore {

class TextureMapperPlatformLayer {

public:

    virtual ~TextureMapperPlatformLayer() { }

35 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0~~, BitmapTexture* mask = 0~~) = 0;

35 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0) = 0;

    virtual void swapBuffers() { }

    virtual void drawBorder(TextureMapper* textureMapper, const Color& color, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)

    {

Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp

@@static const char* vertexTemplate =

        uniform mat4 u_textureSpaceMatrix;

        varying vec2 v_texCoord;

130 varying vec2 v_maskTexCoord;

        varying float v_antialias;

        void noop(inout vec2 dummyParameter) { }

@@static const char* vertexTemplate =

            // The texture position needs to be clamped to 0..1 before the texture matrix is applied.

            vec4 clampedPosition = clamp(vec4(position, 0., 1.), 0., 1.);

            v_texCoord = (u_textureSpaceMatrix * clampedPosition).xy;

179

180 v_maskTexCoord = position;

            gl_Position = u_projectionMatrix * u_modelViewMatrix * vec4(position, 0., 1.);

        }

    );

@@static const char* fragmentTemplate =

    STRINGIFY(

        precision mediump float;

        uniform SamplerType s_sampler;

207 uniform sampler2D s_mask;

        uniform sampler2D s_contentTexture;

        uniform float u_opacity;

        varying float v_antialias;

        varying vec2 v_texCoord;

212 varying vec2 v_maskTexCoord;

        uniform float u_filterAmount;

        uniform vec2 u_blurRadius;

        uniform vec2 u_shadowOffset;

@@static const char* fragmentTemplate =

        void applyTexture(inout vec4 color) { color = SamplerFunction(s_sampler, v_texCoord); }

        void applyOpacity(inout vec4 color) { color *= u_opacity; }

        void applyAntialiasing(inout vec4 color) { color *= antialias(); }

226 void applyMask(inout vec4 color) { color *= texture2D(s_mask, v_maskTexCoord).a; }

        void applyGrayscaleFilter(inout vec4 color)

        {

@@static const char* fragmentTemplate =

            applyTextureIfNeeded(color);

            applySolidColorIfNeeded(color);

            applyAntialiasingIfNeeded(color);

337 applyMaskIfNeeded(color);

            applyOpacityIfNeeded(color);

            applyGrayscaleFilterIfNeeded(color);

            applySepiaFilterIfNeeded(color);

@@PassRefPtr<TextureMapperShaderProgram> TextureMapperShaderProgram::create(PassRe

    SET_APPLIER_FROM_OPTIONS(Rect);

    SET_APPLIER_FROM_OPTIONS(SolidColor);

    SET_APPLIER_FROM_OPTIONS(Opacity);

365 SET_APPLIER_FROM_OPTIONS(Mask);

    SET_APPLIER_FROM_OPTIONS(Antialiasing);

    SET_APPLIER_FROM_OPTIONS(GrayscaleFilter);

    SET_APPLIER_FROM_OPTIONS(SepiaFilter);

Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h

@@public:

        Rect             = 1L << 1,

        SolidColor       = 1L << 2,

        Opacity          = 1L << 3,

45 Mask = 1L << 4,

        Antialiasing     = 1L << 5,

        GrayscaleFilter  = 1L << 6,

        SepiaFilter      = 1L << 7,

Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.cpp

@@PassRefPtr<BitmapTexture> TextureMapperSurfaceBackingStore::texture() const

    return emptyTexture;

}

47 void TextureMapperSurfaceBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

47void TextureMapperSurfaceBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

4848{

4949 if (m_graphicsSurface)

50 m_graphicsSurface->paintToTextureMapper(textureMapper, targetRect, transform, opacity~~, mask~~);

50 m_graphicsSurface->paintToTextureMapper(textureMapper, targetRect, transform, opacity);

}

} // namespace WebCore

Source/WebCore/platform/graphics/texmap/TextureMapperSurfaceBackingStore.h

@@public:

    void setGraphicsSurface(PassRefPtr<GraphicsSurface>);

    void swapBuffersIfNeeded(uint32_t frontBuffer);

    virtual PassRefPtr<BitmapTexture> texture() const;

40 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*);

40 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float);

    virtual ~TextureMapperSurfaceBackingStore() { }

private:

Source/WebCore/platform/graphics/texmap/TextureMapperTile.cpp

@@void TextureMapperTile::updateContents(TextureMapper* textureMapper, GraphicsLay

    m_texture->updateContents(textureMapper, sourceLayer, targetRect, sourceOffset, updateContentsFlag);

}

72 void TextureMapperTile::paint(TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, ~~BitmapTexture* mask,~~ const unsigned exposedEdges)

72void TextureMapperTile::paint(TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, const unsigned exposedEdges)

7373{

7474 if (texture().get())

75 textureMapper->drawTexture(*texture().get(), rect(), transform, opacity, ~~mask,~~ exposedEdges);

75 textureMapper->drawTexture(*texture().get(), rect(), transform, opacity, exposedEdges);

}

} // namespace WebCore

Source/WebCore/platform/graphics/texmap/TextureMapperTile.h

@@public:

    void updateContents(TextureMapper*, Image*, const IntRect&, BitmapTexture::UpdateContentsFlag UpdateCanModifyOriginalImageData);

    void updateContents(TextureMapper*, GraphicsLayer*, const IntRect&, BitmapTexture::UpdateContentsFlag UpdateCanModifyOriginalImageData);

44 virtual void paint(TextureMapper*, const TransformationMatrix&, float, ~~BitmapTexture*,~~ const unsigned exposedEdges);

44 virtual void paint(TextureMapper*, const TransformationMatrix&, float, const unsigned exposedEdges);

    virtual ~TextureMapperTile() { }

    explicit TextureMapperTile(const FloatRect& rect)

Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp

@@TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(co

    return TransformationMatrix::rectToRect(rect(), targetRect);

}

50 void TextureMapperTiledBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

50void TextureMapperTiledBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

{

    updateContentsFromImageIfNeeded(textureMapper);

    TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);

    for (size_t i = 0; i < m_tiles.size(); ++i)

55 m_tiles[i].paint(textureMapper, adjustedTransform, opacity, ~~mask,~~ calculateExposedTileEdges(rect(), m_tiles[i].rect()));

55 m_tiles[i].paint(textureMapper, adjustedTransform, opacity, calculateExposedTileEdges(rect(), m_tiles[i].rect()));

}

void TextureMapperTiledBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)

Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h

@@public:

    virtual ~TextureMapperTiledBackingStore() { }

    virtual PassRefPtr<BitmapTexture> texture() const OVERRIDE;

41 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*) OVERRIDE;

41 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float) OVERRIDE;

    virtual void drawBorder(TextureMapper*, const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) OVERRIDE;

    virtual void drawRepaintCounter(TextureMapper*, int repaintCount, const Color&, const FloatRect&, const TransformationMatrix&) OVERRIDE;

    void updateContents(TextureMapper*, Image*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedBackingStore.cpp

@@void CoordinatedBackingStore::setSize(const FloatSize& size)

    m_pendingSize = size;

}

109 void CoordinatedBackingStore::paintTilesToTextureMapper(Vector<TextureMapperTile*>& tiles, TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, ~~BitmapTexture* mask,~~ const FloatRect& rect)

109void CoordinatedBackingStore::paintTilesToTextureMapper(Vector<TextureMapperTile*>& tiles, TextureMapper* textureMapper, const TransformationMatrix& transform, float opacity, const FloatRect& rect)

110110{

111111 for (size_t i = 0; i < tiles.size(); ++i)

112 tiles[i]->paint(textureMapper, transform, opacity, ~~mask,~~ calculateExposedTileEdges(rect, tiles[i]->rect()));

112 tiles[i]->paint(textureMapper, transform, opacity, calculateExposedTileEdges(rect, tiles[i]->rect()));

}

TransformationMatrix CoordinatedBackingStore::adjustedTransformForRect(const FloatRect& targetRect)

@@TransformationMatrix CoordinatedBackingStore::adjustedTransformForRect(const Flo

    return TransformationMatrix::rectToRect(rect(), targetRect);

}

120 void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity~~, BitmapTexture* mask~~)

120void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)

{

    if (m_tiles.isEmpty())

        return;

@@void CoordinatedBackingStore::paintToTextureMapper(TextureMapper* textureMapper,

    // See TiledBackingStore.

    TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);

155 paintTilesToTextureMapper(previousTilesToPaint, textureMapper, adjustedTransform, opacity, ~~mask,~~ rect());

156 paintTilesToTextureMapper(tilesToPaint, textureMapper, adjustedTransform, opacity, ~~mask,~~ rect());

155 paintTilesToTextureMapper(previousTilesToPaint, textureMapper, adjustedTransform, opacity, rect());

156 paintTilesToTextureMapper(tilesToPaint, textureMapper, adjustedTransform, opacity, rect());

}

void CoordinatedBackingStore::drawBorder(TextureMapper* textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedBackingStore.h

@@public:

    void commitTileOperations(TextureMapper*);

    PassRefPtr<BitmapTexture> texture() const;

    void setSize(const FloatSize&);

65 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float, BitmapTexture*);

65 virtual void paintToTextureMapper(TextureMapper*, const FloatRect&, const TransformationMatrix&, float);

    virtual void drawBorder(TextureMapper*, const Color&, float borderWidth, const FloatRect&, const TransformationMatrix&) OVERRIDE;

    virtual void drawRepaintCounter(TextureMapper*, int repaintCount, const Color&, const FloatRect&, const TransformationMatrix&) OVERRIDE;

@@private:

    CoordinatedBackingStore()

        : m_scale(1.)

    { }

73 void paintTilesToTextureMapper(Vector<TextureMapperTile*>&, TextureMapper*, const TransformationMatrix&, float, ~~BitmapTexture*,~~ const FloatRect&);

73 void paintTilesToTextureMapper(Vector<TextureMapperTile*>&, TextureMapper*, const TransformationMatrix&, float, const FloatRect&);

    TransformationMatrix adjustedTransformForRect(const FloatRect&);

    FloatRect rect() const { return FloatRect(FloatPoint::zero(), m_size); }

LayoutTests/ChangeLog

2013-02-25  No'am Rosenthal  <noam@webkit.org>

        [Texmap] TextureMapper is too eager to use intermediate surfaces.

        https://bugs.webkit.org/show_bug.cgi?id=110762

        Reviewed by NOBODY (OOPS!).

        Added a few ref-tests for correct overlap blending in accelearated compositing mode. 

        Skipping the new reflection test on Mac/Chromium since it's not rendered

        properly on those platforms.

        * compositing/overlap-blending/children-opacity-huge-expected.html: Added.

        * compositing/overlap-blending/children-opacity-huge.html: Added.

        * compositing/overlap-blending/children-opacity-no-overlap-expected.html: Added.

        * compositing/overlap-blending/children-opacity-no-overlap.html: Added.

        * compositing/overlap-blending/reflection-opacity-huge-expected.html: Added.

        * compositing/overlap-blending/reflection-opacity-huge.html: Added.

2013-02-26  Takashi Toyoshima  <toyoshim@chromium.org>

        Add User-Agent header in opening handshake headers.

LayoutTests/compositing/overlap-blending/children-opacity-huge-expected.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      div {

        -webkit-box-sizing: border-box;

      }

      .solid {

        position: absolute;

        width: 2150px;

        height: 200px;

        background-color: green;

      }

      .opacity { opacity: .5; }

      .a { top: 0px; left: 0px;}

      .b { top: 100px; left: 0px;}

      .composited {

        -webkit-transform: translateZ(0);

      }

      * { margin: 0; padding: 0; }

    </style>

  </head>

    <div class="opacity">

    <div class="solid a">1</div>

    <div class="solid b">2</div>

  </div>

</html>

LayoutTests/compositing/overlap-blending/children-opacity-huge.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      div {

        -webkit-box-sizing: border-box;

      }

      .solid {

        position: absolute;

        width: 2150px;

        height: 200px;

        background-color: green;

      }

      .opacity { opacity: .5; }

      .a { top: 0px; left: 0px;}

      .b { top: 100px; left: 0px;}

      .composited {

        -webkit-transform: translateZ(0);

      }

      * { margin: 0; padding: 0; }

    </style>

  </head>

    <div class="opacity composited">

    <div class="solid a composited">1</div>

    <div class="solid b composited">2</div>

  </div>

</html>

LayoutTests/compositing/overlap-blending/children-opacity-no-overlap-expected.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      div {

        -webkit-box-sizing: border-box;

      }

      .solid {

        position: absolute;

        width: 100px;

        height: 100px;

        background-color: green;

      }

      .opacity { opacity: .5; }

      .a { top: 0px; left: 0px;}

      .b { top: 200px; left: 200px;}

      .c { top: 200px; left: 0px;}

      .d { top: 0px; left: 200px;}

      * { margin: 0; padding: 0; }

      .composited {

        -webkit-transform: translateZ(0);

      }

    </style>

  </head>

    <div class="opacity">

      <div class="solid a">1</div>

      <div class="solid b">2</div>

      <div class="solid c">3</div>

      <div class="solid d"></div>

    </div>

</html>

LayoutTests/compositing/overlap-blending/children-opacity-no-overlap.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      div {

        -webkit-box-sizing: border-box;

      }

      .solid {

        position: absolute;

        width: 100px;

        height: 100px;

        background-color: green;

      }

      .opacity { opacity: .5; }

      .a { top: 0px; left: 0px;}

      .b { top: 200px; left: 200px;}

      .c { top: 200px; left: 0px;}

      .d { top: 0px; left: 200px;}

      .composited {

        -webkit-transform: translateZ(0);

      }

      * { margin: 0; padding: 0; }

    </style>

  </head>

    <div class="composited opacity">

      <div class="solid composited a">1</div>

      <div class="solid composited b">2</div>

      <div class="solid composited c">3</div>

      <div class="solid composited d"></div>

    </div>

</html>

LayoutTests/compositing/overlap-blending/reflection-opacity-huge-expected.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      .reflected {

        position: relative;

        width: 2150px;

        height: 200px;

        background-color: green;

        opacity: 0.5;

        -webkit-box-reflect: below -50px;

      }

      * { margin: 0; padding: 0; }

    </style>

  </head>

  <p>Opacity should be applied after reflection, so you should see a green rectangle below. The overlap between the original and reflection should not be visible.</p>

  <div class="reflected">1

  </div>

</html>

LayoutTests/compositing/overlap-blending/reflection-opacity-huge.html

<!DOCTYPE HTML>

<html>

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8">

    <style type="text/css" media="screen">

      .reflected {

        position: relative;

        width: 2150px;

        height: 200px;

        background-color: green;

        opacity: 0.5;

        -webkit-box-reflect: below -50px;

      }

      .composited { -webkit-transform: translateZ(0);}

      * { margin: 0; padding: 0; }

    </style>

  </head>

  <p>Opacity should be applied after reflection, so you should see a green rectangle below. The overlap between the original and reflection should not be visible.</p>

  <div class="reflected composited">1

  </div>

</html>

LayoutTests/platform/chromium/TestExpectations

@@webkit.org/b/94353 platform/chromium/virtual/softwarecompositing/overflow/overfl

webkit.org/b/94353 compositing/overflow/overflow-overlay-with-touch.html [ Failure ]

webkit.org/b/94353 platform/chromium/virtual/softwarecompositing/overflow/overflow-overlay-with-touch.html [ Failure ]

3784webkit.org/b/110871 compositing/overlap-blending/reflection-opacity-huge.html [ ImageOnlyFailure ]

3785

webkit.org/b/90488 [ Win ] http/tests/inspector/network-preflight-options.html [ Pass Slow ]

webkit.org/b/90488 [ Win ] inspector/extensions/extensions-reload.html [ Pass Slow ]

LayoutTests/platform/mac/TestExpectations

@@compositing/overflow/textarea-scroll-touch.html

compositing/overflow/updating-scrolling-content.html

compositing/overflow/scrolling-without-painting.html

# https://bugs.webkit.org/show_bug.cgi?id=110871

compositing/overlap-blending/reflection-opacity-huge.html

# https://bugs.webkit.org/show_bug.cgi?id=95027

fast/block/float/016.html