Attachment 290742 Details for Bug 155546 – Patch

[patch] Patch

bug-155546-20161005124047.patch (text/plain), 54.01 KB, created by Said Abou-Hallawa on 2016-10-05 12:44:00 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Said Abou-Hallawa

Created: 2016-10-05 12:44:00 PDT

Size: 54.01 KB

patch

obsolete

>Subversion Revision: 206810
>diff --git a/Source/WTF/ChangeLog b/Source/WTF/ChangeLog
>index c302906d846aba324735a54d7993a3e7b5282ad8..5696a244c739a3e6d3da0fe91cbce860c41df8a4 100644
>--- a/Source/WTF/ChangeLog
>+++ b/Source/WTF/ChangeLog
>@@ -1,3 +1,38 @@
>+2016-10-05  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        Add SynchronizedFixedQueue class
>+        https://bugs.webkit.org/show_bug.cgi?id=162478
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This class represents a simple producer/consumer worker. It facilitates
>+        synchronizing enqueuing to and dequeuing from a fixed size-queue. It uses
>+        a single lock and a single condition to synchronize all its members among
>+        the working threads. This means a single thread is active at any time and
>+        and the other threads are blocked waiting for the lock to be released. Or
>+        they are sleeping waiting for the condition to be satisfied.
>+
>+        One important function this class provides is the ability to close itself
>+        by any thread. Calling close() causes all the sleeping threads to wake up
>+        and terminates themselves. The close() will return only when all the threads
>+        are terminated so the caller can delete this object immediately.
>+
>+        To track the active working threads, all the working thread have to register
>+        themselves before creating their threads. The working threads also have to
>+        unregister themselves once they are done or the queue is closed.
>+
>+        * WTF.xcodeproj/project.pbxproj:
>+        * wtf/SynchronizedFixedQueue.h: Added.
>+        (WTF::SynchronizedFixedQueue::SynchronizedFixedQueue):
>+        (WTF::SynchronizedFixedQueue::open): Restore the queue to its original state.
>+        (WTF::SynchronizedFixedQueue::close): Wake all the sleeping threads and wait them to unregister themselves.
>+        (WTF::SynchronizedFixedQueue::isOpen): Does the queue accept new items/workers?
>+        (WTF::SynchronizedFixedQueue::registerWorker): Add a new worker to the set of workers.
>+        (WTF::SynchronizedFixedQueue::unregisterWorker): Remove a worker from the set of workers.
>+        (WTF::SynchronizedFixedQueue::isRegisteredWorker): Checks whether a work exists in the set of workers.
>+        (WTF::SynchronizedFixedQueue::enqueue): Enqueue an item to the queue.
>+        (WTF::SynchronizedFixedQueue::dequeue): Dequeue an item form the queue.
>+
> 2016-10-04  Saam Barati  <sbarati@apple.com>
> 
>         String.prototype.toLowerCase should be a DFG/FTL intrinsic
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index f9dd1b08786e7f69ff44d44aceff581a74181e0e..2351c1eb8d56026891528d24cd8290e550c5a5dc 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,72 @@
>+2016-10-05  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        Add the asynchronous image decoding mode
>+        https://bugs.webkit.org/show_bug.cgi?id=155546
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        The asynchronous image decoding targets enhancing the rendering in two
>+        scenarios: the animated images and scrolling a page which large images.
>+        
>+        Because the MemoryCache tries to keep the allocated memory under a certain
>+        limit, the BitmapImage may be requested to delete all or some of its decoded
>+        frames. This means large images or animated images with many frames may
>+        have to run all the image decoding all the time.
>+        
>+        The goal is have the decoded image ready before it has to be drawn. So 
>+        the image does not have to wait the for the current frame to be decoded.
>+        The trickiest part is when should decoding the frame start? If it is too
>+        early, the decoded frames might be destroyed even before they are used by
>+        the MemoryCache which means decoding them was a waste of resources. And
>+        if it is too late, the image decoding will end up being synchronous.
>+
>+        * platform/graphics/ImageFrame.cpp:
>+        (WebCore::ImageFrame::operator=): m_decoding was renamed to m_decodingStatus.
>+        * platform/graphics/ImageFrame.h: Add the enum class DecodingMode and rename m_decoding to m_decodingStatus.
>+        (WebCore::ImageFrame::setDecodingStatus): setDecoding() was renamed to setDecodingStatus().
>+        (WebCore::ImageFrame::decodingStatus): decoding() was renamed to decodingStatus().
>+        (WebCore::ImageFrame::isEmpty): The enum class Decoding was renamed to DecodingStatus.
>+        (WebCore::ImageFrame::isPartial): Ditto.
>+        (WebCore::ImageFrame::isComplete): Ditto.
>+        (WebCore::ImageFrame::setDecoding): Deleted.
>+        (WebCore::ImageFrame::decoding): Deleted.
>+        * platform/graphics/ImageFrameCache.cpp:
>+        (WebCore::ImageFrameCache::newFrameImageAvailable): Notify the image observer with the availability of a new frame.
>+        (WebCore::ImageFrameCache::setNativeImage): ImageFrame::m_decoding was renamed to m_decodingStatus.
>+        (WebCore::ImageFrameCache::setFrameMetadata): Ditto.
>+        (WebCore::ImageFrameCache::decodingQueue): Ensures the decoding WorkQueue is created and return a raw pointer to it.
>+        (WebCore::ImageFrameCache::startAsyncDecoding): Starts a decoding WorkQueue which loops until m_frameRequestQueue is closed.
>+        (WebCore::ImageFrameCache::stopAsyncDecoding): Stops the decoding WorkQueue by closing m_frameRequestQueue.
>+        (WebCore::ImageFrameCache::requestFrameImageAtIndex): Allows the client to send a request for a decoded frame.
>+        (WebCore::ImageFrameCache::cacheFrameAtIndex): Gets the decoded NativeImagePtr on decoding WorkQueue and caches the ImageFrame on the main thread.
>+        * platform/graphics/ImageFrameCache.h:
>+        (WebCore::ImageFrameCache::isAsyncDecoding): Returns true if the ImageFrameCache is registered with m_frameRequestQueue.
>+        * platform/graphics/cg/ImageDecoderCG.cpp: 
>+        (WebCore::createImageSourceOptions): Add support for immediate image decoding mode.
>+        (WebCore::imageSourceOptions): Ditto.
>+        (WebCore::ImageDecoder::createFrameImageAtIndex): Ditto.
>+        * platform/graphics/cg/ImageDecoderCG.h: Change the signature of ImageDecoder::createFrameImageAtIndex() by adding an argument of type ImageFrame::DecodingMode.
>+        * platform/graphics/win/ImageDecoderDirect2D.cpp: 
>+        (WebCore::ImageDecoder::createFrameImageAtIndex): Ditto.
>+        * platform/graphics/win/ImageDecoderDirect2D.h: Ditto.
>+        * platform/image-decoders/ImageDecoder.cpp:
>+        (WebCore::ImageDecoder::createFrameImageAtIndex): Ditto.
>+        * platform/image-decoders/ImageDecoder.h: Ditto.
>+        * platform/image-decoders/bmp/BMPImageReader.cpp:
>+        (WebCore::BMPImageReader::decodeBMP): setDecoding() was renamed to setDecodingStatus().
>+        * platform/image-decoders/gif/GIFImageDecoder.cpp:
>+        (WebCore::GIFImageDecoder::frameComplete): Ditto.
>+        (WebCore::GIFImageDecoder::initFrameBuffer): Ditto.
>+        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
>+        (WebCore::JPEGImageDecoder::outputScanlines): Ditto.
>+        (WebCore::JPEGImageDecoder::jpegComplete): Ditto.
>+        * platform/image-decoders/png/PNGImageDecoder.cpp:
>+        (WebCore::PNGImageDecoder::rowAvailable): Ditto.
>+        (WebCore::PNGImageDecoder::pngComplete): Ditto.
>+        (WebCore::PNGImageDecoder::frameComplete): Ditto.
>+        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
>+        (WebCore::WEBPImageDecoder::decode): Ditto.
>+
> 2016-10-05  Daniel Bates  <dabates@apple.com>
> 
>         Do not follow redirects when sending violation report
>diff --git a/Source/WTF/WTF.xcodeproj/project.pbxproj b/Source/WTF/WTF.xcodeproj/project.pbxproj
>index 6b7357ed9a0d9cdc9e2ef2290176202926f8378b..d2426b17103c51953313d7245f1e368d4233c8c3 100644
>--- a/Source/WTF/WTF.xcodeproj/project.pbxproj
>+++ b/Source/WTF/WTF.xcodeproj/project.pbxproj
>@@ -119,6 +119,7 @@
> 		515F79561CFD3A6900CCED93 /* CrossThreadQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = 515F79551CFD3A6900CCED93 /* CrossThreadQueue.h */; };
> 		539EB0631D55284200C82EF7 /* LEBDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 539EB0621D55284200C82EF7 /* LEBDecoder.h */; };
> 		553071CA1C40427200384898 /* TinyLRUCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 553071C91C40427200384898 /* TinyLRUCache.h */; };
>+		5597F82F1D94B9970066BC21 /* SynchronizedFixedQueue.h in Headers */ = {isa = PBXBuildFile; fileRef = 5597F82C1D94B9970066BC21 /* SynchronizedFixedQueue.h */; };
> 		5C7C88D41D0A3A0A009D2F6D /* UniqueRef.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C7C88D31D0A3A0A009D2F6D /* UniqueRef.h */; };
> 		70A993FE1AD7151300FA615B /* SymbolRegistry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 70A993FC1AD7151300FA615B /* SymbolRegistry.cpp */; };
> 		70A993FF1AD7151300FA615B /* SymbolRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 70A993FD1AD7151300FA615B /* SymbolRegistry.h */; };
>@@ -463,6 +464,7 @@
> 		515F79551CFD3A6900CCED93 /* CrossThreadQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CrossThreadQueue.h; sourceTree = "<group>"; };
> 		539EB0621D55284200C82EF7 /* LEBDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LEBDecoder.h; sourceTree = "<group>"; };
> 		553071C91C40427200384898 /* TinyLRUCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TinyLRUCache.h; sourceTree = "<group>"; };
>+		5597F82C1D94B9970066BC21 /* SynchronizedFixedQueue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SynchronizedFixedQueue.h; sourceTree = "<group>"; };
> 		5B43383A5D0B463C9433D933 /* IndexMap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IndexMap.h; sourceTree = "<group>"; };
> 		5C7C88D31D0A3A0A009D2F6D /* UniqueRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UniqueRef.h; sourceTree = "<group>"; };
> 		5D247B6214689B8600E78B76 /* libWTF.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libWTF.a; sourceTree = BUILT_PRODUCTS_DIR; };
>@@ -1023,6 +1025,7 @@
> 				A748745117A0BDAE00FA04CB /* StringHashDumpContext.h */,
> 				0FDDBFA51666DFA300C55FEF /* StringPrintStream.cpp */,
> 				0FDDBFA61666DFA300C55FEF /* StringPrintStream.h */,
>+				5597F82C1D94B9970066BC21 /* SynchronizedFixedQueue.h */,
> 				0FB317C31C488001007E395A /* SystemTracing.h */,
> 				A8A4731A151A825B004123FF /* TemporaryChange.h */,
> 				A8A4732F151A825B004123FF /* ThreadFunctionInvocation.h */,
>@@ -1407,6 +1410,7 @@
> 				C4F8A93719C65EB400B2B15D /* Stopwatch.h in Headers */,
> 				1A6BB769162F300500DD16DB /* StreamBuffer.h in Headers */,
> 				A8A4743B151A825B004123FF /* StringBuffer.h in Headers */,
>+				5597F82F1D94B9970066BC21 /* SynchronizedFixedQueue.h in Headers */,
> 				A8A4743D151A825B004123FF /* StringBuilder.h in Headers */,
> 				430B47891AAAAC1A001223DA /* StringCommon.h in Headers */,
> 				A8A4743E151A825B004123FF /* StringConcatenate.h in Headers */,
>diff --git a/Source/WTF/wtf/SynchronizedFixedQueue.h b/Source/WTF/wtf/SynchronizedFixedQueue.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..e4c7d5c241b7a96661f879fe9ddbdd2cae17a4e1
>--- /dev/null
>+++ b/Source/WTF/wtf/SynchronizedFixedQueue.h
>@@ -0,0 +1,158 @@
>+/*
>+ * 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 <wtf/Condition.h>
>+#include <wtf/Deque.h>
>+#include <wtf/HashSet.h>
>+#include <wtf/Lock.h>
>+#include <wtf/Locker.h>
>+
>+namespace WTF {
>+
>+template<typename T, size_t BufferSize>
>+class SynchronizedFixedQueue {
>+public:
>+    SynchronizedFixedQueue()
>+    {
>+    }
>+    
>+    void open()
>+    {
>+        LockHolder lockHolder(m_mutex);
>+        
>+        // Restore the queue to its original state.
>+        m_queue.clear();
>+        m_workers.clear();
>+        m_open = true;
>+    }
>+    
>+    void close()
>+    {
>+        LockHolder lockHolder(m_mutex);
>+
>+        // Wake all the sleeping threads up with a closing state.
>+        m_open = false;
>+        m_condition.notifyAll();
>+
>+        // Wait for all the threads to die. The caller of this function might
>+        // delete the SynchronizedFixedQueue itself immediately after this call.
>+        m_condition.wait(m_mutex, [this]() { return !m_workers.size(); } );
>+    }
>+    
>+    bool isOpen()
>+    {
>+        LockHolder lockHolder(m_mutex);
>+        return m_open;
>+    }
>+
>+    bool registerWorker(const void* worker)
>+    {
>+        ASSERT(worker);
>+        
>+        LockHolder lockHolder(m_mutex);
>+        
>+        if (!m_open || m_workers.contains(worker))
>+            return false;
>+        
>+        // Add the worker to the set of workers and try waking up sleeping threads.
>+        m_workers.add(worker);
>+        m_condition.notifyAll();
>+        return true;
>+    }
>+    
>+    bool unregisterWorker(const void* worker)
>+    {
>+        ASSERT(worker);
>+        
>+        LockHolder lockHolder(m_mutex);
>+        
>+        if (!m_workers.contains(worker))
>+            return false;
>+        
>+        // Remove the worker from the set of workers and try waking up sleeping threads.
>+        m_workers.remove(worker);
>+        m_condition.notifyAll();
>+        return true;
>+    }
>+    
>+    bool isRegisteredWorker(const void* worker)
>+    {
>+        LockHolder lockHolder(m_mutex);
>+        return m_workers.contains(worker);
>+    }
>+    
>+    bool enqueue(const T& value)
>+    {
>+        LockHolder lockHolder(m_mutex);
>+
>+        // Wait for an empty place to be available in the queue.
>+        m_condition.wait(m_mutex, [this]() { return !m_open || m_queue.size() < BufferSize; });
>+        
>+        // The queue is closing, exit immediately.
>+        if (!m_open)
>+            return false;
>+        
>+        // Add the item in the queue.
>+        m_queue.append(value);
>+
>+        // Notify the other threads that an item was added to the queue.
>+        m_condition.notifyAll();
>+        return true;
>+    }
>+    
>+    bool dequeue(T& value)
>+    {
>+        LockHolder lockHolder(m_mutex);
>+        
>+        // Wait for an item to be added.
>+        m_condition.wait(m_mutex, [this]() { return !m_open || m_queue.size(); });
>+
>+        // The queue is closing, exit immediately.
>+        if (!m_open)
>+            return false;
>+
>+        // Get a copy from m_queue.first and then remove it.
>+        value = m_queue.first();
>+        m_queue.removeFirst();
>+
>+        // Notify the other threads that an item was removed from the queue.
>+        m_condition.notifyAll();
>+        return true;
>+    }
>+
>+private:
>+    Lock m_mutex;
>+    Condition m_condition;
>+
>+    bool m_open { true };
>+    HashSet<const void*> m_workers;
>+    Deque<T, BufferSize> m_queue;
>+};
>+
>+}
>+
>+using WTF::SynchronizedFixedQueue;
>diff --git a/Source/WebCore/platform/graphics/ImageFrame.cpp b/Source/WebCore/platform/graphics/ImageFrame.cpp
>index 9b71282738a4d0cf67e2632120062f44b342f78c..6b2ce150359e317888ec7357783ab88b6046b9ab 100644
>--- a/Source/WebCore/platform/graphics/ImageFrame.cpp
>+++ b/Source/WebCore/platform/graphics/ImageFrame.cpp
>@@ -50,7 +50,7 @@ ImageFrame& ImageFrame::operator=(const ImageFrame& other)
>     if (this == &other)
>         return *this;
> 
>-    m_decoding = other.m_decoding;
>+    m_decodingStatus = other.m_decodingStatus;
>     m_size = other.m_size;
> 
> #if !USE(CG)
>diff --git a/Source/WebCore/platform/graphics/ImageFrame.h b/Source/WebCore/platform/graphics/ImageFrame.h
>index 0805e30753fa756d935df5d2ced518a5154aff60..90166466087d935fd1ef75421474a91ea4a06fb4 100644
>--- a/Source/WebCore/platform/graphics/ImageFrame.h
>+++ b/Source/WebCore/platform/graphics/ImageFrame.h
>@@ -77,7 +77,8 @@ class ImageFrame {
>     friend class ImageFrameCache;
> public:
>     enum class Caching { Empty, Metadata, MetadataAndImage };
>-    enum class Decoding { Empty, Partial, Complete };
>+    enum class DecodingStatus { Empty, Partial, Complete };
>+    enum class DecodingMode { Immediate, OnDemand };
> 
>     ImageFrame();
>     ImageFrame(const ImageFrame& other) { operator=(other); }
>@@ -96,11 +97,11 @@ public:
>     bool initialize(const IntSize&, bool premultiplyAlpha);
> #endif
> 
>-    void setDecoding(Decoding decoding) { m_decoding = decoding; }
>-    Decoding decoding() const { return m_decoding; }
>-    bool isEmpty() const { return m_decoding == Decoding::Empty; }
>-    bool isPartial() const { return m_decoding == Decoding::Partial; }
>-    bool isComplete() const { return m_decoding == Decoding::Complete; }
>+    void setDecodingStatus(DecodingStatus decodingStatus) { m_decodingStatus = decodingStatus; }
>+    DecodingStatus decodingStatus() const { return m_decodingStatus; }
>+    bool isEmpty() const { return m_decodingStatus == DecodingStatus::Empty; }
>+    bool isPartial() const { return m_decodingStatus == DecodingStatus::Partial; }
>+    bool isComplete() const { return m_decodingStatus == DecodingStatus::Complete; }
> 
>     IntSize size() const;
>     IntSize sizeRespectingOrientation() const { return !m_orientation.usesWidthAsHeight() ? size() : size().transposedSize(); }
>@@ -136,7 +137,7 @@ public:
>     Color singlePixelSolidColor() const;
> 
> private:
>-    Decoding m_decoding { Decoding::Empty };
>+    DecodingStatus m_decodingStatus { DecodingStatus::Empty };
>     IntSize m_size;
> 
> #if !USE(CG)
>diff --git a/Source/WebCore/platform/graphics/ImageFrameCache.cpp b/Source/WebCore/platform/graphics/ImageFrameCache.cpp
>index e7a4171f318b71dbc29c876a9c11d5ff57977d26..ff0389269b8a508a125a7865b4e5f29c1405b3b2 100644
>--- a/Source/WebCore/platform/graphics/ImageFrameCache.cpp
>+++ b/Source/WebCore/platform/graphics/ImageFrameCache.cpp
>@@ -40,7 +40,8 @@
> #endif
> 
> #include <wtf/CheckedArithmetic.h>
>-
>+#include <wtf/MainThread.h>
>+#include <wtf/RunLoop.h>
> 
> namespace WebCore {
> 
>@@ -157,6 +158,12 @@ void ImageFrameCache::didDecodeProperties(unsigned decodedPropertiesSize)
>     m_decodedPropertiesSize = decodedPropertiesSize;
>     decodedSizeChanged(decodedSize);
> }
>+    
>+void ImageFrameCache::newFrameImageAvailable()
>+{
>+    if (m_image && m_image->imageObserver())
>+        m_image->imageObserver()->animationAdvanced(m_image);
>+}
> 
> void ImageFrameCache::growFrames()
> {
>@@ -174,7 +181,7 @@ void ImageFrameCache::setNativeImage(NativeImagePtr&& nativeImage)
> 
>     frame.m_nativeImage = WTFMove(nativeImage);
> 
>-    frame.m_decoding = ImageFrame::Decoding::Complete;
>+    frame.m_decodingStatus = ImageFrame::DecodingStatus::Complete;
>     frame.m_size = nativeImageSize(frame.m_nativeImage);
>     frame.m_hasAlpha = nativeImageHasAlpha(frame.m_nativeImage);
> }
>@@ -196,7 +203,7 @@ void ImageFrameCache::setFrameMetadata(size_t index, SubsamplingLevel subsamplin
>     ImageFrame& frame = m_frames[index];
> 
>     ASSERT(isDecoderAvailable());
>-    frame.m_decoding = m_decoder->frameIsCompleteAtIndex(index) ? ImageFrame::Decoding::Complete : ImageFrame::Decoding::Partial;
>+    frame.m_decodingStatus = m_decoder->frameIsCompleteAtIndex(index) ? ImageFrame::DecodingStatus::Complete : ImageFrame::DecodingStatus::Partial;
>     if (frame.hasMetadata())
>         return;
>     
>@@ -209,6 +216,87 @@ void ImageFrameCache::setFrameMetadata(size_t index, SubsamplingLevel subsamplin
>         frame.m_duration = m_decoder->frameDurationAtIndex(index);
> }
> 
>+WorkQueue* ImageFrameCache::decodingQueue()
>+{
>+    if (!m_decodingQueue)
>+        m_decodingQueue = WorkQueue::create("org.webkit.ImageDecoder", WorkQueue::Type::Serial, WorkQueue::QOS::UserInteractive);
>+    
>+    ASSERT(m_decodingQueue);
>+    return m_decodingQueue.get();
>+}
>+
>+void ImageFrameCache::startAsyncDecoding()
>+{
>+    if (isAsyncDecoding())
>+        return;
>+
>+    m_frameRequestQueue.registerWorker(this);
>+
>+    decodingQueue()->dispatch([this] {
>+        ImageFrameRequest framerequest;
>+        
>+        while (m_frameRequestQueue.dequeue(framerequest))
>+            cacheFrameAtIndex(framerequest.index, framerequest.subsamplingLevel);
>+        
>+        m_frameRequestQueue.unregisterWorker(this);
>+    });
>+}
>+
>+void ImageFrameCache::stopAsyncDecoding()
>+{
>+    if (!isAsyncDecoding())
>+        return;
>+    
>+    m_frameRequestQueue.close();
>+}
>+
>+void ImageFrameCache::requestFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    if (!isDecoderAvailable() || !isAsyncDecoding())
>+        return;
>+    
>+    ASSERT(index < m_frames.size());
>+    ImageFrame& frame = m_frames[index];
>+
>+    if (subsamplingLevel == SubsamplingLevel::Undefinded)
>+        subsamplingLevel = frame.subsamplingLevel();
>+    
>+    if (!frame.hasInvalidNativeImage(subsamplingLevel)) {
>+        // Notify the observer that the image frame is already ready.
>+        newFrameImageAvailable();
>+        return;
>+    }
>+    
>+    m_frameRequestQueue.enqueue({ index, subsamplingLevel });
>+}
>+
>+void ImageFrameCache::cacheFrameAtIndex(size_t index, SubsamplingLevel subsamplingLevel)
>+{
>+    NativeImagePtr nativeImage = m_decoder->createFrameImageAtIndex(index, subsamplingLevel, ImageFrame::DecodingMode::Immediate);
>+
>+    callOnMainThread([this, &nativeImage, index, subsamplingLevel] {
>+        if (!isAsyncDecoding())
>+            return;
>+
>+        ASSERT(index < m_frames.size());
>+        ImageFrame& frame = m_frames[index];
>+
>+        // Clear the current image frame and update the observer with this clearance.
>+        unsigned decodedSize = frame.clear();
>+        decodedSizeDecreased(decodedSize);
>+
>+        // Copy the new image to the cache.
>+        setFrameNativeImage(WTFMove(nativeImage), index, subsamplingLevel);
>+
>+        // Update the observer with the new image frame
>+        decodedSize = frame.frameBytes();
>+        decodedSizeIncreased(decodedSize);
>+
>+        // Notify the observer with the readiness of the image frame.
>+        newFrameImageAvailable();
>+    });
>+}
>+
> const ImageFrame& ImageFrameCache::frameAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::Caching caching)
> {
>     ASSERT(index < m_frames.size());
>diff --git a/Source/WebCore/platform/graphics/ImageFrameCache.h b/Source/WebCore/platform/graphics/ImageFrameCache.h
>index 7ba979823897491a2ae5c79ad2af750a66ff8145..1710562ba34c7ac7e91017a4166cf94d83a43467 100644
>--- a/Source/WebCore/platform/graphics/ImageFrameCache.h
>+++ b/Source/WebCore/platform/graphics/ImageFrameCache.h
>@@ -30,6 +30,8 @@
> 
> #include <wtf/Forward.h>
> #include <wtf/Optional.h>
>+#include <wtf/SynchronizedFixedQueue.h>
>+#include <wtf/WorkQueue.h>
> 
> namespace WebCore {
> 
>@@ -54,6 +56,13 @@ public:
>     void growFrames();
>     void clearMetadata();
> 
>+    // Asynchronous image decoding
>+    WorkQueue* decodingQueue();
>+    void startAsyncDecoding();
>+    void stopAsyncDecoding();
>+    bool isAsyncDecoding() { return m_frameRequestQueue.isRegisteredWorker(this); }
>+    void requestFrameImageAtIndex(size_t, SubsamplingLevel);
>+    
>     // Image metadata which is calculated either by the ImageDecoder or directly
>     // from the NativeImage if this class was created for a memory image.
>     bool isSizeAvailable();
>@@ -99,10 +108,13 @@ private:
>     void decodedSizeIncreased(unsigned decodedSize);
>     void decodedSizeDecreased(unsigned decodedSize);
>     void decodedSizeReset(unsigned decodedSize);
>+    void newFrameImageAvailable();
> 
>     void setNativeImage(NativeImagePtr&&);
>     void setFrameNativeImage(NativeImagePtr&&, size_t, SubsamplingLevel);
>     void setFrameMetadata(size_t, SubsamplingLevel);
>+    
>+    void cacheFrameAtIndex(size_t, SubsamplingLevel);
>     const ImageFrame& frameAtIndex(size_t, SubsamplingLevel, ImageFrame::Caching);
> 
>     // Animated images over a certain size are considered large enough that we'll only hang on to one frame at a time.
>@@ -119,6 +131,16 @@ private:
> 
>     Vector<ImageFrame, 1> m_frames;
> 
>+    // Asynchronous image decoding.
>+    struct ImageFrameRequest {
>+        size_t index;
>+        SubsamplingLevel subsamplingLevel;
>+    };
>+    static const int BufferSize = 8;
>+    using FrameRequestQueue = SynchronizedFixedQueue<ImageFrameRequest, BufferSize>;
>+    FrameRequestQueue m_frameRequestQueue;
>+    RefPtr<WorkQueue> m_decodingQueue;
>+
>     // Image metadata.
>     Optional<bool> m_isSizeAvailable;
>     Optional<size_t> m_frameCount;
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>index 7ad1aabaca7e50498cd4c32b8b8c43840c3bacad..3e26309f5ec6c461aad04ac0a600badf5520f403 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.cpp
>@@ -46,6 +46,7 @@
> #import <ImageIO/CGImageSourcePrivate.h>
> #else
> const CFStringRef kCGImageSourceSubsampleFactor = CFSTR("kCGImageSourceSubsampleFactor");
>+const CFStringRef kCGImageSourceShouldCacheImmediately = CFSTR("kCGImageSourceShouldCacheImmediately");
> #endif
> 
> namespace WebCore {
>@@ -57,31 +58,42 @@ const CFStringRef WebCoreCGImagePropertyAPNGLoopCount = CFSTR("LoopCount");
> const CFStringRef kCGImageSourceShouldPreferRGB32 = CFSTR("kCGImageSourceShouldPreferRGB32");
> const CFStringRef kCGImageSourceSkipMetadata = CFSTR("kCGImageSourceSkipMetadata");
> 
>-static RetainPtr<CFDictionaryRef> createImageSourceOptions(SubsamplingLevel subsamplingLevel)
>+static RetainPtr<CFDictionaryRef> createImageSourceOptions(SubsamplingLevel subsamplingLevel, ImageFrame::DecodingMode decodingMode)
> {
>-    if (subsamplingLevel == SubsamplingLevel::First) {
>-        const unsigned numOptions = 3;
>-        const void* keys[numOptions] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata };
>-        const void* values[numOptions] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue };
>-        return CFDictionaryCreate(nullptr, keys, values, numOptions, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
>-    }
>-    
>-    subsamplingLevel = std::min(SubsamplingLevel::Last, std::max(SubsamplingLevel::First, subsamplingLevel));
>-    int subsampleInt = 1 << static_cast<int>(subsamplingLevel); // [0..3] => [1, 2, 4, 8]
>+    const CFIndex basicOptions = 3;
>+    const CFIndex extraOptions = 3;
>+    const void* keys[basicOptions + extraOptions] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata };
>+    const void* values[basicOptions + extraOptions] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue };
>+    CFIndex numOptions = basicOptions;
>     
>-    RetainPtr<CFNumberRef> subsampleNumber = adoptCF(CFNumberCreate(nullptr,  kCFNumberIntType,  &subsampleInt));
>-    const CFIndex numOptions = 4;
>-    const void* keys[numOptions] = { kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32, kCGImageSourceSkipMetadata, kCGImageSourceSubsampleFactor };
>-    const void* values[numOptions] = { kCFBooleanTrue, kCFBooleanTrue, kCFBooleanTrue, subsampleNumber.get() };
>+    if (subsamplingLevel > SubsamplingLevel::First) {
>+        subsamplingLevel = std::min(SubsamplingLevel::Last, std::max(SubsamplingLevel::First, subsamplingLevel));
>+        int subsampleInt = 1 << static_cast<int>(subsamplingLevel); // [0..3] => [1, 2, 4, 8]
>+        
>+        RetainPtr<CFNumberRef> subsampleNumber = adoptCF(CFNumberCreate(nullptr,  kCFNumberIntType,  &subsampleInt));
>+        
>+        keys[numOptions] = kCGImageSourceSubsampleFactor;
>+        values[numOptions++] = subsampleNumber.get();
>+    }
>+
>+    if (decodingMode == ImageFrame::DecodingMode::Immediate) {
>+        keys[numOptions] = kCGImageSourceShouldCacheImmediately;
>+        values[numOptions++] = kCFBooleanTrue;
>+
>+        keys[numOptions] = kCGImageSourceCreateThumbnailFromImageAlways;
>+        values[numOptions++] = kCFBooleanTrue;
>+    }
>+
>+    ASSERT(numOptions <= basicOptions + extraOptions);
>     return adoptCF(CFDictionaryCreate(nullptr, keys, values, numOptions, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
> }
> 
>-static RetainPtr<CFDictionaryRef> imageSourceOptions(SubsamplingLevel subsamplingLevel = SubsamplingLevel::Default)
>+static RetainPtr<CFDictionaryRef> imageSourceOptions(SubsamplingLevel subsamplingLevel = SubsamplingLevel::Default, ImageFrame::DecodingMode decodingMode = ImageFrame::DecodingMode::OnDemand)
> {
>     if (subsamplingLevel > SubsamplingLevel::First)
>-        return createImageSourceOptions(subsamplingLevel);
>+        return createImageSourceOptions(subsamplingLevel, decodingMode);
>     
>-    static NeverDestroyed<RetainPtr<CFDictionaryRef>> options = createImageSourceOptions(SubsamplingLevel::First);
>+    static NeverDestroyed<RetainPtr<CFDictionaryRef>> options = createImageSourceOptions(SubsamplingLevel::First, decodingMode);
>     return options;
> }
> 
>@@ -331,11 +343,15 @@ unsigned ImageDecoder::frameBytesAtIndex(size_t index, SubsamplingLevel subsampl
>     return frameSize.area() * 4;
> }
> 
>-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
>+NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::DecodingMode decodingMode) const
> {
>     LOG(Images, "ImageDecoder %p createFrameImageAtIndex %lu", this, index);
> 
>-    RetainPtr<CGImageRef> image = adoptCF(CGImageSourceCreateImageAtIndex(m_nativeDecoder.get(), index, imageSourceOptions(subsamplingLevel).get()));
>+    RetainPtr<CGImageRef> image;
>+    if (decodingMode == ImageFrame::DecodingMode::Immediate)
>+        image = adoptCF(CGImageSourceCreateThumbnailAtIndex(m_nativeDecoder.get(), index, imageSourceOptions(subsamplingLevel, decodingMode).get()));
>+    else
>+        image = adoptCF(CGImageSourceCreateImageAtIndex(m_nativeDecoder.get(), index, imageSourceOptions(subsamplingLevel, decodingMode).get()));
>     
> #if PLATFORM(IOS)
>     // <rdar://problem/7371198> - CoreGraphics changed the default caching behaviour in iOS 4.0 to kCGImageCachingTransient
>diff --git a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>index 19329be928b8f6d26a7bbdd926a6cb9efdfdd9fc..15498ec0639f55192868ac6bbdc426e303a7a4fd 100644
>--- a/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>+++ b/Source/WebCore/platform/graphics/cg/ImageDecoderCG.h
>@@ -62,7 +62,7 @@ public:
>     bool frameAllowSubsamplingAtIndex(size_t) const;
>     unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>     
>-    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>+    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, ImageFrame::DecodingMode = ImageFrame::DecodingMode::OnDemand) const;
>     
>     void setData(SharedBuffer&, bool allDataReceived);
>     bool isAllDataReceived() const { return m_isAllDataReceived; }
>diff --git a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>index e6ae277f4331d3be6c38d88072617c1c58897f21..e9de0592be271ca5da63dbc565e64d6e1ed61aa9 100644
>--- a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.cpp
>@@ -192,7 +192,7 @@ void ImageDecoder::setRenderTarget(ID2D1RenderTarget* renderTarget)
>     m_renderTarget = renderTarget;
> }
> 
>-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel) const
>+NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel subsamplingLevel, ImageFrame::DecodingMode) const
> {
>     if (!m_nativeDecoder)
>         return nullptr;
>diff --git a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>index 61ca4dad467b38d2a08f0fff17307a3818ed1a0b..5562456b70849ab4c97f87d0918521ab896d9c67 100644
>--- a/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>+++ b/Source/WebCore/platform/graphics/win/ImageDecoderDirect2D.h
>@@ -67,7 +67,7 @@ public:
>     bool frameAllowSubsamplingAtIndex(size_t) const;
>     unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>     
>-    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default) const;
>+    NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, ImageFrame::DecodingMode = ImageFrame::DecodingMode::OnDemand) const;
>     
>     void setData(SharedBuffer&, bool allDataReceived);
>     bool isAllDataReceived() const { return m_isAllDataReceived; }
>diff --git a/Source/WebCore/platform/image-decoders/ImageDecoder.cpp b/Source/WebCore/platform/image-decoders/ImageDecoder.cpp
>index 54bd1f8b0eaf0bebe825b6c8d64343663dff49d2..620eb64600039299e33ced50d66042323dc3be82 100644
>--- a/Source/WebCore/platform/image-decoders/ImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/ImageDecoder.cpp
>@@ -207,7 +207,7 @@ float ImageDecoder::frameDurationAtIndex(size_t index)
>     return duration;
> }
> 
>-NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel)
>+NativeImagePtr ImageDecoder::createFrameImageAtIndex(size_t index, SubsamplingLevel, ImageFrame::DecodingMode)
> {
>     // Zero-height images can cause problems for some ports. If we have an empty image dimension, just bail.
>     if (size().isEmpty())
>diff --git a/Source/WebCore/platform/image-decoders/ImageDecoder.h b/Source/WebCore/platform/image-decoders/ImageDecoder.h
>index 26746e46359f14cf03d35c4c7b7963ce5243a147..75b3069a3e8674c56ff9909615a268fd5d942d0b 100644
>--- a/Source/WebCore/platform/image-decoders/ImageDecoder.h
>+++ b/Source/WebCore/platform/image-decoders/ImageDecoder.h
>@@ -137,7 +137,7 @@ namespace WebCore {
>         
>         float frameDurationAtIndex(size_t);
>         
>-        NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel);
>+        NativeImagePtr createFrameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default, ImageFrame::DecodingMode = ImageFrame::DecodingMode::OnDemand);
> 
>         void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
>         bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
>diff --git a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
>index 2212f14ff2f47ac9ac187bcd1884b92618da5f8a..38a09ec7366160c6f8dcfb1f262c10360c5769a3 100644
>--- a/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
>+++ b/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.cpp
>@@ -81,7 +81,7 @@ bool BMPImageReader::decodeBMP(bool onlySize)
>         if (!m_buffer->initialize(m_parent->size(), m_parent->premultiplyAlpha()))
>             return m_parent->setFailed(); // Unable to allocate.
> 
>-        m_buffer->setDecoding(ImageFrame::Decoding::Partial);
>+        m_buffer->setDecodingStatus(ImageFrame::DecodingStatus::Partial);
>         m_buffer->setHasAlpha(false);
> 
>         if (!m_isTopDown)
>@@ -117,7 +117,7 @@ bool BMPImageReader::decodeBMP(bool onlySize)
>     }
> 
>     // Done!
>-    m_buffer->setDecoding(ImageFrame::Decoding::Complete);
>+    m_buffer->setDecodingStatus(ImageFrame::DecodingStatus::Complete);
>     return true;
> }
> 
>diff --git a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>index 9befa8a4208207f1d074d1e5d76f5b1e65d68263..109f76779dde620847427a44f0f452035d2ff0a9 100644
>--- a/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp
>@@ -251,7 +251,7 @@ bool GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration,
>     if (buffer.isEmpty() && !initFrameBuffer(frameIndex))
>         return false; // initFrameBuffer() has already called setFailed().
> 
>-    buffer.setDecoding(ImageFrame::Decoding::Complete);
>+    buffer.setDecodingStatus(ImageFrame::DecodingStatus::Complete);
>     buffer.setDuration(frameDuration);
>     buffer.setDisposalMethod(disposalMethod);
> 
>@@ -404,7 +404,7 @@ bool GIFImageDecoder::initFrameBuffer(unsigned frameIndex)
>     buffer->backingStore()->setFrameRect(IntRect(left, top, right - left, bottom - top));
> 
>     // Update our status to be partially complete.
>-    buffer->setDecoding(ImageFrame::Decoding::Partial);
>+    buffer->setDecodingStatus(ImageFrame::DecodingStatus::Partial);
> 
>     // Reset the alpha pixel tracker for this frame.
>     m_currentBufferSawAlpha = false;
>diff --git a/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp b/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>index 40bd88bbc2d2bee6d6da870d0b36d973cc979e11..041695f3dc049de3fb4061c6eb9cc49fe87ab4a0 100644
>--- a/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp
>@@ -616,7 +616,7 @@ bool JPEGImageDecoder::outputScanlines()
>     if (buffer.isEmpty()) {
>         if (!buffer.initialize(scaledSize(), m_premultiplyAlpha))
>             return setFailed();
>-        buffer.setDecoding(ImageFrame::Decoding::Partial);
>+        buffer.setDecodingStatus(ImageFrame::DecodingStatus::Partial);
>         // 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);
>@@ -660,7 +660,7 @@ void JPEGImageDecoder::jpegComplete()
>     // empty.
>     ImageFrame& buffer = m_frameBufferCache[0];
>     buffer.setHasAlpha(false);
>-    buffer.setDecoding(ImageFrame::Decoding::Complete);
>+    buffer.setDecodingStatus(ImageFrame::DecodingStatus::Complete);
> }
> 
> void JPEGImageDecoder::decode(bool onlySize)
>diff --git a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>index 1c53b2d5b8625617f57e1c14abe12262aed3f46a..efadab467a2d7b9260b8a7584770004d5235a095 100644
>--- a/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp
>@@ -438,7 +438,7 @@ void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex,
>             }
>         }
> 
>-        buffer.setDecoding(ImageFrame::Decoding::Partial);
>+        buffer.setDecodingStatus(ImageFrame::DecodingStatus::Partial);
>         buffer.setHasAlpha(false);
> 
> #if ENABLE(APNG)
>@@ -546,7 +546,7 @@ void PNGImageDecoder::pngComplete()
>     }
> #endif
>     if (!m_frameBufferCache.isEmpty())
>-        m_frameBufferCache.first().setDecoding(ImageFrame::Decoding::Complete);
>+        m_frameBufferCache.first().setDecodingStatus(ImageFrame::DecodingStatus::Complete);
> }
> 
> void PNGImageDecoder::decode(bool onlySize, unsigned haltAtFrame)
>@@ -813,7 +813,7 @@ void PNGImageDecoder::frameComplete()
>         return;
> 
>     ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
>-    buffer.setDecoding(ImageFrame::Decoding::Complete);
>+    buffer.setDecodingStatus(ImageFrame::DecodingStatus::Complete);
> 
>     png_bytep interlaceBuffer = m_reader->interlaceBuffer();
> 
>diff --git a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>index 4a38f580b201c65277d341aa7dd1549b302f3134..c7d6acdd39f3f088006e140ec236f918622a33ba 100644
>--- a/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>+++ b/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp
>@@ -127,7 +127,7 @@ bool WEBPImageDecoder::decode(bool onlySize)
>     if (buffer.isEmpty()) {
>         if (!buffer.initialize(size(), m_premultiplyAlpha))
>             return setFailed();
>-        buffer.setDecoding(ImageFrame::Decoding::Partial);
>+        buffer.setDecodingStatus(ImageFrame::DecodingStatus::Partial);
>         buffer.setHasAlpha(m_hasAlpha);
>     }
> 
>@@ -145,7 +145,7 @@ bool WEBPImageDecoder::decode(bool onlySize)
> 
>     switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
>     case VP8_STATUS_OK:
>-        buffer.setDecoding(ImageFrame::Decoding::Complete);
>+        buffer.setDecodingStatus(ImageFrame::DecodingStatus::Complete);
>         clear();
>         return true;
>     case VP8_STATUS_SUSPENDED:
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index fc3b4d9da3815dc8ffc9f6b635c91f802e3cef3c..d5e2e0b4f58263fa0d23e58d47a806e942c1501b 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,42 @@
>+2016-10-05  Said Abou-Hallawa  <sabouhallawa@apple.com>
>+
>+        Add SynchronizedFixedQueue class
>+        https://bugs.webkit.org/show_bug.cgi?id=162478
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add a new test for SynchronizedFixedQueue. The test defines a new class
>+        called ToUpperConverter which converts strings from lower case to upper
>+        case. It creates two threads : (1) produce thread and (2) consume thread.
>+        Here is what each thread does:
>+        
>+        1. Main threads: Enqueues lower case strings into m_lowerQueue.
>+        2. Produce thread: Dequeues lower case strings from m_lowerQueue and 
>+           enqueue their upper case strings in the m_upperQueue.
>+        3. Consume thread: Dequeues upper case strings from m_upperQueue.
>+
>+        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
>+        * TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp: Added.
>+        (TestWebKitAPI::textItem): A helper function which returns a lower case string given an index.
>+        (TestWebKitAPI::toUpper): A helper function which Returns the upper case of a string.
>+        (TestWebKitAPI::ToUpperConverter::ToUpperConverter): 
>+        (TestWebKitAPI::ToUpperConverter::produceQueue): Returns a workQueue for the produce thread.
>+        (TestWebKitAPI::ToUpperConverter::consumeQueue): Returns a workQueue for the consume thread.
>+        (TestWebKitAPI::ToUpperConverter::startProducing): Creates a thread for the producer.
>+        (TestWebKitAPI::ToUpperConverter::startConsuming): Creates a thread for the consumer.
>+        (TestWebKitAPI::ToUpperConverter::start): Starts both the producer and the consumer threads.
>+        (TestWebKitAPI::ToUpperConverter::stopProducing): Terminates the producer thread.
>+        (TestWebKitAPI::ToUpperConverter::stopConsuming): Terminates the consumer thread.
>+        (TestWebKitAPI::ToUpperConverter::stop): Terminates both the producer and the consumer threads.
>+        (TestWebKitAPI::ToUpperConverter::enqueue): Adds a lower case string to the m_lowerQueue on the main thread.
>+        (TestWebKitAPI::ToUpperConverter::isProducing): Returns whether the producing thread is active.
>+        (TestWebKitAPI::ToUpperConverter::isConsuming): Returns whether the consuming thread is active.
>+        (TestWebKitAPI::ToUpperConverter::produced): Returns the number of produced elements.
>+        (TestWebKitAPI::ToUpperConverter::consumed): Returns the number of consumed elements.
>+        (TestWebKitAPI::ToUpperConverter::produce): Starts a producer thread.
>+        (TestWebKitAPI::ToUpperConverter::consume): Starts a consumer thread.
>+        (TestWebKitAPI::TEST):
>+
> 2016-10-04  Andy Estes  <aestes@apple.com>
> 
>         [iOS] Crash in WebResourceLoaderQuickLookDelegate when the client cancels the navigation to a QuickLook resource
>diff --git a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>index 6707e8848dffac0616471cf91f3b7074fb59ee1b..e0dcd0a9e305446a550534ac6eef5eaaa45ec0d6 100644
>--- a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>+++ b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>@@ -139,6 +139,7 @@
> 		52E5CE4914D21EAB003B2BD8 /* ParentFrame_Bundle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 52E5CE4814D21EAB003B2BD8 /* ParentFrame_Bundle.cpp */; };
> 		536770341CC8022800D425B1 /* WebScriptObjectDescription.mm in Sources */ = {isa = PBXBuildFile; fileRef = 536770331CC8022800D425B1 /* WebScriptObjectDescription.mm */; };
> 		536770361CC81B6100D425B1 /* WebScriptObjectDescription.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 536770351CC812F900D425B1 /* WebScriptObjectDescription.html */; };
>+		5597F8361D9596C80066BC21 /* SynchronizedFixedQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5597F8341D9596C80066BC21 /* SynchronizedFixedQueue.cpp */; };
> 		5714ECB91CA8B5B000051AC8 /* DownloadRequestOriginalURL.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 5714ECB81CA8B58800051AC8 /* DownloadRequestOriginalURL.html */; };
> 		5714ECBB1CA8BFE400051AC8 /* DownloadRequestOriginalURLFrame.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 5714ECBA1CA8BFD100051AC8 /* DownloadRequestOriginalURLFrame.html */; };
> 		5714ECBD1CA8C22A00051AC8 /* DownloadRequestOriginalURL2.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 5714ECBC1CA8C21800051AC8 /* DownloadRequestOriginalURL2.html */; };
>@@ -910,6 +911,7 @@
> 		52E5CE4814D21EAB003B2BD8 /* ParentFrame_Bundle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ParentFrame_Bundle.cpp; sourceTree = "<group>"; };
> 		536770331CC8022800D425B1 /* WebScriptObjectDescription.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebScriptObjectDescription.mm; sourceTree = "<group>"; };
> 		536770351CC812F900D425B1 /* WebScriptObjectDescription.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = WebScriptObjectDescription.html; sourceTree = "<group>"; };
>+		5597F8341D9596C80066BC21 /* SynchronizedFixedQueue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SynchronizedFixedQueue.cpp; sourceTree = "<group>"; };
> 		5714ECB81CA8B58800051AC8 /* DownloadRequestOriginalURL.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = DownloadRequestOriginalURL.html; sourceTree = "<group>"; };
> 		5714ECBA1CA8BFD100051AC8 /* DownloadRequestOriginalURLFrame.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = DownloadRequestOriginalURLFrame.html; sourceTree = "<group>"; };
> 		5714ECBC1CA8C21800051AC8 /* DownloadRequestOriginalURL2.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = DownloadRequestOriginalURL2.html; sourceTree = "<group>"; };
>@@ -1783,6 +1785,7 @@
> 				26F1B44315CA434F00D1E4BF /* StringImpl.cpp */,
> 				C01363C713C3997300EF3964 /* StringOperators.cpp */,
> 				7C74D42D188228F300E5ED57 /* StringView.cpp */,
>+				5597F8341D9596C80066BC21 /* SynchronizedFixedQueue.cpp */,
> 				0BCD85691485C98B00EA2003 /* TemporaryChange.cpp */,
> 				5C5E633D1D0B67940085A025 /* UniqueRef.cpp */,
> 				7CD0D5AA1D5534DE000CC9E1 /* Variant.cpp */,
>@@ -2276,6 +2279,7 @@
> 				7C83DF361D0A590C00FEBCF3 /* StringHasher.cpp in Sources */,
> 				7C83DF371D0A590C00FEBCF3 /* StringImpl.cpp in Sources */,
> 				7C83DF381D0A590C00FEBCF3 /* StringOperators.cpp in Sources */,
>+				5597F8361D9596C80066BC21 /* SynchronizedFixedQueue.cpp in Sources */,
> 				7C83DF3A1D0A590C00FEBCF3 /* StringView.cpp in Sources */,
> 				7C83DF3D1D0A590C00FEBCF3 /* TemporaryChange.cpp in Sources */,
> 				7C83DF401D0A590C00FEBCF3 /* TestsController.cpp in Sources */,
>diff --git a/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp b/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..7ec767834a489d0b31ac7915f68e3393f5292bc7
>--- /dev/null
>+++ b/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp
>@@ -0,0 +1,223 @@
>+/*
>+ * 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. AND ITS CONTRIBUTORS ``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 ITS 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 <chrono>
>+#include <thread>
>+
>+#include <wtf/ASCIICType.h>
>+#include <wtf/SynchronizedFixedQueue.h>
>+#include <wtf/WorkQueue.h>
>+#include <wtf/text/CString.h>
>+
>+namespace TestWebKitAPI {
>+
>+static char const* textItem(size_t index)
>+{
>+    static char const* items[] = { "first", "second", "third", "fourth", "fifth", "sixth" };
>+    return index < sizeof(items) / sizeof(items[0]) ? items[index] : nullptr;
>+}
>+
>+static CString toUpper(const CString& lower)
>+{
>+    CString upper = lower;
>+
>+    for (char* buffer = upper.mutableData(); *buffer; ++buffer)
>+        *buffer = toASCIIUpper(*buffer);
>+
>+    return upper;
>+}
>+
>+class ToUpperConverter {
>+public:
>+    ToUpperConverter()
>+    {
>+    }
>+
>+    WorkQueue& produceQueue()
>+    {
>+        static auto& queue = WorkQueue::create("org.webkit.Produce").leakRef();
>+        return queue;
>+    }
>+
>+    WorkQueue& consumeQueue()
>+    {
>+        static auto& queue = WorkQueue::create("org.webkit.Consume").leakRef();
>+        return queue;
>+    }
>+
>+    void startProducing()
>+    {
>+        if (!isProducing())
>+            produce();
>+    }
>+
>+    void startConsuming()
>+    {
>+        if (!isConsuming())
>+            consume();
>+    }
>+    
>+    void start()
>+    {
>+        startProducing();
>+        startConsuming();
>+    }
>+
>+    void stopProducing()
>+    {
>+        if (isProducing())
>+            m_lowerQueue.close();
>+    }
>+    
>+    void stopConsuming()
>+    {
>+        if (isConsuming())
>+            m_upperQueue.close();
>+    }
>+    
>+    void stop()
>+    {
>+        stopProducing();
>+        stopConsuming();
>+    }
>+
>+    void enqueue(const CString& lower)
>+    {
>+        m_lowerQueue.enqueue(lower);
>+    }
>+
>+    bool isProducing() { return m_lowerQueue.isRegisteredWorker(this); }
>+    bool isConsuming() { return m_upperQueue.isRegisteredWorker(this); }
>+
>+    size_t produced() const { return m_produced; }
>+    size_t consumed() const { return m_consumed; }
>+
>+private:
>+    void produce()
>+    {
>+        m_lowerQueue.registerWorker(this);
>+
>+        produceQueue().dispatch([this] {
>+            CString lower;
>+            while (m_lowerQueue.dequeue(lower)) {
>+                m_upperQueue.enqueue(toUpper(lower));
>+                EXPECT_TRUE(lower == textItem(m_produced++));
>+                std::this_thread::sleep_for(std::chrono::milliseconds(10));
>+            }
>+            m_lowerQueue.unregisterWorker(this);
>+        });
>+    }
>+
>+    void consume()
>+    {
>+        m_upperQueue.registerWorker(this);
>+        
>+        consumeQueue().dispatch([this] {
>+            CString upper;
>+            while (m_upperQueue.dequeue(upper)) {
>+                EXPECT_TRUE(upper == toUpper(textItem(m_consumed++)));
>+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
>+            }
>+            m_upperQueue.unregisterWorker(this);
>+        });
>+    }
>+
>+    SynchronizedFixedQueue<CString, 4U> m_lowerQueue;
>+    SynchronizedFixedQueue<CString, 4U> m_upperQueue;
>+    size_t m_produced { 0 };
>+    size_t m_consumed { 0 };
>+};
>+
>+TEST(WTF_SynchronizedFixedQueue, Basic)
>+{
>+    ToUpperConverter converter;
>+
>+    converter.start();
>+    EXPECT_TRUE(converter.isProducing() && converter.isConsuming());
>+
>+    converter.stop();
>+    EXPECT_FALSE(converter.isProducing() || converter.isConsuming());
>+
>+    EXPECT_EQ(converter.produced(), 0U);
>+    EXPECT_EQ(converter.consumed(), 0U);
>+}
>+
>+TEST(WTF_SynchronizedFixedQueue, Produce)
>+{
>+    ToUpperConverter converter;
>+    
>+    converter.startProducing();
>+    EXPECT_TRUE(converter.isProducing() && !converter.isConsuming());
>+
>+    size_t count = 0;
>+    while (char const* item = textItem(count)) {
>+        converter.enqueue(item);
>+        ++count;
>+        
>+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
>+    }
>+
>+    converter.stop();
>+    EXPECT_FALSE(converter.isProducing() || converter.isConsuming());
>+}
>+
>+TEST(WTF_SynchronizedFixedQueue, Consume)
>+{
>+    ToUpperConverter converter;
>+    
>+    converter.startConsuming();
>+    EXPECT_TRUE(!converter.isProducing() && converter.isConsuming());
>+    
>+    converter.stop();
>+    EXPECT_FALSE(converter.isProducing() || converter.isConsuming());
>+}
>+
>+TEST(WTF_SynchronizedFixedQueue, Limits)
>+{
>+    ToUpperConverter converter;
>+
>+    converter.start();
>+    EXPECT_TRUE(converter.isProducing() && converter.isConsuming());
>+
>+    size_t count = 0;
>+    while (char const* item = textItem(count)) {
>+        converter.enqueue(item);
>+        ++count;
>+
>+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
>+    }
>+
>+    std::this_thread::sleep_for(std::chrono::milliseconds(400));
>+
>+    converter.stop();
>+    EXPECT_FALSE(converter.isProducing() || converter.isConsuming());
>+    
>+    EXPECT_EQ(converter.produced(), count);
>+    EXPECT_EQ(converter.consumed(), count);
>+}
>+
>+}

Actions: View | Formatted Diff | Diff

Attachments on bug 155546: 274193 | 274194 | 274195 | 274205 | 274209 | 287662 | 287693 | 287695 | 287703 | 287704 | 287707 | 287712 | 287763 | 287768 | 287771 | 287775 | 287789 | 287797 | 287807 | 287816 | 287822 | 290736 | 290737 | 290742 | 290749 | 290750 | 291329 | 291734 | 291735 | 291736 | 291737 | 291738 | 291997 | 292128 | 293839