Attachment #288468 for bug #159679

View Details Raw Unified Return to Bug 159679

| Differences between



2016-09-09  Said Abou-Hallawa  <sabouhallawa@apple.com>

        Move the pixel data of ImageFrame to a separate class named ImageBackingStore
        https://bugs.webkit.org/show_bug.cgi?id=159679

        Reviewed by NOBODY (OOPS!).

        Move the pixel data manipulation part in ImageFrame into a separate class
        and allocate it on demand.

        * PlatformEfl.cmake:
        * PlatformGTK.cmake:
        * PlatformWinCairo.cmake:
        * WebCore.xcodeproj/project.pbxproj:
        * platform/graphics/Color.cpp:
        (WebCore::premultipliedChannel):
        (WebCore::unpremultipliedChannel):
        (WebCore::makePremultipliedRGBA):
        (WebCore::makeUnPremultipliedRGBA):
        (WebCore::colorFromPremultipliedARGB):
        (WebCore::premultipliedARGBFromColor):
        * platform/graphics/Color.h:
        (WebCore::fastMultiplyBy255):
        * platform/graphics/ImageBackingStore.h: Added.
        (WebCore::ImageBackingStore::create):
        (WebCore::ImageBackingStore::ImageBackingStore):
        (WebCore::ImageBackingStore::setSize):
        (WebCore::ImageBackingStore::setFrameRect):
        (WebCore::ImageBackingStore::size):
        (WebCore::ImageBackingStore::frameRect):
        (WebCore::ImageBackingStore::clear):
        (WebCore::ImageBackingStore::clearRect):
        (WebCore::ImageBackingStore::repeatFirstRow):
        (WebCore::ImageBackingStore::at):
        (WebCore::ImageBackingStore::setRGBA):
        (WebCore::ImageBackingStore::overRGBA):
        (WebCore::ImageBackingStore::inBounds):
        (WebCore::ImageBackingStore::isOverSize):
        * platform/graphics/cg/NativeImageCG.cpp:
        (WebCore::nativeImageHasAlpha):
        * platform/image-decoders/ImageDecoder.cpp:
        (WebCore::ImageFrame::operator=):
        (WebCore::ImageFrame::clearPixelData):
        (WebCore::ImageFrame::zeroFillPixelData):
        (WebCore::ImageFrame::zeroFillFrameRect):
        (WebCore::ImageFrame::copyBitmapData):
        (WebCore::ImageFrame::setSize):
        (WebCore::ImageFrame::setOriginalFrameRect):
        (WebCore::ImageDecoder::frameBytesAtIndex):
        * platform/image-decoders/ImageDecoder.h:
        (WebCore::ImageFrame::copyRowNTimes):
        (WebCore::ImageFrame::size):
        (WebCore::ImageFrame::asNewNativeImage):
        (WebCore::ImageFrame::backingStore):
        (WebCore::ImageFrame::hasBackingStore):
        (WebCore::ImageFrame::originalFrameRect):
        (WebCore::ImageFrame::getAddr):
        (WebCore::ImageFrame::setRGBA):
        (WebCore::ImageFrame::overRGBA):
        (WebCore::ImageDecoder::setSize):
        (WebCore::ImageFrame::setOriginalFrameRect): Deleted.
        (WebCore::ImageFrame::hasPixelData): Deleted.
        (WebCore::ImageFrame::fixPointUnsignedMultiply): Deleted.
        (WebCore::ImageFrame::divide255): Deleted.
        (WebCore::ImageFrame::width): Deleted.
        (WebCore::ImageFrame::height): Deleted.
        (WebCore::ImageDecoder::isOverSize): Deleted.
        * platform/image-decoders/bmp/BMPImageReader.cpp:
        (WebCore::BMPImageReader::decodeBMP):
        (WebCore::BMPImageReader::processInfoHeader):
        * platform/image-decoders/cairo/ImageBackingStoreCairo.cpp: Added.
        (WebCore::ImageBackingStore::image):
        * platform/image-decoders/gif/GIFImageDecoder.cpp:
        (WebCore::GIFImageDecoder::setSize):
        (WebCore::GIFImageDecoder::haveDecodedRow):
        (WebCore::GIFImageDecoder::initFrameBuffer):
        * platform/image-decoders/gif/GIFImageDecoder.h:
        * platform/image-decoders/gif/GIFImageReader.cpp:
        (GIFImageReader::parse):
        * platform/image-decoders/ico/ICOImageDecoder.cpp:
        (WebCore::ICOImageDecoder::setSize):
        (WebCore::ICOImageDecoder::processDirectoryEntries): Deleted.
        * platform/image-decoders/ico/ICOImageDecoder.h:
        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
        (WebCore::JPEGImageReader::decode):
        (WebCore::JPEGImageDecoder::setSize):
        (WebCore::setPixel):
        (WebCore::JPEGImageDecoder::outputScanlines):
        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
        * platform/image-decoders/png/PNGImageDecoder.cpp:
        (WebCore::PNGImageDecoder::setSize):
        (WebCore::PNGImageDecoder::headerAvailable):
        (WebCore::setPixelRGB):
        (WebCore::setPixelRGBA):
        (WebCore::setPixelPremultipliedRGBA):
        (WebCore::PNGImageDecoder::rowAvailable):
        (WebCore::PNGImageDecoder::initFrameBuffer):
        (WebCore::PNGImageDecoder::frameComplete):
        * platform/image-decoders/png/PNGImageDecoder.h:
        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
        (WebCore::WEBPImageDecoder::decode):

2016-09-09  Commit Queue  <commit-queue@webkit.org>

        Unreviewed, rolling out r205771.



    platform/graphics/x11/PlatformDisplayX11.cpp
    platform/graphics/x11/XUniqueResource.cpp

    platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
    platform/image-encoders/JPEGImageEncoder.cpp

    platform/image-decoders/cairo/ImageDecoderCairo.cpp

    platform/network/efl/NetworkStateNotifierEfl.cpp

    platform/network/soup/AuthenticationChallengeSoup.cpp

Lines 155-161 list(APPEND WebCore_SOURCES Source/WebCore/PlatformGTK.cmake_sec1
- Source/WebCore/PlatformGTK.cmake -1 / +1 lines
155	platform/gtk/TemporaryLinkStubs.cpp	155	platform/gtk/TemporaryLinkStubs.cpp
156	platform/gtk/UserAgentGtk.cpp	156	platform/gtk/UserAgentGtk.cpp
157		157
158	platform/image-decoders/cairo/ImageDecoderCairo.cpp	158	platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
159		159
160	platform/mediastream/gtk/SDPProcessorScriptResourceGtk.cpp	160	platform/mediastream/gtk/SDPProcessorScriptResourceGtk.cpp
161		161

Lines 46-52 list(APPEND WebCore_SOURCES Source/WebCore/PlatformWinCairo.cmake_sec1
- Source/WebCore/PlatformWinCairo.cmake -1 / +1 lines
46	platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp	46	platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp
47	platform/graphics/win/SimpleFontDataCairoWin.cpp	47	platform/graphics/win/SimpleFontDataCairoWin.cpp
48		48
49	platform/image-decoders/cairo/ImageDecoderCairo.cpp	49	platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
50		50
51	platform/network/NetworkStorageSessionStub.cpp	51	platform/network/NetworkStorageSessionStub.cpp
52		52



		555B87EC1CAAF0AB00349425 /* ImageDecoderCG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 555B87EA1CAAF0AB00349425 /* ImageDecoderCG.cpp */; };
		555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers */ = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */; };
		55A336F71D8209F40022C4C7 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 /* NativeImage.h */; };
		55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
		5709E8CD1D413D47003244AC /* WebKitSubtleCrypto.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5709E8CA1D413CE3003244AC /* WebKitSubtleCrypto.cpp */; };
		5709E8CE1D413D5B003244AC /* JSWebKitSubtleCryptoCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1FF8F661807460800132674 /* JSWebKitSubtleCryptoCustom.cpp */; };
		5709E8CF1D413D9A003244AC /* WebKitSubtleCrypto.h in Headers */ = {isa = PBXBuildFile; fileRef = 5709E8CB1D413CE3003244AC /* WebKitSubtleCrypto.h */; };

		555B87EA1CAAF0AB00349425 /* ImageDecoderCG.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoderCG.cpp; sourceTree = "<group>"; };
		555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoderCG.h; sourceTree = "<group>"; };
		55A336F61D8209F40022C4C7 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
		55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBackingStore.h; sourceTree = "<group>"; };
		55D408F71A7C631800C78450 /* SVGImageClients.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGImageClients.h; sourceTree = "<group>"; };
		5709E8CA1D413CE3003244AC /* WebKitSubtleCrypto.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebKitSubtleCrypto.cpp; sourceTree = "<group>"; };
		5709E8CB1D413CE3003244AC /* WebKitSubtleCrypto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebKitSubtleCrypto.h; sourceTree = "<group>"; };

				379919941200DDF400EA041C /* WOFFFileFormat.cpp */,
				379919951200DDF400EA041C /* WOFFFileFormat.h */,
				55A336F61D8209F40022C4C7 /* NativeImage.h */,
				55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */,
			);
			path = graphics;
			sourceTree = "<group>";

				582CB0531A78A14B00AFFCC4 /* SimpleLineLayoutTextFragmentIterator.h in Headers */,
				C5A1EA7D152BCF08004D00B6 /* SimplifyMarkupCommand.h in Headers */,
				572A7F211C6E5719009C6149 /* SimulatedClick.h in Headers */,
				55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */,
				31741AAD16636609008A5B7E /* SimulatedClickOptions.h in Headers */,
				FD00D7A514A3F61900734011 /* SincResampler.h in Headers */,
				51327D6011A33A2B004F9D65 /* SinkDocument.h in Headers */,



