Changeset 205181 in webkit


Ignore:
Timestamp:
Aug 30, 2016 8:06:19 AM (8 years ago)
Author:
Antti Koivisto
Message:

Remove StylePendingImage
​https://bugs.webkit.org/show_bug.cgi?id=161245

Reviewed by Andreas Kling.

Instances of this confusing type are used as placeholders during style resolution.
We can get rid of it and make "pending" a state of StyleImage. This simplies the code and
will allow further improvements.

  • WebCore.xcodeproj/project.pbxproj:
  • css/CSSCrossfadeValue.cpp:

(WebCore::CSSCrossfadeValue::isPending):
(WebCore::CSSCrossfadeValue::blend):

  • css/CSSCrossfadeValue.h:
  • css/CSSCursorImageValue.cpp:

(WebCore::CSSCursorImageValue::CSSCursorImageValue):
(WebCore::CSSCursorImageValue::~CSSCursorImageValue):

Save the original URL since the underlying CSSImageValue may change.

(WebCore::CSSCursorImageValue::updateCursorElement):
(WebCore::CSSCursorImageValue::cursorElementRemoved):
(WebCore::CSSCursorImageValue::cursorElementChanged):
(WebCore::CSSCursorImageValue::loadImage):
(WebCore::CSSCursorImageValue::styleImage):
(WebCore::CSSCursorImageValue::isSVGCursor):
(WebCore::CSSCursorImageValue::cachedImageURL):
(WebCore::CSSCursorImageValue::updateCachedImage):
(WebCore::CSSCursorImageValue::detachPendingImage): Deleted.
(WebCore::CSSCursorImageValue::cachedImage): Deleted.
(WebCore::CSSCursorImageValue::cachedOrPendingImage): Deleted.
(WebCore::CSSCursorImageValue::clearCachedImage): Deleted.

  • css/CSSCursorImageValue.h:
  • css/CSSFilterImageValue.cpp:

(WebCore::CSSFilterImageValue::isPending):

  • css/CSSFilterImageValue.h:
  • css/CSSImageGeneratorValue.cpp:

(WebCore::CSSImageGeneratorValue::isPending):
(WebCore::CSSImageGeneratorValue::subimageIsPending):
(WebCore::CSSImageGeneratorValue::cachedImageForCSSValue):

  • css/CSSImageGeneratorValue.h:
  • css/CSSImageSetValue.cpp:

(WebCore::CSSImageSetValue::~CSSImageSetValue):
(WebCore::CSSImageSetValue::loadBestFitImage):
(WebCore::CSSImageSetValue::styleImage):
(WebCore::CSSImageSetValue::traverseSubresources):
(WebCore::CSSImageSetValue::detachPendingImage): Deleted.
(WebCore::CSSImageSetValue::bestFitImage): Deleted.
(WebCore::CSSImageSetValue::cachedOrPendingImageSet): Deleted.

  • css/CSSImageSetValue.h:
  • css/CSSImageValue.cpp:

(WebCore::CSSImageValue::CSSImageValue):
(WebCore::CSSImageValue::~CSSImageValue):
(WebCore::CSSImageValue::isPending):
(WebCore::CSSImageValue::styleImage):
(WebCore::CSSImageValue::loadImage):
(WebCore::CSSImageValue::traverseSubresources):
(WebCore::CSSImageValue::detachPendingImage): Deleted.
(WebCore::CSSImageValue::cachedOrPendingImage): Deleted.
(WebCore::CSSImageValue::cachedImage): Deleted.

  • css/CSSImageValue.h:

(WebCore::CSSImageValue::create):

  • css/StyleResolver.cpp:

(WebCore::StyleResolver::cachedOrPendingFromValue):
(WebCore::StyleResolver::generatedOrPendingFromValue):
(WebCore::StyleResolver::setOrPendingFromValue):
(WebCore::StyleResolver::cursorOrPendingFromValue):

  • page/PageSerializer.cpp:

(WebCore::PageSerializer::retrieveResourcesForProperties):

  • page/animation/CSSPropertyAnimation.cpp:

(WebCore::blendFilter):
(WebCore::crossfadeBlend):

  • rendering/RenderImageResourceStyleImage.cpp:

(WebCore::RenderImageResourceStyleImage::image):

  • rendering/shapes/ShapeOutsideInfo.cpp:

(WebCore::ShapeOutsideInfo::createShapeForImage):

  • rendering/style/StyleCachedImage.cpp:

(WebCore::StyleCachedImage::StyleCachedImage):
(WebCore::StyleCachedImage::~StyleCachedImage):
(WebCore::StyleCachedImage::setCachedImage):
(WebCore::StyleCachedImage::cssValue):
(WebCore::StyleCachedImage::canRender):
(WebCore::StyleCachedImage::isPending):
(WebCore::StyleCachedImage::isLoaded):
(WebCore::StyleCachedImage::errorOccurred):
(WebCore::StyleCachedImage::imageSize):
(WebCore::StyleCachedImage::imageHasRelativeWidth):
(WebCore::StyleCachedImage::imageHasRelativeHeight):
(WebCore::StyleCachedImage::computeIntrinsicDimensions):
(WebCore::StyleCachedImage::usesImageContainerSize):
(WebCore::StyleCachedImage::setContainerSizeForRenderer):
(WebCore::StyleCachedImage::addClient):
(WebCore::StyleCachedImage::removeClient):
(WebCore::StyleCachedImage::image):
(WebCore::StyleCachedImage::knownToBeOpaque):

  • rendering/style/StyleCachedImage.h:
  • rendering/style/StyleGeneratedImage.cpp:

(WebCore::StyleGeneratedImage::isPending):

  • rendering/style/StyleGeneratedImage.h:
  • rendering/style/StyleImage.h:

(WebCore::StyleImage::isCachedImage):
(WebCore::StyleImage::StyleImage):
(WebCore::StyleImage::canRender): Deleted.
(WebCore::StyleImage::isPendingImage): Deleted.

  • rendering/style/StylePendingImage.h: Removed.
  • style/StylePendingResources.cpp:

(WebCore::Style::loadPendingImage):
(WebCore::Style::loadPendingImages):

