packages/webkit: Apply the qtwebkit-use-image-decoders.patch to WebKit/Qt, WebKit/Qtopia

    -Use the built-in webcore decoders because of better RAM performance
    -Move the PR into the .inc

1 files changed, 280 insertions, 0 deletions

diff --git a/packages/webkit/files/qtwebkit-use-image-decoders.patch b/packages/webkit/files/qtwebkit-use-image-decoders.patch
new file mode 100644
index 0000000000..85d3f84a0d
--- /dev/null
+++ b/packages/webkit/files/qtwebkit-use-image-decoders.patch
@@ -0,0 +1,280 @@
+diff --git a/WebCore/WebCore.pro b/WebCore/WebCore.pro
+index bb34e44..23a1cd0 100644
+--- a/WebCore/WebCore.pro
++++ b/WebCore/WebCore.pro
+@@ -6,6 +6,7 @@ CONFIG += building-libs
+ CONFIG += no_batch
+ include($$PWD/../WebKit.pri)
+ gtk-port:LIBS -= -lWebKitGtk
++qt-port:LIBS += -lpng -ljpeg
+ 
+ TEMPLATE = lib
+ qt-port:TARGET = QtWebKit
+@@ -74,6 +75,12 @@ qt-port {
+ INCLUDEPATH += \
+                 $$PWD/platform/qt \
+                 $$PWD/platform/network/qt \
++                $$PWD/platform/image-decoders/bmp \
++                $$PWD/platform/image-decoders/gif \
++                $$PWD/platform/image-decoders/ico \
++                $$PWD/platform/image-decoders/jpeg \
++                $$PWD/platform/image-decoders/png \
++                $$PWD/platform/image-decoders/xbm \
+                 $$PWD/platform/graphics/qt \
+                 $$PWD/platform/graphics/svg/qt \
+                 $$PWD/loader/qt \
+@@ -777,6 +784,13 @@ qt-port {
+     page/qt/EventHandlerQt.cpp \
+     page/qt/FrameQt.cpp \
+     loader/qt/DocumentLoaderQt.cpp \
++    platform/image-decoders/gif/GIFImageDecoder.cpp \
++    platform/image-decoders/gif/GIFImageReader.cpp  \
++    platform/image-decoders/png/PNGImageDecoder.cpp \
++    platform/image-decoders/jpeg/JPEGImageDecoder.cpp \
++    platform/image-decoders/bmp/BMPImageDecoder.cpp \
++    platform/image-decoders/ico/ICOImageDecoder.cpp \
++    platform/image-decoders/xbm/XBMImageDecoder.cpp \
+     platform/graphics/qt/AffineTransformQt.cpp \
+     platform/graphics/qt/ColorQt.cpp \
+     platform/graphics/qt/FloatPointQt.cpp \
+diff --git a/WebCore/platform/graphics/ImageSource.h b/WebCore/platform/graphics/ImageSource.h
+index a75f1d6..2af8c1e 100644
+--- a/WebCore/platform/graphics/ImageSource.h
++++ b/WebCore/platform/graphics/ImageSource.h
+@@ -49,8 +49,8 @@ class SharedBuffer;
+ typedef CGImageSourceRef NativeImageSourcePtr;
+ typedef CGImageRef NativeImagePtr;
+ #elif PLATFORM(QT)
+-class ImageDecoderQt;
+-typedef ImageDecoderQt* NativeImageSourcePtr;
++class ImageDecoder;
++typedef ImageDecoder* NativeImageSourcePtr;
+ typedef QPixmap* NativeImagePtr;
+ #else
+ class ImageDecoder;
+diff --git a/WebCore/platform/graphics/qt/ImageSourceQt.cpp b/WebCore/platform/graphics/qt/ImageSourceQt.cpp
+index 264f90f..d1fd340 100644
+--- a/WebCore/platform/graphics/qt/ImageSourceQt.cpp
++++ b/WebCore/platform/graphics/qt/ImageSourceQt.cpp
+@@ -1,6 +1,7 @@
+ /*
+  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved. 
+  * Copyright (C) 2006 Trolltech ASA
++ * Copyright (C) 2007 Alp Toker <alp.toker@collabora.co.uk>
+  *
+  * All rights reserved.
+  *
+@@ -28,76 +29,78 @@
+ 
+ #include "config.h"
+ #include "ImageSource.h"
+-#include "ImageDecoderQt.h"
+ #include "SharedBuffer.h"
+ 
+-#include <QImage>
+-#include <qdebug.h>
++#include "GIFImageDecoder.h"
++#include "JPEGImageDecoder.h"
++#include "PNGImageDecoder.h"
++#include "BMPImageDecoder.h"
++#include "ICOImageDecoder.h"
++#include "XBMImageDecoder.h"
+ 
++#include <QImage>
++#include <QPixmap>
+ 
+ namespace WebCore {
+-    enum ImageFormat { ImageFormat_None, ImageFormat_GIF, ImageFormat_PNG, ImageFormat_JPEG,
+-                       ImageFormat_BMP,  ImageFormat_ICO,  ImageFormat_XBM };
+ 
+-ImageFormat detectImageFormat(const SharedBuffer& data)
++ImageDecoder* createDecoder(const Vector<char>& data)
+ {
+     // We need at least 4 bytes to figure out what kind of image we're dealing with.
+     int length = data.size();
+     if (length < 4)
+-        return ImageFormat_None;
++        return 0;
+ 
+-    const unsigned char* uContents = (const unsigned char*) data.data();
++    const unsigned char* uContents = (const unsigned char*)data.data();
+     const char* contents = data.data();
+ 
+     // GIFs begin with GIF8(7 or 9).
+     if (strncmp(contents, "GIF8", 4) == 0)
+-        return ImageFormat_GIF;
++        return new GIFImageDecoder();
+ 
+     // Test for PNG.
+-    if (uContents[0] == 0x89 &&
+-        uContents[1] == 0x50 &&
+-        uContents[2] == 0x4E &&
+-        uContents[3] == 0x47)
+-        return ImageFormat_PNG;
++    if (uContents[0]==0x89 &&
++        uContents[1]==0x50 &&
++        uContents[2]==0x4E &&
++        uContents[3]==0x47)
++        return new PNGImageDecoder();
+ 
+     // JPEG
+-    if (uContents[0] == 0xFF &&
+-        uContents[1] == 0xD8 &&
+-        uContents[2] == 0xFF)
+-        return ImageFormat_JPEG;
++    if (uContents[0]==0xFF &&
++        uContents[1]==0xD8 &&
++        uContents[2]==0xFF)
++        return new JPEGImageDecoder();
+ 
+     // BMP
+     if (strncmp(contents, "BM", 2) == 0)
+-        return ImageFormat_BMP;
++        return new BMPImageDecoder();
+ 
+     // ICOs always begin with a 2-byte 0 followed by a 2-byte 1.
+     // CURs begin with 2-byte 0 followed by 2-byte 2.
+     if (!memcmp(contents, "\000\000\001\000", 4) ||
+         !memcmp(contents, "\000\000\002\000", 4))
+-        return ImageFormat_ICO;
+-
++        return new ICOImageDecoder();
++   
+     // XBMs require 8 bytes of info.
+     if (length >= 8 && strncmp(contents, "#define ", 8) == 0)
+-        return ImageFormat_XBM;
++        return new XBMImageDecoder();
+ 
+     // Give up. We don't know what the heck this is.
+-    return ImageFormat_None;
+-}
+-    
+-ImageDecoderQt* createDecoder(const SharedBuffer& data) {
+-    if (detectImageFormat(data) != ImageFormat_None) 
+-        return new ImageDecoderQt();
+     return 0;
+ }
+ 
+ ImageSource::ImageSource()
+-    : m_decoder(0)
++  : m_decoder(0)
++{}
++
++ImageSource::~ImageSource()
+ {
++    clear();
+ }
+ 
+-ImageSource::~ImageSource()
++void ImageSource::clear()
+ {
+     delete m_decoder;
++    m_decoder = 0;
+ }
+ 
+ bool ImageSource::initialized() const
+@@ -111,13 +114,11 @@ void ImageSource::setData(SharedBuffer* data, bool allDataReceived)
+     // This method will examine the data and instantiate an instance of the appropriate decoder plugin.
+     // If insufficient bytes are available to determine the image type, no decoder plugin will be
+     // made.
+-    if (!m_decoder)
+-        m_decoder = createDecoder(*data);
+-
++    delete m_decoder;
++    m_decoder = createDecoder(data->buffer());
+     if (!m_decoder)
+         return;
+-
+-    m_decoder->setData(data->buffer(), allDataReceived);
++    m_decoder->setData(data, allDataReceived);
+ }
+ 
+ bool ImageSource::isSizeAvailable()
+@@ -146,10 +147,7 @@ int ImageSource::repetitionCount()
+ 
+ size_t ImageSource::frameCount() const
+ {
+-    if (!m_decoder)
+-        return 0;
+-
+-    return m_decoder->frameCount();
++    return m_decoder ? m_decoder->frameCount() : 0;
+ }
+ 
+ NativeImagePtr ImageSource::createFrameAtIndex(size_t index)
+@@ -157,25 +155,38 @@ NativeImagePtr ImageSource::createFrameAtIndex(size_t index)
+     if (!m_decoder)
+         return 0;
+ 
+-    
+-    const QPixmap* source = m_decoder->imageAtIndex(index);
+-    if (!source)
++    RGBA32Buffer* buffer = m_decoder->frameBufferAtIndex(index);
++    if (!buffer || buffer->status() == RGBA32Buffer::FrameEmpty)
+         return 0;
+ 
+-    return new QPixmap(*source);
++    return new QPixmap(QPixmap::fromImage(QImage(reinterpret_cast<unsigned char*>(buffer->bytes().data()),
++						 size().width(), size().height(), size().width()*4, QImage::Format_ARGB32)));
++}
++
++bool ImageSource::frameIsCompleteAtIndex(size_t index)
++{
++    if (!m_decoder)
++        return false;
++
++    RGBA32Buffer* buffer = m_decoder->frameBufferAtIndex(index);
++    return buffer && buffer->status() == RGBA32Buffer::FrameComplete;
+ }
+ 
+ float ImageSource::frameDurationAtIndex(size_t index)
+ {
+     if (!m_decoder)
+         return 0;
+-    
++
++    RGBA32Buffer* buffer = m_decoder->frameBufferAtIndex(index);
++    if (!buffer || buffer->status() == RGBA32Buffer::FrameEmpty)
++        return 0;
++
+     // Many annoying ads specify a 0 duration to make an image flash as quickly
+     // as possible.  We follow WinIE's behavior and use a duration of 100 ms
+     // for any frames that specify a duration of <= 50 ms.  See
+     // <http://bugs.webkit.org/show_bug.cgi?id=14413> or Radar 4051389 for
+     // more.
+-    const float duration = m_decoder->duration(index) / 1000.0f;
++    const float duration = buffer->duration() / 1000.0f;
+     return (duration < 0.051f) ? 0.100f : duration;
+ }
+ 
+@@ -183,26 +194,13 @@ bool ImageSource::frameHasAlphaAtIndex(size_t index)
+ {
+     if (!m_decoder || !m_decoder->supportsAlpha())
+         return false;
+-    
+-    const QPixmap* source = m_decoder->imageAtIndex( index);
+-    if (!source)
+-        return false;
+-    
+-    return source->hasAlphaChannel();
+-}
+ 
+-bool ImageSource::frameIsCompleteAtIndex(size_t index)
+-{
+-    return (m_decoder && m_decoder->imageAtIndex(index) != 0);
+-}
++    RGBA32Buffer* buffer = m_decoder->frameBufferAtIndex(index);
++    if (!buffer || buffer->status() == RGBA32Buffer::FrameEmpty)
++        return false;
+ 
+-void ImageSource::clear()
+-{
+-    delete  m_decoder;
+-    m_decoder = 0;
++    return buffer->hasAlpha();
+ }
+-
+-
+ }
+ 
+ // vim: ts=4 sw=4 et