webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

4 files changed, 35 insertions, 45 deletions

diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
index 6011b65bc..368bccad2 100644
--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp
@@ -32,7 +32,6 @@
 #include "BMPImageDecoder.h"
 
 #include "BMPImageReader.h"
-#include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
 
@@ -41,21 +40,20 @@ namespace WebCore {
 // don't pack).
 static const size_t sizeOfFileHeader = 14;
 
-BMPImageDecoder::BMPImageDecoder(ImageSource::AlphaOption alphaOption,
-                                 ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
+BMPImageDecoder::BMPImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
     , m_decodedOffset(0)
 {
 }
 
-void BMPImageDecoder::setData(SharedBuffer* data, bool allDataReceived)
+void BMPImageDecoder::setData(SharedBuffer& data, bool allDataReceived)
 {
     if (failed())
         return;
 
     ImageDecoder::setData(data, allDataReceived);
     if (m_reader)
-        m_reader->setData(data);
+        m_reader->setData(&data);
 }
 
 bool BMPImageDecoder::isSizeAvailable()
@@ -71,20 +69,18 @@ ImageFrame* BMPImageDecoder::frameBufferAtIndex(size_t index)
     if (index)
         return 0;
 
-    if (m_frameBufferCache.isEmpty()) {
+    if (m_frameBufferCache.isEmpty())
         m_frameBufferCache.resize(1);
-        m_frameBufferCache.first().setPremultiplyAlpha(m_premultiplyAlpha);
-    }
 
     ImageFrame* buffer = &m_frameBufferCache.first();
-    if (buffer->status() != ImageFrame::FrameComplete)
+    if (!buffer->isComplete())
         decode(false);
     return buffer;
 }
 
 bool BMPImageDecoder::setFailed()
 {
-    m_reader.clear();
+    m_reader = nullptr;
     return ImageDecoder::setFailed();
 }
 
@@ -99,8 +95,8 @@ void BMPImageDecoder::decode(bool onlySize)
         setFailed();
     // If we're done decoding the image, we don't need the BMPImageReader
     // anymore.  (If we failed, |m_reader| has already been cleared.)
-    else if (!m_frameBufferCache.isEmpty() && (m_frameBufferCache.first().status() == ImageFrame::FrameComplete))
-        m_reader.clear();
+    else if (!m_frameBufferCache.isEmpty() && m_frameBufferCache.first().isComplete())
+        m_reader = nullptr;
 }
 
 bool BMPImageDecoder::decodeHelper(bool onlySize)
@@ -110,7 +106,7 @@ bool BMPImageDecoder::decodeHelper(bool onlySize)
         return false;
 
     if (!m_reader) {
-        m_reader = adoptPtr(new BMPImageReader(this, m_decodedOffset, imgDataOffset, false));
+        m_reader = std::make_unique<BMPImageReader>(this, m_decodedOffset, imgDataOffset, false);
         m_reader->setData(m_data.get());
     }
 
diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
index f5b9d5e27..6b6270ce1 100644
--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h
@@ -28,28 +28,26 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef BMPImageDecoder_h
-#define BMPImageDecoder_h
+#pragma once
 
 #include "BMPImageReader.h"
