Changeset 190124 in webkit


Ignore:
Timestamp:
Sep 22, 2015 11:45:54 AM (9 years ago)
Author:
timothy_horton@apple.com
Message:

Make it more obvious when using an unaccelerated image buffer, and fix a few callers who do
​https://bugs.webkit.org/show_bug.cgi?id=149428

Reviewed by Simon Fraser and Darin Adler.

  • platform/graphics/ImageBuffer.cpp:

(WebCore::ImageBuffer::createCompatibleBuffer):

  • platform/graphics/ImageBuffer.h:

(WebCore::ImageBuffer::create):
Make the RenderingMode parameter to ImageBuffer::create non-optional.

  • platform/graphics/GraphicsContext.h:

(WebCore::GraphicsContext::renderingMode):

  • platform/graphics/GraphicsTypes.h:

Add renderingMode() getter so that every caller doesn't need to do the conversion to RenderingMode.

  • css/CSSFilterImageValue.cpp:

(WebCore::CSSFilterImageValue::image):

  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::LRUImageBufferCache::imageBuffer):

  • rendering/shapes/Shape.cpp:

(WebCore::Shape::createRasterShape):

  • html/shadow/MediaControlElements.cpp:

(WebCore::MediaControlTextTrackContainerElement::createTextTrackRepresentationImage):

  • platform/graphics/cg/ImageBufferCG.cpp:

(WebCore::ImageBuffer::putByteArray):
These five callers create unconditionally unaccelerated ImageBuffers which
should probably instead respect the acceleration bit from the context
that the ImageBuffer will eventually be painted into. Bugs have been filed.

  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::createImageBuffer):

  • html/canvas/CanvasRenderingContext2D.cpp:

(WebCore::CanvasRenderingContext2D::createCompositingBuffer):

  • platform/graphics/CrossfadeGeneratedImage.cpp:

(WebCore::CrossfadeGeneratedImage::drawPattern):
Adjust the argument order and remove defaults which are passed explicitly.

  • page/FrameSnapshotting.cpp:

(WebCore::snapshotFrameRect):
Snapshots are (currently) meant to be taken without accelerated drawing.
Make this explicit.

  • platform/graphics/BitmapImage.cpp:

(WebCore::BitmapImage::drawPattern):
Make use of createCompatibleBuffer. This caller was previously creating
an unconditionally unaccelerated context!

  • platform/graphics/NamedImageGeneratedImage.cpp:

(WebCore::NamedImageGeneratedImage::drawPattern):
Remove a comment.

  • platform/graphics/ShadowBlur.cpp:

(WebCore::ScratchBuffer::getScratchBuffer):
ShadowBlur is only used with unaccelerated contexts, so it's OK to hardcode Unaccelerated here.

  • platform/graphics/filters/FilterEffect.cpp:

(WebCore::FilterEffect::asImageBuffer):
(WebCore::FilterEffect::createImageBufferResult):
Flip the order of the arguments.

(WebCore::FilterEffect::openCLImageToImageBuffer):
This caller was previously creating an unaccelerated buffer; instead, match the destination buffer.

  • rendering/FilterEffectRenderer.cpp:

(WebCore::FilterEffectRenderer::allocateBackingStoreIfNeeded):
Adjust the argument order and remove defaults which are passed explicitly.

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::calculateClipRects):
Get rid of the unneeded renderingMode local, and factor out retrieval of Frame.

  • rendering/svg/RenderSVGResourceClipper.cpp:

(WebCore::RenderSVGResourceClipper::applyClippingToContext):

  • rendering/svg/RenderSVGResourceMasker.cpp:

(WebCore::RenderSVGResourceMasker::applyResource):
These two callers are unconditionally creating unaccelerated buffers,
and changing this to match the destination context seems to actually
break things. This needs further investigation.

  • rendering/svg/RenderSVGResourceGradient.cpp:

(WebCore::createMaskAndSwapContextForTextGradient):
This caller was previously creating an unaccelerated buffer; instead, match the destination buffer.

  • rendering/svg/RenderSVGResourcePattern.cpp:

(WebCore::RenderSVGResourcePattern::buildPattern):
Make use of renderingMode().

  • rendering/svg/SVGRenderingContext.cpp:

(WebCore::SVGRenderingContext::createImageBuffer):
Adjust the argument order.

  • svg/graphics/SVGImage.cpp:

(WebCore::SVGImage::nativeImageForCurrentFrame):

  • WebCoreSupport/WebContextMenuClient.mm:

(WebContextMenuClient::imageForCurrentSharingServicePickerItem):

  • Shared/CoordinatedGraphics/threadedcompositor/ThreadSafeCoordinatedSurface.cpp:

(WebKit::ThreadSafeCoordinatedSurface::create):

Location:
trunk/Source
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r190123 r190124  
     12015-09-22  Tim Horton  <timothy_horton@apple.com>
     2
     3        Make it more obvious when using an unaccelerated image buffer, and fix a few callers who do
     4        https://bugs.webkit.org/show_bug.cgi?id=149428
     5
     6        Reviewed by Simon Fraser and Darin Adler.
     7
     8        * platform/graphics/ImageBuffer.cpp:
     9        (WebCore::ImageBuffer::createCompatibleBuffer):
     10        * platform/graphics/ImageBuffer.h:
     11        (WebCore::ImageBuffer::create):
     12        Make the RenderingMode parameter to ImageBuffer::create non-optional.
     13
     14        * platform/graphics/GraphicsContext.h:
     15        (WebCore::GraphicsContext::renderingMode):
     16        * platform/graphics/GraphicsTypes.h:
     17        Add renderingMode() getter so that every caller doesn't need to do the conversion to RenderingMode.
     18
     19        * css/CSSFilterImageValue.cpp:
     20        (WebCore::CSSFilterImageValue::image):
     21        * html/canvas/WebGLRenderingContextBase.cpp:
     22        (WebCore::WebGLRenderingContextBase::LRUImageBufferCache::imageBuffer):
     23        * rendering/shapes/Shape.cpp:
     24        (WebCore::Shape::createRasterShape):
     25        * html/shadow/MediaControlElements.cpp:
     26        (WebCore::MediaControlTextTrackContainerElement::createTextTrackRepresentationImage):
     27        * platform/graphics/cg/ImageBufferCG.cpp:
     28        (WebCore::ImageBuffer::putByteArray):
     29        These five callers create unconditionally unaccelerated ImageBuffers which
     30        should probably instead respect the acceleration bit from the context
     31        that the ImageBuffer will eventually be painted into. Bugs have been filed.
     32
     33        * html/HTMLCanvasElement.cpp:
     34        (WebCore::HTMLCanvasElement::createImageBuffer):
     35        * html/canvas/CanvasRenderingContext2D.cpp:
     36        (WebCore::CanvasRenderingContext2D::createCompositingBuffer):
     37        * platform/graphics/CrossfadeGeneratedImage.cpp:
     38        (WebCore::CrossfadeGeneratedImage::drawPattern):
     39        Adjust the argument order and remove defaults which are passed explicitly.
     40
     41        * page/FrameSnapshotting.cpp:
     42        (WebCore::snapshotFrameRect):
     43        Snapshots are (currently) meant to be taken without accelerated drawing.
     44        Make this explicit.
     45
     46        * platform/graphics/BitmapImage.cpp:
     47        (WebCore::BitmapImage::drawPattern):
     48        Make use of createCompatibleBuffer. This caller was previously creating
     49        an unconditionally unaccelerated context!
     50
     51        * platform/graphics/NamedImageGeneratedImage.cpp:
     52        (WebCore::NamedImageGeneratedImage::drawPattern):
     53        Remove a comment.
     54
     55        * platform/graphics/ShadowBlur.cpp:
     56        (WebCore::ScratchBuffer::getScratchBuffer):
     57        ShadowBlur is only used with unaccelerated contexts, so it's OK to hardcode Unaccelerated here.
     58
     59        * platform/graphics/filters/FilterEffect.cpp:
     60        (WebCore::FilterEffect::asImageBuffer):
     61        (WebCore::FilterEffect::createImageBufferResult):
     62        Flip the order of the arguments.
     63
     64        (WebCore::FilterEffect::openCLImageToImageBuffer):
     65        This caller was previously creating an unaccelerated buffer; instead, match the destination buffer.
     66
     67        * rendering/FilterEffectRenderer.cpp:
     68        (WebCore::FilterEffectRenderer::allocateBackingStoreIfNeeded):
     69        Adjust the argument order and remove defaults which are passed explicitly.
     70
     71        * rendering/RenderLayer.cpp:
     72        (WebCore::RenderLayer::calculateClipRects):
     73        Get rid of the unneeded renderingMode local, and factor out retrieval of Frame.
     74
     75        * rendering/svg/RenderSVGResourceClipper.cpp:
     76        (WebCore::RenderSVGResourceClipper::applyClippingToContext):
     77        * rendering/svg/RenderSVGResourceMasker.cpp:
     78        (WebCore::RenderSVGResourceMasker::applyResource):
     79        These two callers are unconditionally creating unaccelerated buffers,
     80        and changing this to match the destination context seems to actually
     81        break things. This needs further investigation.
     82
     83        * rendering/svg/RenderSVGResourceGradient.cpp:
     84        (WebCore::createMaskAndSwapContextForTextGradient):
     85        This caller was previously creating an unaccelerated buffer; instead, match the destination buffer.
     86
     87        * rendering/svg/RenderSVGResourcePattern.cpp:
     88        (WebCore::RenderSVGResourcePattern::buildPattern):
     89        Make use of renderingMode().
     90
     91        * rendering/svg/SVGRenderingContext.cpp:
     92        (WebCore::SVGRenderingContext::createImageBuffer):
     93        Adjust the argument order.
     94
     95        * svg/graphics/SVGImage.cpp:
     96        (WebCore::SVGImage::nativeImageForCurrentFrame):
     97
    1982015-09-22  Chris Dumez  <cdumez@apple.com>
    299

  • trunk/Source/WebCore/css/CSSFilterImageValue.cpp

    r189144 r190124  
    121121
    122122    // Transform Image into ImageBuffer.
    123     std::unique_ptr<ImageBuffer> texture = ImageBuffer::create(size);
     123    // FIXME (149424): This buffer should not be unconditionally unaccelerated.
     124    std::unique_ptr<ImageBuffer> texture = ImageBuffer::create(size, Unaccelerated);
    124125    if (!texture)
    125126        return Image::nullImage();

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r189144 r190124  
    578578
    579579    RenderingMode renderingMode = shouldAccelerate(bufferSize) ? Accelerated : Unaccelerated;
    580     m_imageBuffer = ImageBuffer::create(size(), 1, ColorSpaceDeviceRGB, renderingMode);
     580    m_imageBuffer = ImageBuffer::create(size(), renderingMode);
    581581    if (!m_imageBuffer)
    582582        return;

  • trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

    r189987 r190124  
    16851685std::unique_ptr<ImageBuffer> CanvasRenderingContext2D::createCompositingBuffer(const IntRect& bufferRect)
    16861686{
    1687     RenderingMode renderMode = isAccelerated() ? Accelerated : Unaccelerated;
    1688     return ImageBuffer::create(bufferRect.size(), 1, ColorSpaceDeviceRGB, renderMode);
     1687    return ImageBuffer::create(bufferRect.size(), isAccelerated() ? Accelerated : Unaccelerated);
    16891688}
    16901689

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r189581 r190124  
    48814881    }
    48824882
    4883     std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, 1);
     4883    // FIXME (149423): Should this ImageBuffer be unconditionally unaccelerated?
     4884    std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, Unaccelerated);
    48844885    if (!temp)
    48854886        return nullptr;

  • trunk/Source/WebCore/html/shadow/MediaControlElements.cpp

    r189576 r190124  
    13721372    IntRect paintingRect = IntRect(IntPoint(), layer->size());
    13731373
    1374     std::unique_ptr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size(), deviceScaleFactor, ColorSpaceDeviceRGB));
     1374    // FIXME (149422): This buffer should not be unconditionally unaccelerated.
     1375    std::unique_ptr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size(), Unaccelerated, deviceScaleFactor));
    13751376    if (!buffer)
    13761377        return nullptr;

  • trunk/Source/WebCore/page/FrameSnapshotting.cpp

    r189144 r190124  
    100100        scaleFactor *= frame.page()->pageScaleFactor();
    101101
    102     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(imageRect.size(), scaleFactor, ColorSpaceDeviceRGB);
     102    std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(imageRect.size(), Unaccelerated, scaleFactor);
    103103    if (!buffer)
    104104        return nullptr;

  • trunk/Source/WebCore/platform/graphics/BitmapImage.cpp

    r189144 r190124  
    617617    }
    618618    if (!m_cachedImage) {
    619         std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(expandedIntSize(tileRect.size()));
     619        std::unique_ptr<ImageBuffer> buffer = ctxt.createCompatibleBuffer(expandedIntSize(tileRect.size()));
    620620        if (!buffer)
    621621            return;

  • trunk/Source/WebCore/platform/graphics/CrossfadeGeneratedImage.cpp

    r189144 r190124  
    9898void CrossfadeGeneratedImage::drawPattern(GraphicsContext& context, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator compositeOp, const FloatRect& dstRect, BlendMode blendMode)
    9999{
    100     std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(size(), 1, ColorSpaceDeviceRGB, context.isAcceleratedContext() ? Accelerated : Unaccelerated);
     100    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(size(), context.renderingMode());
    101101    if (!imageBuffer)
    102102        return;

  • trunk/Source/WebCore/platform/graphics/GraphicsContext.h

    r189144 r190124  
    3333#include "FontCascade.h"
    3434#include "Gradient.h"
     35#include "GraphicsTypes.h"
    3536#include "Image.h"
    3637#include "ImageOrientation.h"
    … …  
    271272#endif
    272273        bool isAcceleratedContext() const;
     274        RenderingMode renderingMode() const { return isAcceleratedContext() ? Accelerated : Unaccelerated; }
    273275
    274276        WEBCORE_EXPORT void save();

  • trunk/Source/WebCore/platform/graphics/GraphicsTypes.h

    r181191 r190124  
    8585    enum TextAlign { StartTextAlign, EndTextAlign, LeftTextAlign, CenterTextAlign, RightTextAlign };
    8686
     87    enum RenderingMode {
     88        Unaccelerated,
     89        UnacceleratedNonPlatformBuffer, // Use plain memory allocation rather than platform API to allocate backing store.
     90        Accelerated
     91    };
     92
    8793    String compositeOperatorName(CompositeOperator, BlendMode);
    8894    bool parseBlendMode(const String&, BlendMode&);

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.cpp

    r189216 r190124  
    161161std::unique_ptr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, const GraphicsContext& context, bool)
    162162{
    163     return create(size, resolutionScale, colorSpace, context.isAcceleratedContext() ? Accelerated : Unaccelerated);
     163    return create(size, context.renderingMode(), resolutionScale, colorSpace);
    164164}
    165165

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.h

    r189216 r190124  
    5656};
    5757
    58 enum RenderingMode {
    59     Unaccelerated,
    60     UnacceleratedNonPlatformBuffer, // Use plain memory allocation rather than platform API to allocate backing store.
    61     Accelerated
    62 };
    63 
    6458enum BackingStoreCopy {
    6559    CopyBackingStore, // Guarantee subsequent draws don't affect the copy.
    … …  
    7670public:
    7771    // Will return a null pointer on allocation failure.
    78     static std::unique_ptr<ImageBuffer> create(const FloatSize& size, float resolutionScale = 1, ColorSpace colorSpace = ColorSpaceDeviceRGB, RenderingMode renderingMode = Unaccelerated)
     72    static std::unique_ptr<ImageBuffer> create(const FloatSize& size, RenderingMode renderingMode, float resolutionScale = 1, ColorSpace colorSpace = ColorSpaceDeviceRGB)
    7973    {
    8074        bool success = false;

  • trunk/Source/WebCore/platform/graphics/NamedImageGeneratedImage.cpp

    r189144 r190124  
    6464{
    6565#if USE(NEW_THEME)
    66 //    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(size(), 1, ColorSpaceDeviceRGB, context->isAcceleratedContext() ? Accelerated : Unaccelerated);
    6766    std::unique_ptr<ImageBuffer> imageBuffer = context.createCompatibleBuffer(size(), true);
    6867    if (!imageBuffer)

  • trunk/Source/WebCore/platform/graphics/ShadowBlur.cpp

    r189144 r190124  
    8080
    8181        clearScratchBuffer();
    82         m_imageBuffer = ImageBuffer::create(roundedSize, 1);
     82
     83        // ShadowBlur is not used with accelerated drawing, so it's OK to make an unconditionally unaccelerated buffer.
     84        m_imageBuffer = ImageBuffer::create(roundedSize, Unaccelerated, 1);
    8385        return m_imageBuffer.get();
    8486    }

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferCG.cpp

    r189144 r190124  
    323323    // Make a copy of the source to ensure the bits don't change before being drawn
    324324    IntSize sourceCopySize(sourceRect.width(), sourceRect.height());
    325     std::unique_ptr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, 1, ColorSpaceDeviceRGB, Unaccelerated);
     325    // FIXME (149431): Should this ImageBuffer be unconditionally unaccelerated? Making it match the context seems to break putData().
     326    std::unique_ptr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, Unaccelerated, 1, ColorSpaceDeviceRGB);
    326327    if (!sourceCopy)
    327328        return;

  • trunk/Source/WebCore/platform/graphics/filters/FilterEffect.cpp

    r189144 r190124  
    277277        return openCLImageToImageBuffer();
    278278#endif
    279     m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), m_filter.filterScale(), m_resultColorSpace, m_filter.renderingMode());
     279    m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), m_filter.renderingMode(), m_filter.filterScale(), m_resultColorSpace);
    280280    if (!m_imageBufferResult)
    281281        return nullptr;
    … …  
    309309        return nullptr;
    310310
    311     m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size());
     311    m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), m_filter.renderingMode());
    312312    if (!m_imageBufferResult)
    313313        return nullptr;
    … …  
    463463
    464464    FloatSize clampedSize = ImageBuffer::clampedSize(m_absolutePaintRect.size());
    465     m_imageBufferResult = ImageBuffer::create(clampedSize, m_filter.filterScale(), m_resultColorSpace, m_filter.renderingMode());
     465    m_imageBufferResult = ImageBuffer::create(clampedSize, m_filter.renderingMode(), m_filter.filterScale(), m_resultColorSpace);
    466466    if (!m_imageBufferResult)
    467467        return nullptr;

  • trunk/Source/WebCore/platform/graphics/texmap/BitmapTexture.cpp

    r189144 r190124  
    3636void BitmapTexture::updateContents(TextureMapper* textureMapper, GraphicsLayer* sourceLayer, const IntRect& targetRect, const IntPoint& offset, UpdateContentsFlag updateContentsFlag)
    3737{
    38     std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(targetRect.size());
     38    // Making an unconditionally unaccelerated buffer here is OK because this code
     39    // isn't used by any platforms that respect the accelerated bit.
     40    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(targetRect.size(), Unaccelerated);
    3941
    4042    if (!imageBuffer)

  • trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp

    r189144 r190124  
    324324        IntSize logicalSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height());
    325325        if (!sourceImage() || sourceImage()->logicalSize() != logicalSize)
    326             setSourceImage(ImageBuffer::create(logicalSize, filterScale(), ColorSpaceDeviceRGB, renderingMode()));
     326            setSourceImage(ImageBuffer::create(logicalSize, renderingMode(), filterScale()));
    327327        m_graphicsBufferAttached = true;
    328328    }

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r189841 r190124  
    68926892   
    68936893    FilterInfo& filterInfo = FilterInfo::get(*this);
     6894    Frame& frame = renderer().frame();
    68946895    if (!filterInfo.renderer()) {
    68956896        RefPtr<FilterEffectRenderer> filterRenderer = FilterEffectRenderer::create();
    6896         filterRenderer->setFilterScale(renderer().frame().page()->deviceScaleFactor());
    6897         RenderingMode renderingMode = renderer().frame().settings().acceleratedFiltersEnabled() ? Accelerated : Unaccelerated;
    6898         filterRenderer->setRenderingMode(renderingMode);
     6897        filterRenderer->setFilterScale(frame.page()->deviceScaleFactor());
     6898        filterRenderer->setRenderingMode(frame.settings().acceleratedFiltersEnabled() ? Accelerated : Unaccelerated);
    68996899        filterInfo.setRenderer(WTF::move(filterRenderer));
    69006900       
    69016901        // We can optimize away code paths in other places if we know that there are no software filters.
    69026902        renderer().view().setHasSoftwareFilters(true);
    6903     } else if (filterInfo.renderer()->filterScale() != renderer().frame().page()->deviceScaleFactor()) {
    6904         filterInfo.renderer()->setFilterScale(renderer().frame().page()->deviceScaleFactor());
     6903    } else if (filterInfo.renderer()->filterScale() != frame.page()->deviceScaleFactor()) {
     6904        filterInfo.renderer()->setFilterScale(frame.page()->deviceScaleFactor());
    69056905        filterInfo.renderer()->clearIntermediateResults();
    69066906    }

  • trunk/Source/WebCore/rendering/shapes/Shape.cpp

    r189144 r190124  
    180180    IntRect marginRect = snappedIntRect(marginR);
    181181    auto intervals = std::make_unique<RasterShapeIntervals>(marginRect.height(), -marginRect.y());
    182     std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(imageRect.size());
     182    // FIXME (149420): This buffer should not be unconditionally unaccelerated.
     183    std::unique_ptr<ImageBuffer> imageBuffer = ImageBuffer::create(imageRect.size(), Unaccelerated);
    183184
    184185    if (imageBuffer) {

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceClipper.cpp

    r189144 r190124  
    141141
    142142    if (shouldCreateClipperMaskImage && !repaintRect.isEmpty()) {
     143        // FIXME (149469): This image buffer should not be unconditionally unaccelerated. Making it match the context breaks nested clipping, though.
    143144        clipperMaskImage = SVGRenderingContext::createImageBuffer(repaintRect, absoluteTransform, ColorSpaceDeviceRGB, Unaccelerated);
    144145        if (!clipperMaskImage)

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceGradient.cpp

    r189144 r190124  
    6262    FloatRect repaintRect = textRootBlock->repaintRectInLocalCoordinates();
    6363
    64     auto maskImage = SVGRenderingContext::createImageBuffer(repaintRect, absoluteTransform, ColorSpaceDeviceRGB, Unaccelerated);
     64    auto maskImage = SVGRenderingContext::createImageBuffer(repaintRect, absoluteTransform, ColorSpaceDeviceRGB, context->renderingMode());
    6565    if (!maskImage)
    6666        return false;

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourceMasker.cpp

    r189144 r190124  
    7070        const SVGRenderStyle& svgStyle = style().svgStyle();
    7171        ColorSpace colorSpace = svgStyle.colorInterpolation() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB;
     72        // FIXME (149470): This image buffer should not be unconditionally unaccelerated. Making it match the context breaks alpha masking, though.
    7273        maskerData->maskImage = SVGRenderingContext::createImageBuffer(repaintRect, absoluteTransform, colorSpace, Unaccelerated);
    7374        if (!maskerData->maskImage)

  • trunk/Source/WebCore/rendering/svg/RenderSVGResourcePattern.cpp

    r190079 r190124  
    9595
    9696    // Build tile image.
    97     auto tileImage = createTileImage(m_attributes, tileBoundaries, absoluteTileBoundaries, tileImageTransform, clampedAbsoluteTileBoundaries, context.isAcceleratedContext() ? Accelerated : Unaccelerated);
     97    auto tileImage = createTileImage(m_attributes, tileBoundaries, absoluteTileBoundaries, tileImageTransform, clampedAbsoluteTileBoundaries, context.renderingMode());
    9898    if (!tileImage)
    9999        return nullptr;

  • trunk/Source/WebCore/rendering/svg/SVGRenderingContext.cpp

    r189144 r190124  
    258258    FloatSize clampedSize = ImageBuffer::clampedSize(paintRect.size(), scale);
    259259
    260     auto imageBuffer = ImageBuffer::create(clampedSize, 1, colorSpace, renderingMode);
     260    auto imageBuffer = ImageBuffer::create(clampedSize, renderingMode, 1, colorSpace);
    261261    if (!imageBuffer)
    262262        return nullptr;
    … …  
    280280        return nullptr;
    281281
    282     auto imageBuffer = ImageBuffer::create(clampedSize, 1, colorSpace, renderingMode);
     282    auto imageBuffer = ImageBuffer::create(clampedSize, renderingMode, 1, colorSpace);
    283283    if (!imageBuffer)
    284284        return nullptr;

  • trunk/Source/WebCore/svg/graphics/SVGImage.cpp

    r189144 r190124  
    174174        return 0;
    175175
    176     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(size(), 1);
     176    // Cairo does not use the accelerated drawing flag, so it's OK to make an unconditionally unaccelerated buffer.
     177    std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(size(), Unaccelerated);
    177178    if (!buffer) // failed to allocate image
    178179        return 0;

  • trunk/Source/WebKit/mac/ChangeLog

    r190092 r190124  
     12015-09-22  Tim Horton  <timothy_horton@apple.com>
     2
     3        Make it more obvious when using an unaccelerated image buffer, and fix a few callers who do
     4        https://bugs.webkit.org/show_bug.cgi?id=149428
     5
     6        Reviewed by Simon Fraser and Darin Adler.
     7
     8        * WebCoreSupport/WebContextMenuClient.mm:
     9        (WebContextMenuClient::imageForCurrentSharingServicePickerItem):
     10
    1112015-09-21  Alexey Proskuryakov  <ap@apple.com>
    212

  • trunk/Source/WebKit/mac/WebCoreSupport/WebContextMenuClient.mm

    r189144 r190124  
    472472        return nil;
    473473
    474     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(rect.size());
     474    // This is effectively a snapshot, and will be painted in an unaccelerated fashion in line with FrameSnapshotting.
     475    std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(rect.size(), Unaccelerated);
    475476    if (!buffer)
    476477        return nil;

  • trunk/Source/WebKit2/ChangeLog

    r190121 r190124  
     12015-09-22  Tim Horton  <timothy_horton@apple.com>
     2
     3        Make it more obvious when using an unaccelerated image buffer, and fix a few callers who do
     4        https://bugs.webkit.org/show_bug.cgi?id=149428
     5
     6        Reviewed by Simon Fraser and Darin Adler.
     7
     8        * Shared/CoordinatedGraphics/threadedcompositor/ThreadSafeCoordinatedSurface.cpp:
     9        (WebKit::ThreadSafeCoordinatedSurface::create):
     10
    1112015-09-22  Andreas Kling  <akling@apple.com>
    212

  • trunk/Source/WebKit2/Shared/CoordinatedGraphics/threadedcompositor/ThreadSafeCoordinatedSurface.cpp

    r190095 r190124  
    3838Ref<ThreadSafeCoordinatedSurface> ThreadSafeCoordinatedSurface::create(const IntSize& size, CoordinatedSurface::Flags flags)
    3939{
    40     return adoptRef(*new ThreadSafeCoordinatedSurface(size, flags, ImageBuffer::create(size)));
     40    // Making an unconditionally unaccelerated buffer here is OK because this code
     41    // isn't used by any platforms that respect the accelerated bit.
     42    return adoptRef(*new ThreadSafeCoordinatedSurface(size, flags, ImageBuffer::create(size, Unaccelerated)));
    4143}
    4244
Note: See TracChangeset for help on using the changeset viewer.