Changeset 230522 in webkit


Ignore:
Timestamp:
Apr 11, 2018 6:47:26 AM (6 years ago)
Author:
Antti Koivisto
Message:

ImageFrame type used by non-Cocoa image decoder should not be the same as that used by ImageSource
https://bugs.webkit.org/show_bug.cgi?id=184418

Reviewed by Said Abou-Hallawa.

ScalableImageDecoder uses ImageFrame class which is meant to be an implementation detail of ImageSource.
There are bunch of fields and methods in the type that are only used by one or the other client. For hackability
there should be an unrelated frame type for ScalableImageDecoder.

This patch adds ScalableImageDecoderFrame type used in ScalableImageDecoder only. It then cleans up
unneeded things from both ImageFrame and ScalableImageDecoderFrame.

  • platform/ImageDecoders.cmake:
  • platform/graphics/ImageFrame.cpp:

(WebCore::ImageFrame::operator=):
(WebCore::ImageFrame::clearImage):
(WebCore::ImageFrame::size const):
(WebCore::ImageFrame::initialize): Deleted.

  • platform/graphics/ImageFrame.h:

(WebCore::ImageFrame::setDisposalMethod): Deleted.
(WebCore::ImageFrame::disposalMethod const): Deleted.
(WebCore::ImageFrame::backingStore const): Deleted.
(WebCore::ImageFrame::hasBackingStore const): Deleted.

  • platform/image-decoders/ScalableImageDecoder.cpp:

(WebCore::ScalableImageDecoder::frameIsCompleteAtIndex const):
(WebCore::ScalableImageDecoder::frameDurationAtIndex const):
(WebCore::ScalableImageDecoder::createFrameImageAtIndex):

  • platform/image-decoders/ScalableImageDecoder.h:
  • platform/image-decoders/ScalableImageDecoderFrame.cpp: Copied from Source/WebCore/platform/graphics/ImageFrame.cpp.

(WebCore::ScalableImageDecoderFrame::ScalableImageDecoderFrame):
(WebCore::ScalableImageDecoderFrame::~ScalableImageDecoderFrame):
(WebCore::ScalableImageDecoderFrame::operator=):
(WebCore::ScalableImageDecoderFrame::setDecodingStatus):
(WebCore::ScalableImageDecoderFrame::decodingStatus const):
(WebCore::ScalableImageDecoderFrame::clearImage):
(WebCore::ScalableImageDecoderFrame::clear):
(WebCore::ScalableImageDecoderFrame::initialize):
(WebCore::ScalableImageDecoderFrame::size const):
(WebCore::ImageFrame::ImageFrame): Deleted.
(WebCore::ImageFrame::~ImageFrame): Deleted.
(WebCore::ImageFrame::defaultFrame): Deleted.
(WebCore::ImageFrame::operator=): Deleted.
(WebCore::ImageFrame::setDecodingStatus): Deleted.
(WebCore::ImageFrame::decodingStatus const): Deleted.
(WebCore::ImageFrame::clearImage): Deleted.
(WebCore::ImageFrame::clear): Deleted.
(WebCore::ImageFrame::initialize): Deleted.
(WebCore::ImageFrame::size const): Deleted.
(WebCore::ImageFrame::hasNativeImage const): Deleted.
(WebCore::ImageFrame::hasFullSizeNativeImage const): Deleted.
(WebCore::ImageFrame::hasDecodedNativeImageCompatibleWithOptions const): Deleted.
(WebCore::ImageFrame::singlePixelSolidColor const): Deleted.

  • platform/image-decoders/ScalableImageDecoderFrame.h: Copied from Source/WebCore/platform/graphics/ImageFrame.h.

(WebCore::ScalableImageDecoderFrame::ScalableImageDecoderFrame):
(WebCore::ScalableImageDecoderFrame::disposalMethod const):
(WebCore::ScalableImageDecoderFrame::hasAlpha const):
(WebCore::ScalableImageDecoderFrame::hasBackingStore const):
(WebCore::ImageFrame::ImageFrame): Deleted.
(WebCore::ImageFrame::isInvalid const): Deleted.
(WebCore::ImageFrame::isPartial const): Deleted.
(WebCore::ImageFrame::isComplete const): Deleted.
(WebCore::ImageFrame::sizeRespectingOrientation const): Deleted.
(WebCore::ImageFrame::frameBytes const): Deleted.
(WebCore::ImageFrame::subsamplingLevel const): Deleted.
(WebCore::ImageFrame::setDisposalMethod): Deleted.
(WebCore::ImageFrame::disposalMethod const): Deleted.
(WebCore::ImageFrame::nativeImage const): Deleted.
(WebCore::ImageFrame::setOrientation): Deleted.
(WebCore::ImageFrame::orientation const): Deleted.
(WebCore::ImageFrame::setDuration): Deleted.
(WebCore::ImageFrame::duration const): Deleted.
(WebCore::ImageFrame::setHasAlpha): Deleted.
(WebCore::ImageFrame::hasAlpha const): Deleted.
(WebCore::ImageFrame::hasNativeImage): Deleted.
(WebCore::ImageFrame::hasFullSizeNativeImage): Deleted.
(WebCore::ImageFrame::hasMetadata const): Deleted.
(WebCore::ImageFrame::backingStore const): Deleted.
(WebCore::ImageFrame::hasBackingStore const): Deleted.

  • platform/image-decoders/bmp/BMPImageDecoder.cpp:

(WebCore::BMPImageDecoder::frameBufferAtIndex):

  • platform/image-decoders/bmp/BMPImageDecoder.h:
  • platform/image-decoders/bmp/BMPImageReader.h:

(WebCore::BMPImageReader::setBuffer):

  • platform/image-decoders/gif/GIFImageDecoder.cpp:

(WebCore::GIFImageDecoder::findFirstRequiredFrameToDecode):
(WebCore::GIFImageDecoder::frameBufferAtIndex):
(WebCore::GIFImageDecoder::clearFrameBufferCache):
(WebCore::GIFImageDecoder::haveDecodedRow):
(WebCore::GIFImageDecoder::frameComplete):
(WebCore::GIFImageDecoder::initFrameBuffer):

  • platform/image-decoders/gif/GIFImageDecoder.h:
  • platform/image-decoders/gif/GIFImageReader.cpp:

(GIFImageReader::parse):

  • platform/image-decoders/gif/GIFImageReader.h:

(GIFFrameContext::GIFFrameContext):

  • platform/image-decoders/ico/ICOImageDecoder.cpp:

(WebCore::ICOImageDecoder::frameBufferAtIndex):

  • platform/image-decoders/ico/ICOImageDecoder.h:
  • platform/image-decoders/jpeg/JPEGImageDecoder.cpp:

(WebCore::JPEGImageDecoder::frameBufferAtIndex):
(WebCore::setPixel):
(WebCore::JPEGImageDecoder::outputScanlines):
(WebCore::JPEGImageDecoder::jpegComplete):

  • platform/image-decoders/jpeg/JPEGImageDecoder.h:
  • platform/image-decoders/png/PNGImageDecoder.cpp:

(WebCore::PNGImageDecoder::frameBufferAtIndex):
(WebCore::PNGImageDecoder::rowAvailable):
(WebCore::PNGImageDecoder::readChunks):
(WebCore::PNGImageDecoder::clearFrameBufferCache):
(WebCore::PNGImageDecoder::initFrameBuffer):
(WebCore::PNGImageDecoder::frameComplete):

  • platform/image-decoders/png/PNGImageDecoder.h:
  • platform/image-decoders/webp/WEBPImageDecoder.cpp:

(WebCore::WEBPImageDecoder::frameBufferAtIndex):
(WebCore::WEBPImageDecoder::findFirstRequiredFrameToDecode):
(WebCore::WEBPImageDecoder::decodeFrame):
(WebCore::WEBPImageDecoder::initFrameBuffer):
(WebCore::WEBPImageDecoder::applyPostProcessing):
(WebCore::WEBPImageDecoder::clearFrameBufferCache):

  • platform/image-decoders/webp/WEBPImageDecoder.h:
Location:
trunk/Source/WebCore
Files:
21 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r230521 r230522  
     12018-04-11  Antti Koivisto  <antti@apple.com>
     2
     3        ImageFrame type used by non-Cocoa image decoder should not be the same as that used by ImageSource
     4        https://bugs.webkit.org/show_bug.cgi?id=184418
     5
     6        Reviewed by Said Abou-Hallawa.
     7
     8        ScalableImageDecoder uses ImageFrame class which is meant to be an implementation detail of ImageSource.
     9        There are bunch of fields and methods in the type that are only used by one or the other client. For hackability
     10        there should be an unrelated frame type for ScalableImageDecoder.
     11
     12        This patch adds ScalableImageDecoderFrame type used in ScalableImageDecoder only. It then cleans up
     13        unneeded things from both ImageFrame and ScalableImageDecoderFrame.
     14
     15        * platform/ImageDecoders.cmake:
     16        * platform/graphics/ImageFrame.cpp:
     17        (WebCore::ImageFrame::operator=):
     18        (WebCore::ImageFrame::clearImage):
     19        (WebCore::ImageFrame::size const):
     20        (WebCore::ImageFrame::initialize): Deleted.
     21        * platform/graphics/ImageFrame.h:
     22        (WebCore::ImageFrame::setDisposalMethod): Deleted.
     23        (WebCore::ImageFrame::disposalMethod const): Deleted.
     24        (WebCore::ImageFrame::backingStore const): Deleted.
     25        (WebCore::ImageFrame::hasBackingStore const): Deleted.
     26        * platform/image-decoders/ScalableImageDecoder.cpp:
     27        (WebCore::ScalableImageDecoder::frameIsCompleteAtIndex const):
     28        (WebCore::ScalableImageDecoder::frameDurationAtIndex const):
     29        (WebCore::ScalableImageDecoder::createFrameImageAtIndex):
     30        * platform/image-decoders/ScalableImageDecoder.h:
     31        * platform/image-decoders/ScalableImageDecoderFrame.cpp: Copied from Source/WebCore/platform/graphics/ImageFrame.cpp.
     32        (WebCore::ScalableImageDecoderFrame::ScalableImageDecoderFrame):
     33        (WebCore::ScalableImageDecoderFrame::~ScalableImageDecoderFrame):
     34        (WebCore::ScalableImageDecoderFrame::operator=):
     35        (WebCore::ScalableImageDecoderFrame::setDecodingStatus):
     36        (WebCore::ScalableImageDecoderFrame::decodingStatus const):
     37        (WebCore::ScalableImageDecoderFrame::clearImage):
     38        (WebCore::ScalableImageDecoderFrame::clear):
     39        (WebCore::ScalableImageDecoderFrame::initialize):
     40        (WebCore::ScalableImageDecoderFrame::size const):
     41        (WebCore::ImageFrame::ImageFrame): Deleted.
     42        (WebCore::ImageFrame::~ImageFrame): Deleted.
     43        (WebCore::ImageFrame::defaultFrame): Deleted.
     44        (WebCore::ImageFrame::operator=): Deleted.
     45        (WebCore::ImageFrame::setDecodingStatus): Deleted.
     46        (WebCore::ImageFrame::decodingStatus const): Deleted.
     47        (WebCore::ImageFrame::clearImage): Deleted.
     48        (WebCore::ImageFrame::clear): Deleted.
     49        (WebCore::ImageFrame::initialize): Deleted.
     50        (WebCore::ImageFrame::size const): Deleted.
     51        (WebCore::ImageFrame::hasNativeImage const): Deleted.
     52        (WebCore::ImageFrame::hasFullSizeNativeImage const): Deleted.
     53        (WebCore::ImageFrame::hasDecodedNativeImageCompatibleWithOptions const): Deleted.
     54        (WebCore::ImageFrame::singlePixelSolidColor const): Deleted.
     55        * platform/image-decoders/ScalableImageDecoderFrame.h: Copied from Source/WebCore/platform/graphics/ImageFrame.h.
     56        (WebCore::ScalableImageDecoderFrame::ScalableImageDecoderFrame):
     57        (WebCore::ScalableImageDecoderFrame::disposalMethod const):
     58        (WebCore::ScalableImageDecoderFrame::hasAlpha const):
     59        (WebCore::ScalableImageDecoderFrame::hasBackingStore const):
     60        (WebCore::ImageFrame::ImageFrame): Deleted.
     61        (WebCore::ImageFrame::isInvalid const): Deleted.
     62        (WebCore::ImageFrame::isPartial const): Deleted.
     63        (WebCore::ImageFrame::isComplete const): Deleted.
     64        (WebCore::ImageFrame::sizeRespectingOrientation const): Deleted.
     65        (WebCore::ImageFrame::frameBytes const): Deleted.
     66        (WebCore::ImageFrame::subsamplingLevel const): Deleted.
     67        (WebCore::ImageFrame::setDisposalMethod): Deleted.
     68        (WebCore::ImageFrame::disposalMethod const): Deleted.
     69        (WebCore::ImageFrame::nativeImage const): Deleted.
     70        (WebCore::ImageFrame::setOrientation): Deleted.
     71        (WebCore::ImageFrame::orientation const): Deleted.
     72        (WebCore::ImageFrame::setDuration): Deleted.
     73        (WebCore::ImageFrame::duration const): Deleted.
     74        (WebCore::ImageFrame::setHasAlpha): Deleted.
     75        (WebCore::ImageFrame::hasAlpha const): Deleted.
     76        (WebCore::ImageFrame::hasNativeImage): Deleted.
     77        (WebCore::ImageFrame::hasFullSizeNativeImage): Deleted.
     78        (WebCore::ImageFrame::hasMetadata const): Deleted.
     79        (WebCore::ImageFrame::backingStore const): Deleted.
     80        (WebCore::ImageFrame::hasBackingStore const): Deleted.
     81        * platform/image-decoders/bmp/BMPImageDecoder.cpp:
     82        (WebCore::BMPImageDecoder::frameBufferAtIndex):
     83        * platform/image-decoders/bmp/BMPImageDecoder.h:
     84        * platform/image-decoders/bmp/BMPImageReader.h:
     85        (WebCore::BMPImageReader::setBuffer):
     86        * platform/image-decoders/gif/GIFImageDecoder.cpp:
     87        (WebCore::GIFImageDecoder::findFirstRequiredFrameToDecode):
     88        (WebCore::GIFImageDecoder::frameBufferAtIndex):
     89        (WebCore::GIFImageDecoder::clearFrameBufferCache):
     90        (WebCore::GIFImageDecoder::haveDecodedRow):
     91        (WebCore::GIFImageDecoder::frameComplete):
     92        (WebCore::GIFImageDecoder::initFrameBuffer):
     93        * platform/image-decoders/gif/GIFImageDecoder.h:
     94        * platform/image-decoders/gif/GIFImageReader.cpp:
     95        (GIFImageReader::parse):
     96        * platform/image-decoders/gif/GIFImageReader.h:
     97        (GIFFrameContext::GIFFrameContext):
     98        * platform/image-decoders/ico/ICOImageDecoder.cpp:
     99        (WebCore::ICOImageDecoder::frameBufferAtIndex):
     100        * platform/image-decoders/ico/ICOImageDecoder.h:
     101        * platform/image-decoders/jpeg/JPEGImageDecoder.cpp:
     102        (WebCore::JPEGImageDecoder::frameBufferAtIndex):
     103        (WebCore::setPixel):
     104        (WebCore::JPEGImageDecoder::outputScanlines):
     105        (WebCore::JPEGImageDecoder::jpegComplete):
     106        * platform/image-decoders/jpeg/JPEGImageDecoder.h:
     107        * platform/image-decoders/png/PNGImageDecoder.cpp:
     108        (WebCore::PNGImageDecoder::frameBufferAtIndex):
     109        (WebCore::PNGImageDecoder::rowAvailable):
     110        (WebCore::PNGImageDecoder::readChunks):
     111        (WebCore::PNGImageDecoder::clearFrameBufferCache):
     112        (WebCore::PNGImageDecoder::initFrameBuffer):
     113        (WebCore::PNGImageDecoder::frameComplete):
     114        * platform/image-decoders/png/PNGImageDecoder.h:
     115        * platform/image-decoders/webp/WEBPImageDecoder.cpp:
     116        (WebCore::WEBPImageDecoder::frameBufferAtIndex):
     117        (WebCore::WEBPImageDecoder::findFirstRequiredFrameToDecode):
     118        (WebCore::WEBPImageDecoder::decodeFrame):
     119        (WebCore::WEBPImageDecoder::initFrameBuffer):
     120        (WebCore::WEBPImageDecoder::applyPostProcessing):
     121        (WebCore::WEBPImageDecoder::clearFrameBufferCache):
     122        * platform/image-decoders/webp/WEBPImageDecoder.h:
     123
    11242018-04-11  Antoine Quint  <graouts@apple.com>
    2125
  • trunk/Source/WebCore/platform/ImageDecoders.cmake

    r228451 r230522  
    1111list(APPEND WebCore_SOURCES
    1212    platform/image-decoders/ScalableImageDecoder.cpp
     13    platform/image-decoders/ScalableImageDecoderFrame.cpp
    1314
    1415    platform/image-decoders/bmp/BMPImageDecoder.cpp
  • trunk/Source/WebCore/platform/graphics/ImageFrame.cpp

    r225616 r230522  
    5454    m_size = other.m_size;
    5555
    56 #if !USE(CG)
    57     if (other.backingStore())
    58         initialize(*other.backingStore());
    59     else
    60         m_backingStore = nullptr;
    61     m_disposalMethod = other.m_disposalMethod;
    62 #endif
    63 
    6456    m_nativeImage = other.m_nativeImage;
    6557    m_subsamplingLevel = other.m_subsamplingLevel;
     
    8678unsigned ImageFrame::clearImage()
    8779{
    88 #if !USE(CG)
    89     if (hasBackingStore())
    90         m_backingStore = nullptr;
    91 #endif
    92 
    9380    if (!hasNativeImage())
    9481        return 0;
     
    11097}
    11198
    112 #if !USE(CG)
    113 bool ImageFrame::initialize(const ImageBackingStore& backingStore)
    114 {
    115     if (&backingStore == this->backingStore())
    116         return true;
    117 
    118     m_backingStore = ImageBackingStore::create(backingStore);
    119     return m_backingStore != nullptr;
    120 }
    121 
    122 bool ImageFrame::initialize(const IntSize& size, bool premultiplyAlpha)
    123 {
    124     if (size.isEmpty())
    125         return false;
    126 
    127     m_backingStore = ImageBackingStore::create(size, premultiplyAlpha);
    128     return m_backingStore != nullptr;
    129 }
    130 #endif
    131 
    13299IntSize ImageFrame::size() const
    133100{
    134 #if !USE(CG)
    135     if (hasBackingStore())
    136         return backingStore()->size();
    137 #endif
    138101    return m_size;
    139102}
  • trunk/Source/WebCore/platform/graphics/ImageFrame.h

    r228974 r230522  
    5454    unsigned clear();
    5555
    56 #if !USE(CG)
    57     bool initialize(const ImageBackingStore&);
    58     bool initialize(const IntSize&, bool premultiplyAlpha);
    59 #endif
    60 
    6156    void setDecodingStatus(DecodingStatus);
    6257    DecodingStatus decodingStatus() const;
     
    7065    unsigned frameBytes() const { return hasNativeImage() ? (size().area() * sizeof(uint32_t)).unsafeGet() : 0; }
    7166    SubsamplingLevel subsamplingLevel() const { return m_subsamplingLevel; }
    72 
    73 #if !USE(CG)
    74     enum class DisposalMethod { Unspecified, DoNotDispose, RestoreToBackground, RestoreToPrevious };
    75     void setDisposalMethod(DisposalMethod method) { m_disposalMethod = method; }
    76     DisposalMethod disposalMethod() const { return m_disposalMethod; }
    77 #endif
    7867
    7968    NativeImagePtr nativeImage() const { return m_nativeImage; }
     
    9382    bool hasMetadata() const { return !size().isEmpty(); }
    9483
    95 #if !USE(CG)
    96     ImageBackingStore* backingStore() const { return m_backingStore ? m_backingStore.get() : nullptr; }
    97     bool hasBackingStore() const { return backingStore(); }
    98 #endif
    99 
    10084    Color singlePixelSolidColor() const;
    10185
     
    10387    DecodingStatus m_decodingStatus { DecodingStatus::Invalid };
    10488    IntSize m_size;
    105 
    106 #if !USE(CG)
    107     std::unique_ptr<ImageBackingStore> m_backingStore;
    108     DisposalMethod m_disposalMethod { DisposalMethod::Unspecified };
    109 #endif
    11089
    11190    NativeImagePtr m_nativeImage;
  • trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoder.cpp

    r228974 r230522  
    177177    // operation to succeed should not require decoding the entire frame.
    178178    // This function should be implementable in a way that allows const.
    179     ImageFrame* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
     179    auto* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
    180180    return buffer && buffer->isComplete();
    181181}
     
    206206    // the entire frame. This function should be implementable in a way that
    207207    // allows const.
    208     ImageFrame* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
     208    auto* buffer = const_cast<ScalableImageDecoder*>(this)->frameBufferAtIndex(index);
    209209    if (!buffer || buffer->isInvalid())
    210210        return 0_s;
     
    226226        return nullptr;
    227227
    228     ImageFrame* buffer = frameBufferAtIndex(index);
     228    auto* buffer = frameBufferAtIndex(index);
    229229    if (!buffer || buffer->isInvalid() || !buffer->hasBackingStore())
    230230        return nullptr;
  • trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoder.h

    r225616 r230522  
    3030
    3131#include "ImageDecoder.h"
    32 #include "ImageFrame.h"
    3332#include "IntRect.h"
     33#include "ScalableImageDecoderFrame.h"
    3434#include "SharedBuffer.h"
    3535#include <wtf/Assertions.h>
     
    4242
    4343// ScalableImageDecoder is a base for all format-specific decoders
    44 // (e.g. JPEGImageDecoder). This base manages the ImageFrame cache.
     44// (e.g. JPEGImageDecoder). This base manages the ScalableImageDecoderFrame cache.
    4545
    4646class ScalableImageDecoder : public ImageDecoder {
     
    135135    // Decodes as much of the requested frame as possible, and returns an
    136136    // ScalableImageDecoder-owned pointer.
    137     virtual ImageFrame* frameBufferAtIndex(size_t) = 0;
     137    virtual ScalableImageDecoderFrame* frameBufferAtIndex(size_t) = 0;
    138138
    139139    bool frameIsCompleteAtIndex(size_t) const override;
     
    206206
    207207    RefPtr<SharedBuffer> m_data; // The encoded data.
    208     Vector<ImageFrame, 1> m_frameBufferCache;
     208    Vector<ScalableImageDecoderFrame, 1> m_frameBufferCache;
    209209    mutable Lock m_mutex;
    210210    bool m_scaled { false };
  • trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoderFrame.cpp

    r230521 r230522  
    2525
    2626#include "config.h"
    27 #include "ImageFrame.h"
     27#include "ScalableImageDecoderFrame.h"
    2828
    2929#include <wtf/NeverDestroyed.h>
     
    3131namespace WebCore {
    3232
    33 ImageFrame::ImageFrame()
     33ScalableImageDecoderFrame::ScalableImageDecoderFrame()
    3434{
    3535}
    3636
    37 ImageFrame::~ImageFrame()
     37ScalableImageDecoderFrame::~ScalableImageDecoderFrame()
    3838{
    39     clearImage();
    4039}
    4140
    42 const ImageFrame& ImageFrame::defaultFrame()
    43 {
    44     static NeverDestroyed<ImageFrame> sharedInstance;
    45     return sharedInstance;
    46 }
    47 
    48 ImageFrame& ImageFrame::operator=(const ImageFrame& other)
     41ScalableImageDecoderFrame& ScalableImageDecoderFrame::operator=(const ScalableImageDecoderFrame& other)
    4942{
    5043    if (this == &other)
     
    5245
    5346    m_decodingStatus = other.m_decodingStatus;
    54     m_size = other.m_size;
    5547
    56 #if !USE(CG)
    5748    if (other.backingStore())
    5849        initialize(*other.backingStore());
     
    6051        m_backingStore = nullptr;
    6152    m_disposalMethod = other.m_disposalMethod;
    62 #endif
    63 
    64     m_nativeImage = other.m_nativeImage;
    65     m_subsamplingLevel = other.m_subsamplingLevel;
    66     m_decodingOptions = other.m_decodingOptions;
    6753
    6854    m_orientation = other.m_orientation;
     
    7258}
    7359
    74 void ImageFrame::setDecodingStatus(DecodingStatus decodingStatus)
     60void ScalableImageDecoderFrame::setDecodingStatus(DecodingStatus decodingStatus)
    7561{
    7662    ASSERT(decodingStatus != DecodingStatus::Decoding);
     
    7864}
    7965
    80 DecodingStatus ImageFrame::decodingStatus() const
     66DecodingStatus ScalableImageDecoderFrame::decodingStatus() const
    8167{
    8268    ASSERT(m_decodingStatus != DecodingStatus::Decoding);
     
    8470}
    8571
    86 unsigned ImageFrame::clearImage()
     72void ScalableImageDecoderFrame::clear()
    8773{
    88 #if !USE(CG)
    89     if (hasBackingStore())
    90         m_backingStore = nullptr;
    91 #endif
    92 
    93     if (!hasNativeImage())
    94         return 0;
    95 
    96     unsigned frameBytes = this->frameBytes();
    97 
    98     clearNativeImageSubimages(m_nativeImage);
    99     m_nativeImage = nullptr;
    100     m_decodingOptions = DecodingOptions();
    101 
    102     return frameBytes;
     74    *this = ScalableImageDecoderFrame();
    10375}
    10476
    105 unsigned ImageFrame::clear()
    106 {
    107     unsigned frameBytes = clearImage();
    108     *this = ImageFrame();
    109     return frameBytes;
    110 }
    111 
    112 #if !USE(CG)
    113 bool ImageFrame::initialize(const ImageBackingStore& backingStore)
     77bool ScalableImageDecoderFrame::initialize(const ImageBackingStore& backingStore)
    11478{
    11579    if (&backingStore == this->backingStore())
     
    12084}
    12185
    122 bool ImageFrame::initialize(const IntSize& size, bool premultiplyAlpha)
     86bool ScalableImageDecoderFrame::initialize(const IntSize& size, bool premultiplyAlpha)
    12387{
    12488    if (size.isEmpty())
     
    12892    return m_backingStore != nullptr;
    12993}
    130 #endif
    13194
    132 IntSize ImageFrame::size() const
     95IntSize ScalableImageDecoderFrame::size() const
    13396{
    134 #if !USE(CG)
    13597    if (hasBackingStore())
    13698        return backingStore()->size();
    137 #endif
    138     return m_size;
    139 }
    140    
    141 bool ImageFrame::hasNativeImage(const std::optional<SubsamplingLevel>& subsamplingLevel) const
    142 {
    143     return m_nativeImage && (!subsamplingLevel || *subsamplingLevel >= m_subsamplingLevel);
    144 }
    145 
    146 bool ImageFrame::hasFullSizeNativeImage(const std::optional<SubsamplingLevel>& subsamplingLevel) const
    147 {
    148     return hasNativeImage(subsamplingLevel) && (m_decodingOptions.isSynchronous() || m_decodingOptions.hasFullSize());
    149 }
    150 
    151 bool ImageFrame::hasDecodedNativeImageCompatibleWithOptions(const std::optional<SubsamplingLevel>& subsamplingLevel, const DecodingOptions& decodingOptions) const
    152 {
    153     return hasNativeImage(subsamplingLevel) && m_decodingOptions.isAsynchronousCompatibleWith(decodingOptions);
    154 }
    155 
    156 Color ImageFrame::singlePixelSolidColor() const
    157 {
    158     if (!hasNativeImage() || m_size != IntSize(1, 1))
    159         return Color();
    160 
    161     return nativeImageSinglePixelSolidColor(m_nativeImage);
     99    return { };
    162100}
    163101
  • trunk/Source/WebCore/platform/image-decoders/ScalableImageDecoderFrame.h

    r230521 r230522  
    3737namespace WebCore {
    3838
    39 class ImageFrame {
    40     friend class ImageSource;
     39class ScalableImageDecoderFrame {
    4140public:
    42     enum class Caching { Metadata, MetadataAndImage };
     41    ScalableImageDecoderFrame();
     42    ScalableImageDecoderFrame(const ScalableImageDecoderFrame& other) { operator=(other); }
    4343
    44     ImageFrame();
    45     ImageFrame(const ImageFrame& other) { operator=(other); }
     44    ~ScalableImageDecoderFrame();
    4645
    47     ~ImageFrame();
     46    ScalableImageDecoderFrame& operator=(const ScalableImageDecoderFrame& other);
    4847
    49     static const ImageFrame& defaultFrame();
     48    void clear();
    5049
    51     ImageFrame& operator=(const ImageFrame& other);
    52 
    53     unsigned clearImage();
    54     unsigned clear();
    55 
    56 #if !USE(CG)
    5750    bool initialize(const ImageBackingStore&);
    5851    bool initialize(const IntSize&, bool premultiplyAlpha);
    59 #endif
    6052
    6153    void setDecodingStatus(DecodingStatus);
     
    6759
    6860    IntSize size() const;
    69     IntSize sizeRespectingOrientation() const { return !m_orientation.usesWidthAsHeight() ? size() : size().transposedSize(); }
    70     unsigned frameBytes() const { return hasNativeImage() ? (size().area() * sizeof(uint32_t)).unsafeGet() : 0; }
    71     SubsamplingLevel subsamplingLevel() const { return m_subsamplingLevel; }
    7261
    73 #if !USE(CG)
    7462    enum class DisposalMethod { Unspecified, DoNotDispose, RestoreToBackground, RestoreToPrevious };
    7563    void setDisposalMethod(DisposalMethod method) { m_disposalMethod = method; }
    7664    DisposalMethod disposalMethod() const { return m_disposalMethod; }
    77 #endif
    78 
    79     NativeImagePtr nativeImage() const { return m_nativeImage; }
    8065
    8166    void setOrientation(ImageOrientation orientation) { m_orientation = orientation; };
     
    8772    void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
    8873    bool hasAlpha() const { return !hasMetadata() || m_hasAlpha; }
    89 
    90     bool hasNativeImage(const std::optional<SubsamplingLevel>& = { }) const;
    91     bool hasFullSizeNativeImage(const std::optional<SubsamplingLevel>& = { }) const;
    92     bool hasDecodedNativeImageCompatibleWithOptions(const std::optional<SubsamplingLevel>&, const DecodingOptions&) const;
    9374    bool hasMetadata() const { return !size().isEmpty(); }
    9475
    95 #if !USE(CG)
    9676    ImageBackingStore* backingStore() const { return m_backingStore ? m_backingStore.get() : nullptr; }
    9777    bool hasBackingStore() const { return backingStore(); }
    98 #endif
    99 
    100     Color singlePixelSolidColor() const;
    10178
    10279private:
    10380    DecodingStatus m_decodingStatus { DecodingStatus::Invalid };
    104     IntSize m_size;
    10581
    106 #if !USE(CG)
    10782    std::unique_ptr<ImageBackingStore> m_backingStore;
    10883    DisposalMethod m_disposalMethod { DisposalMethod::Unspecified };
    109 #endif
    110 
    111     NativeImagePtr m_nativeImage;
    112     SubsamplingLevel m_subsamplingLevel { SubsamplingLevel::Default };
    113     DecodingOptions m_decodingOptions;
    11484
    11585    ImageOrientation m_orientation { DefaultImageOrientation };
  • trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.cpp

    r222151 r230522  
    5757}
    5858
    59 ImageFrame* BMPImageDecoder::frameBufferAtIndex(size_t index)
     59ScalableImageDecoderFrame* BMPImageDecoder::frameBufferAtIndex(size_t index)
    6060{
    6161    if (index)
     
    6565        m_frameBufferCache.grow(1);
    6666
    67     ImageFrame* buffer = &m_frameBufferCache.first();
     67    auto* buffer = &m_frameBufferCache.first();
    6868    if (!buffer->isComplete())
    6969        decode(false, isAllDataReceived());
  • trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageDecoder.h

    r222151 r230522  
    4646    String filenameExtension() const final { return ASCIILiteral("bmp"); }
    4747    void setData(SharedBuffer&, bool allDataReceived) final;
    48     ImageFrame* frameBufferAtIndex(size_t index) final;
     48    ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) final;
    4949    // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid
    5050    // accessing deleted memory, especially when calling this from inside
  • trunk/Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h

    r222151 r230522  
    6565    // |parent| is the decoder that owns us.
    6666    // |startOffset| points to the start of the BMP within the file.
    67     // |buffer| points at an empty ImageFrame that we'll initialize and
     67    // |buffer| points at an empty ScalableImageDecoderFrame that we'll initialize and
    6868    // fill with decoded data.
    6969    BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);
    7070
    71     void setBuffer(ImageFrame* buffer) { m_buffer = buffer; }
     71    void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }
    7272    void setData(SharedBuffer* data) { m_data = data; }
    7373
     
    270270
    271271    // The destination for the pixel data.
    272     ImageFrame* m_buffer;
     272    ScalableImageDecoderFrame* m_buffer;
    273273
    274274    // The file to decode.
  • trunk/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.cpp

    r228974 r230522  
    107107
    108108    for (size_t i = frameIndex; i > 0; --i) {
    109         ImageFrame& frame = m_frameBufferCache[i - 1];
     109        auto& frame = m_frameBufferCache[i - 1];
    110110
    111111        // Frames with disposal method RestoreToPrevious are useless, skip them.
    112         if (frame.disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)
     112        if (frame.disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious)
    113113            continue;
    114114
     
    120120        // If the disposal method of this frame is RestoreToBackground and it fills the whole area,
    121121        // the next frame's backing store is initialized to transparent, so we start decoding with it.
    122         if (frame.disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) {
     122        if (frame.disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground) {
    123123            // We cannot use frame.backingStore()->frameRect() here, because it has been cleared
    124124            // when the frame was removed from the cache. We need to get the values from the
     
    138138}
    139139
    140 ImageFrame* GIFImageDecoder::frameBufferAtIndex(size_t index)
     140ScalableImageDecoderFrame* GIFImageDecoder::frameBufferAtIndex(size_t index)
    141141{
    142142    if (index >= frameCount())
    143143        return 0;
    144144
    145     ImageFrame& frame = m_frameBufferCache[index];
     145    auto& frame = m_frameBufferCache[index];
    146146    if (!frame.isComplete()) {
    147147        for (auto i = findFirstRequiredFrameToDecode(index); i <= index; i++)
     
    174174    // this case.
    175175    clearBeforeFrame = std::min(clearBeforeFrame, m_frameBufferCache.size() - 1);
    176     const Vector<ImageFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
     176    const Vector<ScalableImageDecoderFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
    177177
    178178    // We need to preserve frames such that:
     
    194194    //     has a disposal method other than DisposalMethod::RestoreToPrevious, stop
    195195    //     scanning, as we'll only need this frame when decoding the next one.
    196     Vector<ImageFrame>::iterator i(end);
    197     for (; (i != m_frameBufferCache.begin()) && (i->isInvalid() || (i->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)); --i) {
     196    Vector<ScalableImageDecoderFrame>::iterator i(end);
     197    for (; (i != m_frameBufferCache.begin()) && (i->isInvalid() || (i->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious)); --i) {
    198198        if (i->isComplete() && (i != end))
    199199            i->clear();
     
    201201
    202202    // Now |i| holds the last frame we need to preserve; clear prior frames.
    203     for (Vector<ImageFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
     203    for (Vector<ScalableImageDecoderFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
    204204        ASSERT(!j->isPartial());
    205205        if (!j->isInvalid())
     
    238238
    239239    // Initialize the frame if necessary.
    240     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     240    auto& buffer = m_frameBufferCache[frameIndex];
    241241    if ((buffer.isInvalid() && !initFrameBuffer(frameIndex)) || !buffer.hasBackingStore())
    242242        return false;
     
    271271}
    272272
    273 bool GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration, ImageFrame::DisposalMethod disposalMethod)
     273bool GIFImageDecoder::frameComplete(unsigned frameIndex, unsigned frameDuration, ScalableImageDecoderFrame::DisposalMethod disposalMethod)
    274274{
    275275    // Initialize the frame if necessary.  Some GIFs insert do-nothing frames,
    276276    // in which case we never reach haveDecodedRow() before getting here.
    277     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     277    auto& buffer = m_frameBufferCache[frameIndex];
    278278    if (buffer.isInvalid() && !initFrameBuffer(frameIndex))
    279279        return false; // initFrameBuffer() has already called setFailed().
     
    299299            // don't affect the start state of this frame) the same way we do in
    300300            // initFrameBuffer().
    301             const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
    302             while (frameIndex && (prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious))
     301            const auto* prevBuffer = &m_frameBufferCache[--frameIndex];
     302            while (frameIndex && (prevBuffer->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious))
    303303                prevBuffer = &m_frameBufferCache[--frameIndex];
    304304
     
    312312            // rect, we know the current frame has no alpha.
    313313            IntRect prevRect = prevBuffer->backingStore()->frameRect();
    314             if ((prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
     314            if ((prevBuffer->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
    315315                buffer.setHasAlpha(false);
    316316        }
     
    371371    const GIFFrameContext* frameContext = m_reader->frameContext();
    372372    IntRect frameRect(frameContext->xOffset, frameContext->yOffset, frameContext->width, frameContext->height);
    373     ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
     373    auto* const buffer = &m_frameBufferCache[frameIndex];
    374374
    375375    if (!frameIndex) {
     
    386386        // first frame specifies this method, it will get treated like
    387387        // DisposalMethod::RestoreToBackground below and reset to a completely empty image.)
    388         const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
    389         ImageFrame::DisposalMethod prevMethod = prevBuffer->disposalMethod();
    390         while (frameIndex && (prevMethod == ImageFrame::DisposalMethod::RestoreToPrevious)) {
     388        const auto* prevBuffer = &m_frameBufferCache[--frameIndex];
     389        auto prevMethod = prevBuffer->disposalMethod();
     390        while (frameIndex && (prevMethod == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious)) {
    391391            prevBuffer = &m_frameBufferCache[--frameIndex];
    392392            prevMethod = prevBuffer->disposalMethod();
     
    395395        ASSERT(prevBuffer->isComplete());
    396396
    397         if ((prevMethod == ImageFrame::DisposalMethod::Unspecified) || (prevMethod == ImageFrame::DisposalMethod::DoNotDispose)) {
     397        if ((prevMethod == ScalableImageDecoderFrame::DisposalMethod::Unspecified) || (prevMethod == ScalableImageDecoderFrame::DisposalMethod::DoNotDispose)) {
    398398            // Preserve the last frame as the starting state for this frame.
    399399            if (!prevBuffer->backingStore() || !buffer->initialize(*prevBuffer->backingStore()))
  • trunk/Source/WebCore/platform/image-decoders/gif/GIFImageDecoder.h

    r222910 r230522  
    5151    size_t frameCount() const final;
    5252    RepetitionCount repetitionCount() const final;
    53     ImageFrame* frameBufferAtIndex(size_t index) final;
     53    ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) final;
    5454    // CAUTION: setFailed() deletes |m_reader|. Be careful to avoid
    5555    // accessing deleted memory, especially when calling this from inside
     
    6060    // Callbacks from the GIF reader.
    6161    bool haveDecodedRow(unsigned frameIndex, const Vector<unsigned char>& rowBuffer, size_t width, size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels);
    62     bool frameComplete(unsigned frameIndex, unsigned frameDuration, ImageFrame::DisposalMethod);
     62    bool frameComplete(unsigned frameIndex, unsigned frameDuration, ScalableImageDecoderFrame::DisposalMethod);
    6363    void gifComplete();
    6464
  • trunk/Source/WebCore/platform/image-decoders/gif/GIFImageReader.cpp

    r222910 r230522  
    577577            // matching those in the GIF spec!
    578578            int disposalMethod = ((*currentComponent) >> 2) & 0x7;
    579             currentFrame->disposalMethod = static_cast<WebCore::ImageFrame::DisposalMethod>(disposalMethod);
     579            currentFrame->disposalMethod = static_cast<WebCore::ScalableImageDecoderFrame::DisposalMethod>(disposalMethod);
    580580            // Some specs say that disposal method 3 is "overwrite previous", others that setting
    581581            // the third bit of the field (i.e. method 4) is. We map both to the same value.
    582582            if (disposalMethod == 4)
    583                 currentFrame->disposalMethod = WebCore::ImageFrame::DisposalMethod::RestoreToPrevious;
     583                currentFrame->disposalMethod = WebCore::ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious;
    584584            currentFrame->delayTime = GETINT16(currentComponent + 1) * 10;
    585585            GETN(1, GIFConsumeBlock);
  • trunk/Source/WebCore/platform/image-decoders/gif/GIFImageReader.h

    r223794 r230522  
    155155    unsigned height;
    156156    int tpixel; // Index of transparent pixel.
    157     WebCore::ImageFrame::DisposalMethod disposalMethod; // Restore to background, leave in place, etc.
     157    WebCore::ScalableImageDecoderFrame::DisposalMethod disposalMethod; // Restore to background, leave in place, etc.
    158158    size_t localColormapPosition; // Per-image colormap.
    159159    int localColormapSize; // Size of local colormap array.
     
    174174        , height(0)
    175175        , tpixel(0)
    176         , disposalMethod(WebCore::ImageFrame::DisposalMethod::Unspecified)
     176        , disposalMethod(WebCore::ScalableImageDecoderFrame::DisposalMethod::Unspecified)
    177177        , localColormapPosition(0)
    178178        , localColormapSize(0)
  • trunk/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.cpp

    r223728 r230522  
    9191}
    9292
    93 ImageFrame* ICOImageDecoder::frameBufferAtIndex(size_t index)
     93ScalableImageDecoderFrame* ICOImageDecoder::frameBufferAtIndex(size_t index)
    9494{
    9595    // Ensure |index| is valid.
     
    9797        return 0;
    9898
    99     ImageFrame* buffer = &m_frameBufferCache[index];
     99    auto* buffer = &m_frameBufferCache[index];
    100100    if (!buffer->isComplete())
    101101        decode(index, false, isAllDataReceived());
  • trunk/Source/WebCore/platform/image-decoders/ico/ICOImageDecoder.h

    r222151 r230522  
    5252    bool setSize(const IntSize&) final;
    5353    size_t frameCount() const final;
    54     ImageFrame* frameBufferAtIndex(size_t) final;
     54    ScalableImageDecoderFrame* frameBufferAtIndex(size_t) final;
    5555    // CAUTION: setFailed() deletes all readers and decoders. Be careful to
    5656    // avoid accessing deleted memory, especially when calling this from
  • trunk/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

    r228974 r230522  
    512512}
    513513
    514 ImageFrame* JPEGImageDecoder::frameBufferAtIndex(size_t index)
     514ScalableImageDecoderFrame* JPEGImageDecoder::frameBufferAtIndex(size_t index)
    515515{
    516516    if (index)
     
    520520        m_frameBufferCache.grow(1);
    521521
    522     ImageFrame& frame = m_frameBufferCache[0];
     522    auto& frame = m_frameBufferCache[0];
    523523    if (!frame.isComplete())
    524524        decode(false, isAllDataReceived());
     
    533533
    534534template <J_COLOR_SPACE colorSpace>
    535 void setPixel(ImageFrame& buffer, uint32_t* currentAddress, JSAMPARRAY samples, int column)
     535void setPixel(ScalableImageDecoderFrame& buffer, uint32_t* currentAddress, JSAMPARRAY samples, int column)
    536536{
    537537    JSAMPLE* jsample = *samples + column * (colorSpace == JCS_RGB ? 3 : 4);
     
    558558
    559559template <J_COLOR_SPACE colorSpace, bool isScaled>
    560 bool JPEGImageDecoder::outputScanlines(ImageFrame& buffer)
     560bool JPEGImageDecoder::outputScanlines(ScalableImageDecoderFrame& buffer)
    561561{
    562562    JSAMPARRAY samples = m_reader->samples();
     
    586586
    587587template <J_COLOR_SPACE colorSpace>
    588 bool JPEGImageDecoder::outputScanlines(ImageFrame& buffer)
     588bool JPEGImageDecoder::outputScanlines(ScalableImageDecoderFrame& buffer)
    589589{
    590590    return m_scaled ? outputScanlines<colorSpace, true>(buffer) : outputScanlines<colorSpace, false>(buffer);
     
    597597
    598598    // Initialize the framebuffer if needed.
    599     ImageFrame& buffer = m_frameBufferCache[0];
     599    auto& buffer = m_frameBufferCache[0];
    600600    if (buffer.isInvalid()) {
    601601        if (!buffer.initialize(scaledSize(), m_premultiplyAlpha))
     
    643643    // Hand back an appropriately sized buffer, even if the image ended up being
    644644    // empty.
    645     ImageFrame& buffer = m_frameBufferCache[0];
     645    auto& buffer = m_frameBufferCache[0];
    646646    buffer.setHasAlpha(false);
    647647    buffer.setDecodingStatus(DecodingStatus::Complete);
  • trunk/Source/WebCore/platform/image-decoders/jpeg/JPEGImageDecoder.h

    r222151 r230522  
    5454        String filenameExtension() const override { return ASCIILiteral("jpg"); }
    5555        bool setSize(const IntSize&) override;
    56         ImageFrame* frameBufferAtIndex(size_t index) override;
     56        ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;
    5757        // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
    5858        // accessing deleted memory, especially when calling this from inside
     
    8181
    8282        template <J_COLOR_SPACE colorSpace>
    83         bool outputScanlines(ImageFrame& buffer);
     83        bool outputScanlines(ScalableImageDecoderFrame& buffer);
    8484
    8585        template <J_COLOR_SPACE colorSpace, bool isScaled>
    86         bool outputScanlines(ImageFrame& buffer);
     86        bool outputScanlines(ScalableImageDecoderFrame& buffer);
    8787
    8888        std::unique_ptr<JPEGImageReader> m_reader;
  • trunk/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.cpp

    r229309 r230522  
    254254}
    255255
    256 ImageFrame* PNGImageDecoder::frameBufferAtIndex(size_t index)
     256ScalableImageDecoderFrame* PNGImageDecoder::frameBufferAtIndex(size_t index)
    257257{
    258258#if ENABLE(APNG)
     
    270270        m_frameBufferCache.grow(1);
    271271
    272     ImageFrame& frame = m_frameBufferCache[index];
     272    auto& frame = m_frameBufferCache[index];
    273273    if (!frame.isComplete())
    274274        decode(false, index, isAllDataReceived());
     
    429429        return;
    430430#endif
    431     ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
     431    auto& buffer = m_frameBufferCache[m_currentFrame];
    432432    if (buffer.isInvalid()) {
    433433        png_structp png = m_reader->pngPtr();
     
    633633
    634634        if (m_currentFrame < m_frameBufferCache.size()) {
    635             ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
     635            auto& buffer = m_frameBufferCache[m_currentFrame];
    636636
    637637            if (!m_delayDenominator)
     
    641641
    642642            if (m_dispose == 2)
    643                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::RestoreToPrevious);
     643                buffer.setDisposalMethod(ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious);
    644644            else if (m_dispose == 1)
    645                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::RestoreToBackground);
     645                buffer.setDisposalMethod(ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground);
    646646            else
    647                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::DoNotDispose);
     647                buffer.setDisposalMethod(ScalableImageDecoderFrame::DisposalMethod::DoNotDispose);
    648648        }
    649649
     
    725725    // See GIFImageDecoder for full explanation.
    726726    clearBeforeFrame = std::min(clearBeforeFrame, m_frameBufferCache.size() - 1);
    727     const Vector<ImageFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
    728 
    729     Vector<ImageFrame>::iterator i(end);
    730     for (; (i != m_frameBufferCache.begin()) && (i->isInvalid() || (i->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)); --i) {
     727    const Vector<ScalableImageDecoderFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
     728
     729    Vector<ScalableImageDecoderFrame>::iterator i(end);
     730    for (; (i != m_frameBufferCache.begin()) && (i->isInvalid() || (i->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious)); --i) {
    731731        if (i->isComplete() && (i != end))
    732732            i->clear();
     
    734734
    735735    // Now |i| holds the last frame we need to preserve; clear prior frames.
    736     for (Vector<ImageFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
     736    for (Vector<ScalableImageDecoderFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
    737737        ASSERT(!j->isPartial());
    738738        if (j->isInvalid())
     
    746746        return;
    747747
    748     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     748    auto& buffer = m_frameBufferCache[frameIndex];
    749749
    750750    // The starting state for this frame depends on the previous frame's
     
    756756    // first frame specifies this method, it will get treated like
    757757    // DisposeOverwriteBgcolor below and reset to a completely empty image.)
    758     const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
    759     ImageFrame::DisposalMethod prevMethod = prevBuffer->disposalMethod();
    760     while (frameIndex && (prevMethod == ImageFrame::DisposalMethod::RestoreToPrevious)) {
     758    const auto* prevBuffer = &m_frameBufferCache[--frameIndex];
     759    auto prevMethod = prevBuffer->disposalMethod();
     760    while (frameIndex && (prevMethod == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious)) {
    761761        prevBuffer = &m_frameBufferCache[--frameIndex];
    762762        prevMethod = prevBuffer->disposalMethod();
     
    766766    ASSERT(prevBuffer->isComplete());
    767767
    768     if (prevMethod == ImageFrame::DisposalMethod::DoNotDispose) {
     768    if (prevMethod == ScalableImageDecoderFrame::DisposalMethod::DoNotDispose) {
    769769        // Preserve the last frame as the starting state for this frame.
    770770        if (!prevBuffer->backingStore() || !buffer.initialize(*prevBuffer->backingStore()))
     
    810810        return;
    811811
    812     ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
     812    auto& buffer = m_frameBufferCache[m_currentFrame];
    813813    buffer.setDecodingStatus(DecodingStatus::Complete);
    814814
     
    844844            else {
    845845                size_t frameIndex = m_currentFrame;
    846                 const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
    847                 while (frameIndex && (prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious))
     846                const auto* prevBuffer = &m_frameBufferCache[--frameIndex];
     847                while (frameIndex && (prevBuffer->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToPrevious))
    848848                    prevBuffer = &m_frameBufferCache[--frameIndex];
    849849
    850850                IntRect prevRect = prevBuffer->backingStore()->frameRect();
    851                 if ((prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
     851                if ((prevBuffer->disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
    852852                    buffer.setHasAlpha(false);
    853853            }
  • trunk/Source/WebCore/platform/image-decoders/png/PNGImageDecoder.h

    r222151 r230522  
    5252#endif
    5353        bool setSize(const IntSize&) override;
    54         ImageFrame* frameBufferAtIndex(size_t index) override;
     54        ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;
    5555        // CAUTION: setFailed() deletes |m_reader|.  Be careful to avoid
    5656        // accessing deleted memory, especially when calling this from inside
  • trunk/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.cpp

    r229309 r230522  
    7171}
    7272
    73 ImageFrame* WEBPImageDecoder::frameBufferAtIndex(size_t index)
     73ScalableImageDecoderFrame* WEBPImageDecoder::frameBufferAtIndex(size_t index)
    7474{
    7575    if (index >= frameCount())
     
    118118        // that the next frame will be rendered on top of a transparent background, and can be decoded
    119119        // without dependencies. This can only be checked for frames prior to frameIndex.
    120         if (firstIndependentFrame < frameIndex && m_frameBufferCache[firstIndependentFrame].disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground)
     120        if (firstIndependentFrame < frameIndex && m_frameBufferCache[firstIndependentFrame].disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground)
    121121            return firstIndependentFrame + 1;
    122122    }
     
    171171
    172172    ASSERT(m_frameBufferCache.size() > frameIndex);
    173     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     173    auto& buffer = m_frameBufferCache[frameIndex];
    174174    buffer.setDuration(Seconds::fromMilliseconds(webpFrame.duration));
    175     buffer.setDisposalMethod(webpFrame.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ? ImageFrame::DisposalMethod::RestoreToBackground : ImageFrame::DisposalMethod::DoNotDispose);
     175    buffer.setDisposalMethod(webpFrame.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ? ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground : ScalableImageDecoderFrame::DisposalMethod::DoNotDispose);
    176176    ASSERT(!buffer.isComplete());
    177177
     
    224224        return false;
    225225
    226     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     226    auto& buffer = m_frameBufferCache[frameIndex];
    227227
    228228    // Initialize the frame rect in our buffer.
     
    237237            return false;
    238238    } else {
    239         const ImageFrame& prevBuffer = m_frameBufferCache[frameIndex - 1];
     239        const auto& prevBuffer = m_frameBufferCache[frameIndex - 1];
    240240        ASSERT(prevBuffer.isComplete());
    241241
     
    244244            return false;
    245245
    246         if (prevBuffer.disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) {
     246        if (prevBuffer.disposalMethod() == ScalableImageDecoderFrame::DisposalMethod::RestoreToBackground) {
    247247            // We want to clear the previous frame to transparent, without
    248248            // affecting pixels in the image outside of the frame.
     
    260260void WEBPImageDecoder::applyPostProcessing(size_t frameIndex, WebPIDecoder* decoder, WebPDecBuffer& decoderBuffer, bool blend)
    261261{
    262     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     262    auto& buffer = m_frameBufferCache[frameIndex];
    263263    int decodedWidth = 0;
    264264    int decodedHeight = 0;
     
    353353    // won't need any frame before them to render, so we can clear them all.
    354354    for (int i = clearBeforeFrame - 1; i >= 0; i--) {
    355         ImageFrame& buffer = m_frameBufferCache[i];
     355        auto& buffer = m_frameBufferCache[i];
    356356        if (!buffer.isInvalid())
    357357            buffer.clear();
  • trunk/Source/WebCore/platform/image-decoders/webp/WEBPImageDecoder.h

    r222841 r230522  
    4949    String filenameExtension() const override { return ASCIILiteral("webp"); }
    5050    void setData(SharedBuffer&, bool) final;
    51     ImageFrame* frameBufferAtIndex(size_t index) override;
     51    ScalableImageDecoderFrame* frameBufferAtIndex(size_t index) override;
    5252    RepetitionCount repetitionCount() const override;
    5353    size_t frameCount() const override { return m_frameCount; }
Note: See TracChangeset for help on using the changeset viewer.