Changeset 205346 in webkit


Ignore:
Timestamp:
Sep 2, 2016 9:26:40 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r205344.
​https://bugs.webkit.org/show_bug.cgi?id=161533

Hitting assertions under CachedResource::removeClient in a few
tests (Requested by anttik on #webkit).

Reverted changeset:

"Reverse ownership relation of StyleCachedImage and
CSSImageValue"
​https://bugs.webkit.org/show_bug.cgi?id=161447
​http://trac.webkit.org/changeset/205344

Location:
trunk/Source/WebCore
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r205344 r205346  
     12016-09-02  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r205344.
     4        https://bugs.webkit.org/show_bug.cgi?id=161533
     5
     6        Hitting assertions under CachedResource::removeClient in a few
     7        tests (Requested by anttik on #webkit).
     8
     9        Reverted changeset:
     10
     11        "Reverse ownership relation of StyleCachedImage and
     12        CSSImageValue"
     13        https://bugs.webkit.org/show_bug.cgi?id=161447
     14        http://trac.webkit.org/changeset/205344
     15
    1162016-09-02  Antti Koivisto  <antti@apple.com>
    217

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

    r205344 r205346  
    2727#include "CachedImage.h"
    2828#include "CachedResourceLoader.h"
     29#include "StyleCachedImage.h"
     30#include "StyleImage.h"
    2931#include "SVGCursorElement.h"
    3032#include "SVGLengthContext.h"
    … …  
    108110    }
    109111
    110     if (auto* cursorElement = updateCursorElement(*loader.document())) {
    111         if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
    112             m_imageValue = CSSImageValue::create(cursorElement->href());
    113     }
    114 
    115112    downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options);
    116113}
    117114
    118 CachedImage* CSSCursorImageValue::cachedImage() const
     115StyleCachedImage& CSSCursorImageValue::styleImage(const Document& document)
    119116{
     117    // Need to delegate completely so that changes in device scale factor can be handled appropriately.
     118    StyleCachedImage* styleImage;
    120119    if (is<CSSImageSetValue>(m_imageValue.get()))
    121         return downcast<CSSImageSetValue>(m_imageValue.get()).cachedImage();
     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);
    122129
    123     return downcast<CSSImageValue>(m_imageValue.get()).cachedImage();
    124 }
    125 
    126 float CSSCursorImageValue::scaleFactor() const
    127 {
    128     if (is<CSSImageSetValue>(m_imageValue.get()))
    129         return downcast<CSSImageSetValue>(m_imageValue.get()).bestFitScaleFactor();
    130 
    131     return 1;
     130    return *styleImage;
    132131}
    133132

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

    r205344 r205346  
    3232class SVGCursorElement;
    3333class SVGElement;
     34class StyleCachedImage;
    3435
    3536class CSSCursorImageValue final : public CSSValue {
    … …  
    5455
    5556    void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    56     CachedImage* cachedImage() const;
    57 
    58     float scaleFactor() const;
     57    StyleCachedImage& styleImage(const Document&);
    5958
    6059    void removeReferencedElement(SVGElement*);

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

    r205344 r205346  
    254254        auto& imageValue = downcast<CSSImageValue>(value);
    255255        imageValue.loadImage(cachedResourceLoader, options);
    256         return imageValue.cachedImage();
     256        return imageValue.styleImage().cachedImage();
    257257    }
    258258   

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

    r205344 r205346  
    3636#include "Document.h"
    3737#include "Page.h"
     38#include "StyleCachedImage.h"
    3839#include <wtf/text/StringBuilder.h>
    3940
    … …  
    4243CSSImageSetValue::CSSImageSetValue()
    4344    : CSSValueList(ImageSetClass, CommaSeparator)
     45    , m_accessedBestFitImage(false)
     46    , m_scaleFactor(1)
    4447{
    4548}
    … …  
    4750CSSImageSetValue::~CSSImageSetValue()
    4851{
     52    if (m_image)
     53        m_image->detachFromCSSValue();
    4954}
    5055
    … …  
    7580CSSImageSetValue::ImageWithScale CSSImageSetValue::bestImageForScaleFactor()
    7681{
    77     if (!m_imagesInSet.size())
    78         fillImageSet();
    79 
    8082    ImageWithScale image;
    8183    size_t numberOfImages = m_imagesInSet.size();
    8284    for (size_t i = 0; i < numberOfImages; ++i) {
    8385        image = m_imagesInSet.at(i);
    84         if (image.scaleFactor >= m_deviceScaleFactor)
     86        if (image.scaleFactor >= m_scaleFactor)
    8587            return image;
    8688    }
    … …  
    9193{
    9294    Document* document = loader.document();
    93     updateDeviceScaleFactor(*document);
    94    
     95    if (Page* page = document->page())
     96        m_scaleFactor = page->deviceScaleFactor();
     97    else
     98        m_scaleFactor = 1;
     99
     100    if (!m_imagesInSet.size())
     101        fillImageSet();
     102
    95103    if (m_accessedBestFitImage)
    96104        return;
    97 
    98105    // FIXME: In the future, we want to take much more than deviceScaleFactor into acount here.
    99106    // All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
    … …  
    106113        updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
    107114    }
    108     m_cachedImage = loader.requestImage(request);
    109     m_bestFitImageScaleFactor = image.scaleFactor;
    110     m_accessedBestFitImage = true;
     115    if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
     116        styleImage(*document).setCachedImage(*cachedImage, image.scaleFactor);
     117        m_accessedBestFitImage = true;
     118    }
    111119}
    112120
    113 void CSSImageSetValue::updateDeviceScaleFactor(const Document& document)
     121StyleCachedImage& CSSImageSetValue::styleImage(const Document& document)
    114122{
    115     float deviceScaleFactor = document.page() ? document.page()->deviceScaleFactor() : 1;
    116     if (deviceScaleFactor == m_deviceScaleFactor)
    117         return;
    118     m_deviceScaleFactor = deviceScaleFactor;
    119     m_accessedBestFitImage = false;
    120     m_cachedImage = nullptr;
     123    if (!m_image)
     124        m_image = StyleCachedImage::create(*this);
     125    else if (!m_image->isPending()) {
     126        float deviceScaleFactor = 1;
     127        if (Page* page = document.page())
     128            deviceScaleFactor = page->deviceScaleFactor();
     129
     130        // If the deviceScaleFactor has changed, we may not have the best image loaded, so we have to re-assess.
     131        if (deviceScaleFactor != m_scaleFactor) {
     132            m_accessedBestFitImage = false;
     133            m_image->detachFromCSSValue();
     134            m_image = StyleCachedImage::create(*this);
     135        }
     136    }
     137
     138    return *m_image;
    121139}
    122140
    … …  
    153171bool CSSImageSetValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    154172{
    155     if (!m_cachedImage)
     173    if (!m_image)
    156174        return false;
    157     return handler(*m_cachedImage);
     175    CachedImage* cachedResource = m_image->cachedImage();
     176    if (!cachedResource)
     177        return false;
     178    return handler(*cachedResource);
    158179}
    159180
    160181CSSImageSetValue::CSSImageSetValue(const CSSImageSetValue& cloneFrom)
    161182    : CSSValueList(cloneFrom)
     183    , m_accessedBestFitImage(false)
     184    , m_scaleFactor(1)
    162185{
    163186    // Non-CSSValueList data is not accessible through CSS OM, no need to clone.

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

    r205344 r205346  
    2828
    2929#include "CSSValueList.h"
    30 #include "CachedImageClient.h"
    31 #include "CachedResourceHandle.h"
    3230
    3331namespace WebCore {
    … …  
    3533class CachedResourceLoader;
    3634class Document;
     35class StyleCachedImage;
     36class StyleImage;
    3737struct ResourceLoaderOptions;
    3838
    3939class CSSImageSetValue final : public CSSValueList {
    4040public:
     41
    4142    static Ref<CSSImageSetValue> create()
    4243    {
    … …  
    4647
    4748    void loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    48     CachedImage* cachedImage() const { return m_cachedImage.get(); }
     49    StyleCachedImage& styleImage(const Document&);
    4950
    5051    String customCSSText() const;
    5152
    52     float bestFitScaleFactor() const { return m_bestFitImageScaleFactor; };
     53    bool isPending() const { return !m_accessedBestFitImage; }
    5354
    5455    struct ImageWithScale {
    … …  
    6061
    6162    Ref<CSSImageSetValue> cloneForCSSOM() const;
    62 
    63     void updateDeviceScaleFactor(const Document&);
    6463
    6564protected:
    … …  
    7372    static inline bool compareByScaleFactor(ImageWithScale first, ImageWithScale second) { return first.scaleFactor < second.scaleFactor; }
    7473
    75     CachedResourceHandle<CachedImage> m_cachedImage;
    76     bool m_accessedBestFitImage { false };
    77     float m_bestFitImageScaleFactor { 1 };
    78     float m_deviceScaleFactor { 1 };
     74    RefPtr<StyleCachedImage> m_image;
     75    bool m_accessedBestFitImage;
     76
     77    // This represents the scale factor that we used to find the best fit image. It does not necessarily
     78    // correspond to the scale factor of the best fit image.
     79    float m_scaleFactor;
    7980
    8081    Vector<ImageWithScale> m_imagesInSet;

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

    r205344 r205346  
    3333#include "Element.h"
    3434#include "MemoryCache.h"
     35#include "StyleCachedImage.h"
    3536
    3637namespace WebCore {
    … …  
    4647    : CSSValue(ImageClass)
    4748    , m_url(image.url())
    48     , m_cachedImage(&image)
     49    , m_image(StyleCachedImage::create(*this))
    4950    , m_accessedImage(true)
    5051{
     52    m_image->setCachedImage(image);
    5153}
    5254
    … …  
    5456CSSImageValue::~CSSImageValue()
    5557{
     58    if (m_image)
     59        m_image->detachFromCSSValue();
    5660}
    5761
    5862bool CSSImageValue::isPending() const
    5963{
    60     return !m_accessedImage;
     64    return !m_image || !m_image->cachedImage();
     65}
     66
     67StyleCachedImage& CSSImageValue::styleImage()
     68{
     69    if (!m_image)
     70        m_image = StyleCachedImage::create(*this);
     71
     72    return *m_image;
    6173}
    6274
    … …  
    7789        updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
    7890    }
    79     m_cachedImage = loader.requestImage(request);
     91    if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request))
     92        styleImage().setCachedImage(*cachedImage);
    8093}
    8194
    8295bool CSSImageValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    8396{
    84     if (!m_cachedImage)
     97    if (!m_image)
    8598        return false;
    86     return handler(*m_cachedImage);
     99    CachedResource* cachedResource = m_image->cachedImage();
     100    if (!cachedResource)
     101        return false;
     102    return handler(*cachedResource);
    87103}
    88104
    … …  
    107123bool CSSImageValue::knownToBeOpaque(const RenderElement* renderer) const
    108124{
    109     if (!m_cachedImage)
    110         return false;
    111     return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
     125    return m_image ? m_image->knownToBeOpaque(renderer) : false;
    112126}
    113127

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

    r205344 r205346  
    2323
    2424#include "CSSValue.h"
    25 #include "CachedResourceHandle.h"
    2625#include <wtf/RefPtr.h>
    2726
    … …  
    3130class CachedResourceLoader;
    3231class Element;
     32class StyleCachedImage;
    3333class RenderElement;
    3434struct ResourceLoaderOptions;
    … …  
    4242    bool isPending() const;
    4343    void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    44     CachedImage* cachedImage() const { return m_cachedImage.get(); }
     44    StyleCachedImage& styleImage();
    4545
    4646    const String& url() const { return m_url; }
    … …  
    6363
    6464    String m_url;
    65     CachedResourceHandle<CachedImage> m_cachedImage;
     65    RefPtr<StyleCachedImage> m_image;
    6666    bool m_accessedImage;
    6767    AtomicString m_initiatorName;

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

    r205344 r205346  
    4747#include "SVGRenderStyle.h"
    4848#include "StyleBuilderConverter.h"
    49 #include "StyleCachedImage.h"
    5049#include "StyleFontSizeFunctions.h"
    5150#include "StyleGeneratedImage.h"
    … …  
    13151314            didSet = true;
    13161315        } else if (is<CSSImageSetValue>(item.get())) {
    1317             styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
     1316            styleResolver.style()->setContent(styleResolver.setOrPendingFromValue(CSSPropertyContent, downcast<CSSImageSetValue>(item.get())), didSet);
    13181317            didSet = true;
    13191318        }
    13201319
    13211320        if (is<CSSImageValue>(item.get())) {
    1322             styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
     1321            styleResolver.style()->setContent(styleResolver.cachedOrPendingFromValue(CSSPropertyContent, downcast<CSSImageValue>(item.get())), didSet);
    13231322            didSet = true;
    13241323            continue;

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

    r205344 r205346  
    17031703RefPtr<StyleImage> StyleResolver::styleImage(CSSPropertyID property, CSSValue& value)
    17041704{
     1705    if (is<CSSImageValue>(value))
     1706        return cachedOrPendingFromValue(property, downcast<CSSImageValue>(value));
     1707
    17051708    if (is<CSSImageGeneratorValue>(value)) {
    17061709        if (is<CSSGradientValue>(value))
    1707             return styleGeneratedImageFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
    1708         return styleGeneratedImageFromValue(property, downcast<CSSImageGeneratorValue>(value));
    1709     }
    1710 
    1711     if (is<CSSImageValue>(value) || is<CSSImageSetValue>(value) || is<CSSCursorImageValue>(value))
    1712         return styleCachedImageFromValue(property, value);
     1710            return generatedOrPendingFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
     1711        return generatedOrPendingFromValue(property, downcast<CSSImageGeneratorValue>(value));
     1712    }
     1713
     1714    if (is<CSSImageSetValue>(value))
     1715        return setOrPendingFromValue(property, downcast<CSSImageSetValue>(value));
     1716
     1717    if (is<CSSCursorImageValue>(value))
     1718        return cursorOrPendingFromValue(property, downcast<CSSCursorImageValue>(value));
    17131719
    17141720    return nullptr;
    17151721}
    17161722
    1717 Ref<StyleCachedImage> StyleResolver::styleCachedImageFromValue(CSSPropertyID property, CSSValue& value)
    1718 {
    1719     auto image = StyleCachedImage::create(value);
     1723Ref<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue& value)
     1724{
     1725    Ref<StyleImage> image = value.styleImage();
    17201726    if (image->isPending())
    17211727        m_state.ensurePendingResources().pendingImages.set(property, &value);
    … …  
    17231729}
    17241730
    1725 Ref<StyleGeneratedImage> StyleResolver::styleGeneratedImageFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
     1731Ref<StyleImage> StyleResolver::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
    17261732{
    17271733    if (is<CSSFilterImageValue>(value)) {
    … …  
    17331739
    17341740    return StyleGeneratedImage::create(value);
     1741}
     1742
     1743RefPtr<StyleImage> StyleResolver::setOrPendingFromValue(CSSPropertyID property, CSSImageSetValue& value)
     1744{
     1745    auto& image = value.styleImage(document());
     1746    if (image.isPending())
     1747        m_state.ensurePendingResources().pendingImages.set(property, &value);
     1748    return &image;
     1749}
     1750
     1751RefPtr<StyleImage> StyleResolver::cursorOrPendingFromValue(CSSPropertyID property, CSSCursorImageValue& value)
     1752{
     1753    auto& image = value.styleImage(document());
     1754    if (image.isPending())
     1755        m_state.ensurePendingResources().pendingImages.set(property, &value);
     1756    return &image;
    17351757}
    17361758

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

    r205344 r205346  
    7373class SelectorFilter;
    7474class Settings;
    75 class StyleCachedImage;
    76 class StyleGeneratedImage;
    7775class StyleImage;
    7876class StyleKeyframe;
    … …  
    461459
    462460    RefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue&);
    463     Ref<StyleCachedImage> styleCachedImageFromValue(CSSPropertyID, CSSValue&);
    464     Ref<StyleGeneratedImage> styleGeneratedImageFromValue(CSSPropertyID, CSSImageGeneratorValue&);
     461    Ref<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue&);
     462    Ref<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue&);
     463    RefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue&);
     464    RefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue&);
    465465
    466466    bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }

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

    r205344 r205346  
    332332            continue;
    333333
    334         auto* image = downcast<CSSImageValue>(*cssValue).cachedImage();
     334        auto& styleImage = downcast<CSSImageValue>(*cssValue).styleImage();
     335
     336        auto* image = styleImage.cachedImage();
    335337        if (!image)
    336338            continue;

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

    r205344 r205346  
    381381}
    382382
     383static inline bool layerImagesIdentical(const FillLayer& layer1, const FillLayer& layer2)
     384{
     385    // We just care about pointer equivalency.
     386    return layer1.image() == layer2.image();
     387}
     388
    383389bool FillLayer::imagesIdentical(const FillLayer* layer1, const FillLayer* layer2)
    384390{
    385391    for (; layer1 && layer2; layer1 = layer1->next(), layer2 = layer2->next()) {
    386         if (!arePointingToEqualData(layer1->image(), layer2->image()))
     392        if (!layerImagesIdentical(*layer1, *layer2))
    387393            return false;
    388394    }

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

    r205344 r205346  
    2525#include "StyleCachedImage.h"
    2626
    27 #include "CSSCursorImageValue.h"
    2827#include "CSSImageSetValue.h"
    29 #include "CSSImageValue.h"
    3028#include "CachedImage.h"
    3129#include "RenderElement.h"
    … …  
    3432
    3533StyleCachedImage::StyleCachedImage(CSSValue& cssValue)
    36     : m_cssValue(cssValue)
     34    : m_cssValue(&cssValue)
    3735{
    38     ASSERT(is<CSSImageValue>(m_cssValue) || is<CSSImageSetValue>(m_cssValue) || is<CSSCursorImageValue>(m_cssValue));
    39 
    4036    m_isCachedImage = true;
    4137}
    … …  
    4339StyleCachedImage::~StyleCachedImage()
    4440{
     41    if (m_image)
     42        m_image->removeClient(this);
    4543}
    4644
    47 bool StyleCachedImage::operator==(const StyleImage& other) const
     45void StyleCachedImage::setCachedImage(CachedImage& image, float scaleFactor)
    4846{
    49     if (!is<StyleCachedImage>(other))
    50         return false;
    51     auto& otherCached = downcast<StyleCachedImage>(other);
    52     if (&otherCached == this)
    53         return true;
    54     if (m_cssValue.ptr() == otherCached.m_cssValue.ptr())
    55         return true;
    56     if (m_cachedImage && m_cachedImage == otherCached.m_cachedImage)
    57         return true;
    58     return false;
    59 }
    60 
    61 CachedImage* StyleCachedImage::cachedImage() const
    62 {
    63     if (!m_cachedImage) {
    64         if (is<CSSImageValue>(m_cssValue)) {
    65             auto& imageValue = downcast<CSSImageValue>(m_cssValue.get());
    66             m_cachedImage = imageValue.cachedImage();
    67         } else if (is<CSSImageSetValue>(m_cssValue)) {
    68             auto& imageSetValue = downcast<CSSImageSetValue>(m_cssValue.get());
    69             m_cachedImage = imageSetValue.cachedImage();
    70             m_scaleFactor = imageSetValue.bestFitScaleFactor();
    71         } else if (is<CSSCursorImageValue>(m_cssValue.get())) {
    72             auto& cursorValue = downcast<CSSCursorImageValue>(m_cssValue.get());
    73             m_cachedImage = cursorValue.cachedImage();
    74             m_scaleFactor = cursorValue.scaleFactor();
    75         }
    76     }
    77     return m_cachedImage.get();
     47    ASSERT(!m_image);
     48    m_image = &image;
     49    m_image->addClient(this);
     50    m_scaleFactor = scaleFactor;
    7851}
    7952
    8053PassRefPtr<CSSValue> StyleCachedImage::cssValue() const
    8154{
    82     return const_cast<CSSValue*>(m_cssValue.ptr());
     55    if (m_cssValue)
     56        return m_cssValue;
     57    return CSSPrimitiveValue::create(m_image->url(), CSSPrimitiveValue::CSS_URI);
    8358}
    8459
    8560bool StyleCachedImage::canRender(const RenderObject* renderer, float multiplier) const
    8661{
    87     auto* image = cachedImage();
    88     if (!image)
     62    if (!m_image)
    8963        return false;
    90     return image->canRender(renderer, multiplier);
     64    return m_image->canRender(renderer, multiplier);
    9165}
    9266
    9367bool StyleCachedImage::isPending() const
    9468{
    95     return !m_cachedImage;
     69    return !m_image;
    9670}
    9771
    9872bool StyleCachedImage::isLoaded() const
    9973{
    100     auto* image = cachedImage();
    101     if (!image)
     74    if (!m_image)
    10275        return false;
    103     return image->isLoaded();
     76    return m_image->isLoaded();
    10477}
    10578
    10679bool StyleCachedImage::errorOccurred() const
    10780{
    108     auto* image = cachedImage();
    109     if (!image)
     81    if (!m_image)
    11082        return false;
    111     return image->errorOccurred();
     83    return m_image->errorOccurred();
    11284}
    11385
    11486FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
    11587{
    116     auto* image = cachedImage();
    117     if (!image)
     88    if (!m_image)
    11889        return { };
    119     FloatSize size = image->imageSizeForRenderer(renderer, multiplier);
     90    FloatSize size = m_image->imageSizeForRenderer(renderer, multiplier);
    12091    size.scale(1 / m_scaleFactor);
    12192    return size;
    … …  
    12495bool StyleCachedImage::imageHasRelativeWidth() const
    12596{
    126     auto* image = cachedImage();
    127     if (!image)
     97    if (!m_image)
    12898        return false;
    129     return image->imageHasRelativeWidth();
     99    return m_image->imageHasRelativeWidth();
    130100}
    131101
    132102bool StyleCachedImage::imageHasRelativeHeight() const
    133103{
    134     auto* image = cachedImage();
    135     if (!image)
     104    if (!m_image)
    136105        return false;
    137     return image->imageHasRelativeHeight();
     106    return m_image->imageHasRelativeHeight();
    138107}
    139108
    140109void StyleCachedImage::computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
    141110{
    142     auto* image = cachedImage();
    143     if (!image)
     111    if (!m_image)
    144112        return;
    145     image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
     113    m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
    146114}
    147115
    148116bool StyleCachedImage::usesImageContainerSize() const
    149117{
    150     auto* image = cachedImage();
    151     if (!image)
     118    if (!m_image)
    152119        return false;
    153     return image->usesImageContainerSize();
     120    return m_image->usesImageContainerSize();
    154121}
    155122
    156123void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
    157124{
    158     auto* image = cachedImage();
    159     if (!image)
     125    if (!m_image)
    160126        return;
    161     image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
     127    m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
    162128}
    163129
    164130void StyleCachedImage::addClient(RenderElement* renderer)
    165131{
    166     auto* image = cachedImage();
    167     if (!image)
     132    if (!m_image)
    168133        return;
    169     image->addClient(renderer);
     134    m_image->addClient(renderer);
    170135}
    171136
    172137void StyleCachedImage::removeClient(RenderElement* renderer)
    173138{
    174     auto* image = cachedImage();
    175     if (!image)
     139    if (!m_image)
    176140        return;
    177     image->removeClient(renderer);
     141    m_image->removeClient(renderer);
    178142}
    179143
    180144RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
    181145{
    182     auto* image = cachedImage();
    183     if (!image)
     146    if (!m_image)
    184147        return nullptr;
    185     return image->imageForRenderer(renderer);
     148    return m_image->imageForRenderer(renderer);
    186149}
    187150
    … …  
    193156bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const
    194157{
    195     auto* image = cachedImage();
    196     if (!image)
     158    if (!m_image)
    197159        return false;
    198     return image->currentFrameKnownToBeOpaque(renderer);
     160    return m_image->currentFrameKnownToBeOpaque(renderer);
    199161}
    200162

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

    r205344 r205346  
    3333class CSSValue;
    3434class CachedImage;
    35 class Document;
    3635
    37 class StyleCachedImage final : public StyleImage {
     36class StyleCachedImage final : public StyleImage, private CachedImageClient {
    3837    WTF_MAKE_FAST_ALLOCATED;
    3938public:
    … …  
    4140    virtual ~StyleCachedImage();
    4241
    43     bool operator==(const StyleImage& other) const override;
     42    CachedImage* cachedImage() const override { return m_image.get(); }
    4443
    45     CachedImage* cachedImage() const override;
     44    void detachFromCSSValue() { m_cssValue = nullptr; }
     45    void setCSSValue(CSSValue& value) { m_cssValue = &value; }
    4646
    47     WrappedImagePtr data() const override { return m_cachedImage.get(); }
     47    void setCachedImage(CachedImage&, float scaleFactor = 1);
     48
     49    WrappedImagePtr data() const override { return m_image.get(); }
    4850
    4951    PassRefPtr<CSSValue> cssValue() const override;
    … …  
    6870    StyleCachedImage(CSSValue&);
    6971
    70     Ref<CSSValue> m_cssValue;
    71     mutable float m_scaleFactor { 1 };
    72     mutable CachedResourceHandle<CachedImage> m_cachedImage;
     72    CSSValue* m_cssValue;
     73    float m_scaleFactor { 1 };
     74    CachedResourceHandle<CachedImage> m_image;
    7375};
    7476

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

    r205344 r205346  
    4242
    4343private:
    44     bool operator==(const StyleImage& other) const override { return data() == other.data(); }
    45 
    4644    WrappedImagePtr data() const override { return m_imageGeneratorValue.ptr(); }
    4745

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

    r205344 r205346  
    4646    virtual ~StyleImage() { }
    4747
    48     virtual bool operator==(const StyleImage& other) const = 0;
     48    bool operator==(const StyleImage& other) const
     49    {
     50        return &other == this || (data() && data() == other.data());
     51    }
    4952
    5053    virtual PassRefPtr<CSSValue> cssValue() const = 0;
Note: See TracChangeset for help on using the changeset viewer.