Location:
trunk/Source/WebCore
Files:
1 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r205180 r205181  
     12016-08-30  Antti Koivisto  <antti@apple.com>
     2
     3        Remove StylePendingImage
     4        https://bugs.webkit.org/show_bug.cgi?id=161245
     5
     6        Reviewed by Andreas Kling.
     7
     8        Instances of this confusing type are used as placeholders during style resolution.
     9        We can get rid of it and make "pending" a state of StyleImage. This simplies the code and
     10        will allow further improvements.
     11
     12        * WebCore.xcodeproj/project.pbxproj:
     13        * css/CSSCrossfadeValue.cpp:
     14        (WebCore::CSSCrossfadeValue::isPending):
     15        (WebCore::CSSCrossfadeValue::blend):
     16        * css/CSSCrossfadeValue.h:
     17        * css/CSSCursorImageValue.cpp:
     18        (WebCore::CSSCursorImageValue::CSSCursorImageValue):
     19        (WebCore::CSSCursorImageValue::~CSSCursorImageValue):
     20
     21            Save the original URL since the underlying CSSImageValue may change.
     22
     23        (WebCore::CSSCursorImageValue::updateCursorElement):
     24        (WebCore::CSSCursorImageValue::cursorElementRemoved):
     25        (WebCore::CSSCursorImageValue::cursorElementChanged):
     26        (WebCore::CSSCursorImageValue::loadImage):
     27        (WebCore::CSSCursorImageValue::styleImage):
     28        (WebCore::CSSCursorImageValue::isSVGCursor):
     29        (WebCore::CSSCursorImageValue::cachedImageURL):
     30        (WebCore::CSSCursorImageValue::updateCachedImage):
     31        (WebCore::CSSCursorImageValue::detachPendingImage): Deleted.
     32        (WebCore::CSSCursorImageValue::cachedImage): Deleted.
     33        (WebCore::CSSCursorImageValue::cachedOrPendingImage): Deleted.
     34        (WebCore::CSSCursorImageValue::clearCachedImage): Deleted.
     35        * css/CSSCursorImageValue.h:
     36        * css/CSSFilterImageValue.cpp:
     37        (WebCore::CSSFilterImageValue::isPending):
     38        * css/CSSFilterImageValue.h:
     39        * css/CSSImageGeneratorValue.cpp:
     40        (WebCore::CSSImageGeneratorValue::isPending):
     41        (WebCore::CSSImageGeneratorValue::subimageIsPending):
     42        (WebCore::CSSImageGeneratorValue::cachedImageForCSSValue):
     43        * css/CSSImageGeneratorValue.h:
     44        * css/CSSImageSetValue.cpp:
     45        (WebCore::CSSImageSetValue::~CSSImageSetValue):
     46        (WebCore::CSSImageSetValue::loadBestFitImage):
     47        (WebCore::CSSImageSetValue::styleImage):
     48        (WebCore::CSSImageSetValue::traverseSubresources):
     49        (WebCore::CSSImageSetValue::detachPendingImage): Deleted.
     50        (WebCore::CSSImageSetValue::bestFitImage): Deleted.
     51        (WebCore::CSSImageSetValue::cachedOrPendingImageSet): Deleted.
     52        * css/CSSImageSetValue.h:
     53        * css/CSSImageValue.cpp:
     54        (WebCore::CSSImageValue::CSSImageValue):
     55        (WebCore::CSSImageValue::~CSSImageValue):
     56        (WebCore::CSSImageValue::isPending):
     57        (WebCore::CSSImageValue::styleImage):
     58        (WebCore::CSSImageValue::loadImage):
     59        (WebCore::CSSImageValue::traverseSubresources):
     60        (WebCore::CSSImageValue::detachPendingImage): Deleted.
     61        (WebCore::CSSImageValue::cachedOrPendingImage): Deleted.
     62        (WebCore::CSSImageValue::cachedImage): Deleted.
     63        * css/CSSImageValue.h:
     64        (WebCore::CSSImageValue::create):
     65        * css/StyleResolver.cpp:
     66        (WebCore::StyleResolver::cachedOrPendingFromValue):
     67        (WebCore::StyleResolver::generatedOrPendingFromValue):
     68        (WebCore::StyleResolver::setOrPendingFromValue):
     69        (WebCore::StyleResolver::cursorOrPendingFromValue):
     70        * page/PageSerializer.cpp:
     71        (WebCore::PageSerializer::retrieveResourcesForProperties):
     72        * page/animation/CSSPropertyAnimation.cpp:
     73        (WebCore::blendFilter):
     74        (WebCore::crossfadeBlend):
     75        * rendering/RenderImageResourceStyleImage.cpp:
     76        (WebCore::RenderImageResourceStyleImage::image):
     77        * rendering/shapes/ShapeOutsideInfo.cpp:
     78        (WebCore::ShapeOutsideInfo::createShapeForImage):
     79        * rendering/style/StyleCachedImage.cpp:
     80        (WebCore::StyleCachedImage::StyleCachedImage):
     81        (WebCore::StyleCachedImage::~StyleCachedImage):
     82        (WebCore::StyleCachedImage::setCachedImage):
     83        (WebCore::StyleCachedImage::cssValue):
     84        (WebCore::StyleCachedImage::canRender):
     85        (WebCore::StyleCachedImage::isPending):
     86        (WebCore::StyleCachedImage::isLoaded):
     87        (WebCore::StyleCachedImage::errorOccurred):
     88        (WebCore::StyleCachedImage::imageSize):
     89        (WebCore::StyleCachedImage::imageHasRelativeWidth):
     90        (WebCore::StyleCachedImage::imageHasRelativeHeight):
     91        (WebCore::StyleCachedImage::computeIntrinsicDimensions):
     92        (WebCore::StyleCachedImage::usesImageContainerSize):
     93        (WebCore::StyleCachedImage::setContainerSizeForRenderer):
     94        (WebCore::StyleCachedImage::addClient):
     95        (WebCore::StyleCachedImage::removeClient):
     96        (WebCore::StyleCachedImage::image):
     97        (WebCore::StyleCachedImage::knownToBeOpaque):
     98        * rendering/style/StyleCachedImage.h:
     99        * rendering/style/StyleGeneratedImage.cpp:
     100        (WebCore::StyleGeneratedImage::isPending):
     101        * rendering/style/StyleGeneratedImage.h:
     102        * rendering/style/StyleImage.h:
     103        (WebCore::StyleImage::isCachedImage):
     104        (WebCore::StyleImage::StyleImage):
     105        (WebCore::StyleImage::canRender): Deleted.
     106        (WebCore::StyleImage::isPendingImage): Deleted.
     107        * rendering/style/StylePendingImage.h: Removed.
     108        * style/StylePendingResources.cpp:
     109        (WebCore::Style::loadPendingImage):
     110        (WebCore::Style::loadPendingImages):
     111
    11122016-08-30  Philippe Normand  <pnormand@igalia.com>
    2113

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r205161 r205181  
    504504                0FA24D79162DF91900A3F4C0 /* GraphicsLayerUpdater.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FA24D77162DF91900A3F4C0 /* GraphicsLayerUpdater.cpp */; };
    505505                0FA24D7A162DF91900A3F4C0 /* GraphicsLayerUpdater.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FA24D78162DF91900A3F4C0 /* GraphicsLayerUpdater.h */; settings = {ATTRIBUTES = (Private, ); }; };
    506                 0FA6F96F1BCF614A0031EE70 /* StylePendingImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FA6F96E1BCF614A0031EE70 /* StylePendingImage.h */; };
    507506                0FA88EBD16A8D1BD00F99984 /* ScrollingStateFrameScrollingNodeMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0FA88EBC16A8D1BD00F99984 /* ScrollingStateFrameScrollingNodeMac.mm */; };
    508507                0FB6252E18DE1B1500A07C05 /* GeometryUtilities.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FB6252C18DE1B1500A07C05 /* GeometryUtilities.cpp */; };
    … …  
    72777276                0FA24D77162DF91900A3F4C0 /* GraphicsLayerUpdater.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GraphicsLayerUpdater.cpp; sourceTree = "<group>"; };
    72787277                0FA24D78162DF91900A3F4C0 /* GraphicsLayerUpdater.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GraphicsLayerUpdater.h; sourceTree = "<group>"; };
    7279                 0FA6F96E1BCF614A0031EE70 /* StylePendingImage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StylePendingImage.h; sourceTree = "<group>"; };
    72807278                0FA88EBC16A8D1BD00F99984 /* ScrollingStateFrameScrollingNodeMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollingStateFrameScrollingNodeMac.mm; sourceTree = "<group>"; };
    72817279                0FB6252C18DE1B1500A07C05 /* GeometryUtilities.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GeometryUtilities.cpp; sourceTree = "<group>"; };
    … …  
    2119321191                                BC5EB74B0E81E06700B25965 /* StyleMultiColData.cpp */,
    2119421192                                BC5EB74C0E81E06700B25965 /* StyleMultiColData.h */,
    21195                                 0FA6F96E1BCF614A0031EE70 /* StylePendingImage.h */,
    2119621193                                BC2272E10E82EE9B00E7F975 /* StyleRareInheritedData.cpp */,
    2119721194                                BC2272E20E82EE9B00E7F975 /* StyleRareInheritedData.h */,
    … …  
    2636226359                                0FF50272102BA96A0066F39A /* StyleMedia.h in Headers */,
    2636326360                                BC5EB74E0E81E06700B25965 /* StyleMultiColData.h in Headers */,
    26364                                 0FA6F96F1BCF614A0031EE70 /* StylePendingImage.h in Headers */,
    2636526361                                E4DACE6A1D12E10B0075980F /* StylePendingResources.h in Headers */,
    2636626362                                A80E6DFC0A199067007FB8C5 /* StyleProperties.h in Headers */,

  • trunk/Source/WebCore/css/CSSCrossfadeValue.cpp

    r201290 r205181  
    111111}
    112112
    113 bool CSSCrossfadeValue::isPending()
     113bool CSSCrossfadeValue::isPending() const
    114114{
    115115    return CSSImageGeneratorValue::subimageIsPending(m_fromValue)
    … …  
    200200    if (!m_cachedToImage || !m_cachedFromImage)
    201201        return nullptr;
    202     RefPtr<StyleCachedImage> toStyledImage = StyleCachedImage::create(m_cachedToImage.get());
    203     RefPtr<StyleCachedImage> fromStyledImage = StyleCachedImage::create(m_cachedFromImage.get());
    204 
    205     auto fromImageValue = CSSImageValue::create(m_cachedFromImage->url(), fromStyledImage.get());
    206     auto toImageValue = CSSImageValue::create(m_cachedToImage->url(), toStyledImage.get());
     202    auto fromImageValue = CSSImageValue::create(*m_cachedFromImage);
     203    auto toImageValue = CSSImageValue::create(*m_cachedToImage);
    207204
    208205    double fromPercentage = from.m_percentageValue->getDoubleValue();

  • trunk/Source/WebCore/css/CSSCrossfadeValue.h

    r205093 r205181  
    5858
    5959    bool isPrefixed() const { return m_isPrefixed; }
    60     bool isPending();
     60    bool isPending() const;
    6161    bool knownToBeOpaque(const RenderElement*) const;
    6262

  • trunk/Source/WebCore/css/CSSCursorImageValue.cpp

    r204566 r205181  
    2929#include "StyleCachedImage.h"
    3030#include "StyleImage.h"
    31 #include "StylePendingImage.h"
    3231#include "SVGCursorElement.h"
    3332#include "SVGLengthContext.h"
    … …  
    4746    , m_hotSpot(hotSpot)
    4847{
    49 }
    50 
    51 inline void CSSCursorImageValue::detachPendingImage()
    52 {
    53     if (is<StylePendingImage>(m_image.get()))
    54         downcast<StylePendingImage>(*m_image).detachFromCSSValue();
     48    if (is<CSSImageValue>(m_imageValue.get()))
     49        m_originalURL = { ParsedURLString, downcast<CSSImageValue>(m_imageValue.get()).url() };
    5550}
    5651
    5752CSSCursorImageValue::~CSSCursorImageValue()
    5853{
    59     detachPendingImage();
    60 
    6154    for (auto* element : m_cursorElements)
    6255        element->removeClient(*this);
    … …  
    7871SVGCursorElement* CSSCursorImageValue::updateCursorElement(const Document& document)
    7972{
    80     if (!isSVGCursor())
     73    if (!m_originalURL.hasFragmentIdentifier())
    8174        return nullptr;
    8275
    83     auto* element = SVGURIReference::targetElementFromIRIString(downcast<CSSImageValue>(m_imageValue.get()).url(), document);
     76    auto* element = SVGURIReference::targetElementFromIRIString(m_originalURL, document);
    8477    if (!is<SVGCursorElement>(element))
    8578        return nullptr;
    … …  
    9689{
    9790    m_cursorElements.remove(&cursorElement);
    98     clearCachedImage();
    9991}
    10092
    10193void CSSCursorImageValue::cursorElementChanged(SVGCursorElement& cursorElement)
    10294{
    103     clearCachedImage();
    104 
    10595    // FIXME: This will override hot spot specified in CSS, which is probably incorrect.
    10696    SVGLengthContext lengthContext(nullptr);
    … …  
    113103}
    114104
    115 StyleImage* CSSCursorImageValue::cachedImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     105void CSSCursorImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    116106{
    117     if (is<CSSImageSetValue>(m_imageValue.get()))
    118         return downcast<CSSImageSetValue>(m_imageValue.get()).bestFitImage(loader, options);
    119 
    120     auto* cursorElement = loader.document() ? updateCursorElement(*loader.document()) : nullptr;
    121 
    122     if (!m_isImageValid) {
    123         m_isImageValid = true;
    124         // For SVG images we need to lazily substitute in the correct URL. Rather than attempt
    125         // to change the URL of the CSSImageValue (which would then change behavior like cssText),
    126         // we create an alternate CSSImageValue to use.
    127         if (cursorElement) {
    128             detachPendingImage();
    129             Ref<CSSImageValue> svgImageValue(CSSImageValue::create(cursorElement->href()));
    130             StyleCachedImage* cachedImage = svgImageValue->cachedImage(loader, options);
    131             m_image = cachedImage;
    132             return cachedImage;
    133         }
    134 
    135         if (is<CSSImageValue>(m_imageValue.get())) {
    136             detachPendingImage();
    137             m_image = downcast<CSSImageValue>(m_imageValue.get()).cachedImage(loader, options);
    138         }
     107    if (is<CSSImageSetValue>(m_imageValue.get())) {
     108        downcast<CSSImageSetValue>(m_imageValue.get()).loadBestFitImage(loader, options);
     109        return;
    139110    }
    140111
    141     if (is<StyleCachedImage>(m_image.get()))
    142         return downcast<StyleCachedImage>(m_image.get());
    143 
    144     return nullptr;
     112    downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options);
    145113}
    146114
    147 StyleImage* CSSCursorImageValue::cachedOrPendingImage(const Document& document)
     115StyleCachedImage& CSSCursorImageValue::styleImage(const Document& document)
    148116{
    149117    // Need to delegate completely so that changes in device scale factor can be handled appropriately.
     118    StyleCachedImage* styleImage;
    150119    if (is<CSSImageSetValue>(m_imageValue.get()))
    151         return downcast<CSSImageSetValue>(m_imageValue.get()).cachedOrPendingImageSet(document);
     120        styleImage = &downcast<CSSImageSetValue>(m_imageValue.get()).styleImage(document);
     121    else {
     122        if (auto* cursorElement = updateCursorElement(document)) {
     123            if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
     124                m_imageValue = CSSImageValue::create(cursorElement->href());
     125        }
     126        styleImage = &downcast<CSSImageValue>(m_imageValue.get()).styleImage();
     127    }
     128    styleImage->setCSSValue(*this);
    152129
    153     if (!m_image)
    154         m_image = StylePendingImage::create(this);
    155 
    156     return m_image.get();
    157 }
    158 
    159 bool CSSCursorImageValue::isSVGCursor() const
    160 {
    161     if (is<CSSImageValue>(m_imageValue.get())) {
    162         URL kurl(ParsedURLString, downcast<CSSImageValue>(m_imageValue.get()).url());
    163         return kurl.hasFragmentIdentifier();
    164     }
    165     return false;
    166 }
    167 
    168 String CSSCursorImageValue::cachedImageURL()
    169 {
    170     if (!is<StyleCachedImage>(m_image.get()))
    171         return String();
    172     return downcast<StyleCachedImage>(*m_image).cachedImage()->url();
    173 }
    174 
    175 void CSSCursorImageValue::clearCachedImage()
    176 {
    177     detachPendingImage();
    178     m_image = nullptr;
    179     m_isImageValid = false;
     130    return *styleImage;
    180131}
    181132

  • trunk/Source/WebCore/css/CSSCursorImageValue.h

    r205093 r205181  
    3232class SVGCursorElement;
    3333class SVGElement;
     34class StyleCachedImage;
    3435
    3536class CSSCursorImageValue final : public CSSValue {
    … …  
    5354    String customCSSText() const;
    5455
    55     SVGCursorElement* updateCursorElement(const Document&);
    56     StyleImage* cachedImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    57     StyleImage* cachedOrPendingImage(const Document&);
     56    void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
     57    StyleCachedImage& styleImage(const Document&);
    5858
    5959    void removeReferencedElement(SVGElement*);
    … …  
    6767    CSSCursorImageValue(Ref<CSSValue>&& imageValue, bool hasHotSpot, const IntPoint& hotSpot);
    6868
    69     void detachPendingImage();
     69    SVGCursorElement* updateCursorElement(const Document&);
    7070
    71     bool isSVGCursor() const;
    72     String cachedImageURL();
    73     void clearCachedImage();
    74 
     71    URL m_originalURL;
    7572    Ref<CSSValue> m_imageValue;
    7673
    7774    bool m_hasHotSpot;
    7875    IntPoint m_hotSpot;
    79     RefPtr<StyleImage> m_image;
    80     bool m_isImageValid { false };
    8176    HashSet<SVGCursorElement*> m_cursorElements;
    8277};

  • trunk/Source/WebCore/css/CSSFilterImageValue.cpp

    r201290 r205181  
    7474}
    7575
    76 bool CSSFilterImageValue::isPending()
     76bool CSSFilterImageValue::isPending() const
    7777{
    7878    return CSSImageGeneratorValue::subimageIsPending(m_imageValue);

  • trunk/Source/WebCore/css/CSSFilterImageValue.h

    r205093 r205181  
    6060    FloatSize fixedSize(const RenderElement*);
    6161
    62     bool isPending();
     62    bool isPending() const;
    6363    bool knownToBeOpaque(const RenderElement*) const;
    6464

  • trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp

    r201290 r205181  
    168168}
    169169
    170 bool CSSImageGeneratorValue::isPending()
     170bool CSSImageGeneratorValue::isPending() const
    171171{
    172172    switch (classType()) {
    … …  
    233233}
    234234
    235 bool CSSImageGeneratorValue::subimageIsPending(CSSValue& value)
     235bool CSSImageGeneratorValue::subimageIsPending(const CSSValue& value)
    236236{
    237237    if (is<CSSImageValue>(value))
    238         return downcast<CSSImageValue>(value).cachedOrPendingImage().isPendingImage();
     238        return downcast<CSSImageValue>(value).isPending();
    239239   
    240240    if (is<CSSImageGeneratorValue>(value))
    … …  
    252252{
    253253    if (is<CSSImageValue>(value)) {
    254         StyleCachedImage* styleCachedImage = downcast<CSSImageValue>(value).cachedImage(cachedResourceLoader, options);
    255         if (!styleCachedImage)
    256             return nullptr;
    257 
    258         return styleCachedImage->cachedImage();
     254        auto& imageValue = downcast<CSSImageValue>(value);
     255        imageValue.loadImage(cachedResourceLoader, options);
     256        return imageValue.styleImage().cachedImage();
    259257    }
    260258   

  • trunk/Source/WebCore/css/CSSImageGeneratorValue.h

    r201290 r205181  
    5555    FloatSize fixedSize(const RenderElement*);
    5656
    57     bool isPending();
     57    bool isPending() const;
    5858    bool knownToBeOpaque(const RenderElement*) const;
    5959
    … …  
    6969    // Helper functions for Crossfade and Filter.
    7070    static CachedImage* cachedImageForCSSValue(CSSValue&, CachedResourceLoader&, const ResourceLoaderOptions&);
    71     static bool subimageIsPending(CSSValue&);
     71    static bool subimageIsPending(const CSSValue&);
    7272
    7373private:

  • trunk/Source/WebCore/css/CSSImageSetValue.cpp

    r204566 r205181  
    3737#include "Page.h"
    3838#include "StyleCachedImage.h"
    39 #include "StylePendingImage.h"
    4039#include <wtf/text/StringBuilder.h>
    4140
    … …  
    4948}
    5049
    51 inline void CSSImageSetValue::detachPendingImage()
    52 {
    53     if (is<StylePendingImage>(m_image.get()))
    54         downcast<StylePendingImage>(*m_image).detachFromCSSValue();
    55 }
    56 
    5750CSSImageSetValue::~CSSImageSetValue()
    5851{
    59     detachPendingImage();
    60 
    61     if (is<StyleCachedImage>(m_image.get()))
    62         downcast<StyleCachedImage>(*m_image).detachFromCSSValue();
     52    if (m_image)
     53        m_image->detachFromCSSValue();
    6354}
    6455
    … …  
    9990}
    10091
    101 StyleCachedImage* CSSImageSetValue::bestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     92void CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    10293{
    10394    Document* document = loader.document();
    … …  
    110101        fillImageSet();
    111102
    112     if (!m_accessedBestFitImage) {
    113         // FIXME: In the future, we want to take much more than deviceScaleFactor into acount here.
    114         // All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
    115         // and any CSS transforms. https://bugs.webkit.org/show_bug.cgi?id=81698
    116         ImageWithScale image = bestImageForScaleFactor();
    117         CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
    118         request.setInitiator(cachedResourceRequestInitiators().css);
    119         if (options.mode == FetchOptions::Mode::Cors) {
    120             ASSERT(document->securityOrigin());
    121             updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
    122         }
    123         if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
    124             detachPendingImage();
    125             m_image = StyleCachedImage::createForImageSet(cachedImage.get(), image.scaleFactor, *this);
    126             m_accessedBestFitImage = true;
    127         }
     103    if (m_accessedBestFitImage)
     104        return;
     105    // FIXME: In the future, we want to take much more than deviceScaleFactor into acount here.
     106    // All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
     107    // and any CSS transforms. https://bugs.webkit.org/show_bug.cgi?id=81698
     108    ImageWithScale image = bestImageForScaleFactor();
     109    CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
     110    request.setInitiator(cachedResourceRequestInitiators().css);
     111    if (options.mode == FetchOptions::Mode::Cors) {
     112        ASSERT(document->securityOrigin());
     113        updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
    128114    }
    129 
    130     return is<StyleCachedImage>(m_image.get()) ? downcast<StyleCachedImage>(m_image.get()) : nullptr;
     115    if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
     116        styleImage(*document).setCachedImage(*cachedImage, image.scaleFactor);
     117        m_accessedBestFitImage = true;
     118    }
    131119}
    132120
    133 StyleImage* CSSImageSetValue::cachedOrPendingImageSet(const Document& document)
     121StyleCachedImage& CSSImageSetValue::styleImage(const Document& document)
    134122{
    135123    if (!m_image)
    136         m_image = StylePendingImage::create(this);
    137     else if (!m_image->isPendingImage()) {
     124        m_image = StyleCachedImage::create(*this);
     125    else if (!m_image->isPending()) {
    138126        float deviceScaleFactor = 1;
    139127        if (Page* page = document.page())
    … …  
    143131        if (deviceScaleFactor != m_scaleFactor) {
    144132            m_accessedBestFitImage = false;
    145             m_image = StylePendingImage::create(this);
     133            m_image->detachFromCSSValue();
     134            m_image = StyleCachedImage::create(*this);
    146135        }
    147136    }
    148137
    149     return m_image.get();
     138    return *m_image;
    150139}
    151140
    … …  
    182171bool CSSImageSetValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    183172{
    184     if (!is<StyleCachedImage>(m_image.get()))
     173    if (!m_image)
    185174        return false;
    186     CachedImage* cachedResource = downcast<StyleCachedImage>(*m_image).cachedImage();
    187     ASSERT(cachedResource);
     175    CachedImage* cachedResource = m_image->cachedImage();
     176    if (!cachedResource)
     177        return false;
    188178    return handler(*cachedResource);
    189179}

  • trunk/Source/WebCore/css/CSSImageSetValue.h

    r205093 r205181  
    4646    ~CSSImageSetValue();
    4747
    48     StyleCachedImage* bestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    49 
    50     // Returns a StyleCachedImage if the best fit image has been cached already, otherwise a StylePendingImage.
    51     StyleImage* cachedOrPendingImageSet(const Document&);
     48    void loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
     49    StyleCachedImage& styleImage(const Document&);
    5250
    5351    String customCSSText() const;
    … …  
    7169    CSSImageSetValue(const CSSImageSetValue& cloneFrom);
    7270
    73     void detachPendingImage();
    7471    void fillImageSet();
    7572    static inline bool compareByScaleFactor(ImageWithScale first, ImageWithScale second) { return first.scaleFactor < second.scaleFactor; }
    7673
    77     RefPtr<StyleImage> m_image;
     74    RefPtr<StyleCachedImage> m_image;
    7875    bool m_accessedBestFitImage;
    7976

  • trunk/Source/WebCore/css/CSSImageValue.cpp

    r204014 r205181  
    3434#include "MemoryCache.h"
    3535#include "StyleCachedImage.h"
    36 #include "StylePendingImage.h"
    3736
    3837namespace WebCore {
    … …  
    4544}
    4645
    47 CSSImageValue::CSSImageValue(const String& url, StyleImage* image)
     46CSSImageValue::CSSImageValue(CachedImage& image)
    4847    : CSSValue(ImageClass)
    49     , m_url(url)
    50     , m_image(image)
     48    , m_url(image.url())
     49    , m_image(StyleCachedImage::create(*this))
    5150    , m_accessedImage(true)
    5251{
     52    m_image->setCachedImage(image);
    5353}
    5454
    55 inline void CSSImageValue::detachPendingImage()
    56 {
    57     if (is<StylePendingImage>(m_image.get()))
    58         downcast<StylePendingImage>(*m_image).detachFromCSSValue();
    59 }
    6055
    6156CSSImageValue::~CSSImageValue()
    6257{
    63     detachPendingImage();
     58    if (m_image)
     59        m_image->detachFromCSSValue();
    6460}
    6561
    66 StyleImage& CSSImageValue::cachedOrPendingImage()
     62bool CSSImageValue::isPending() const
     63{
     64    return !m_image || !m_image->cachedImage();
     65}
     66
     67StyleCachedImage& CSSImageValue::styleImage()
    6768{
    6869    if (!m_image)
    69         m_image = StylePendingImage::create(this);
     70        m_image = StyleCachedImage::create(*this);
    7071
    7172    return *m_image;
    7273}
    7374
    74 StyleCachedImage* CSSImageValue::cachedImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     75void CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    7576{
    76     if (!m_accessedImage) {
    77         m_accessedImage = true;
     77    if (m_accessedImage)
     78        return;
     79    m_accessedImage = true;
    7880
    79         CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
    80         if (m_initiatorName.isEmpty())
    81             request.setInitiator(cachedResourceRequestInitiators().css);
    82         else
    83             request.setInitiator(m_initiatorName);
     81    CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
     82    if (m_initiatorName.isEmpty())
     83        request.setInitiator(cachedResourceRequestInitiators().css);
     84    else
     85        request.setInitiator(m_initiatorName);
    8486
    85         if (options.mode == FetchOptions::Mode::Cors) {
    86             ASSERT(loader.document()->securityOrigin());
    87             updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
    88         }
    89         if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
    90             detachPendingImage();
    91             m_image = StyleCachedImage::create(cachedImage.get());
    92         }
     87    if (options.mode == FetchOptions::Mode::Cors) {
     88        ASSERT(loader.document()->securityOrigin());
     89        updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
    9390    }
    94 
    95     return is<StyleCachedImage>(m_image.get()) ? downcast<StyleCachedImage>(m_image.get()) : nullptr;
     91    if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request))
     92        styleImage().setCachedImage(*cachedImage);
    9693}
    9794
    9895bool CSSImageValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    9996{
    100     if (!is<StyleCachedImage>(m_image.get()))
     97    if (!m_image)
    10198        return false;
    102     CachedResource* cachedResource = downcast<StyleCachedImage>(*m_image).cachedImage();
    103     ASSERT(cachedResource);
     99    CachedResource* cachedResource = m_image->cachedImage();
     100    if (!cachedResource)
     101        return false;
    104102    return handler(*cachedResource);
    105103}

  • trunk/Source/WebCore/css/CSSImageValue.h

    r205093 r205181  
    2727namespace WebCore {
    2828
     29class CachedImage;
    2930class CachedResourceLoader;
    3031class Element;
    3132class StyleCachedImage;
    32 class StyleImage;
    3333class RenderElement;
    3434struct ResourceLoaderOptions;
    … …  
    3737public:
    3838    static Ref<CSSImageValue> create(const String& url) { return adoptRef(*new CSSImageValue(url)); }
    39     static Ref<CSSImageValue> create(const String& url, StyleImage* image) { return adoptRef(*new CSSImageValue(url, image)); }
     39    static Ref<CSSImageValue> create(CachedImage& image) { return adoptRef(*new CSSImageValue(image)); }
    4040    ~CSSImageValue();
    4141
    42     StyleCachedImage* cachedImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    43     // Returns a StyleCachedImage if the image is cached already, otherwise a StylePendingImage.
    44     StyleImage& cachedOrPendingImage();
     42    bool isPending() const;
     43    void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
     44    StyleCachedImage& styleImage();
    4545
    4646    const String& url() const { return m_url; }
    … …  
    6060private:
    6161    explicit CSSImageValue(const String& url);
    62     CSSImageValue(const String& url, StyleImage*);
    63     void detachPendingImage();
     62    explicit CSSImageValue(CachedImage&);
    6463
    6564    String m_url;
    66     RefPtr<StyleImage> m_image;
     65    RefPtr<StyleCachedImage> m_image;
    6766    bool m_accessedImage;
    6867    AtomicString m_initiatorName;

  • trunk/Source/WebCore/css/StyleResolver.cpp

    r204566 r205181  
    124124#include "StyleFontSizeFunctions.h"
    125125#include "StyleGeneratedImage.h"
    126 #include "StylePendingImage.h"
    127126#include "StyleProperties.h"
    128127#include "StylePropertyShorthand.h"
    … …  
    17241723Ref<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue& value)
    17251724{
    1726     Ref<StyleImage> image = value.cachedOrPendingImage();
    1727     if (image->isPendingImage())
     1725    Ref<StyleImage> image = value.styleImage();
     1726    if (image->isPending())
    17281727        m_state.ensurePendingResources().pendingImages.set(property, &value);
    17291728    return image;
    … …  
    17361735        downcast<CSSFilterImageValue>(value).createFilterOperations(this);
    17371736    }
    1738 
    1739     if (value.isPending()) {
     1737    if (value.isPending())
    17401738        m_state.ensurePendingResources().pendingImages.set(property, &value);
    1741         return StylePendingImage::create(&value);
    1742     }
     1739
    17431740    return StyleGeneratedImage::create(value);
    17441741}
    … …  
    17461743RefPtr<StyleImage> StyleResolver::setOrPendingFromValue(CSSPropertyID property, CSSImageSetValue& value)
    17471744{
    1748     RefPtr<StyleImage> image = value.cachedOrPendingImageSet(document());
    1749     if (image && image->isPendingImage())
     1745    auto& image = value.styleImage(document());
     1746    if (image.isPending())
    17501747        m_state.ensurePendingResources().pendingImages.set(property, &value);
    1751     return image;
     1748    return &image;
    17521749}
    17531750
    17541751RefPtr<StyleImage> StyleResolver::cursorOrPendingFromValue(CSSPropertyID property, CSSCursorImageValue& value)
    17551752{
    1756     RefPtr<StyleImage> image = value.cachedOrPendingImage(document());
    1757     if (image && image->isPendingImage())
     1753    auto& image = value.styleImage(document());
     1754    if (image.isPending())
    17581755        m_state.ensurePendingResources().pendingImages.set(property, &value);
    1759     return image;
     1756    return &image;
    17601757}
    17611758

  • trunk/Source/WebCore/page/PageSerializer.cpp

    r203324 r205181  
    332332            continue;
    333333
    334         auto& styleImage = downcast<CSSImageValue>(*cssValue).cachedOrPendingImage();
    335         // Non cached-images are just place-holders and do not contain data.
    336         if (!is<StyleCachedImage>(styleImage))
     334        auto& styleImage = downcast<CSSImageValue>(*cssValue).styleImage();
     335
     336        auto* image = styleImage.cachedImage();
     337        if (!image)
    337338            continue;
    338 
    339         CachedImage* image = downcast<StyleCachedImage>(styleImage).cachedImage();
    340339
    341340        URL url = document->completeURL(image->url());

  • trunk/Source/WebCore/page/animation/CSSPropertyAnimation.cpp

    r201290 r205181  
    226226    FilterOperations filterResult = blendFilterOperations(anim, from, to, progress);
    227227
    228     RefPtr<StyleCachedImage> styledImage = StyleCachedImage::create(image);
    229     auto imageValue = CSSImageValue::create(image->url(), styledImage.get());
     228    auto imageValue = CSSImageValue::create(*image);
    230229    auto filterValue = ComputedStyleExtractor::valueForFilter(anim->renderer()->style(), filterResult, DoNotAdjustPixelValues);
    231230
    … …  
    291290        return toStyleImage;
    292291
    293     auto fromImageValue = CSSImageValue::create(fromStyleImage->cachedImage()->url(), fromStyleImage);
    294     auto toImageValue = CSSImageValue::create(toStyleImage->cachedImage()->url(), toStyleImage);
     292    auto fromImageValue = CSSImageValue::create(*fromStyleImage->cachedImage());
     293    auto toImageValue = CSSImageValue::create(*toStyleImage->cachedImage());
    295294    auto percentageValue = CSSPrimitiveValue::create(progress, CSSPrimitiveValue::CSS_NUMBER);
    296295

  • trunk/Source/WebCore/rendering/RenderImageResourceStyleImage.cpp

    r191083 r205181  
    6464{
    6565    // Generated content may trigger calls to image() while we're still pending, don't assert but gracefully exit.
    66     if (m_styleImage->isPendingImage())
     66    if (m_styleImage->isPending())
    6767        return nullptr;
    6868    return m_styleImage->image(m_renderer, IntSize(width, height));

  • trunk/Source/WebCore/rendering/shapes/ShapeOutsideInfo.cpp

    r191234 r205181  
    157157        : LayoutRect(LayoutPoint(), imageSize);
    158158
    159     ASSERT(!styleImage->isPendingImage());
     159    ASSERT(!styleImage->isPending());
    160160    RefPtr<Image> image = styleImage->image(const_cast<RenderBox*>(&m_renderer), imageSize);
    161161    return Shape::createRasterShape(image.get(), shapeImageThreshold, imageRect, marginRect, writingMode, margin);

  • trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp

    r204566 r205181  
    3131namespace WebCore {
    3232
    33 StyleCachedImage::StyleCachedImage(CachedImage* image, float scaleFactor, CSSImageSetValue* cssValue)
    34     : m_image(image)
    35     , m_scaleFactor(scaleFactor)
    36     , m_cssImageSetValue(cssValue)
     33StyleCachedImage::StyleCachedImage(CSSValue& cssValue)
     34    : m_cssValue(&cssValue)
    3735{
    3836    m_isCachedImage = true;
    39     m_image->addClient(this);
    4037}
    4138
    4239StyleCachedImage::~StyleCachedImage()
    4340{
    44     m_image->removeClient(this);
     41    if (m_image)
     42        m_image->removeClient(this);
     43}
     44
     45void StyleCachedImage::setCachedImage(CachedImage& image, float scaleFactor)
     46{
     47    ASSERT(!m_image);
     48    m_image = &image;
     49    m_image->addClient(this);
     50    m_scaleFactor = scaleFactor;
    4551}
    4652
    4753PassRefPtr<CSSValue> StyleCachedImage::cssValue() const
    4854{
    49     if (m_cssImageSetValue)
    50         return const_cast<CSSImageSetValue*>(m_cssImageSetValue);
     55    if (m_cssValue)
     56        return m_cssValue;
    5157    return CSSPrimitiveValue::create(m_image->url(), CSSPrimitiveValue::CSS_URI);
    5258}
    … …  
    5460bool StyleCachedImage::canRender(const RenderObject* renderer, float multiplier) const
    5561{
     62    if (!m_image)
     63        return false;
    5664    return m_image->canRender(renderer, multiplier);
     65}
     66
     67bool StyleCachedImage::isPending() const
     68{
     69    return !m_image;
    5770}
    5871
    5972bool StyleCachedImage::isLoaded() const
    6073{
     74    if (!m_image)
     75        return false;
    6176    return m_image->isLoaded();
    6277}
    … …  
    6479bool StyleCachedImage::errorOccurred() const
    6580{
     81    if (!m_image)
     82        return false;
    6683    return m_image->errorOccurred();
    6784}
    … …  
    6986FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
    7087{
     88    if (!m_image)
     89        return { };
    7190    FloatSize size = m_image->imageSizeForRenderer(renderer, multiplier);
    7291    size.scale(1 / m_scaleFactor);
    … …  
    7695bool StyleCachedImage::imageHasRelativeWidth() const
    7796{
     97    if (!m_image)
     98        return false;
    7899    return m_image->imageHasRelativeWidth();
    79100}
    … …  
    81102bool StyleCachedImage::imageHasRelativeHeight() const
    82103{
     104    if (!m_image)
     105        return false;
    83106    return m_image->imageHasRelativeHeight();
    84107}
    … …  
    86109void StyleCachedImage::computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
    87110{
     111    if (!m_image)
     112        return;
    88113    m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
    89114}
    … …  
    91116bool StyleCachedImage::usesImageContainerSize() const
    92117{
     118    if (!m_image)
     119        return false;
    93120    return m_image->usesImageContainerSize();
    94121}
    … …  
    96123void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
    97124{
     125    if (!m_image)
     126        return;
    98127    m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
    99128}
    … …  
    101130void StyleCachedImage::addClient(RenderElement* renderer)
    102131{
     132    if (!m_image)
     133        return;
    103134    m_image->addClient(renderer);
    104135}
    … …  
    106137void StyleCachedImage::removeClient(RenderElement* renderer)
    107138{
     139    if (!m_image)
     140        return;
    108141    m_image->removeClient(renderer);
    109142}
    … …  
    111144RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
    112145{
     146    if (!m_image)
     147        return nullptr;
    113148    return m_image->imageForRenderer(renderer);
    114149}
    … …  
    121156bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const
    122157{
     158    if (!m_image)
     159        return false;
    123160    return m_image->currentFrameKnownToBeOpaque(renderer);
    124161}

  • trunk/Source/WebCore/rendering/style/StyleCachedImage.h

    r204560 r205181  
    3131namespace WebCore {
    3232
    33 class CSSImageSetValue;
     33class CSSValue;
    3434class CachedImage;
    3535
    … …  
    3737    WTF_MAKE_FAST_ALLOCATED;
    3838public:
    39     static Ref<StyleCachedImage> create(CachedImage* image) { return adoptRef(*new StyleCachedImage(image, 1, nullptr)); }
    40     static Ref<StyleCachedImage> createForImageSet(CachedImage* image, float scaleFactor, CSSImageSetValue& cssValue) { return adoptRef(*new StyleCachedImage(image, scaleFactor, &cssValue)); }
     39    static Ref<StyleCachedImage> create(CSSValue& cssValue) { return adoptRef(*new StyleCachedImage(cssValue)); }
    4140    virtual ~StyleCachedImage();
    4241
    4342    CachedImage* cachedImage() const override { return m_image.get(); }
    4443
    45     void detachFromCSSValue() { m_cssImageSetValue = nullptr; }
     44    void detachFromCSSValue() { m_cssValue = nullptr; }
     45    void setCSSValue(CSSValue& value) { m_cssValue = &value; }
    4646
    47 private:
     47    void setCachedImage(CachedImage&, float scaleFactor = 1);
     48
    4849    WrappedImagePtr data() const override { return m_image.get(); }
    4950
    … …  
    5152   
    5253    bool canRender(const RenderObject*, float multiplier) const override;
     54    bool isPending() const override;
    5355    bool isLoaded() const override;
    5456    bool errorOccurred() const override;
    … …  
    6567    bool knownToBeOpaque(const RenderElement*) const override;
    6668
    67     StyleCachedImage(CachedImage*, float scaleFactor, CSSImageSetValue*);
     69private:
     70    StyleCachedImage(CSSValue&);
    6871
     72    CSSValue* m_cssValue;
     73    float m_scaleFactor { 1 };
    6974    CachedResourceHandle<CachedImage> m_image;
    70     float m_scaleFactor;
    71     CSSImageSetValue* m_cssImageSetValue; // Not retained; it owns us.
    7275};
    7376

  • trunk/Source/WebCore/rendering/style/StyleGeneratedImage.cpp

    r194496 r205181  
    4141{
    4242    return const_cast<CSSImageGeneratorValue*>(m_imageGeneratorValue.ptr());
     43}
     44
     45bool StyleGeneratedImage::isPending() const
     46{
     47    return m_imageGeneratorValue->isPending();
    4348}
    4449

  • trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h

    r197563 r205181  
    4646    PassRefPtr<CSSValue> cssValue() const override;
    4747
     48    bool isPending() const override;
    4849    FloatSize imageSize(const RenderElement*, float multiplier) const override;
    4950    bool imageHasRelativeWidth() const override { return !m_fixedSize; }

  • trunk/Source/WebCore/rendering/style/StyleImage.h

    r204560 r205181  
    4848    bool operator==(const StyleImage& other) const
    4949    {
    50         return data() == other.data();
     50        return &other == this || (data() && data() == other.data());
    5151    }
    5252
    … …  
    5454
    5555    virtual bool canRender(const RenderObject*, float /*multiplier*/) const { return true; }
     56    virtual bool isPending() const = 0;
    5657    virtual bool isLoaded() const { return true; }
    5758    virtual bool errorOccurred() const { return false; }
    … …  
    7172
    7273    ALWAYS_INLINE bool isCachedImage() const { return m_isCachedImage; }
    73     ALWAYS_INLINE bool isPendingImage() const { return m_isPendingImage; }
    7474    ALWAYS_INLINE bool isGeneratedImage() const { return m_isGeneratedImage; }
    7575
    … …  
    7777    StyleImage()
    7878        : m_isCachedImage(false)
    79         , m_isPendingImage(false)
    8079        , m_isGeneratedImage(false)
    8180    {
    8281    }
    8382    bool m_isCachedImage : 1;
    84     bool m_isPendingImage : 1;
    8583    bool m_isGeneratedImage : 1;
    8684};

  • trunk/Source/WebCore/style/StylePendingResources.cpp

    r204566 r205181  
    2727#include "StylePendingResources.h"
    2828
     29#include "CSSCursorImageValue.h"
     30#include "CSSImageGeneratorValue.h"
     31#include "CSSImageSetValue.h"
     32#include "CSSImageValue.h"
    2933#include "CachedResourceLoader.h"
    3034#include "CachedSVGDocumentReference.h"
    … …  
    3741#include "StyleCachedImage.h"
    3842#include "StyleGeneratedImage.h"
    39 #include "StylePendingImage.h"
    4043#include "TransformFunctions.h"
    4144
    … …  
    4447
    4548enum class LoadPolicy { Normal, ShapeOutside };
    46 static RefPtr<StyleImage> loadPendingImage(Document& document, const StyleImage& image, const Element* element, LoadPolicy loadPolicy = LoadPolicy::Normal)
     49static void loadPendingImage(Document& document, const StyleImage* styleImage, const Element* element, LoadPolicy loadPolicy = LoadPolicy::Normal)
    4750{
    48     auto& pendingImage = downcast<StylePendingImage>(image);
     51    if (!styleImage || !styleImage->isPending())
     52        return;
     53
    4954    ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
    5055    options.contentSecurityPolicyImposition = element && element->isInUserAgentShadowTree() ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck;
    … …  
    5661    }
    5762
    58     if (auto imageValue = pendingImage.cssImageValue())
    59         return imageValue->cachedImage(document.cachedResourceLoader(), options);
     63    auto cssValue = const_cast<StyleImage*>(styleImage)->cssValue();
     64    if (is<CSSImageValue>(cssValue.get())) {
     65        downcast<CSSImageValue>(*cssValue).loadImage(document.cachedResourceLoader(), options);
     66        return;
     67    };
    6068
    61     if (auto imageGeneratorValue = pendingImage.cssImageGeneratorValue()) {
    62         imageGeneratorValue->loadSubimages(document.cachedResourceLoader(), options);
    63         return StyleGeneratedImage::create(*imageGeneratorValue);
    64     }
     69    if (is<CSSImageSetValue>(cssValue.get())) {
     70        downcast<CSSImageSetValue>(*cssValue).loadBestFitImage(document.cachedResourceLoader(), options);
     71        return;
     72    };
    6573
    66     if (auto cursorImageValue = pendingImage.cssCursorImageValue())
    67         return cursorImageValue->cachedImage(document.cachedResourceLoader(), options);
     74    if (is<CSSImageGeneratorValue>(cssValue.get())) {
     75        downcast<CSSImageGeneratorValue>(*cssValue).loadSubimages(document.cachedResourceLoader(), options);
     76        return;
     77    };
    6878
    69     if (auto imageSetValue = pendingImage.cssImageSetValue())
    70         return imageSetValue->bestFitImage(document.cachedResourceLoader(), options);
    71 
    72     return nullptr;
     79    if (is<CSSCursorImageValue>(cssValue.get())) {
     80        downcast<CSSCursorImageValue>(*cssValue).loadImage(document.cachedResourceLoader(), options);
     81        return;
     82    };
    7383}
    7484
    … …  
    7888        switch (currentProperty) {
    7989        case CSSPropertyBackgroundImage: {
    80             for (FillLayer* backgroundLayer = &style.ensureBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next()) {
    81                 auto* styleImage = backgroundLayer->image();
    82                 if (is<StylePendingImage>(styleImage))
    83                     backgroundLayer->setImage(loadPendingImage(document, *styleImage, element));
    84             }
     90            for (auto* backgroundLayer = &style.ensureBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next())
     91                loadPendingImage(document, backgroundLayer->image(), element);
    8592            break;
    8693        }
    8794        case CSSPropertyContent: {
    88             for (ContentData* contentData = const_cast<ContentData*>(style.contentData()); contentData; contentData = contentData->next()) {
     95            for (auto* contentData = const_cast<ContentData*>(style.contentData()); contentData; contentData = contentData->next()) {
    8996                if (is<ImageContentData>(*contentData)) {
    9097                    auto& styleImage = downcast<ImageContentData>(*contentData).image();
    91                     if (is<StylePendingImage>(styleImage)) {
    92                         if (auto loadedImage = loadPendingImage(document, styleImage, element))
    93                             downcast<ImageContentData>(*contentData).setImage(WTFMove(loadedImage));
    94                     }
     98                    loadPendingImage(document, &styleImage, element);
    9599                }
    96100            }
    … …  
    98102        }
    99103        case CSSPropertyCursor: {
    100             if (CursorList* cursorList = style.cursors()) {
    101                 for (size_t i = 0; i < cursorList->size(); ++i) {
    102                     CursorData& currentCursor = cursorList->at(i);
    103                     auto* styleImage = currentCursor.image();
    104                     if (is<StylePendingImage>(styleImage))
    105                         currentCursor.setImage(loadPendingImage(document, *styleImage, element));
    106                 }
     104            if (auto* cursorList = style.cursors()) {
     105                for (size_t i = 0; i < cursorList->size(); ++i)
     106                    loadPendingImage(document, cursorList->at(i).image(), element);
    107107            }
    108108            break;
    109109        }
    110110        case CSSPropertyListStyleImage: {
    111             auto* styleImage = style.listStyleImage();
    112             if (is<StylePendingImage>(styleImage))
    113                 style.setListStyleImage(loadPendingImage(document, *styleImage, element));
     111            loadPendingImage(document, style.listStyleImage(), element);
    114112            break;
    115113        }
    116114        case CSSPropertyBorderImageSource: {
    117             auto* styleImage = style.borderImageSource();
    118             if (is<StylePendingImage>(styleImage))
    119                 style.setBorderImageSource(loadPendingImage(document, *styleImage, element));
     115            loadPendingImage(document, style.borderImageSource(), element);
    120116            break;
    121117        }
    122118        case CSSPropertyWebkitBoxReflect: {
    123             if (StyleReflection* reflection = style.boxReflect()) {
    124                 const NinePieceImage& maskImage = reflection->mask();
    125                 auto* styleImage = maskImage.image();
    126                 if (is<StylePendingImage>(styleImage)) {
    127                     auto loadedImage = loadPendingImage(document, *styleImage, element);
    128                     reflection->setMask(NinePieceImage(WTFMove(loadedImage), maskImage.imageSlices(), maskImage.fill(), maskImage.borderSlices(), maskImage.outset(), maskImage.horizontalRule(), maskImage.verticalRule()));
    129                 }
    130             }
     119            if (auto* reflection = style.boxReflect())
     120                loadPendingImage(document, reflection->mask().image(), element);
    131121            break;
    132122        }
    133123        case CSSPropertyWebkitMaskBoxImageSource: {
    134             auto* styleImage = style.maskBoxImageSource();
    135             if (is<StylePendingImage>(styleImage))
    136                 style.setMaskBoxImageSource(loadPendingImage(document, *styleImage, element));
     124            loadPendingImage(document, style.maskBoxImageSource(), element);
    137125            break;
    138126        }
    139127        case CSSPropertyWebkitMaskImage: {
    140             for (FillLayer* maskLayer = &style.ensureMaskLayers(); maskLayer; maskLayer = maskLayer->next()) {
    141                 auto* styleImage = maskLayer->image();
    142                 if (is<StylePendingImage>(styleImage))
    143                     maskLayer->setImage(loadPendingImage(document, *styleImage, element));
    144             }
     128            for (auto* maskLayer = &style.ensureMaskLayers(); maskLayer; maskLayer = maskLayer->next())
     129                loadPendingImage(document, maskLayer->image(), element);
    145130            break;
    146131        }
    147132#if ENABLE(CSS_SHAPES)
    148133        case CSSPropertyWebkitShapeOutside: {
    149             if (!style.shapeOutside())
    150                 return;
    151 
    152             StyleImage* image = style.shapeOutside()->image();
    153             if (is<StylePendingImage>(image))
    154                 style.shapeOutside()->setImage(loadPendingImage(document, *image, element, LoadPolicy::ShapeOutside));
    155 
     134            if (style.shapeOutside())
     135                loadPendingImage(document, style.shapeOutside()->image(), element, LoadPolicy::ShapeOutside);
    156136            break;
    157137        }
Note: See TracChangeset for help on using the changeset viewer.