static const RGBA32 lightenedBlack = 0xFF545454;
static const RGBA32 darkenedWhite = 0xFFABABAB;

static inline unsigned premultipliedChannel(unsigned c, unsigned a)
{
    return fastDivideBy255(c * a + 254);
}

static inline unsigned unpremultipliedChannel(unsigned c, unsigned a)
{
    return (fastMultiplyBy255(c) + a - 1) / a;
}

RGBA32 makeRGB(int r, int g, int b)
{
    return 0xFF000000 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));

    return std::max(0, std::min(a, 255)) << 24 | std::max(0, std::min(r, 255)) << 16 | std::max(0, std::min(g, 255)) << 8 | std::max(0, std::min(b, 255));
}

RGBA32 makePremultipliedRGBA(int r, int g, int b, int a)
{
    return makeRGBA(premultipliedChannel(r, a), premultipliedChannel(g, a), premultipliedChannel(b, a), a);
}

RGBA32 makeUnPremultipliedRGBA(int r, int g, int b, int a)
{
    return makeRGBA(unpremultipliedChannel(r, a), unpremultipliedChannel(g, a), unpremultipliedChannel(b, a), a);
}

static int colorFloatToRGBAByte(float f)
{
    // We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding

Color colorFromPremultipliedARGB(RGBA32 pixelColor)
{
    int alpha = alphaChannel(pixelColor);
    if (alpha && alpha < 255)
        pixelColor = makeUnPremultipliedRGBA(redChannel(pixelColor), greenChannel(pixelColor), blueChannel(pixelColor), alpha);
    return Color(pixelColor);
            greenChannel(pixelColor) * 255 / alpha,
            blueChannel(pixelColor) * 255 / alpha,
            alpha);
    } else
        return Color(pixelColor);
}

RGBA32 premultipliedARGBFromColor(const Color& color)

    unsigned pixelColor;

    unsigned alpha = color.alpha();
    if (alpha < 255)
        pixelColor = makePremultipliedRGBA(color.red(), color.green(), color.blue(), alpha);
    else
        pixelColor = color.rgb();
            fastDivideBy255(color.blue() * alpha + 254),
            alpha).rgb();
    } else
         pixelColor = color.rgb();

    return pixelColor;
}

Lines 55-60 typedef unsigned RGBA32; // Deprecated: Source/WebCore/platform/graphics/Color.h_sec1
- Source/WebCore/platform/graphics/Color.h +9 lines
55	WEBCORE_EXPORT RGBA32 makeRGB(int r, int g, int b);	55	WEBCORE_EXPORT RGBA32 makeRGB(int r, int g, int b);
56	WEBCORE_EXPORT RGBA32 makeRGBA(int r, int g, int b, int a);	56	WEBCORE_EXPORT RGBA32 makeRGBA(int r, int g, int b, int a);
57		57
		58	RGBA32 makePremultipliedRGBA(int r, int g, int b, int a);
		59	RGBA32 makeUnPremultipliedRGBA(int r, int g, int b, int a);
		60
58	WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha);	61	WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha);
59	WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, Optional<float> overrideAlpha);	62	WEBCORE_EXPORT RGBA32 colorWithOverrideAlpha(RGBA32 color, Optional<float> overrideAlpha);
60		63
Lines 218-223 Color blend(const Color& from, const Col Source/WebCore/platform/graphics/Color.h_sec2
218		221
219	int differenceSquared(const Color&, const Color&);	222	int differenceSquared(const Color&, const Color&);
220		223
		224	uint16_t fastMultiplyBy255(uint16_t value);
221	uint16_t fastDivideBy255(uint16_t);	225	uint16_t fastDivideBy255(uint16_t);
222		226
223	#if USE(CG)	227	#if USE(CG)
Lines 290-295 inline uint8_t roundAndClampColorChannel Source/WebCore/platform/graphics/Color.h_sec3
290	return std::max(0.f, std::min(255.f, std::round(value)));	294	return std::max(0.f, std::min(255.f, std::round(value)));
291	}	295	}
292		296
		297	inline uint16_t fastMultiplyBy255(uint16_t value)
		298	{
		299	return (value << 8) - value;
		300	}
		301