-#include <wtf/OwnPtr.h>
 
 namespace WebCore {
 
     // This class decodes the BMP image format.
-    class BMPImageDecoder : public ImageDecoder {
+    class BMPImageDecoder final : public ImageDecoder {
     public:
-        BMPImageDecoder(ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
+        BMPImageDecoder(AlphaOption, GammaAndColorProfileOption);
 
         // ImageDecoder
-        virtual String filenameExtension() const { return "bmp"; }
-        virtual void setData(SharedBuffer*, bool allDataReceived);
-        virtual bool isSizeAvailable();
-        virtual ImageFrame* frameBufferAtIndex(size_t index);
+        String filenameExtension() const override { return "bmp"; }
+        void setData(SharedBuffer&, bool allDataReceived) override;
+        bool isSizeAvailable() override;
+        ImageFrame* frameBufferAtIndex(size_t index) override;
         // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
         // accessing deleted memory, especially when calling this from inside
         // BMPImageReader!
-        virtual bool setFailed();
+        bool setFailed() override;
 
     private:
         inline uint32_t readUint32(int offset) const
@@ -77,9 +75,7 @@ namespace WebCore {
         size_t m_decodedOffset;
 
         // The reader used to do most of the BMP decoding.
-        OwnPtr<BMPImageReader> m_reader;
+        std::unique_ptr<BMPImageReader> m_reader;
     };
 
 } // namespace WebCore
-
-#endif
diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
index 5c005534e..2212f14ff 100644
--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
@@ -77,17 +77,12 @@ bool BMPImageReader::decodeBMP(bool onlySize)
 
     // 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().width(), m_parent->size().height()))
+    if (m_buffer->isEmpty()) {
+        if (!m_buffer->initialize(m_parent->size(), m_parent->premultiplyAlpha()))
             return m_parent->setFailed(); // Unable to allocate.
-        m_buffer->setStatus(ImageFrame::FramePartial);
-        // setSize() calls eraseARGB(), which resets the alpha flag, so we force
-        // it back to false here.  We'll set it true below in all cases where
-        // 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()));
+        m_buffer->setDecoding(ImageFrame::Decoding::Partial);
+        m_buffer->setHasAlpha(false);
 
         if (!m_isTopDown)
             m_coord.setY(m_parent->size().height() - 1);
@@ -122,7 +117,7 @@ bool BMPImageReader::decodeBMP(bool onlySize)
     }
 
     // Done!
-    m_buffer->setStatus(ImageFrame::FrameComplete);
+    m_buffer->setDecoding(ImageFrame::Decoding::Complete);
     return true;
 }
 
@@ -171,7 +166,7 @@ bool BMPImageReader::processInfoHeader()
         return m_parent->setFailed();
 
     // Set our size.
-    if (!m_parent->setSize(m_infoHeader.biWidth, m_infoHeader.biHeight))
+    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
@@ -674,7 +669,7 @@ BMPImageReader::ProcessingResult BMPImageReader::processNonRLEData(bool inRLE, i
                         // transparent, on the assumption that most ICOs on the
                         // web will not be doing a lot of inverting.
                         if (colorIndex) {
-                            setRGBA(0, 0, 0, 0);
+                            setPixel(0, 0, 0, 0);
                             m_buffer->setHasAlpha(true);
                         } else
                             m_coord.move(1, 0);
@@ -707,13 +702,14 @@ BMPImageReader::ProcessingResult BMPImageReader::processNonRLEData(bool inRLE, i
                 } else {
                     m_seenNonZeroAlphaPixel = true;
                     if (m_seenZeroAlphaPixel) {
-                        m_buffer->zeroFillPixelData();
+                        m_buffer->backingStore()->clear();
+                        m_buffer->setHasAlpha(true);
                         m_seenZeroAlphaPixel = false;
                     } else if (alpha != 255)
                         m_buffer->setHasAlpha(true);
                 }
 
-                setRGBA(getComponent(pixel, 0), getComponent(pixel, 1),
+                setPixel(getComponent(pixel, 0), getComponent(pixel, 1),
                         getComponent(pixel, 2), alpha);
             }
         }
diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
index b5cb96e3f..03bcac60a 100644
--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h
@@ -239,16 +239,16 @@ namespace WebCore {
         // right by one.
         inline void setI(size_t colorIndex)
         {
-            setRGBA(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
+            setPixel(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
         }
 
         // Like setI(), but with the individual component values specified.
-        inline void setRGBA(unsigned red,
+        inline void setPixel(unsigned red,
                             unsigned green,
                             unsigned blue,
                             unsigned alpha)
         {
-            m_buffer->setRGBA(m_coord.x(), m_coord.y(), red, green, blue, alpha);
+            m_buffer->backingStore()->setPixel(m_coord.x(), m_coord.y(), red, green, blue, alpha);
             m_coord.move(1, 0);
         }
 
@@ -262,8 +262,10 @@ namespace WebCore {
                              unsigned blue,
                              unsigned alpha)
         {
-            while (m_coord.x() < endCoord)
-                setRGBA(red, green, blue, alpha);
+            if (endCoord <= m_coord.x())
+                return;
+            m_buffer->backingStore()->fillRect(IntRect(m_coord.x(), m_coord.y(), endCoord - m_coord.x(), 1), red, green, blue, alpha);
+            m_coord.setX(endCoord);
         }
 
         // Resets the relevant local variables to start drawing at the left edge