Changeset 205419 in webkit


Ignore:
Timestamp:
Sep 4, 2016 6:42:42 AM (8 years ago)
Author:
Antti Koivisto
Message:

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

Reviewed by Andreas Kling.

Currently StyleCachedImage (which represents an image in RenderStyle) has a weak ref to the
underlying CSSImageValue/CSSImageSetValue which actually owns it. This is awkwards especially since
StyleGeneratedImage, the other StyleImage subclass has reversed relationship where it refs
the underlying CSSImageGeneratorValue.

This patch makes StyleCachedImage similar to StyleGeneratedImage. StyleCachedImage now refs the
underlying CSSImageValue/CSSImageSetValue. CSSImageValues no longer need to know about StyleCachedImage.
Instead they reference CachedImages (memory cache objects) directly. StyleCachedImage instances are now
conceptually unique to RenderStyle instances. Actual resources are shared as before by sharing CachedImages.

  • css/CSSCursorImageValue.cpp:

(WebCore::CSSCursorImageValue::loadImage):
(WebCore::CSSCursorImageValue::cachedImage):
(WebCore::CSSCursorImageValue::styleImage): Deleted.

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

(WebCore::CSSImageGeneratorValue::cachedImageForCSSValue):

  • css/CSSImageSetValue.cpp:

(WebCore::CSSImageSetValue::~CSSImageSetValue):
(WebCore::CSSImageSetValue::loadBestFitImage):
(WebCore::CSSImageSetValue::traverseSubresources):
(WebCore::CSSImageSetValue::styleImage): Deleted.

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

(WebCore::CSSImageValue::CSSImageValue):
(WebCore::CSSImageValue::~CSSImageValue):
(WebCore::CSSImageValue::isPending):
(WebCore::CSSImageValue::loadImage):
(WebCore::CSSImageValue::traverseSubresources):
(WebCore::CSSImageValue::knownToBeOpaque):
(WebCore::CSSImageValue::styleImage): Deleted.

  • css/CSSImageValue.h:
  • css/StyleBuilderCustom.h:

(WebCore::StyleBuilderCustom::applyValueContent):

  • css/StyleResolver.cpp:

(WebCore::StyleResolver::styleImage):
(WebCore::StyleResolver::styleCachedImageFromValue):
(WebCore::StyleResolver::styleGeneratedImageFromValue):
(WebCore::StyleResolver::cachedOrPendingFromValue): Deleted.
(WebCore::StyleResolver::generatedOrPendingFromValue): Deleted.
(WebCore::StyleResolver::setOrPendingFromValue): Deleted.
(WebCore::StyleResolver::cursorOrPendingFromValue): Deleted.

  • css/StyleResolver.h:
  • editing/TextIterator.cpp:

(WebCore::fullyClipsContents):

  • page/PageSerializer.cpp:

(WebCore::PageSerializer::retrieveResourcesForProperties):

  • rendering/style/FillLayer.cpp:

(WebCore::FillLayer::imagesIdentical):

Compare data equality instead of pointer equality for StyleImages (since StyleImages are no longer shared).

(WebCore::layerImagesIdentical): Deleted.

  • rendering/style/StyleCachedImage.cpp:

(WebCore::StyleCachedImage::StyleCachedImage):
(WebCore::StyleCachedImage::~StyleCachedImage):
(WebCore::StyleCachedImage::cachedImage):
(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):
(WebCore::StyleCachedImage::setCachedImage): Deleted.

  • rendering/style/StyleCachedImage.h:
