Changeset 109016 in webkit


Ignore:
Timestamp:
Feb 27, 2012 12:43:47 PM (12 years ago)
Author:
mdelaney@apple.com
Message:

Add ImageBuffer support for having a hi-res backing store. This allows
ImageBuffer clients to specify a scale factor upon creation so that they
don't have to maintain that info themselves as they use/pass around the ImageBuffer.
​https://bugs.webkit.org/show_bug.cgi?id=79395

Reviewed by Dan Bernstein.

No new tests. This patch doesn't change behavior.

  • platform/graphics/ImageBuffer.h:

(WebCore::ImageBuffer::create): Scale the backing store by the resolution scale.
(WebCore::ImageBuffer::logicalSize): Differentiate the logical size from the backing store's size.
(WebCore::ImageBuffer::internalSize): The backing store's size.

  • platform/graphics/cg/ImageBufferCG.cpp: Prefer the explicit use of logicalSize and internalSize.

Explicitly state a 1x scale for all ImageBuffer creation sites
since this is what they currently assume.

  • html/HTMLCanvasElement.cpp:
  • html/canvas/CanvasRenderingContext2D.cpp:
  • html/canvas/WebGLRenderingContext.cpp:
  • page/Frame.cpp:
  • platform/graphics/CrossfadeGeneratedImage.cpp:
  • platform/graphics/ShadowBlur.cpp:
  • platform/graphics/filters/FEColorMatrix.cpp:
  • platform/graphics/filters/FEDropShadow.cpp:
  • platform/graphics/filters/FilterEffect.cpp:
  • platform/mac/ScrollbarThemeMac.mm:
  • rendering/FilterEffectRenderer.cpp:
  • rendering/RenderThemeMac.mm:
  • rendering/svg/SVGImageBufferTools.cpp:
  • svg/graphics/SVGImage.cpp:
  • svg/graphics/SVGImageCache.cpp:

Update ImageBuffer::size() calls to new versions.

  • platform/graphics/GraphicsContext.cpp:
  • platform/graphics/ImageBuffer.cpp:
  • platform/graphics/skia/PlatformContextSkia.cpp:
Location:
trunk/Source/WebCore
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r109015 r109016  
     12012-02-27  Matthew Delaney  <mdelaney@apple.com>
     2
     3        Add ImageBuffer support for having a hi-res backing store. This allows
     4        ImageBuffer clients to specify a scale factor upon creation so that they
     5        don't have to maintain that info themselves as they use/pass around the ImageBuffer.
     6        https://bugs.webkit.org/show_bug.cgi?id=79395
     7
     8        Reviewed by Dan Bernstein.
     9
     10        No new tests. This patch doesn't change behavior.
     11
     12        * platform/graphics/ImageBuffer.h:
     13        (WebCore::ImageBuffer::create): Scale the backing store by the resolution scale.
     14        (WebCore::ImageBuffer::logicalSize): Differentiate the logical size from the backing store's size.
     15        (WebCore::ImageBuffer::internalSize): The backing store's size.
     16
     17        * platform/graphics/cg/ImageBufferCG.cpp: Prefer the explicit use of logicalSize and internalSize.
     18
     19        Explicitly state a 1x scale for all ImageBuffer creation sites
     20        since this is what they currently assume.
     21        * html/HTMLCanvasElement.cpp:
     22        * html/canvas/CanvasRenderingContext2D.cpp:
     23        * html/canvas/WebGLRenderingContext.cpp:
     24        * page/Frame.cpp:
     25        * platform/graphics/CrossfadeGeneratedImage.cpp:
     26        * platform/graphics/ShadowBlur.cpp:
     27        * platform/graphics/filters/FEColorMatrix.cpp:
     28        * platform/graphics/filters/FEDropShadow.cpp:
     29        * platform/graphics/filters/FilterEffect.cpp:
     30        * platform/mac/ScrollbarThemeMac.mm:
     31        * rendering/FilterEffectRenderer.cpp:
     32        * rendering/RenderThemeMac.mm:
     33        * rendering/svg/SVGImageBufferTools.cpp:
     34        * svg/graphics/SVGImage.cpp:
     35        * svg/graphics/SVGImageCache.cpp:
     36
     37        Update ImageBuffer::size() calls to new versions.
     38        * platform/graphics/GraphicsContext.cpp:
     39        * platform/graphics/ImageBuffer.cpp:
     40        * platform/graphics/skia/PlatformContextSkia.cpp:
     41
    1422012-02-27  Mihnea Ovidenie  <mihnea@adobe.com>
    243

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

    r108658 r109016  
    514514#endif
    515515    DeferralMode deferralMode = shouldDefer() ? Deferred : NonDeferred;
    516     m_imageBuffer = ImageBuffer::create(bufferSize, ColorSpaceDeviceRGB, renderingMode, deferralMode);
     516    m_imageBuffer = ImageBuffer::create(bufferSize, 1, ColorSpaceDeviceRGB, renderingMode, deferralMode);
    517517    if (!m_imageBuffer)
    518518        return;
    … …  
    524524#if USE(JSC)
    525525    JSC::JSLock lock(JSC::SilenceAssertionsOnly);
    526     scriptExecutionContext()->globalData()->heap.reportExtraMemoryCost(m_imageBuffer->dataSize());
     526    size_t numBytes = 4 * m_imageBuffer->internalSize().width() * m_imageBuffer->internalSize().height();
     527    scriptExecutionContext()->globalData()->heap.reportExtraMemoryCost(numBytes);
    527528#endif
    528529

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

    r108597 r109016  
    15221522{
    15231523    RenderingMode renderMode = isAccelerated() ? Accelerated : Unaccelerated;
    1524     return ImageBuffer::create(bufferRect.size(), ColorSpaceDeviceRGB, renderMode);
     1524    return ImageBuffer::create(bufferRect.size(), 1, ColorSpaceDeviceRGB, renderMode);
    15251525}
    15261526
    … …  
    18841884    IntRect destRect = enclosingIntRect(clipRect);
    18851885    destRect.move(destOffset);
    1886     destRect.intersect(IntRect(IntPoint(), buffer->size()));
     1886    destRect.intersect(IntRect(IntPoint(), buffer->internalSize()));
    18871887    if (destRect.isEmpty())
    18881888        return;
    … …  
    20902090
    20912091#if USE(IOSURFACE_CANVAS_BACKING_STORE)
    2092         OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskRect.size(), ColorSpaceDeviceRGB, Accelerated);
     2092        OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskRect.size(), 1, ColorSpaceDeviceRGB, Accelerated);
    20932093#else
    2094         OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskRect.size());
     2094        OwnPtr<ImageBuffer> maskImage = ImageBuffer::create(maskRect.size(), 1);
    20952095#endif
    20962096

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

    r108861 r109016  
    53315331        if (!buf)
    53325332            break;
    5333         if (buf->size() != size)
     5333        if (buf->logicalSize() != size)
    53345334            continue;
    53355335        bubbleToFront(i);
    … …  
    53375337    }
    53385338
    5339     OwnPtr<ImageBuffer> temp = ImageBuffer::create(size);
     5339    OwnPtr<ImageBuffer> temp = ImageBuffer::create(size, 1);
    53405340    if (!temp)
    53415341        return 0;

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

    r108700 r109016  
    10951095    IntRect paintingRect = pixelSnappedIntRect(renderer->paintingRootRect(topLevelRect));
    10961096
    1097     OwnPtr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size()));
     1097    OwnPtr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size(), 1, ColorSpaceDeviceRGB));
    10981098    if (!buffer)
    10991099        return 0;
    … …  
    11181118    IntRect paintingRect = enclosingIntRect(selection()->bounds());
    11191119
    1120     OwnPtr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size()));
     1120    OwnPtr<ImageBuffer> buffer(ImageBuffer::create(paintingRect.size(), 1, ColorSpaceDeviceRGB));
    11211121    if (!buffer)
    11221122        return 0;

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

    r102893 r109016  
    9696void CrossfadeGeneratedImage::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator compositeOp, const FloatRect& dstRect)
    9797{
    98     OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(m_size, ColorSpaceDeviceRGB, context->isAcceleratedContext() ? Accelerated : Unaccelerated);
     98    OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(m_size, 1, ColorSpaceDeviceRGB, context->isAcceleratedContext() ? Accelerated : Unaccelerated);
    9999    if (!imageBuffer)
    100100        return;

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

    r107157 r109016  
    488488}
    489489
    490 void GraphicsContext::drawTiledImage(Image* image, ColorSpace styleColorSpace, const IntRect& rect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op, bool useLowQualityScale)
     490void GraphicsContext::drawTiledImage(Image* image, ColorSpace styleColorSpace, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize, CompositeOperator op, bool useLowQualityScale)
    491491{
    492492    if (paintingDisabled() || !image)
    … …  
    496496        InterpolationQuality previousInterpolationQuality = imageInterpolationQuality();
    497497        setImageInterpolationQuality(InterpolationLow);
    498         image->drawTiled(this, rect, srcPoint, tileSize, styleColorSpace, op);
     498        image->drawTiled(this, destRect, srcPoint, tileSize, styleColorSpace, op);
    499499        setImageInterpolationQuality(previousInterpolationQuality);
    500500    } else
    501         image->drawTiled(this, rect, srcPoint, tileSize, styleColorSpace, op);
     501        image->drawTiled(this, destRect, srcPoint, tileSize, styleColorSpace, op);
    502502}
    503503
    … …  
    554554
    555555    if (tsw == -1)
    556         tsw = image->width();
     556        tsw = image->logicalSize().width();
    557557    if (tsh == -1)
    558         tsh = image->height();
     558        tsh = image->logicalSize().height();
    559559
    560560    if (tw == -1)
    561         tw = image->width();
     561        tw = image->logicalSize().width();
    562562    if (th == -1)
    563         th = image->height();
     563        th = image->logicalSize().height();
    564564
    565565    if (useLowQualityScale) {
    … …  
    755755    IntSize scaledSize(static_cast<int>(ceil(size.width() * transform.xScale())), static_cast<int>(ceil(size.height() * transform.yScale())));
    756756
    757     OwnPtr<ImageBuffer> buffer = ImageBuffer::create(scaledSize, ColorSpaceDeviceRGB, isAcceleratedContext() ? Accelerated : Unaccelerated);
     757    OwnPtr<ImageBuffer> buffer = ImageBuffer::create(scaledSize, 1, ColorSpaceDeviceRGB, isAcceleratedContext() ? Accelerated : Unaccelerated);
    758758    if (!buffer)
    759759        return nullptr;

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

    r106836 r109016  
    7272inline void ImageBuffer::genericConvertToLuminanceMask()
    7373{
    74     IntRect luminanceRect(IntPoint(), size());
     74    IntRect luminanceRect(IntPoint(), internalSize());
    7575    RefPtr<ByteArray> srcPixelArray = getUnmultipliedImageData(luminanceRect);
    7676   

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

    r106836 r109016  
    3232#include "ColorSpace.h"
    3333#include "FloatRect.h"
     34#include "GraphicsContext.h"
    3435#if USE(ACCELERATED_COMPOSITING)
    3536#include "GraphicsLayer.h"
    … …  
    4748namespace WebCore {
    4849
    49     class GraphicsContext;
    5050    class Image;
    5151    class ImageData;
    … …  
    7878    public:
    7979        // Will return a null pointer on allocation failure.
    80         static PassOwnPtr<ImageBuffer> create(const IntSize& size, ColorSpace colorSpace = ColorSpaceDeviceRGB, RenderingMode renderingMode = Unaccelerated, DeferralMode deferralMode = NonDeferred)
     80        static PassOwnPtr<ImageBuffer> create(const IntSize& size, float resolutionScale = 1, ColorSpace colorSpace = ColorSpaceDeviceRGB, RenderingMode renderingMode = Unaccelerated, DeferralMode deferralMode = NonDeferred)
    8181        {
    8282            bool success = false;
    83             OwnPtr<ImageBuffer> buf = adoptPtr(new ImageBuffer(size, colorSpace, renderingMode, deferralMode, success));
    84             if (success)
    85                 return buf.release();
    86             return nullptr;
     83            float scaledWidth = ceilf(resolutionScale * size.width());
     84            float scaledHeight = ceilf(resolutionScale * size.height());
     85            IntSize internalSize(scaledWidth, scaledHeight);
     86
     87            OwnPtr<ImageBuffer> buf = adoptPtr(new ImageBuffer(internalSize, colorSpace, renderingMode, deferralMode, success));
     88            if (!success)
     89                return nullptr;
     90
     91            buf->m_logicalSize = size;
     92            buf->m_resolutionScale = resolutionScale;
     93            buf->context()->scale(FloatSize(resolutionScale, resolutionScale));
     94            return buf.release();
    8795        }
    8896
    8997        ~ImageBuffer();
    9098
    91         const IntSize& size() const { return m_size; }
    92         int width() const { return m_size.width(); }
    93         int height() const { return m_size.height(); }
    94        
    95         size_t dataSize() const;
    96        
     99        // The actual resolution of the backing store
     100        const IntSize& internalSize() const { return m_size; }
     101        const IntSize& logicalSize() const { return m_logicalSize; }
     102
    97103        GraphicsContext* context() const;
    98104
    … …  
    112118        void platformTransformColorSpace(const Vector<int>&);
    113119#else
    114         AffineTransform baseTransform() const { return AffineTransform(1, 0, 0, -1, 0, m_size.height()); }
     120        AffineTransform baseTransform() const { return AffineTransform(1, 0, 0, -1, 0, internalSize().height()); }
    115121#endif
    116122#if USE(ACCELERATED_COMPOSITING)
    … …  
    122128        NativeImagePtr copyNativeImage(BackingStoreCopy = CopyBackingStore) const;
    123129#endif
    124 
    125130        void clip(GraphicsContext*, const FloatRect&) const;
    126131
    … …  
    137142    private:
    138143        ImageBufferData m_data;
    139 
    140144        IntSize m_size;
     145        IntSize m_logicalSize;
     146        float m_resolutionScale;
    141147        OwnPtr<GraphicsContext> m_context;
    142148

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

    r108008 r109016  
    7474#endif
    7575        // We do not need to recreate the buffer if the current buffer is large enough.
    76         if (m_imageBuffer && m_imageBuffer->width() >= size.width() && m_imageBuffer->height() >= size.height())
     76        if (m_imageBuffer && m_imageBuffer->logicalSize().width() >= size.width() && m_imageBuffer->logicalSize().height() >= size.height())
    7777            return m_imageBuffer.get();
    7878
    … …  
    8181
    8282        clearScratchBuffer();
    83         m_imageBuffer = ImageBuffer::create(roundedSize);
     83        m_imageBuffer = ImageBuffer::create(roundedSize, 1);
    8484        return m_imageBuffer.get();
    8585    }
    … …  
    441441    GraphicsContextStateSaver stateSaver(*graphicsContext);
    442442
    443     IntSize bufferSize = m_layerImage->size();
     443    IntSize bufferSize = m_layerImage->internalSize();
    444444    if (bufferSize != m_layerSize) {
    445445        // The rect passed to clipToImageBuffer() has to be the size of the entire buffer,

  • trunk/Source/WebCore/platform/graphics/cairo/ImageBufferCairo.cpp

    r106836 r109016  
    7777}
    7878
    79 size_t ImageBuffer::dataSize() const
    80 {
    81     return m_size.width() * m_size.height() * 4;
    82 }
    83 
    8479GraphicsContext* ImageBuffer::context() const
    8580{

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

    r106860 r109016  
    109109
    110110ImageBuffer::ImageBuffer(const IntSize& size, ColorSpace imageColorSpace, RenderingMode renderingMode, DeferralMode, bool& success)
    111     : m_data(size)
     111    : m_data(size) // NOTE: The input here isn't important as ImageBufferDataCG's constructor just ignores it.
    112112    , m_size(size)
    113113{
    … …  
    122122    // Prevent integer overflows
    123123    m_data.m_bytesPerRow = 4 * width;
    124     Checked<size_t, RecordOverflow> dataSize = height * m_data.m_bytesPerRow;
    125     if (dataSize.hasOverflowed())
     124    Checked<size_t, RecordOverflow> numBytes = height * m_data.m_bytesPerRow;
     125    if (numBytes.hasOverflowed())
    126126        return;
    127127
    … …  
    163163        cgContext.adoptCF(CGBitmapContextCreate(m_data.m_data, width.unsafeGet(), height.unsafeGet(), 8, m_data.m_bytesPerRow.unsafeGet(), m_data.m_colorSpace, m_data.m_bitmapInfo));
    164164        // Create a live image that wraps the data.
    165         m_data.m_dataProvider.adoptCF(CGDataProviderCreateWithData(0, m_data.m_data, dataSize.unsafeGet(), releaseImageData));
     165        m_data.m_dataProvider.adoptCF(CGDataProviderCreateWithData(0, m_data.m_data, numBytes.unsafeGet(), releaseImageData));
    166166    }
    167167
    … …  
    181181ImageBuffer::~ImageBuffer()
    182182{
    183 }
    184 
    185 size_t ImageBuffer::dataSize() const
    186 {
    187     return m_size.height() * m_data.m_bytesPerRow.unsafeGet();
    188183}
    189184
    … …  
    223218        switch (copyBehavior) {
    224219        case DontCopyBackingStore:
    225             image = CGImageCreate(m_size.width(), m_size.height(), 8, 32, m_data.m_bytesPerRow.unsafeGet(), m_data.m_colorSpace, m_data.m_bitmapInfo, m_data.m_dataProvider.get(), 0, true, kCGRenderingIntentDefault);
     220            image = CGImageCreate(internalSize().width(), internalSize().height(), 8, 32, m_data.m_bytesPerRow.unsafeGet(), m_data.m_colorSpace, m_data.m_bitmapInfo, m_data.m_dataProvider.get(), 0, true, kCGRenderingIntentDefault);
    226221            break;
    227222        case CopyBackingStore:
    … …  
    256251        image.adoptCF(copyNativeImage(DontCopyBackingStore));
    257252
    258     destContext->drawNativeImage(image.get(), m_size, colorSpace, destRect, srcRect, op);
     253    FloatRect adjustedSrcRect = srcRect;
     254    adjustedSrcRect.scale(m_resolutionScale, m_resolutionScale);
     255    destContext->drawNativeImage(image.get(), internalSize(), colorSpace, destRect, adjustedSrcRect, op);
    259256}
    260257
    261258void ImageBuffer::drawPattern(GraphicsContext* destContext, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
    262259{
     260    FloatRect adjustedSrcRect = srcRect;
     261    adjustedSrcRect.scale(m_resolutionScale, m_resolutionScale);
     262
    263263    if (!m_context->isAcceleratedContext()) {
    264264        if (destContext == m_context || destContext->isAcceleratedContext()) {
    265265            RefPtr<Image> copy = copyImage(CopyBackingStore); // Drawing into our own buffer, need to deep copy.
    266             copy->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
     266            copy->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, styleColorSpace, op, destRect);
    267267        } else {
    268268            RefPtr<Image> imageForRendering = copyImage(DontCopyBackingStore);
    269             imageForRendering->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
     269            imageForRendering->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, styleColorSpace, op, destRect);
    270270        }
    271271    } else {
    272272        RefPtr<Image> copy = copyImage(CopyBackingStore);
    273         copy->drawPattern(destContext, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
     273        copy->drawPattern(destContext, adjustedSrcRect, patternTransform, phase, styleColorSpace, op, destRect);
    274274    }
    275275}
    … …  
    278278{
    279279    CGContextRef platformContextToClip = contextToClip->platformContext();
     280    // FIXME: This image needs to be grayscale to be used as an alpha mask here.
    280281    RetainPtr<CGImageRef> image(AdoptCF, copyNativeImage(DontCopyBackingStore));
    281282    CGContextTranslateCTM(platformContextToClip, rect.x(), rect.y() + rect.height());
    … …  
    294295#endif
    295296    }
    296     return m_data.getData(rect, m_size, m_context->isAcceleratedContext(), true);
     297    return m_data.getData(rect, internalSize(), m_context->isAcceleratedContext(), true);
    297298}
    298299
    … …  
    305306#endif
    306307    }
    307     return m_data.getData(rect, m_size, m_context->isAcceleratedContext(), false);
     308    return m_data.getData(rect, internalSize(), m_context->isAcceleratedContext(), false);
    308309}
    309310
    … …  
    311312{
    312313    if (!m_context->isAcceleratedContext()) {
    313         m_data.putData(source, sourceSize, sourceRect, destPoint, m_size, m_context->isAcceleratedContext(), multiplied == Unmultiplied);
     314        m_data.putData(source, sourceSize, sourceRect, destPoint, internalSize(), m_context->isAcceleratedContext(), multiplied == Unmultiplied);
    314315        return;
    315316    }
    … …  
    318319    // Make a copy of the source to ensure the bits don't change before being drawn
    319320    IntSize sourceCopySize(sourceRect.width(), sourceRect.height());
    320     OwnPtr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, ColorSpaceDeviceRGB, Unaccelerated);
     321    OwnPtr<ImageBuffer> sourceCopy = ImageBuffer::create(sourceCopySize, 1, ColorSpaceDeviceRGB, Unaccelerated);
    321322    if (!sourceCopy)
    322323        return;
    323     sourceCopy->m_data.putData(source, sourceSize, sourceRect, IntPoint(-sourceRect.x(), -sourceRect.y()), sourceCopy->size(), sourceCopy->context()->isAcceleratedContext(), multiplied == Unmultiplied);
     324
     325    sourceCopy->m_data.putData(source, sourceSize, sourceRect, IntPoint(-sourceRect.x(), -sourceRect.y()), sourceCopy->internalSize(), sourceCopy->context()->isAcceleratedContext(), multiplied == Unmultiplied);
    324326
    325327    // Set up context for using drawImage as a direct bit copy
    … …  
    334336
    335337    // Draw the image in CG coordinate space
    336     IntPoint destPointInCGCoords(destPoint.x() + sourceRect.x(), m_size.height() - (destPoint.y()+sourceRect.y()) - sourceRect.height());
     338    IntPoint destPointInCGCoords(destPoint.x() + sourceRect.x(), internalSize().height() - (destPoint.y()+sourceRect.y()) - sourceRect.height());
    337339    IntRect destRectInCGCoords(destPointInCGCoords, sourceCopySize);
    338340    RetainPtr<CGImageRef> sourceCopyImage(AdoptCF, sourceCopy->copyNativeImage());
    … …  
    419421    if (CFEqual(uti.get(), jpegUTI())) {
    420422        // JPEGs don't have an alpha channel, so we have to manually composite on top of black.
    421         arr = getPremultipliedImageData(IntRect(IntPoint(0, 0), m_size));
     423        arr = getPremultipliedImageData(IntRect(IntPoint(0, 0), internalSize()));
    422424
    423425        unsigned char *data = arr->data();
    424         for (int i = 0; i < width() * height(); i++)
     426        for (int i = 0; i < internalSize().width() * internalSize().height(); i++)
    425427            data[i * 4 + 3] = 255; // The image is already premultiplied, so we just need to make it opaque.
    426428
    427429        RetainPtr<CGDataProviderRef> dataProvider;
    428430   
    429         dataProvider.adoptCF(CGDataProviderCreateWithData(0, data,
    430                                                           4 * width() * height(), 0));
     431        dataProvider.adoptCF(CGDataProviderCreateWithData(0, data, 4 * internalSize().width() * internalSize().height(), 0));
    431432   
    432433        if (!dataProvider)
    433434            return "data:,";
    434435
    435         image.adoptCF(CGImageCreate(width(), height(), 8, 32, 4 * width(),
     436        image.adoptCF(CGImageCreate(internalSize().width(), internalSize().height(), 8, 32, 4 * internalSize().width(),
    436437                                    CGColorSpaceCreateDeviceRGB(), kCGBitmapByteOrderDefault | kCGImageAlphaLast,
    437438                                    dataProvider.get(), 0, false, kCGRenderingIntentDefault));

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

    r106836 r109016  
    104104
    105105    // TODO: Direct pixel access to ImageBuffer would avoid copying the ImageData.
    106     IntRect shadowArea(IntPoint(), resultImage->size());
     106    IntRect shadowArea(IntPoint(), resultImage->internalSize());
    107107    RefPtr<ByteArray> srcPixelArray = resultImage->getPremultipliedImageData(shadowArea);
    108108

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

    r106836 r109016  
    128128    if (m_imageBufferResult)
    129129        return m_imageBufferResult.get();
    130     m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), ColorSpaceLinearRGB, m_filter->renderingMode());
     130    m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), 1, ColorSpaceLinearRGB, m_filter->renderingMode());
    131131    IntRect destinationRect(IntPoint(), m_absolutePaintRect.size());
    132132    if (m_premultipliedImageResult)
    … …  
    265265    if (m_absolutePaintRect.isEmpty())
    266266        return 0;
    267     m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), ColorSpaceLinearRGB, m_filter->renderingMode());
     267    m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), 1, ColorSpaceLinearRGB, m_filter->renderingMode());
    268268    if (!m_imageBufferResult)
    269269        return 0;

  • trunk/Source/WebCore/platform/graphics/qt/ImageBufferQt.cpp

    r106836 r109016  
    110110}
    111111
    112 size_t ImageBuffer::dataSize() const
    113 {
    114     return m_size.width() * m_size.height() * 4;
    115 }
    116 
    117112GraphicsContext* ImageBuffer::context() const
    118113{

  • trunk/Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp

    r106836 r109016  
    170170}
    171171
    172 size_t ImageBuffer::dataSize() const
    173 {
    174     return m_size.width() * m_size.height() * 4;
    175 }
    176 
    177172PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior) const
    178173{

  • trunk/Source/WebCore/platform/graphics/skia/PlatformContextSkia.cpp

    r108714 r109016  
    242242    canvas()->clipRect(bounds);
    243243
    244     if (imageBuffer->size().isEmpty())
     244    if (imageBuffer->internalSize().isEmpty())
    245245        return;
    246246

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

    r108135 r109016  
    3333    ~BitmapTextureImageBuffer() { destroy(); }
    3434    virtual void destroy() { m_image.clear(); }
    35     virtual IntSize size() const { return m_image->size(); }
     35    virtual IntSize size() const { return m_image->internalSize(); }
    3636    virtual void didReset();
    3737    virtual bool isValid() const { return m_image; }

  • trunk/Source/WebCore/platform/graphics/wince/ImageBufferWinCE.cpp

    r106836 r109016  
    8787ImageBuffer::~ImageBuffer()
    8888{
    89 }
    90 
    91 size_t ImageBuffer::dataSize() const
    92 {
    93     return m_size.width() * m_size.height() * 4;
    9489}
    9590

  • trunk/Source/WebCore/platform/graphics/wx/ImageBufferWx.cpp

    r106836 r109016  
    4747ImageBuffer::~ImageBuffer()
    4848{
    49 }
    50 
    51 size_t ImageBuffer::dataSize() const
    52 {
    53     notImplemented();
    54     return 0;
    5549}
    5650

  • trunk/Source/WebCore/platform/mac/ScrollbarThemeMac.mm

    r107119 r109016  
    590590        bufferRect.intersect(damageRect);
    591591       
    592         OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(bufferRect.size());
     592        OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(bufferRect.size(), 1);
    593593        if (!imageBuffer)
    594594            return true;

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

    r107822 r109016  
    323323    // buffer if we have not yet done so.
    324324    if (!m_graphicsBufferAttached) {
    325         setSourceImage(ImageBuffer::create(IntSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height()), ColorSpaceDeviceRGB, renderingMode()));
     325        IntSize logicalSize(m_sourceDrawingRegion.width(), m_sourceDrawingRegion.height());
     326        setSourceImage(ImageBuffer::create(logicalSize, 1, ColorSpaceDeviceRGB, renderingMode()));
    326327        m_graphicsBufferAttached = true;
    327328    }

  • trunk/Source/WebCore/rendering/RenderThemeMac.mm

    r108261 r109016  
    991991    trackInfo.filler1 = 0;
    992992
    993     OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(inflatedRect.size());
     993    OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(inflatedRect.size(), 1);
    994994    if (!imageBuffer)
    995995        return true;

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

    r106108 r109016  
    6161
    6262    IntSize clampedSize = clampedAbsoluteSize(paintRect.size());
    63     OwnPtr<ImageBuffer> image = ImageBuffer::create(clampedSize, colorSpace, renderingMode);
     63    OwnPtr<ImageBuffer> image = ImageBuffer::create(clampedSize, 1, colorSpace, renderingMode);
    6464    if (!image)
    6565        return false;
    … …  
    9090        return false;
    9191
    92     OwnPtr<ImageBuffer> image = ImageBuffer::create(imageSize, colorSpace, renderingMode);
     92    OwnPtr<ImageBuffer> image = ImageBuffer::create(imageSize, 1, colorSpace, renderingMode);
    9393    if (!image)
    9494        return false;

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

    r108834 r109016  
    313313        if (!m_page)
    314314            return 0;
    315         OwnPtr<ImageBuffer> buffer = ImageBuffer::create(size());
     315        OwnPtr<ImageBuffer> buffer = ImageBuffer::create(size(), 1);
    316316        if (!buffer) // failed to allocate image
    317317            return 0;

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

    r108834 r109016  
    145145
    146146    // Create and cache new image and image buffer at requested size.
    147     OwnPtr<ImageBuffer> newBuffer = ImageBuffer::create(size);
     147    OwnPtr<ImageBuffer> newBuffer = ImageBuffer::create(size, 1);
    148148    if (!newBuffer)
    149149        return Image::nullImage();
Note: See TracChangeset for help on using the changeset viewer.