293	inline uint16_t fastDivideBy255(uint16_t value)	302	inline uint16_t fastDivideBy255(uint16_t value)
294	{	303	{
295	// While this is an approximate algorithm for division by 255, it gives perfectly accurate results for 16-bit values.	304	// While this is an approximate algorithm for division by 255, it gives perfectly accurate results for 16-bit values.



/*
 * Copyright (C) 2016 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "Color.h"
#include "IntRect.h"
#include "IntSize.h"
#include "NativeImage.h"

#include <wtf/Vector.h>

namespace WebCore {

class ImageBackingStore {
public:
    static std::unique_ptr<ImageBackingStore> create(const IntSize& size, bool premultiplyAlpha)
    {
        return std::make_unique<ImageBackingStore>(size, premultiplyAlpha);
    }

    static std::unique_ptr<ImageBackingStore> create(const ImageBackingStore& other)
    {
        return std::make_unique<ImageBackingStore>(other);
    }

    ImageBackingStore(const IntSize& size, bool premultiplyAlpha = true)
        : m_premultiplyAlpha(premultiplyAlpha)
    {
        ASSERT(!size.isEmpty());
        setSize(size);
    }

    ImageBackingStore(const ImageBackingStore& other)
    {
        if (this == &other)
            return;

        m_pixels = other.m_pixels;
        m_pixelsPtr = m_pixels.data();
        m_size = other.m_size;
        m_premultiplyAlpha = other.m_premultiplyAlpha;
    }

    NativeImagePtr image() const;

    bool setSize(const IntSize& size)
    {
        if (!m_pixels.tryReserveCapacity(size.area()))
            return false;

        m_pixels.resize(size.area());
        m_pixelsPtr = m_pixels.data();
        m_size = size;
        m_frameRect = IntRect(IntPoint(), m_size);
        clear();
        return true;
    }

    void setFrameRect(const IntRect& frameRect)
    {
        ASSERT(!m_size.isEmpty());
        ASSERT(inBounds(frameRect));
        m_frameRect = frameRect;
    }

    IntSize size() const { return m_size; }
    IntRect frameRect() const { return m_frameRect; }

    void clear()
    {
        memset(m_pixelsPtr, 0, m_size.area() * sizeof(RGBA32));
    }

    void clearRect(const IntRect& rect)
    {
        if (rect.isEmpty() || !inBounds(rect))
            return;

        size_t rectWidthInBytes = rect.width() * sizeof(RGBA32);
        RGBA32* start = at(rect.x(), rect.y());
        for (int i = 0; i < rect.height(); ++i) {
            memset(start, 0, rectWidthInBytes);
            start += m_size.width();
        }
    }

    void repeatFirstRow(const IntRect& rect)
    {
        if (rect.isEmpty() || !inBounds(rect))
            return;

        size_t rectWidthInBytes = rect.width() * sizeof(RGBA32);
        RGBA32* src = at(rect.x(), rect.y());
        RGBA32* dest = src + m_size.width();
        for (int i = 1; i < rect.height(); ++i) {
            memcpy(dest, src, rectWidthInBytes);
            dest += m_size.width();
        }
    }

    RGBA32* at(int x, int y) const
    {
        return m_pixelsPtr + y * m_size.width() + x;
    }

    void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
    {
        setRGBA(at(x, y), r, g, b, a);
    }

    void setRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
    {
        if (m_premultiplyAlpha && !a)
            *dest = 0;
        else if (m_premultiplyAlpha && a < 255)
            *dest = makePremultipliedRGBA(r, g, b, a);
        else
            *dest = makeRGBA(r, g, b, a);
    }

    void overRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
    {
        if (!a)
            return;

        if (a >= 255 || !alphaChannel(*dest)) {
            setRGBA(dest, r, g, b, a);
            return;
        }

        if (!m_premultiplyAlpha)
            *dest = makePremultipliedRGBA(redChannel(*dest), greenChannel(*dest), blueChannel(*dest), alphaChannel(*dest));

        unsigned d = 255 - a;

        r = fastDivideBy255(r * a + redChannel(*dest) * d);
        g = fastDivideBy255(g * a + greenChannel(*dest) * d);
        b = fastDivideBy255(b * a + blueChannel(*dest) * d);
        a += fastDivideBy255(d * alphaChannel(*dest));

        if (m_premultiplyAlpha)
            *dest = makeRGBA(r, g, b, a);
        else
            *dest = makeUnPremultipliedRGBA(r, g, b, a);
    }

    bool inBounds(const IntRect& rect) const
    {
        return IntRect(IntPoint(), m_size).contains(rect);
    }

    static bool isOverSize(const IntSize& size)
    {
        static unsigned long long MaxPixels = ((1 << 29) - 1);
        unsigned long long pixels = static_cast<unsigned long long>(size.width()) * static_cast<unsigned long long>(size.height());
        return pixels > MaxPixels;
    }

private:
    Vector<RGBA32> m_pixels;
    RGBA32* m_pixelsPtr { nullptr };
    IntSize m_size;
    IntRect m_frameRect; // This will always just be the entire buffer except for GIF and PNG frames
    bool m_premultiplyAlpha { true };
};

}



    return image ? IntSize(CGImageGetWidth(image.get()), CGImageGetHeight(image.get())) : IntSize();
}

bool nativeImageHasAlpha(const NativeImagePtr& image)
{
    CGImageAlphaInfo info = CGImageGetAlphaInfo(image.get());
    return (info >= kCGImageAlphaPremultipliedLast) && (info <= kCGImageAlphaFirst);
}

Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)



        return *this;

    copyBitmapData(other);
    setHasAlpha(other.m_hasAlpha);
    setStatus(other.status());
    setDuration(other.duration());
    setDisposalMethod(other.disposalMethod());


void ImageFrame::clearPixelData()
{
    m_backingStore = nullptr;
    m_bytes = 0;
    m_status = FrameEmpty;
    // NOTE: Do not reset other members here; clearFrameBufferCache() calls this
    // to free the bitmap data, but other functions like initFrameBuffer() and


void ImageFrame::zeroFillPixelData()
{
    m_backingStore->clear();
    m_hasAlpha = true;
}

void ImageFrame::zeroFillFrameRect(const IntRect& rect)
{
    ASSERT(IntRect(IntPoint(), m_size).contains(rect));

    if (rect.isEmpty())
        return;

    m_backingStore->clearRect(rect);
    PixelData* start = m_bytes + (rect.y() * width()) + rect.x();
    for (int i = 0; i < rect.height(); ++i) {
        memset(start, 0, rectWidthInBytes);
        start += width();
    }

    setHasAlpha(true);
}


    if (this == &other)
        return true;

    if (other.m_backingStore)
        m_backingStore = ImageBackingStore::create(*other.m_backingStore.get());
    else
        m_backingStore = nullptr;
    
    return true;
}

bool ImageFrame::setSize(const IntSize& size)
{
    ASSERT(!m_backingStore);
    m_backingStore = ImageBackingStore::create(size, m_premultiplyAlpha);
    return m_backingStore != nullptr;
        return false;
    m_backingStore.resize(backingStoreSize);
    m_bytes = m_backingStore.data();
    m_size = IntSize(newWidth, newHeight);

    zeroFillPixelData();
    return true;
}

bool ImageFrame::hasAlpha() const

    m_hasAlpha = alpha;
}

void ImageFrame::setOriginalFrameRect(const IntRect& frameRect)
{
    if (m_backingStore)
        m_backingStore->setFrameRect(frameRect);
}

void ImageFrame::setStatus(FrameStatus status)
{
    m_status = status;

    if (m_frameBufferCache.size() <= index)
        return 0;
    // FIXME: Use the dimension of the requested frame.
    return m_size.area() * sizeof(RGBA32);
}

float ImageDecoder::frameDurationAtIndex(size_t index)




#pragma once

#include "ImageBackingStore.h"
#include "ImageSource.h"
#include "IntRect.h"
#include "IntSize.h"
#include "PlatformScreen.h"
#include "SharedBuffer.h"
#include <wtf/Assertions.h>

            DisposeOverwritePrevious  // Clear frame to previous framebuffer
                                      // contents
        };
        typedef unsigned PixelData;

        ImageFrame();


        // endY.
        void copyRowNTimes(int startX, int endX, int startY, int endY)
        {
            m_backingStore->repeatFirstRow(IntRect(startX, startY, endX -startX , endY - startY));
            ASSERT(endX <= width());
            ASSERT(startY < height());
            ASSERT(endY <= height());
            const int rowBytes = (endX - startX) * sizeof(PixelData);
            const PixelData* const startAddr = getAddr(startX, startY);
            for (int destY = startY + 1; destY < endY; ++destY)
                memcpy(getAddr(startX, destY), startAddr, rowBytes);
        }

        // Allocates space for the pixel data.  Must be called before any pixels
        // are written.  Must only be called once.  Returns whether allocation
        // succeeded.
        bool setSize(const IntSize&);
        IntSize size() const { return m_backingStore->size(); }

        // Returns a caller-owned pointer to the underlying native image data.
        // (Actual use: This pointer will be owned by BitmapImage and freed in
        // FrameData::clear()).
        NativeImagePtr asNewNativeImage() const { return m_backingStore->image(); }

        inline ImageBackingStore* backingStore() const { return m_backingStore ? m_backingStore.get() : nullptr; }
        inline bool hasBackingStore() const { return backingStore(); }
        
        bool hasAlpha() const;
        IntRect originalFrameRect() const { return m_backingStore ? m_backingStore->frameRect() : IntRect(); }
        FrameStatus status() const { return m_status; }
        unsigned duration() const { return m_duration; }
        FrameDisposalMethod disposalMethod() const { return m_disposalMethod; }
        bool premultiplyAlpha() const { return m_premultiplyAlpha; }

        void setBackingStore(const ImageBackingStore*);
        
        void setHasAlpha(bool alpha);
        void setOriginalFrameRect(const IntRect&);
        void setStatus(FrameStatus status);
        void setDuration(unsigned duration) { m_duration = duration; }
        void setDisposalMethod(FrameDisposalMethod method) { m_disposalMethod = method; }
        void setPremultiplyAlpha(bool premultiplyAlpha) { m_premultiplyAlpha = premultiplyAlpha; }

        inline RGBA32* getAddr(int x, int y)
        {
            setRGBA(getAddr(x, y), r, g, b, a);
        }

        inline PixelData* getAddr(int x, int y)
        {
            return m_bytes + (y * width()) + x;
        }

        inline bool hasPixelData() const
        {
            return m_backingStore->at(x, y);
        }

        inline void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
        // This multipler produces exactly the same result for all values in range 0 - 255.
        static const unsigned fixPointShift = 24;
        static const unsigned fixPointMult = static_cast<unsigned>(1.0 / 255.0 * (1 << fixPointShift)) + 1;
        // Multiplies unsigned value by fixpoint value and converts back to unsigned.
        static unsigned fixPointUnsignedMultiply(unsigned fixed, unsigned v)
        {
            m_backingStore->setRGBA(x, y, r, g, b, a);
        }

        inline void setRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
        {
            m_backingStore->setRGBA(dest, r, g, b, a);
                if (!a) {
                    *dest = 0;
                    return;
                }

                unsigned alphaMult = a * fixPointMult;
                r = fixPointUnsignedMultiply(r, alphaMult);
                g = fixPointUnsignedMultiply(g, alphaMult);
                b = fixPointUnsignedMultiply(b, alphaMult);
            }
            *dest = (a << 24 | r << 16 | g << 8 | b);
        }

#if ENABLE(APNG)
        inline void overRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
        {
            m_backingStore->overRGBA(dest, r, g, b, a);
        }

        inline void overRGBA(PixelData* dest, unsigned r, unsigned g, unsigned b, unsigned a)
        {
            if (!a)
                return;

            if (a < 255) {
                unsigned aDest = ((*dest) >> 24) & 255;
                if (aDest) {
                    unsigned rDest = ((*dest) >> 16) & 255;
                    unsigned gDest = ((*dest) >> 8) & 255;
                    unsigned bDest = (*dest) & 255;
                    unsigned aAux = 255 - a;
                    if (!m_premultiplyAlpha) {
                        rDest = divide255(rDest * aDest);
                        gDest = divide255(gDest * aDest);
                        bDest = divide255(bDest * aDest);
                    }
                    r = divide255(r * a + rDest * aAux);
                    g = divide255(g * a + gDest * aAux);
                    b = divide255(b * a + bDest * aAux);
                    a += divide255(aDest * aAux);
                    if (!m_premultiplyAlpha) {
                        r = (r * 255 + a - 1) / a;
                        g = (g * 255 + a - 1) / a;
                        b = (b * 255 + a - 1) / a;
                    }
                } else if (m_premultiplyAlpha) {
                    r = divide255(r * a);
                    g = divide255(g * a);
                    b = divide255(b * a);
                }
            }
            *dest = (a << 24 | r << 16 | g << 8 | b);
        }
#endif

    private:
        std::unique_ptr<ImageBackingStore> m_backingStore;
        {
            return m_size.width();
        }

        int height() const
        {
            return m_size.height();
        }

        Vector<PixelData> m_backingStore;
        PixelData* m_bytes; // The memory is backed by m_backingStore.
        IntSize m_size;
        bool m_hasAlpha;
        IntRect m_originalFrameRect; // This will always just be the entire
                                     // buffer except for GIF frames whose
                                     // original rect was smaller than the
                                     // overall image size.
        FrameStatus m_status;
        unsigned m_duration;
        FrameDisposalMethod m_disposalMethod;


        // Returns whether the size is legal (i.e. not going to result in
        // overflow elsewhere).  If not, marks decoding as failed.
        virtual bool setSize(const IntSize& size)
        {
            if (ImageBackingStore::isOverSize(size))
                return setFailed();
            m_size = size;
            m_sizeAvailable = true;
            return true;
        }

        ImageOrientation m_orientation;

    private:
        // Some code paths compute the size of the image as "width * height * 4"
        // and return it as a (signed) int.  Avoid overflow.
        static bool isOverSize(unsigned width, unsigned height)
        {
            unsigned long long total_size = static_cast<unsigned long long>(width)
                                          * static_cast<unsigned long long>(height);
            return total_size > ((1 << 29) - 1);
        }

        IntSize m_size;
        bool m_sizeAvailable { false };
#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)



    // Initialize the framebuffer if needed.
    ASSERT(m_buffer);  // Parent should set this before asking us to decode!
    if (m_buffer->status() == ImageFrame::FrameEmpty) {
        if (!m_buffer->setSize(m_parent->size()))
            return m_parent->setFailed(); // Unable to allocate.
        m_buffer->setStatus(ImageFrame::FramePartial);
        // setSize() calls eraseARGB(), which resets the alpha flag, so we force

        // these 0s could actually show through.
        m_buffer->setHasAlpha(false);

        // For BMPs, the frame always fills the entire image.
        m_buffer->setOriginalFrameRect(IntRect(IntPoint(), m_parent->size()));

        if (!m_isTopDown)
            m_coord.setY(m_parent->size().height() - 1);
    }

        return m_parent->setFailed();

    // Set our size.
    if (!m_parent->setSize(IntSize(m_infoHeader.biWidth, m_infoHeader.biHeight)))
        return false;

    // For paletted images, bitmaps can set biClrUsed to 0 to mean "all



/*
 * Copyright (C) 2016 Apple Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#include "config.h"
#include "ImageBackingStore.h"

#include <cairo.h>

namespace WebCore {

NativeImagePtr ImageBackingStore::image() const
{
    return adoptRef(cairo_image_surface_create_for_data(
        reinterpret_cast<unsigned char*>(const_cast<RGBA32*>(m_pixelsPtr)),
        CAIRO_FORMAT_ARGB32, size().width(), size().height(), size().width() * sizeof(RGBA32)));
}

} // namespace WebCore



    return ImageDecoder::isSizeAvailable();
}

bool GIFImageDecoder::setSize(const IntSize& size)
{
    if (ImageDecoder::isSizeAvailable() && this->size() == size)
        return true;

    if (!ImageDecoder::setSize(size))
        return false;

    prepareScaleDataIfNecessary();


    // Initialize the frame if necessary.
    ImageFrame& buffer = m_frameBufferCache[frameIndex];
    if (((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex)) || !buffer.hasBackingStore())
        return false;

    RGBA32* currentAddress = buffer.getAddr(xBegin, yBegin);
    // Write one row's worth of data into the frame.  
    for (int x = xBegin; x < xEnd; ++x) {
        const unsigned char sourceValue = rowBuffer[(m_scaled ? m_scaledColumns[x] : x) - frameContext->xOffset];


    if (!frameIndex) {
        // This is the first frame, so we're not relying on any previous data.
        if (!buffer->setSize(scaledSize()))
            return setFailed();
    } else {
        // The starting state for this frame depends on the previous frame's

        } else {
            // We want to clear the previous frame to transparent, without
            // affecting pixels in the image outside of the frame.
            IntRect prevRect = prevBuffer->originalFrameRect();
            const IntSize& bufferSize = scaledSize();
            if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
                // Clearing the first frame, or a frame the size of the whole
                // image, results in a completely empty image.
                if (!buffer->setSize(bufferSize))
                    return setFailed();
            } else {
                // Copy the whole previous buffer, then clear just its frame.

Lines 44-50 namespace WebCore { Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h_sec1
- Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h -1 / +1 lines
44	String filenameExtension() const override { return "gif"; }	44	String filenameExtension() const override { return "gif"; }
45	void setData(SharedBuffer& data, bool allDataReceived) override;	45	void setData(SharedBuffer& data, bool allDataReceived) override;
46	bool isSizeAvailable() override;	46	bool isSizeAvailable() override;
47	bool setSize(unsigned width, unsigned height) override;	47	bool setSize(const IntSize&) override;
48	size_t frameCount() override;	48	size_t frameCount() override;
49	int repetitionCount() const override;	49	int repetitionCount() const override;
50	ImageFrame* frameBufferAtIndex(size_t index) override;	50	ImageFrame* frameBufferAtIndex(size_t index) override;




            // CALLBACK: Inform the decoderplugin of our size.
            // Note: A subsequent frame might have dimensions larger than the "screen" dimensions.
            if (m_client && !m_client->setSize(WebCore::IntSize(m_screenWidth, m_screenHeight)))
                return false;

            m_screenBgcolor = currentComponent[5];

                yOffset = 0;

                // CALLBACK: Inform the decoderplugin of our size.
                if (m_client && !m_client->setSize(WebCore::IntSize(m_screenWidth, m_screenHeight)))
                    return false;
            }




    return (index && (index < m_dirEntries.size())) ? m_dirEntries[index].m_size : size();
}

bool ICOImageDecoder::setSize(const IntSize& size)
{
    // The size calculated inside the BMPImageReader had better match the one in
    // the icon directory.
    return m_frameSize.isEmpty() ? ImageDecoder::setSize(size) : (size == m_frameSize) || setFailed());
}

size_t ICOImageDecoder::frameCount()

    const IconDirectoryEntry& dirEntry = m_dirEntries.first();
    // Technically, this next call shouldn't be able to fail, since the width
    // and height here are each <= 256, and |m_frameSize| is empty.
    return setSize(dirEntry.m_size);
}

ICOImageDecoder::IconDirectoryEntry ICOImageDecoder::readDirectoryEntry()

Lines 49-55 namespace WebCore { Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h_sec1
- Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h -1 / +1 lines
49	bool isSizeAvailable() override;	49	bool isSizeAvailable() override;
50	IntSize size() override;	50	IntSize size() override;
51	IntSize frameSizeAtIndex(size_t, SubsamplingLevel) override;	51	IntSize frameSizeAtIndex(size_t, SubsamplingLevel) override;
52	bool setSize(unsigned width, unsigned height) override;	52	bool setSize(const IntSize&) override;
53	size_t frameCount() override;	53	size_t frameCount() override;
54	ImageFrame* frameBufferAtIndex(size_t) override;	54	ImageFrame* frameBufferAtIndex(size_t) override;
55	// CAUTION: setFailed() deletes all readers and decoders. Be careful to	55	// CAUTION: setFailed() deletes all readers and decoders. Be careful to



            m_state = JPEG_START_DECOMPRESS;

            // We can fill in the size now that the header is available.
            if (!m_decoder->setSize(IntSize(m_info.image_width, m_info.image_height)))
                return false;

            m_decoder->setOrientation(readImageOrientation(info()));

    return ImageDecoder::isSizeAvailable();
}

bool JPEGImageDecoder::setSize(const IntSize& size)
{
    if (!ImageDecoder::setSize(size))
        return false;

    prepareScaleDataIfNecessary();

}

template <J_COLOR_SPACE colorSpace>
void setPixel(ImageFrame& buffer, RGBA32* currentAddress, JSAMPARRAY samples, int column)
{
    JSAMPLE* jsample = *samples + column * (colorSpace == JCS_RGB ? 3 : 4);


        if (destY < 0)
            continue;

        RGBA32* currentAddress = buffer.getAddr(0, destY);
        for (int x = 0; x < width; ++x) {
            setPixel<colorSpace>(buffer, currentAddress, samples, isScaled ? m_scaledColumns[x] : x);
            ++currentAddress;

    // Initialize the framebuffer if needed.
    ImageFrame& buffer = m_frameBufferCache[0];
    if (buffer.status() == ImageFrame::FrameEmpty) {
        if (!buffer.setSize(scaledSize()))
            return setFailed();
        buffer.setStatus(ImageFrame::FramePartial);
        // The buffer is transparent outside the decoded area while the image is
        // loading. The completed image will be marked fully opaque in jpegComplete().
        buffer.setHasAlpha(true);

        // For JPEGs, the frame always fills the entire image.
        buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
    }

    jpeg_decompress_struct* info = m_reader->info();

Lines 50-56 namespace WebCore { Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h_sec1
- Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h -1 / +1 lines
50	// ImageDecoder	50	// ImageDecoder
51	String filenameExtension() const override { return "jpg"; }	51	String filenameExtension() const override { return "jpg"; }
52	bool isSizeAvailable() override;	52	bool isSizeAvailable() override;
53	bool setSize(unsigned width, unsigned height) override;	53	bool setSize(const IntSize&) override;
54	ImageFrame* frameBufferAtIndex(size_t index) override;	54	ImageFrame* frameBufferAtIndex(size_t index) override;
55	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid	55	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid
56	// accessing deleted memory, especially when calling this from inside	56	// accessing deleted memory, especially when calling this from inside



    return ImageDecoder::isSizeAvailable();
}

bool PNGImageDecoder::setSize(const IntSize& size)
{
    if (!ImageDecoder::setSize(size))
        return false;

    prepareScaleDataIfNecessary();

    // will cease to exist.  Note that we'll still properly set the failure flag
    // in this case as soon as we longjmp().
    m_doNothingOnFailure = true;
    bool result = setSize(IntSize(width, height));
    m_doNothingOnFailure = false;
    if (!result) {
        longjmp(JMPBUF(png), 1);

    }
}

static inline void setPixelRGB(RGBA32* dest, png_bytep pixel)
{
    *dest = 0xFF000000U | pixel[0] << 16 | pixel[1] << 8 | pixel[2];
}

static inline void setPixelRGBA(RGBA32* dest, png_bytep pixel, unsigned char& nonTrivialAlphaMask)
{
    unsigned char a = pixel[3];
    *dest = a << 24 | pixel[0] << 16 | pixel[1] << 8 | pixel[2];
    nonTrivialAlphaMask |= (255 - a);
}

static inline void setPixelPremultipliedRGBA(RGBA32* dest, png_bytep pixel, unsigned char& nonTrivialAlphaMask)
{
    unsigned char a = pixel[3];
    unsigned char r = fastDivideBy255(pixel[0] * a);

    ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
    if (buffer.status() == ImageFrame::FrameEmpty) {
        png_structp png = m_reader->pngPtr();
        if (!buffer.setSize(scaledSize())) {
            longjmp(JMPBUF(png), 1);
            return;
        }

            initFrameBuffer(m_currentFrame);
        else
#endif
        // For PNGs, the frame always fills the entire image.
        buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
    }

    /* libpng comments (here to explain what follows).

    }

    // Write the decoded row pixels to the frame buffer.
    RGBA32* address = buffer.getAddr(0, y);
    int width = scaledSize().width();
    unsigned char nonTrivialAlphaMask = 0;


    } else {
        // We want to clear the previous frame to transparent, without
        // affecting pixels in the image outside of the frame.
        IntRect prevRect = prevBuffer->originalFrameRect();
        if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
            // Clearing the first frame, or a frame the size of the whole
            // image, results in a completely empty image.

    png_bytep interlaceBuffer = m_reader->interlaceBuffer();

    if (m_currentFrame && interlaceBuffer) {
        IntRect rect = buffer.originalFrameRect();
        bool hasAlpha = m_reader->hasAlpha();
        unsigned colorChannels = hasAlpha ? 4 : 3;
        bool nonTrivialAlpha = false;

#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
        for (int y = 0; y < rect.maxY() - rect.y(); ++y) {
            png_bytep row = interlaceBuffer + (m_scaled ? m_scaledRows[y] : y) * colorChannels * size().width();
            RGBA32* address = buffer.getAddr(rect.x(), y + rect.y());
            for (int x = 0; x < rect.maxX() - rect.x(); ++x) {
                png_bytep pixel = row + (m_scaled ? m_scaledColumns[x] : x) * colorChannels;
                unsigned alpha = hasAlpha ? pixel[3] : 255;

        png_bytep row = interlaceBuffer;
        for (int y = rect.y(); y < rect.maxY(); ++y, row += colorChannels * size().width()) {
            png_bytep pixel = row;
            RGBA32* address = buffer.getAddr(rect.x(), y);
            for (int x = rect.x(); x < rect.maxX(); ++x, pixel += colorChannels) {
                unsigned alpha = hasAlpha ? pixel[3] : 255;
                nonTrivialAlpha |= alpha < 255;

Lines 48-54 namespace WebCore { Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h_sec1
- Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h -1 / +1 lines
48	int repetitionCount() const override { return m_playCount-1; }	48	int repetitionCount() const override { return m_playCount-1; }
49	#endif	49	#endif
50	bool isSizeAvailable() override;	50	bool isSizeAvailable() override;
51	bool setSize(unsigned width, unsigned height) override;	51	bool setSize(const IntSize&) override;
52	ImageFrame* frameBufferAtIndex(size_t index) override;	52	ImageFrame* frameBufferAtIndex(size_t index) override;
53	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid	53	// CAUTION: setFailed() deletes \|m_reader\|. Be careful to avoid
54	// accessing deleted memory, especially when calling this from inside	54	// accessing deleted memory, especially when calling this from inside



            return setFailed();
        m_hasAlpha = false;
#endif
        if (!setSize(IntSize(width, height)))
            return setFailed();
    }


    ASSERT(buffer.status() != ImageFrame::FrameComplete);

    if (buffer.status() == ImageFrame::FrameEmpty) {
        if (!buffer.setSize(size()))
            return setFailed();
        buffer.setStatus(ImageFrame::FramePartial);
        buffer.setHasAlpha(m_hasAlpha);
        buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
    }

    if (!m_decoder) {
        WEBP_CSP_MODE mode = outputMode(m_hasAlpha);
        if (!m_premultiplyAlpha)
            mode = outputMode(false);
        int rowStride = size().width() * sizeof(RGBA32);
        uint8_t* output = reinterpret_cast<uint8_t*>(buffer.getAddr(0, 0));
        int outputSize = size().height() * rowStride;
        m_decoder = WebPINewRGB(mode, output, outputSize, rowStride);

Return to Bug 159679

Lines 183-192 list(APPEND WebCore_SOURCES Source/WebCore/PlatformEfl.cmake_sec1
- Source/WebCore/PlatformEfl.cmake -2 / +1 lines
183	platform/graphics/x11/PlatformDisplayX11.cpp	183	platform/graphics/x11/PlatformDisplayX11.cpp
184	platform/graphics/x11/XUniqueResource.cpp	184	platform/graphics/x11/XUniqueResource.cpp
185		185
		186	platform/image-decoders/cairo/ImageBackingStoreCairo.cpp
186	platform/image-encoders/JPEGImageEncoder.cpp	187	platform/image-encoders/JPEGImageEncoder.cpp
187		188
188	platform/image-decoders/cairo/ImageDecoderCairo.cpp
189
190	platform/network/efl/NetworkStateNotifierEfl.cpp	189	platform/network/efl/NetworkStateNotifierEfl.cpp
191		190
192	platform/network/soup/AuthenticationChallengeSoup.cpp	191	platform/network/soup/AuthenticationChallengeSoup.cpp

Lines 142-148 ImageFrame& ImageFrame::operator=(const Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec1
- Source/WebCore/platform/image-decoders/ImageDecoder.cpp -29 / +20 lines
142	return *this;	142	return *this;
143		143
144	copyBitmapData(other);	144	copyBitmapData(other);
145	setOriginalFrameRect(other.originalFrameRect());	145	setHasAlpha(other.m_hasAlpha);
146	setStatus(other.status());	146	setStatus(other.status());
147	setDuration(other.duration());	147	setDuration(other.duration());
148	setDisposalMethod(other.disposalMethod());	148	setDisposalMethod(other.disposalMethod());
Lines 152-159 ImageFrame& ImageFrame::operator=(const Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec2
152		152
153	void ImageFrame::clearPixelData()	153	void ImageFrame::clearPixelData()
154	{	154	{
155	m_backingStore.clear();	155	m_backingStore = nullptr;
156	m_bytes = 0;
157	m_status = FrameEmpty;	156	m_status = FrameEmpty;
158	// NOTE: Do not reset other members here; clearFrameBufferCache() calls this	157	// NOTE: Do not reset other members here; clearFrameBufferCache() calls this
159	// to free the bitmap data, but other functions like initFrameBuffer() and	158	// to free the bitmap data, but other functions like initFrameBuffer() and
Lines 163-186 void ImageFrame::clearPixelData() Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec3
163		162
164	void ImageFrame::zeroFillPixelData()	163	void ImageFrame::zeroFillPixelData()
165	{	164	{
166	memset(m_bytes, 0, m_size.width() * m_size.height() * sizeof(PixelData));	165	m_backingStore->clear();
167	m_hasAlpha = true;	166	m_hasAlpha = true;
168	}	167	}
169		168
170	void ImageFrame::zeroFillFrameRect(const IntRect& rect)	169	void ImageFrame::zeroFillFrameRect(const IntRect& rect)
171	{	170	{
172	ASSERT(IntRect(IntPoint(), m_size).contains(rect));
173
174	if (rect.isEmpty())	171	if (rect.isEmpty())
175	return;	172	return;
176		173
177	size_t rectWidthInBytes = rect.width() * sizeof(PixelData);	174	m_backingStore->clearRect(rect);
178	PixelData* start = m_bytes + (rect.y() * width()) + rect.x();
179	for (int i = 0; i < rect.height(); ++i) {
180	memset(start, 0, rectWidthInBytes);
181	start += width();
182	}
183
184	setHasAlpha(true);	175	setHasAlpha(true);
185	}	176	}
186		177
Lines 189-213 bool ImageFrame::copyBitmapData(const Im Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec4
189	if (this == &other)	180	if (this == &other)
190	return true;	181	return true;
191		182
192	m_backingStore = other.m_backingStore;	183	if (other.m_backingStore)
193	m_bytes = m_backingStore.data();	184	m_backingStore = ImageBackingStore::create(*other.m_backingStore.get());
194	m_size = other.m_size;	185	else
195	setHasAlpha(other.m_hasAlpha);	186	m_backingStore = nullptr;
		187
196	return true;	188	return true;
197	}	189	}
198		190
199	bool ImageFrame::setSize(int newWidth, int newHeight)	191	bool ImageFrame::setSize(const IntSize& size)
200	{	192	{
201	ASSERT(!width() && !height());	193	ASSERT(!m_backingStore);
202	size_t backingStoreSize = newWidth * newHeight;	194	m_backingStore = ImageBackingStore::create(size, m_premultiplyAlpha);
203	if (!m_backingStore.tryReserveCapacity(backingStoreSize))	195	return m_backingStore != nullptr;
204	return false;
205	m_backingStore.resize(backingStoreSize);
206	m_bytes = m_backingStore.data();
207	m_size = IntSize(newWidth, newHeight);
208
209	zeroFillPixelData();
210	return true;
211	}	196	}
212		197
213	bool ImageFrame::hasAlpha() const	198	bool ImageFrame::hasAlpha() const
Lines 220-225 void ImageFrame::setHasAlpha(bool alpha) Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec5
220	m_hasAlpha = alpha;	205	m_hasAlpha = alpha;
221	}	206	}
222		207
		208	void ImageFrame::setOriginalFrameRect(const IntRect& frameRect)
		209	{
		210	if (m_backingStore)
		211	m_backingStore->setFrameRect(frameRect);
		212	}
		213
223	void ImageFrame::setStatus(FrameStatus status)	214	void ImageFrame::setStatus(FrameStatus status)
224	{	215	{
225	m_status = status;	216	m_status = status;
Lines 286-292 unsigned ImageDecoder::frameBytesAtIndex Source/WebCore/platform/image-decoders/ImageDecoder.cpp_sec6
286	if (m_frameBufferCache.size() <= index)	277	if (m_frameBufferCache.size() <= index)
287	return 0;	278	return 0;
288	// FIXME: Use the dimension of the requested frame.	279	// FIXME: Use the dimension of the requested frame.
289	return m_size.area() * sizeof(ImageFrame::PixelData);	280	return m_size.area() * sizeof(RGBA32);
290	}	281	}
291		282
292	float ImageDecoder::frameDurationAtIndex(size_t index)	283	float ImageDecoder::frameDurationAtIndex(size_t index)

Lines 447-453 bool GIFImageReader::parse(size_t dataPo Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp_sec1
- Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp -2 / +2 lines
447		447
448	// CALLBACK: Inform the decoderplugin of our size.	448	// CALLBACK: Inform the decoderplugin of our size.
449	// Note: A subsequent frame might have dimensions larger than the "screen" dimensions.	449	// Note: A subsequent frame might have dimensions larger than the "screen" dimensions.
450	if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))	450	if (m_client && !m_client->setSize(WebCore::IntSize(m_screenWidth, m_screenHeight)))
451	return false;	451	return false;
452		452
453	m_screenBgcolor = currentComponent[5];	453	m_screenBgcolor = currentComponent[5];
Lines 664-670 bool GIFImageReader::parse(size_t dataPo Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp_sec2
664	yOffset = 0;	664	yOffset = 0;
665		665
666	// CALLBACK: Inform the decoderplugin of our size.	666	// CALLBACK: Inform the decoderplugin of our size.
667	if (m_client && !m_client->setSize(m_screenWidth, m_screenHeight))	667	if (m_client && !m_client->setSize(WebCore::IntSize(m_screenWidth, m_screenHeight)))
668	return false;	668	return false;
669	}	669	}
670		670

Lines 322-328 public: Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp_sec1
- Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp -9 / +6 lines
322	m_state = JPEG_START_DECOMPRESS;	322	m_state = JPEG_START_DECOMPRESS;
323		323
324	// We can fill in the size now that the header is available.	324	// We can fill in the size now that the header is available.
325	if (!m_decoder->setSize(m_info.image_width, m_info.image_height))	325	if (!m_decoder->setSize(IntSize(m_info.image_width, m_info.image_height)))
326	return false;	326	return false;
327		327
328	m_decoder->setOrientation(readImageOrientation(info()));	328	m_decoder->setOrientation(readImageOrientation(info()));
Lines 519-527 bool JPEGImageDecoder::isSizeAvailable() Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp_sec2
519	return ImageDecoder::isSizeAvailable();	519	return ImageDecoder::isSizeAvailable();
520	}	520	}
521		521
522	bool JPEGImageDecoder::setSize(unsigned width, unsigned height)	522	bool JPEGImageDecoder::setSize(const IntSize& size)
523	{	523	{
524	if (!ImageDecoder::setSize(width, height))	524	if (!ImageDecoder::setSize(size))
525	return false;	525	return false;
526		526
527	prepareScaleDataIfNecessary();	527	prepareScaleDataIfNecessary();
Lines 551-557 bool JPEGImageDecoder::setFailed() Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp_sec3
551	}	551	}
552		552
553	template <J_COLOR_SPACE colorSpace>	553	template <J_COLOR_SPACE colorSpace>
554	void setPixel(ImageFrame& buffer, ImageFrame::PixelData* currentAddress, JSAMPARRAY samples, int column)	554	void setPixel(ImageFrame& buffer, RGBA32* currentAddress, JSAMPARRAY samples, int column)
555	{	555	{
556	JSAMPLE* jsample = samples + column (colorSpace == JCS_RGB ? 3 : 4);	556	JSAMPLE* jsample = samples + column (colorSpace == JCS_RGB ? 3 : 4);
557		557
Lines 594-600 bool JPEGImageDecoder::outputScanlines(I Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp_sec4
594	if (destY < 0)	594	if (destY < 0)
595	continue;	595	continue;
596		596
597	ImageFrame::PixelData* currentAddress = buffer.getAddr(0, destY);	597	RGBA32* currentAddress = buffer.getAddr(0, destY);
598	for (int x = 0; x < width; ++x) {	598	for (int x = 0; x < width; ++x) {
599	setPixel<colorSpace>(buffer, currentAddress, samples, isScaled ? m_scaledColumns[x] : x);	599	setPixel<colorSpace>(buffer, currentAddress, samples, isScaled ? m_scaledColumns[x] : x);
600	++currentAddress;	600	++currentAddress;
Lines 617-631 bool JPEGImageDecoder::outputScanlines() Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp_sec5
617	// Initialize the framebuffer if needed.	617	// Initialize the framebuffer if needed.
618	ImageFrame& buffer = m_frameBufferCache[0];	618	ImageFrame& buffer = m_frameBufferCache[0];
619	if (buffer.status() == ImageFrame::FrameEmpty) {	619	if (buffer.status() == ImageFrame::FrameEmpty) {
620	if (!buffer.setSize(scaledSize().width(), scaledSize().height()))	620	if (!buffer.setSize(scaledSize()))
621	return setFailed();	621	return setFailed();
622	buffer.setStatus(ImageFrame::FramePartial);	622	buffer.setStatus(ImageFrame::FramePartial);
623	// The buffer is transparent outside the decoded area while the image is	623	// The buffer is transparent outside the decoded area while the image is
624	// loading. The completed image will be marked fully opaque in jpegComplete().	624	// loading. The completed image will be marked fully opaque in jpegComplete().
625	buffer.setHasAlpha(true);	625	buffer.setHasAlpha(true);
626
627	// For JPEGs, the frame always fills the entire image.
628	buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
629	}	626	}
630		627
631	jpeg_decompress_struct* info = m_reader->info();	628	jpeg_decompress_struct* info = m_reader->info();

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +102 lines
		1	2016-09-09 Said Abou-Hallawa <sabouhallawa@apple.com>
		2
		3	Move the pixel data of ImageFrame to a separate class named ImageBackingStore
		4	https://bugs.webkit.org/show_bug.cgi?id=159679
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Move the pixel data manipulation part in ImageFrame into a separate class
		9	and allocate it on demand.
		10
		11	* PlatformEfl.cmake:
		12	* PlatformGTK.cmake:
		13	* PlatformWinCairo.cmake:
		14	* WebCore.xcodeproj/project.pbxproj:
		15	* platform/graphics/Color.cpp:
		16	(WebCore::premultipliedChannel):
		17	(WebCore::unpremultipliedChannel):
		18	(WebCore::makePremultipliedRGBA):
		19	(WebCore::makeUnPremultipliedRGBA):
		20	(WebCore::colorFromPremultipliedARGB):
		21	(WebCore::premultipliedARGBFromColor):
		22	* platform/graphics/Color.h:
		23	(WebCore::fastMultiplyBy255):
		24	* platform/graphics/ImageBackingStore.h: Added.
		25	(WebCore::ImageBackingStore::create):
		26	(WebCore::ImageBackingStore::ImageBackingStore):
		27	(WebCore::ImageBackingStore::setSize):
		28	(WebCore::ImageBackingStore::setFrameRect):
		29	(WebCore::ImageBackingStore::size):
		30	(WebCore::ImageBackingStore::frameRect):
		31	(WebCore::ImageBackingStore::clear):
		32	(WebCore::ImageBackingStore::clearRect):
		33	(WebCore::ImageBackingStore::repeatFirstRow):
		34	(WebCore::ImageBackingStore::at):
		35	(WebCore::ImageBackingStore::setRGBA):
		36	(WebCore::ImageBackingStore::overRGBA):
		37	(WebCore::ImageBackingStore::inBounds):
		38	(WebCore::ImageBackingStore::isOverSize):
		39	* platform/graphics/cg/NativeImageCG.cpp:
		40	(WebCore::nativeImageHasAlpha):
		41	* platform/image-decoders/ImageDecoder.cpp:
		42	(WebCore::ImageFrame::operator=):
		43	(WebCore::ImageFrame::clearPixelData):
		44	(WebCore::ImageFrame::zeroFillPixelData):
		45	(WebCore::ImageFrame::zeroFillFrameRect):
		46	(WebCore::ImageFrame::copyBitmapData):
		47	(WebCore::ImageFrame::setSize):
		48	(WebCore::ImageFrame::setOriginalFrameRect):
		49	(WebCore::ImageDecoder::frameBytesAtIndex):
		50	* platform/image-decoders/ImageDecoder.h:
		51	(WebCore::ImageFrame::copyRowNTimes):
		52	(WebCore::ImageFrame::size):
		53	(WebCore::ImageFrame::asNewNativeImage):
		54	(WebCore::ImageFrame::backingStore):
		55	(WebCore::ImageFrame::hasBackingStore):
		56	(WebCore::ImageFrame::originalFrameRect):
		57	(WebCore::ImageFrame::getAddr):
		58	(WebCore::ImageFrame::setRGBA):
		59	(WebCore::ImageFrame::overRGBA):
		60	(WebCore::ImageDecoder::setSize):
		61	(WebCore::ImageFrame::setOriginalFrameRect): Deleted.
		62	(WebCore::ImageFrame::hasPixelData): Deleted.
		63	(WebCore::ImageFrame::fixPointUnsignedMultiply): Deleted.
		64	(WebCore::ImageFrame::divide255): Deleted.
65	(WebCore::ImageFrame::width): Deleted.
66	(WebCore::ImageFrame::height): Deleted.
67	(WebCore::ImageDecoder::isOverSize): Deleted.
68	* platform/image-decoders/bmp/BMPImageReader.cpp:
69	(WebCore::BMPImageReader::decodeBMP):
70	(WebCore::BMPImageReader::processInfoHeader):
71	* platform/image-decoders/cairo/ImageBackingStoreCairo.cpp: Added.
72	(WebCore::ImageBackingStore::image):
73	* platform/image-decoders/gif/GIFImageDecoder.cpp:
74	(WebCore::GIFImageDecoder::setSize):
75	(WebCore::GIFImageDecoder::haveDecodedRow):
76	(WebCore::GIFImageDecoder::initFrameBuffer):
77	* platform/image-decoders/gif/GIFImageDecoder.h:
78	* platform/image-decoders/gif/GIFImageReader.cpp:
79	(GIFImageReader::parse):
80	* platform/image-decoders/ico/ICOImageDecoder.cpp:
81	(WebCore::ICOImageDecoder::setSize):
82	(WebCore::ICOImageDecoder::processDirectoryEntries): Deleted.
83	* platform/image-decoders/ico/ICOImageDecoder.h:
84	* platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
85	(WebCore::JPEGImageReader::decode):
86	(WebCore::JPEGImageDecoder::setSize):
87	(WebCore::setPixel):
88	(WebCore::JPEGImageDecoder::outputScanlines):
89	* platform/image-decoders/jpeg/JPEGImageDecoder.h:
90	* platform/image-decoders/png/PNGImageDecoder.cpp:
91	(WebCore::PNGImageDecoder::setSize):
92	(WebCore::PNGImageDecoder::headerAvailable):
93	(WebCore::setPixelRGB):
94	(WebCore::setPixelRGBA):
95	(WebCore::setPixelPremultipliedRGBA):
96	(WebCore::PNGImageDecoder::rowAvailable):
97	(WebCore::PNGImageDecoder::initFrameBuffer):
98	(WebCore::PNGImageDecoder::frameComplete):
99	* platform/image-decoders/png/PNGImageDecoder.h:
100	* platform/image-decoders/webp/WEBPImageDecoder.cpp:
101	(WebCore::WEBPImageDecoder::decode):
102
1	2016-09-09 Commit Queue <commit-queue@webkit.org>	103	2016-09-09 Commit Queue <commit-queue@webkit.org>
2		104
3	Unreviewed, rolling out r205771.	105	Unreviewed, rolling out r205771.

Lines 2275-2280 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- Source/WebCore/WebCore.xcodeproj/project.pbxproj +4 lines
2275	555B87EC1CAAF0AB00349425 /* ImageDecoderCG.cpp in Sources / = {isa = PBXBuildFile; fileRef = 555B87EA1CAAF0AB00349425 / ImageDecoderCG.cpp */; };	2275	555B87EC1CAAF0AB00349425 /* ImageDecoderCG.cpp in Sources / = {isa = PBXBuildFile; fileRef = 555B87EA1CAAF0AB00349425 / ImageDecoderCG.cpp */; };
2276	555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers / = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 / ImageDecoderCG.h */; };	2276	555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers / = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 / ImageDecoderCG.h */; };
2277	55A336F71D8209F40022C4C7 /* NativeImage.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 / NativeImage.h */; };	2277	55A336F71D8209F40022C4C7 /* NativeImage.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F61D8209F40022C4C7 / NativeImage.h */; };
		2278	55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers / = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 / ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