Location:
trunk/Source/WebCore
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r205417 r205419  
     12016-09-04  Antti Koivisto  <antti@apple.com>
     2
     3        Reverse ownership relation of StyleCachedImage and CSSImageValue
     4        https://bugs.webkit.org/show_bug.cgi?id=161447
     5
     6        Reviewed by Andreas Kling.
     7
     8        Currently StyleCachedImage (which represents an image in RenderStyle) has a weak ref to the
     9        underlying CSSImageValue/CSSImageSetValue which actually owns it. This is awkwards especially since
     10        StyleGeneratedImage, the other StyleImage subclass has reversed relationship where it refs
     11        the underlying CSSImageGeneratorValue.
     12
     13        This patch makes StyleCachedImage similar to StyleGeneratedImage. StyleCachedImage now refs the
     14        underlying CSSImageValue/CSSImageSetValue. CSSImageValues no longer need to know about StyleCachedImage.
     15        Instead they reference CachedImages (memory cache objects) directly. StyleCachedImage instances are now
     16        conceptually unique to RenderStyle instances. Actual resources are shared as before by sharing CachedImages.
     17
     18        * css/CSSCursorImageValue.cpp:
     19        (WebCore::CSSCursorImageValue::loadImage):
     20        (WebCore::CSSCursorImageValue::cachedImage):
     21        (WebCore::CSSCursorImageValue::styleImage): Deleted.
     22        * css/CSSCursorImageValue.h:
     23        * css/CSSImageGeneratorValue.cpp:
     24        (WebCore::CSSImageGeneratorValue::cachedImageForCSSValue):
     25        * css/CSSImageSetValue.cpp:
     26        (WebCore::CSSImageSetValue::~CSSImageSetValue):
     27        (WebCore::CSSImageSetValue::loadBestFitImage):
     28        (WebCore::CSSImageSetValue::traverseSubresources):
     29        (WebCore::CSSImageSetValue::styleImage): Deleted.
     30        * css/CSSImageSetValue.h:
     31        * css/CSSImageValue.cpp:
     32        (WebCore::CSSImageValue::CSSImageValue):
     33        (WebCore::CSSImageValue::~CSSImageValue):
     34        (WebCore::CSSImageValue::isPending):
     35        (WebCore::CSSImageValue::loadImage):
     36        (WebCore::CSSImageValue::traverseSubresources):
     37        (WebCore::CSSImageValue::knownToBeOpaque):
     38        (WebCore::CSSImageValue::styleImage): Deleted.
     39        * css/CSSImageValue.h:
     40        * css/StyleBuilderCustom.h:
     41        (WebCore::StyleBuilderCustom::applyValueContent):
     42        * css/StyleResolver.cpp:
     43        (WebCore::StyleResolver::styleImage):
     44        (WebCore::StyleResolver::styleCachedImageFromValue):
     45        (WebCore::StyleResolver::styleGeneratedImageFromValue):
     46        (WebCore::StyleResolver::cachedOrPendingFromValue): Deleted.
     47        (WebCore::StyleResolver::generatedOrPendingFromValue): Deleted.
     48        (WebCore::StyleResolver::setOrPendingFromValue): Deleted.
     49        (WebCore::StyleResolver::cursorOrPendingFromValue): Deleted.
     50        * css/StyleResolver.h:
     51        * editing/TextIterator.cpp:
     52        (WebCore::fullyClipsContents):
     53        * page/PageSerializer.cpp:
     54        (WebCore::PageSerializer::retrieveResourcesForProperties):
     55        * rendering/style/FillLayer.cpp:
     56        (WebCore::FillLayer::imagesIdentical):
     57
     58            Compare data equality instead of pointer equality for StyleImages (since StyleImages are no longer shared).
     59
     60        (WebCore::layerImagesIdentical): Deleted.
     61        * rendering/style/StyleCachedImage.cpp:
     62        (WebCore::StyleCachedImage::StyleCachedImage):
     63        (WebCore::StyleCachedImage::~StyleCachedImage):
     64        (WebCore::StyleCachedImage::cachedImage):
     65        (WebCore::StyleCachedImage::cssValue):
     66        (WebCore::StyleCachedImage::canRender):
     67        (WebCore::StyleCachedImage::isPending):
     68        (WebCore::StyleCachedImage::isLoaded):
     69        (WebCore::StyleCachedImage::errorOccurred):
     70        (WebCore::StyleCachedImage::imageSize):
     71        (WebCore::StyleCachedImage::imageHasRelativeWidth):
     72        (WebCore::StyleCachedImage::imageHasRelativeHeight):
     73        (WebCore::StyleCachedImage::computeIntrinsicDimensions):
     74        (WebCore::StyleCachedImage::usesImageContainerSize):
     75        (WebCore::StyleCachedImage::setContainerSizeForRenderer):
     76        (WebCore::StyleCachedImage::addClient):
     77        (WebCore::StyleCachedImage::removeClient):
     78        (WebCore::StyleCachedImage::image):
     79        (WebCore::StyleCachedImage::knownToBeOpaque):
     80        (WebCore::StyleCachedImage::setCachedImage): Deleted.
     81        * rendering/style/StyleCachedImage.h:
     82
    1832016-09-03  Wenson Hsieh  <wenson_hsieh@apple.com>
    284

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

    r205346 r205419  
    2727#include "CachedImage.h"
    2828#include "CachedResourceLoader.h"
    29 #include "StyleCachedImage.h"
    30 #include "StyleImage.h"
    3129#include "SVGCursorElement.h"
    3230#include "SVGLengthContext.h"
    … …  
    103101}
    104102
    105 void CSSCursorImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     103std::pair<CachedImage*, float> CSSCursorImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    106104{
    107     if (is<CSSImageSetValue>(m_imageValue.get())) {
    108         downcast<CSSImageSetValue>(m_imageValue.get()).loadBestFitImage(loader, options);
    109         return;
     105    if (is<CSSImageSetValue>(m_imageValue.get()))
     106        return downcast<CSSImageSetValue>(m_imageValue.get()).loadBestFitImage(loader, options);
     107
     108    if (auto* cursorElement = updateCursorElement(*loader.document())) {
     109        if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
     110            m_imageValue = CSSImageValue::create(cursorElement->href());
    110111    }
    111112
    112     downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options);
    113 }
    114 
    115 StyleCachedImage& CSSCursorImageValue::styleImage(const Document& document)
    116 {
    117     // Need to delegate completely so that changes in device scale factor can be handled appropriately.
    118     StyleCachedImage* styleImage;
    119     if (is<CSSImageSetValue>(m_imageValue.get()))
    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);
    129 
    130     return *styleImage;
     113    return { downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options), 1 };
    131114}
    132115

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

    r205346 r205419  
    3232class SVGCursorElement;
    3333class SVGElement;
    34 class StyleCachedImage;
    3534
    3635class CSSCursorImageValue final : public CSSValue {
    … …  
    5453    String customCSSText() const;
    5554
    56     void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    57     StyleCachedImage& styleImage(const Document&);
     55    std::pair<CachedImage*, float> loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    5856
    5957    void removeReferencedElement(SVGElement*);

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

    r205346 r205419  
    253253    if (is<CSSImageValue>(value)) {
    254254        auto& imageValue = downcast<CSSImageValue>(value);
    255         imageValue.loadImage(cachedResourceLoader, options);
    256         return imageValue.styleImage().cachedImage();
     255        return imageValue.loadImage(cachedResourceLoader, options);
    257256    }
    258257   

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

    r205346 r205419  
    3636#include "Document.h"
    3737#include "Page.h"
    38 #include "StyleCachedImage.h"
    3938#include <wtf/text/StringBuilder.h>
    4039
    … …  
    4342CSSImageSetValue::CSSImageSetValue()
    4443    : CSSValueList(ImageSetClass, CommaSeparator)
    45     , m_accessedBestFitImage(false)
    46     , m_scaleFactor(1)
    4744{
    4845}
    … …  
    5047CSSImageSetValue::~CSSImageSetValue()
    5148{
    52     if (m_image)
    53         m_image->detachFromCSSValue();
    5449}
    5550
    … …  
    8075CSSImageSetValue::ImageWithScale CSSImageSetValue::bestImageForScaleFactor()
    8176{
     77    if (!m_imagesInSet.size())
     78        fillImageSet();
     79
    8280    ImageWithScale image;
    8381    size_t numberOfImages = m_imagesInSet.size();
    8482    for (size_t i = 0; i < numberOfImages; ++i) {
    8583        image = m_imagesInSet.at(i);
    86         if (image.scaleFactor >= m_scaleFactor)
     84        if (image.scaleFactor >= m_deviceScaleFactor)
    8785            return image;
    8886    }
    … …  
    9088}
    9189
    92 void CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     90std::pair<CachedImage*, float> CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    9391{
    9492    Document* document = loader.document();
    95     if (Page* page = document->page())
    96         m_scaleFactor = page->deviceScaleFactor();
    97     else
    98         m_scaleFactor = 1;
     93    updateDeviceScaleFactor(*document);
     94   
     95    if (!m_accessedBestFitImage) {
     96        m_accessedBestFitImage = true;
    9997
    100     if (!m_imagesInSet.size())
    101         fillImageSet();
    102 
    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);
     98        // FIXME: In the future, we want to take much more than deviceScaleFactor into acount here.
     99        // All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
     100        // and any CSS transforms. https://bugs.webkit.org/show_bug.cgi?id=81698
     101        ImageWithScale image = bestImageForScaleFactor();
     102        CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
     103        request.setInitiator(cachedResourceRequestInitiators().css);
     104        if (options.mode == FetchOptions::Mode::Cors) {
     105            ASSERT(document->securityOrigin());
     106            updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
     107        }
     108        m_cachedImage = loader.requestImage(request);
     109        m_bestFitImageScaleFactor = image.scaleFactor;
    114110    }
    115     if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
    116         styleImage(*document).setCachedImage(*cachedImage, image.scaleFactor);
    117         m_accessedBestFitImage = true;
    118     }
     111    return { m_cachedImage.get(), m_bestFitImageScaleFactor };
    119112}
    120113
    121 StyleCachedImage& CSSImageSetValue::styleImage(const Document& document)
     114void CSSImageSetValue::updateDeviceScaleFactor(const Document& document)
    122115{
    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;
     116    float deviceScaleFactor = document.page() ? document.page()->deviceScaleFactor() : 1;
     117    if (deviceScaleFactor == m_deviceScaleFactor)
     118        return;
     119    m_deviceScaleFactor = deviceScaleFactor;
     120    m_accessedBestFitImage = false;
     121    m_cachedImage = nullptr;
    139122}
    140123
    … …  
    171154bool CSSImageSetValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    172155{
    173     if (!m_image)
     156    if (!m_cachedImage)
    174157        return false;
    175     CachedImage* cachedResource = m_image->cachedImage();
    176     if (!cachedResource)
    177         return false;
    178     return handler(*cachedResource);
     158    return handler(*m_cachedImage);
    179159}
    180160
    181161CSSImageSetValue::CSSImageSetValue(const CSSImageSetValue& cloneFrom)
    182162    : CSSValueList(cloneFrom)
    183     , m_accessedBestFitImage(false)
    184     , m_scaleFactor(1)
    185163{
    186164    // Non-CSSValueList data is not accessible through CSS OM, no need to clone.

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

    r205346 r205419  
    2828
    2929#include "CSSValueList.h"
     30#include "CachedImageClient.h"
     31#include "CachedResourceHandle.h"
    3032
    3133namespace WebCore {
    … …  
    3335class CachedResourceLoader;
    3436class Document;
    35 class StyleCachedImage;
    36 class StyleImage;
    3737struct ResourceLoaderOptions;
    3838
    3939class CSSImageSetValue final : public CSSValueList {
    4040public:
    41 
    4241    static Ref<CSSImageSetValue> create()
    4342    {
    … …  
    4645    ~CSSImageSetValue();
    4746
    48     void loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
    49     StyleCachedImage& styleImage(const Document&);
     47    std::pair<CachedImage*, float> loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
     48    CachedImage* cachedImage() const { return m_cachedImage.get(); }
    5049
    5150    String customCSSText() const;
    52 
    53     bool isPending() const { return !m_accessedBestFitImage; }
    5451
    5552    struct ImageWithScale {
    … …  
    6158
    6259    Ref<CSSImageSetValue> cloneForCSSOM() const;
     60
     61    void updateDeviceScaleFactor(const Document&);
    6362
    6463protected:
    … …  
    7271    static inline bool compareByScaleFactor(ImageWithScale first, ImageWithScale second) { return first.scaleFactor < second.scaleFactor; }
    7372
    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;
     73    CachedResourceHandle<CachedImage> m_cachedImage;
     74    bool m_accessedBestFitImage { false };
     75    float m_bestFitImageScaleFactor { 1 };
     76    float m_deviceScaleFactor { 1 };
    8077
    8178    Vector<ImageWithScale> m_imagesInSet;

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

    r205346 r205419  
    3333#include "Element.h"
    3434#include "MemoryCache.h"
    35 #include "StyleCachedImage.h"
    3635
    3736namespace WebCore {
    … …  
    4746    : CSSValue(ImageClass)
    4847    , m_url(image.url())
    49     , m_image(StyleCachedImage::create(*this))
     48    , m_cachedImage(&image)
    5049    , m_accessedImage(true)
    5150{
    52     m_image->setCachedImage(image);
    5351}
    5452
    … …  
    5654CSSImageValue::~CSSImageValue()
    5755{
    58     if (m_image)
    59         m_image->detachFromCSSValue();
    6056}
    6157
    6258bool CSSImageValue::isPending() const
    6359{
    64     return !m_image || !m_image->cachedImage();
     60    return !m_accessedImage;
    6561}
    6662
    67 StyleCachedImage& CSSImageValue::styleImage()
     63CachedImage* CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    6864{
    69     if (!m_image)
    70         m_image = StyleCachedImage::create(*this);
     65    if (!m_accessedImage) {
     66        m_accessedImage = true;
    7167
    72     return *m_image;
    73 }
     68        CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
     69        if (m_initiatorName.isEmpty())
     70            request.setInitiator(cachedResourceRequestInitiators().css);
     71        else
     72            request.setInitiator(m_initiatorName);
    7473
    75 void CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
    76 {
    77     if (m_accessedImage)
    78         return;
    79     m_accessedImage = true;
    80 
    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);
    86 
    87     if (options.mode == FetchOptions::Mode::Cors) {
    88         ASSERT(loader.document()->securityOrigin());
    89         updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
     74        if (options.mode == FetchOptions::Mode::Cors) {
     75            ASSERT(loader.document()->securityOrigin());
     76            updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
     77        }
     78        m_cachedImage = loader.requestImage(request);
    9079    }
    91     if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request))
    92         styleImage().setCachedImage(*cachedImage);
     80    return m_cachedImage.get();
    9381}
    9482
    9583bool CSSImageValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
    9684{
    97     if (!m_image)
     85    if (!m_cachedImage)
    9886        return false;
    99     CachedResource* cachedResource = m_image->cachedImage();
    100     if (!cachedResource)
    101         return false;
    102     return handler(*cachedResource);
     87    return handler(*m_cachedImage);
    10388}
    10489
    … …  
    123108bool CSSImageValue::knownToBeOpaque(const RenderElement* renderer) const
    124109{
    125     return m_image ? m_image->knownToBeOpaque(renderer) : false;
     110    if (!m_cachedImage)
     111        return false;
     112    return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
    126113}
    127114

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

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

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

    r205346 r205419  
    4747#include "SVGRenderStyle.h"
    4848#include "StyleBuilderConverter.h"
     49#include "StyleCachedImage.h"
    4950#include "StyleFontSizeFunctions.h"
    5051#include "StyleGeneratedImage.h"
    … …  
    13141315            didSet = true;
    13151316        } else if (is<CSSImageSetValue>(item.get())) {
    1316             styleResolver.style()->setContent(styleResolver.setOrPendingFromValue(CSSPropertyContent, downcast<CSSImageSetValue>(item.get())), didSet);
     1317            styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
    13171318            didSet = true;
    13181319        }
    13191320
    13201321        if (is<CSSImageValue>(item.get())) {
    1321             styleResolver.style()->setContent(styleResolver.cachedOrPendingFromValue(CSSPropertyContent, downcast<CSSImageValue>(item.get())), didSet);
     1322            styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
    13221323            didSet = true;
    13231324            continue;

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

    r205346 r205419  
    17031703RefPtr<StyleImage> StyleResolver::styleImage(CSSPropertyID property, CSSValue& value)
    17041704{
    1705     if (is<CSSImageValue>(value))
    1706         return cachedOrPendingFromValue(property, downcast<CSSImageValue>(value));
    1707 
    17081705    if (is<CSSImageGeneratorValue>(value)) {
    17091706        if (is<CSSGradientValue>(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));
     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);
    17191713
    17201714    return nullptr;
    17211715}
    17221716
    1723 Ref<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue& value)
    1724 {
    1725     Ref<StyleImage> image = value.styleImage();
     1717Ref<StyleCachedImage> StyleResolver::styleCachedImageFromValue(CSSPropertyID property, CSSValue& value)
     1718{
     1719    auto image = StyleCachedImage::create(value);
    17261720    if (image->isPending())
    17271721        m_state.ensurePendingResources().pendingImages.set(property, &value);
    … …  
    17291723}
    17301724
    1731 Ref<StyleImage> StyleResolver::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
     1725Ref<StyleGeneratedImage> StyleResolver::styleGeneratedImageFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
    17321726{
    17331727    if (is<CSSFilterImageValue>(value)) {
    … …  
    17391733
    17401734    return StyleGeneratedImage::create(value);
    1741 }
    1742 
    1743 RefPtr<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 
    1751 RefPtr<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;
    17571735}
    17581736

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

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

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

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

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

    r205346 r205419  
    381381}
    382382
    383 static 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 
    389383bool FillLayer::imagesIdentical(const FillLayer* layer1, const FillLayer* layer2)
    390384{
    391385    for (; layer1 && layer2; layer1 = layer1->next(), layer2 = layer2->next()) {
    392         if (!layerImagesIdentical(*layer1, *layer2))
     386        if (!arePointingToEqualData(layer1->image(), layer2->image()))
    393387            return false;
    394388    }

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

    r205346 r205419  
    33 *           (C) 2000 Antti Koivisto (koivisto@kde.org)
    44 *           (C) 2000 Dirk Mueller (mueller@kde.org)
    5  * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
     5 * Copyright (C) 2003, 2005-2008, 2016 Apple Inc. All rights reserved.
    66 *
    77 * This library is free software; you can redistribute it and/or
    … …  
    2525#include "StyleCachedImage.h"
    2626
     27#include "CSSCursorImageValue.h"
    2728#include "CSSImageSetValue.h"
     29#include "CSSImageValue.h"
    2830#include "CachedImage.h"
    2931#include "RenderElement.h"
    … …  
    3234
    3335StyleCachedImage::StyleCachedImage(CSSValue& cssValue)
    34     : m_cssValue(&cssValue)
     36    : m_cssValue(cssValue)
    3537{
     38    ASSERT(is<CSSImageValue>(m_cssValue) || is<CSSImageSetValue>(m_cssValue) || is<CSSCursorImageValue>(m_cssValue));
     39
    3640    m_isCachedImage = true;
    3741}
    … …  
    3943StyleCachedImage::~StyleCachedImage()
    4044{
    41     if (m_image)
    42         m_image->removeClient(this);
    4345}
    4446
    45 void StyleCachedImage::setCachedImage(CachedImage& image, float scaleFactor)
     47bool StyleCachedImage::operator==(const StyleImage& other) const
    4648{
    47     ASSERT(!m_image);
    48     m_image = &image;
    49     m_image->addClient(this);
    50     m_scaleFactor = scaleFactor;
     49    if (!is<StyleCachedImage>(other))
     50        return false;
     51    auto& otherCached = downcast<StyleCachedImage>(other);
     52    if (&otherCached == this)
     53        return true;
     54    if (m_scaleFactor != otherCached.m_scaleFactor)
     55        return false;
     56    if (m_cssValue.ptr() == otherCached.m_cssValue.ptr())
     57        return true;
     58    if (m_cachedImage && m_cachedImage == otherCached.m_cachedImage)
     59        return true;
     60    return false;
     61}
     62
     63void StyleCachedImage::load(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     64{
     65    ASSERT(isPending());
     66
     67    if (is<CSSImageValue>(m_cssValue)) {
     68        auto& imageValue = downcast<CSSImageValue>(m_cssValue.get());
     69        m_cachedImage = imageValue.loadImage(loader, options);
     70        return;
     71    }
     72
     73    if (is<CSSImageSetValue>(m_cssValue)) {
     74        auto& imageSetValue = downcast<CSSImageSetValue>(m_cssValue.get());
     75        std::tie(m_cachedImage, m_scaleFactor) = imageSetValue.loadBestFitImage(loader, options);
     76        return;
     77    }
     78
     79    if (is<CSSCursorImageValue>(m_cssValue.get())) {
     80        auto& cursorValue = downcast<CSSCursorImageValue>(m_cssValue.get());
     81        std::tie(m_cachedImage, m_scaleFactor) = cursorValue.loadImage(loader, options);
     82        return;
     83    }
     84}
     85
     86CachedImage* StyleCachedImage::cachedImage() const
     87{
     88    return m_cachedImage.get();
    5189}
    5290
    5391PassRefPtr<CSSValue> StyleCachedImage::cssValue() const
    5492{
    55     if (m_cssValue)
    56         return m_cssValue;
    57     return CSSPrimitiveValue::create(m_image->url(), CSSPrimitiveValue::CSS_URI);
     93    return const_cast<CSSValue*>(m_cssValue.ptr());
    5894}
    5995
    6096bool StyleCachedImage::canRender(const RenderObject* renderer, float multiplier) const
    6197{
    62     if (!m_image)
     98    if (!m_cachedImage)
    6399        return false;
    64     return m_image->canRender(renderer, multiplier);
     100    return m_cachedImage->canRender(renderer, multiplier);
    65101}
    66102
    67103bool StyleCachedImage::isPending() const
    68104{
    69     return !m_image;
     105    return !m_cachedImage;
    70106}
    71107
    72108bool StyleCachedImage::isLoaded() const
    73109{
    74     if (!m_image)
     110    if (!m_cachedImage)
    75111        return false;
    76     return m_image->isLoaded();
     112    return m_cachedImage->isLoaded();
    77113}
    78114
    79115bool StyleCachedImage::errorOccurred() const
    80116{
    81     if (!m_image)
     117    if (!m_cachedImage)
    82118        return false;
    83     return m_image->errorOccurred();
     119    return m_cachedImage->errorOccurred();
    84120}
    85121
    86122FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
    87123{
    88     if (!m_image)
     124    if (!m_cachedImage)
    89125        return { };
    90     FloatSize size = m_image->imageSizeForRenderer(renderer, multiplier);
     126    FloatSize size = m_cachedImage->imageSizeForRenderer(renderer, multiplier);
    91127    size.scale(1 / m_scaleFactor);
    92128    return size;
    … …  
    95131bool StyleCachedImage::imageHasRelativeWidth() const
    96132{
    97     if (!m_image)
     133    if (!m_cachedImage)
    98134        return false;
    99     return m_image->imageHasRelativeWidth();
     135    return m_cachedImage->imageHasRelativeWidth();
    100136}
    101137
    102138bool StyleCachedImage::imageHasRelativeHeight() const
    103139{
    104     if (!m_image)
     140    if (!m_cachedImage)
    105141        return false;
    106     return m_image->imageHasRelativeHeight();
     142    return m_cachedImage->imageHasRelativeHeight();
    107143}
    108144
    109145void StyleCachedImage::computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
    110146{
    111     if (!m_image)
     147    if (!m_cachedImage)
    112148        return;
    113     m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
     149    m_cachedImage->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
    114150}
    115151
    116152bool StyleCachedImage::usesImageContainerSize() const
    117153{
    118     if (!m_image)
     154    if (!m_cachedImage)
    119155        return false;
    120     return m_image->usesImageContainerSize();
     156    return m_cachedImage->usesImageContainerSize();
    121157}
    122158
    123159void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
    124160{
    125     if (!m_image)
     161    if (!m_cachedImage)
    126162        return;
    127     m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
     163    m_cachedImage->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
    128164}
    129165
    130166void StyleCachedImage::addClient(RenderElement* renderer)
    131167{
    132     if (!m_image)
     168    if (!m_cachedImage)
    133169        return;
    134     m_image->addClient(renderer);
     170    m_cachedImage->addClient(renderer);
    135171}
    136172
    137173void StyleCachedImage::removeClient(RenderElement* renderer)
    138174{
    139     if (!m_image)
     175    if (!m_cachedImage)
    140176        return;
    141     m_image->removeClient(renderer);
     177    m_cachedImage->removeClient(renderer);
    142178}
    143179
    144180RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
    145181{
    146     if (!m_image)
     182    if (!m_cachedImage)
    147183        return nullptr;
    148     return m_image->imageForRenderer(renderer);
     184    return m_cachedImage->imageForRenderer(renderer);
    149185}
    150186
    … …  
    156192bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const
    157193{
    158     if (!m_image)
     194    if (!m_cachedImage)
    159195        return false;
    160     return m_image->currentFrameKnownToBeOpaque(renderer);
     196    return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
    161197}
    162198

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

    r205346 r205419  
    3333class CSSValue;
    3434class CachedImage;
     35class Document;
    3536
    36 class StyleCachedImage final : public StyleImage, private CachedImageClient {
     37class StyleCachedImage final : public StyleImage {
    3738    WTF_MAKE_FAST_ALLOCATED;
    3839public:
    … …  
    4041    virtual ~StyleCachedImage();
    4142
    42     CachedImage* cachedImage() const override { return m_image.get(); }
     43    bool operator==(const StyleImage& other) const override;
    4344
    44     void detachFromCSSValue() { m_cssValue = nullptr; }
    45     void setCSSValue(CSSValue& value) { m_cssValue = &value; }
     45    CachedImage* cachedImage() const override;
    4646
    47     void setCachedImage(CachedImage&, float scaleFactor = 1);
    48 
    49     WrappedImagePtr data() const override { return m_image.get(); }
     47    WrappedImagePtr data() const override { return m_cachedImage.get(); }
    5048
    5149    PassRefPtr<CSSValue> cssValue() const override;
    … …  
    5351    bool canRender(const RenderObject*, float multiplier) const override;
    5452    bool isPending() const override;
     53    void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
    5554    bool isLoaded() const override;
    5655    bool errorOccurred() const override;
    … …  
    7069    StyleCachedImage(CSSValue&);
    7170
    72     CSSValue* m_cssValue;
    73     float m_scaleFactor { 1 };
    74     CachedResourceHandle<CachedImage> m_image;
     71    Ref<CSSValue> m_cssValue;
     72    mutable float m_scaleFactor { 1 };
     73    mutable CachedResourceHandle<CachedImage> m_cachedImage;
    7574};
    7675

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

    r205181 r205419  
    4646{
    4747    return m_imageGeneratorValue->isPending();
     48}
     49
     50void StyleGeneratedImage::load(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
     51{
     52    m_imageGeneratorValue->loadSubimages(loader, options);
    4853}
    4954

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

    r205346 r205419  
    4242
    4343private:
     44    bool operator==(const StyleImage& other) const override { return data() == other.data(); }
     45
    4446    WrappedImagePtr data() const override { return m_imageGeneratorValue.ptr(); }
    4547
    … …  
    4749
    4850    bool isPending() const override;
     51    void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
    4952    FloatSize imageSize(const RenderElement*, float multiplier) const override;
    5053    bool imageHasRelativeWidth() const override { return !m_fixedSize; }

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

    r205346 r205419  
    3636
    3737class CachedImage;
     38class CachedResourceLoader;
    3839class CSSValue;
    3940class RenderElement;
    4041class RenderObject;
     42struct ResourceLoaderOptions;
    4143
    4244typedef const void* WrappedImagePtr;
    … …  
    4648    virtual ~StyleImage() { }
    4749
    48     bool operator==(const StyleImage& other) const
    49     {
    50         return &other == this || (data() && data() == other.data());
    51     }
     50    virtual bool operator==(const StyleImage& other) const = 0;
    5251
    5352    virtual PassRefPtr<CSSValue> cssValue() const = 0;
    … …  
    5554    virtual bool canRender(const RenderObject*, float /*multiplier*/) const { return true; }
    5655    virtual bool isPending() const = 0;
     56    virtual void load(CachedResourceLoader&, const ResourceLoaderOptions&) = 0;
    5757    virtual bool isLoaded() const { return true; }
    5858    virtual bool errorOccurred() const { return false; }

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

    r205181 r205419  
    2828
    2929#include "CSSCursorImageValue.h"
    30 #include "CSSImageGeneratorValue.h"
    31 #include "CSSImageSetValue.h"
    32 #include "CSSImageValue.h"
    3330#include "CachedResourceLoader.h"
    3431#include "CachedSVGDocumentReference.h"
    … …  
    6158    }
    6259
    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     };
    68 
    69     if (is<CSSImageSetValue>(cssValue.get())) {
    70         downcast<CSSImageSetValue>(*cssValue).loadBestFitImage(document.cachedResourceLoader(), options);
    71         return;
    72     };
    73 
    74     if (is<CSSImageGeneratorValue>(cssValue.get())) {
    75         downcast<CSSImageGeneratorValue>(*cssValue).loadSubimages(document.cachedResourceLoader(), options);
    76         return;
    77     };
    78 
    79     if (is<CSSCursorImageValue>(cssValue.get())) {
    80         downcast<CSSCursorImageValue>(*cssValue).loadImage(document.cachedResourceLoader(), options);
    81         return;
    82     };
     60    const_cast<StyleImage&>(*styleImage).load(document.cachedResourceLoader(), options);
    8361}
    8462
Note: See TracChangeset for help on using the changeset viewer.