2278	5709E8CD1D413D47003244AC /* WebKitSubtleCrypto.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5709E8CA1D413CE3003244AC / WebKitSubtleCrypto.cpp */; };	2279	5709E8CD1D413D47003244AC /* WebKitSubtleCrypto.cpp in Sources / = {isa = PBXBuildFile; fileRef = 5709E8CA1D413CE3003244AC / WebKitSubtleCrypto.cpp */; };
2279	5709E8CE1D413D5B003244AC /* JSWebKitSubtleCryptoCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = E1FF8F661807460800132674 / JSWebKitSubtleCryptoCustom.cpp */; };	2280	5709E8CE1D413D5B003244AC /* JSWebKitSubtleCryptoCustom.cpp in Sources / = {isa = PBXBuildFile; fileRef = E1FF8F661807460800132674 / JSWebKitSubtleCryptoCustom.cpp */; };
2280	5709E8CF1D413D9A003244AC /* WebKitSubtleCrypto.h in Headers / = {isa = PBXBuildFile; fileRef = 5709E8CB1D413CE3003244AC / WebKitSubtleCrypto.h */; };	2281	5709E8CF1D413D9A003244AC /* WebKitSubtleCrypto.h in Headers / = {isa = PBXBuildFile; fileRef = 5709E8CB1D413CE3003244AC / WebKitSubtleCrypto.h */; };
Lines 9291-9296 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
9291	555B87EA1CAAF0AB00349425 /* ImageDecoderCG.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoderCG.cpp; sourceTree = "<group>"; };	9292	555B87EA1CAAF0AB00349425 /* ImageDecoderCG.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoderCG.cpp; sourceTree = "<group>"; };
9292	555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoderCG.h; sourceTree = "<group>"; };	9293	555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoderCG.h; sourceTree = "<group>"; };
9293	55A336F61D8209F40022C4C7 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };	9294	55A336F61D8209F40022C4C7 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
		9295	55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBackingStore.h; sourceTree = "<group>"; };
9294	55D408F71A7C631800C78450 /* SVGImageClients.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGImageClients.h; sourceTree = "<group>"; };	9296	55D408F71A7C631800C78450 /* SVGImageClients.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVGImageClients.h; sourceTree = "<group>"; };
9295	5709E8CA1D413CE3003244AC /* WebKitSubtleCrypto.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebKitSubtleCrypto.cpp; sourceTree = "<group>"; };	9297	5709E8CA1D413CE3003244AC /* WebKitSubtleCrypto.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebKitSubtleCrypto.cpp; sourceTree = "<group>"; };
9296	5709E8CB1D413CE3003244AC /* WebKitSubtleCrypto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebKitSubtleCrypto.h; sourceTree = "<group>"; };	9298	5709E8CB1D413CE3003244AC /* WebKitSubtleCrypto.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebKitSubtleCrypto.h; sourceTree = "<group>"; };
Lines 20769-20774 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
20769	379919941200DDF400EA041C /* WOFFFileFormat.cpp */,	20771	379919941200DDF400EA041C /* WOFFFileFormat.cpp */,
20770	379919951200DDF400EA041C /* WOFFFileFormat.h */,	20772	379919951200DDF400EA041C /* WOFFFileFormat.h */,
20771	55A336F61D8209F40022C4C7 /* NativeImage.h */,	20773	55A336F61D8209F40022C4C7 /* NativeImage.h */,
		20774	55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */,
20772	);	20775	);
20773	path = graphics;	20776	path = graphics;
20774	sourceTree = "<group>";	20777	sourceTree = "<group>";
Lines 26339-26344 Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
26339	582CB0531A78A14B00AFFCC4 /* SimpleLineLayoutTextFragmentIterator.h in Headers */,	26342	582CB0531A78A14B00AFFCC4 /* SimpleLineLayoutTextFragmentIterator.h in Headers */,
26340	C5A1EA7D152BCF08004D00B6 /* SimplifyMarkupCommand.h in Headers */,	26343	C5A1EA7D152BCF08004D00B6 /* SimplifyMarkupCommand.h in Headers */,
26341	572A7F211C6E5719009C6149 /* SimulatedClick.h in Headers */,	26344	572A7F211C6E5719009C6149 /* SimulatedClick.h in Headers */,
		26345	55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */,
26342	31741AAD16636609008A5B7E /* SimulatedClickOptions.h in Headers */,	26346	31741AAD16636609008A5B7E /* SimulatedClickOptions.h in Headers */,
26343	FD00D7A514A3F61900734011 /* SincResampler.h in Headers */,	26347	FD00D7A514A3F61900734011 /* SincResampler.h in Headers */,
26344	51327D6011A33A2B004F9D65 /* SinkDocument.h in Headers */,	26348	51327D6011A33A2B004F9D65 /* SinkDocument.h in Headers */,

Lines 49-54 const RGBA32 Color::transparent; Source/WebCore/platform/graphics/Color.cpp_sec1
- Source/WebCore/platform/graphics/Color.cpp -16 / +27 lines
49	static const RGBA32 lightenedBlack = 0xFF545454;	49	static const RGBA32 lightenedBlack = 0xFF545454;
50	static const RGBA32 darkenedWhite = 0xFFABABAB;	50	static const RGBA32 darkenedWhite = 0xFFABABAB;
51		51
		52	static inline unsigned premultipliedChannel(unsigned c, unsigned a)
		53	{
		54	return fastDivideBy255(c * a + 254);
		55	}
		56
		57	static inline unsigned unpremultipliedChannel(unsigned c, unsigned a)
		58	{
		59	return (fastMultiplyBy255(c) + a - 1) / a;
		60	}
		61
52	RGBA32 makeRGB(int r, int g, int b)	62	RGBA32 makeRGB(int r, int g, int b)
53	{	63	{
54	return 0xFF000000 \| std::max(0, std::min(r, 255)) << 16 \| std::max(0, std::min(g, 255)) << 8 \| std::max(0, std::min(b, 255));	64	return 0xFF000000 \| std::max(0, std::min(r, 255)) << 16 \| std::max(0, std::min(g, 255)) << 8 \| std::max(0, std::min(b, 255));
Lines 59-64 RGBA32 makeRGBA(int r, int g, int b, int Source/WebCore/platform/graphics/Color.cpp_sec2
59	return std::max(0, std::min(a, 255)) << 24 \| std::max(0, std::min(r, 255)) << 16 \| std::max(0, std::min(g, 255)) << 8 \| std::max(0, std::min(b, 255));	69	return std::max(0, std::min(a, 255)) << 24 \| std::max(0, std::min(r, 255)) << 16 \| std::max(0, std::min(g, 255)) << 8 \| std::max(0, std::min(b, 255));
60	}	70	}
61		71
		72	RGBA32 makePremultipliedRGBA(int r, int g, int b, int a)
		73	{
		74	return makeRGBA(premultipliedChannel(r, a), premultipliedChannel(g, a), premultipliedChannel(b, a), a);
		75	}
		76
		77	RGBA32 makeUnPremultipliedRGBA(int r, int g, int b, int a)
		78	{
		79	return makeRGBA(unpremultipliedChannel(r, a), unpremultipliedChannel(g, a), unpremultipliedChannel(b, a), a);
		80	}
		81
62	static int colorFloatToRGBAByte(float f)	82	static int colorFloatToRGBAByte(float f)
63	{	83	{
64	// We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding	84	// We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding
Lines 482-495 void Color::getHSV(double& hue, double& Source/WebCore/platform/graphics/Color.cpp_sec3
482	Color colorFromPremultipliedARGB(RGBA32 pixelColor)	502	Color colorFromPremultipliedARGB(RGBA32 pixelColor)
483	{	503	{
484	int alpha = alphaChannel(pixelColor);	504	int alpha = alphaChannel(pixelColor);
485	if (alpha && alpha < 255) {	505	if (alpha && alpha < 255)
486	return Color::createUnchecked(	506	pixelColor = makeUnPremultipliedRGBA(redChannel(pixelColor), greenChannel(pixelColor), blueChannel(pixelColor), alpha);
487	redChannel(pixelColor) * 255 / alpha,	507	return Color(pixelColor);
488	greenChannel(pixelColor) * 255 / alpha,
489	blueChannel(pixelColor) * 255 / alpha,
490	alpha);
491	} else
492	return Color(pixelColor);
493	}	508	}
494		509
495	RGBA32 premultipliedARGBFromColor(const Color& color)	510	RGBA32 premultipliedARGBFromColor(const Color& color)
Lines 497-510 RGBA32 premultipliedARGBFromColor(const Source/WebCore/platform/graphics/Color.cpp_sec4
497	unsigned pixelColor;	512	unsigned pixelColor;
498		513
499	unsigned alpha = color.alpha();	514	unsigned alpha = color.alpha();
500	if (alpha < 255) {	515	if (alpha < 255)
501	pixelColor = Color::createUnchecked(	516	pixelColor = makePremultipliedRGBA(color.red(), color.green(), color.blue(), alpha);
502	fastDivideBy255(color.red() * alpha + 254),	517	else
503	fastDivideBy255(color.green() * alpha + 254),	518	pixelColor = color.rgb();
504	fastDivideBy255(color.blue() * alpha + 254),
505	alpha).rgb();
506	} else
507	pixelColor = color.rgb();
508		519
509	return pixelColor;	520	return pixelColor;
510	}	521	}

Line 0 Source/WebCore/platform/graphics/ImageBackingStore.h_sec1
- Source/WebCore/platform/graphics/ImageBackingStore.h +190 lines
		1	/*
		2	* Copyright (C) 2016 Apple Inc. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
		14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
		15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
		17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
		21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#pragma once
		27
		28	#include "Color.h"
		29	#include "IntRect.h"
		30	#include "IntSize.h"
		31	#include "NativeImage.h"
		32
		33	#include <wtf/Vector.h>
		34
		35	namespace WebCore {
		36
		37	class ImageBackingStore {
		38	public:
		39	static std::unique_ptr<ImageBackingStore> create(const IntSize& size, bool premultiplyAlpha)
		40	{
		41	return std::make_unique<ImageBackingStore>(size, premultiplyAlpha);
		42	}
		43
		44	static std::unique_ptr<ImageBackingStore> create(const ImageBackingStore& other)
		45	{
		46	return std::make_unique<ImageBackingStore>(other);
		47	}
		48
		49	ImageBackingStore(const IntSize& size, bool premultiplyAlpha = true)
		50	: m_premultiplyAlpha(premultiplyAlpha)
		51	{
		52	ASSERT(!size.isEmpty());
		53	setSize(size);
		54	}
		55
		56	ImageBackingStore(const ImageBackingStore& other)
		57	{
		58	if (this == &other)
		59	return;
		60
		61	m_pixels = other.m_pixels;
		62	m_pixelsPtr = m_pixels.data();
		63	m_size = other.m_size;
		64	m_premultiplyAlpha = other.m_premultiplyAlpha;
65	}
66
67	NativeImagePtr image() const;
68
69	bool setSize(const IntSize& size)
70	{
71	if (!m_pixels.tryReserveCapacity(size.area()))
72	return false;
73
74	m_pixels.resize(size.area());
75	m_pixelsPtr = m_pixels.data();
76	m_size = size;
77	m_frameRect = IntRect(IntPoint(), m_size);
78	clear();
79	return true;
80	}
81
82	void setFrameRect(const IntRect& frameRect)
83	{
84	ASSERT(!m_size.isEmpty());
85	ASSERT(inBounds(frameRect));
86	m_frameRect = frameRect;
87	}
88
89	IntSize size() const { return m_size; }
90	IntRect frameRect() const { return m_frameRect; }
91
92	void clear()
93	{
94	memset(m_pixelsPtr, 0, m_size.area() * sizeof(RGBA32));
95	}
96
97	void clearRect(const IntRect& rect)
98	{
99	if (rect.isEmpty() \|\| !inBounds(rect))
100	return;
101
102	size_t rectWidthInBytes = rect.width() * sizeof(RGBA32);
103	RGBA32* start = at(rect.x(), rect.y());
104	for (int i = 0; i < rect.height(); ++i) {
105	memset(start, 0, rectWidthInBytes);
106	start += m_size.width();
107	}
108	}
109
110	void repeatFirstRow(const IntRect& rect)
111	{
112	if (rect.isEmpty() \|\| !inBounds(rect))
113	return;
114
115	size_t rectWidthInBytes = rect.width() * sizeof(RGBA32);
116	RGBA32* src = at(rect.x(), rect.y());
117	RGBA32* dest = src + m_size.width();
118	for (int i = 1; i < rect.height(); ++i) {
119	memcpy(dest, src, rectWidthInBytes);
120	dest += m_size.width();
121	}
122	}
123
124	RGBA32* at(int x, int y) const
125	{
126	return m_pixelsPtr + y * m_size.width() + x;
127	}
128
129	void setRGBA(int x, int y, unsigned r, unsigned g, unsigned b, unsigned a)
130	{
131	setRGBA(at(x, y), r, g, b, a);
132	}
133
134	void setRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
135	{
136	if (m_premultiplyAlpha && !a)
137	*dest = 0;
138	else if (m_premultiplyAlpha && a < 255)
139	*dest = makePremultipliedRGBA(r, g, b, a);
140	else
141	*dest = makeRGBA(r, g, b, a);
142	}
143
144	void overRGBA(RGBA32* dest, unsigned r, unsigned g, unsigned b, unsigned a)
145	{
146	if (!a)
147	return;
148
149	if (a >= 255 \|\| !alphaChannel(*dest)) {
150	setRGBA(dest, r, g, b, a);
151	return;
152	}
153
154	if (!m_premultiplyAlpha)
155	dest = makePremultipliedRGBA(redChannel(dest), greenChannel(dest), blueChannel(dest), alphaChannel(*dest));
156
157	unsigned d = 255 - a;
158
159	r = fastDivideBy255(r * a + redChannel(dest) d);
160	g = fastDivideBy255(g * a + greenChannel(dest) d);
161	b = fastDivideBy255(b * a + blueChannel(dest) d);
162	a += fastDivideBy255(d * alphaChannel(*dest));
163
164	if (m_premultiplyAlpha)
165	*dest = makeRGBA(r, g, b, a);
166	else
167	*dest = makeUnPremultipliedRGBA(r, g, b, a);
168	}
169
170	bool inBounds(const IntRect& rect) const
171	{
172	return IntRect(IntPoint(), m_size).contains(rect);
173	}
174
175	static bool isOverSize(const IntSize& size)
176	{
177	static unsigned long long MaxPixels = ((1 << 29) - 1);
178	unsigned long long pixels = static_cast<unsigned long long>(size.width()) * static_cast<unsigned long long>(size.height());
179	return pixels > MaxPixels;
180	}
181
182	private:
183	Vector<RGBA32> m_pixels;
184	RGBA32* m_pixelsPtr { nullptr };
185	IntSize m_size;
186	IntRect m_frameRect; // This will always just be the entire buffer except for GIF and PNG frames
187	bool m_premultiplyAlpha { true };
188	};
189
190	}

Lines 47-56 IntSize nativeImageSize(const NativeImag Source/WebCore/platform/graphics/cg/NativeImageCG.cpp_sec1
- Source/WebCore/platform/graphics/cg/NativeImageCG.cpp -3 / +3 lines
47	return image ? IntSize(CGImageGetWidth(image.get()), CGImageGetHeight(image.get())) : IntSize();	47	return image ? IntSize(CGImageGetWidth(image.get()), CGImageGetHeight(image.get())) : IntSize();
48	}	48	}
49		49
50	bool nativeImageHasAlpha(const NativeImagePtr&)	50	bool nativeImageHasAlpha(const NativeImagePtr& image)
51	{	51	{
52	// FIXME: Answer correctly the question: does the CGImageRef have alpha channnel?	52	CGImageAlphaInfo info = CGImageGetAlphaInfo(image.get());
53	return true;	53	return (info >= kCGImageAlphaPremultipliedLast) && (info <= kCGImageAlphaFirst);
54	}	54	}
55		55
56	Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)	56	Color nativeImageSinglePixelSolidColor(const NativeImagePtr& image)

Lines 88-98 IntSize ICOImageDecoder::frameSizeAtInde Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp_sec1
- Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp -3 / +3 lines
88	return (index && (index < m_dirEntries.size())) ? m_dirEntries[index].m_size : size();	88	return (index && (index < m_dirEntries.size())) ? m_dirEntries[index].m_size : size();
89	}	89	}
90		90
91	bool ICOImageDecoder::setSize(unsigned width, unsigned height)	91	bool ICOImageDecoder::setSize(const IntSize& size)
92	{	92	{
93	// The size calculated inside the BMPImageReader had better match the one in	93	// The size calculated inside the BMPImageReader had better match the one in
94	// the icon directory.	94	// the icon directory.
95	return m_frameSize.isEmpty() ? ImageDecoder::setSize(width, height) : ((IntSize(width, height) == m_frameSize) \|\| setFailed());	95	return m_frameSize.isEmpty() ? ImageDecoder::setSize(size) : (size == m_frameSize) \|\| setFailed());
96	}	96	}
97		97
98	size_t ICOImageDecoder::frameCount()	98	size_t ICOImageDecoder::frameCount()
Lines 279-285 bool ICOImageDecoder::processDirectoryEn Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp_sec2
279	const IconDirectoryEntry& dirEntry = m_dirEntries.first();	279	const IconDirectoryEntry& dirEntry = m_dirEntries.first();
280	// Technically, this next call shouldn't be able to fail, since the width	280	// Technically, this next call shouldn't be able to fail, since the width
281	// and height here are each <= 256, and \|m_frameSize\| is empty.	281	// and height here are each <= 256, and \|m_frameSize\| is empty.
282	return setSize(dirEntry.m_size.width(), dirEntry.m_size.height());	282	return setSize(dirEntry.m_size);
283	}	283	}
284		284
285	ICOImageDecoder::IconDirectoryEntry ICOImageDecoder::readDirectoryEntry()	285	ICOImageDecoder::IconDirectoryEntry ICOImageDecoder::readDirectoryEntry()