⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 101177 in webkit


Ignore:
Timestamp:
Nov 25, 2011, 10:08:38 AM (15 years ago)
Author:
Antti Koivisto
Message:

StyleGeneratedImage should ref CSSImageGeneratorValue
​https://bugs.webkit.org/show_bug.cgi?id=73074

Reviewed by Andreas Kling and Nikolas Zimmermann.

RenderStyle owns a bunch of StyleImage objects. However StyleGeneratedImage does not ref the
CSSImageGeneratorValue it holds so we currently rely on the stylesheet to keep the CSSImageGeneratorValues
alive as long as RenderStyle stays alive. While this works (RenderStyles are thrown away if stylesheets
change) it is not particularly robust or nice.

  • Use RefPtr<CSSImageGeneratorValue> in StyleGeneratedImage
  • Remove the RefPtr<StyleGeneratedImage> from CSSImageGeneratorValue. There is no good reason to cache StyleGeneratedImage as it is a small and uncommon object. With that the whole back-reference becomes unnecessary.
  • Switch more places to use (Pass)RefPtr<StyleImage> for consistency.
  • css/CSSImageGeneratorValue.cpp:

(WebCore::CSSImageGeneratorValue::CSSImageGeneratorValue):

  • css/CSSImageGeneratorValue.h:
  • css/CSSStyleApplyProperty.cpp:
  • css/CSSStyleSelector.cpp:

(WebCore::CSSStyleSelector::applyProperty):
(WebCore::CSSStyleSelector::styleImage):
(WebCore::CSSStyleSelector::cachedOrPendingFromValue):
(WebCore::CSSStyleSelector::generatedOrPendingFromValue):
(WebCore::CSSStyleSelector::loadPendingImage):
(WebCore::CSSStyleSelector::loadPendingImages):

  • css/CSSStyleSelector.h:
  • rendering/style/FillLayer.h:

(WebCore::FillLayer::setImage):

  • rendering/style/NinePieceImage.h:

(WebCore::NinePieceImage::NinePieceImage):

  • rendering/style/StyleGeneratedImage.cpp:

(WebCore::StyleGeneratedImage::StyleGeneratedImage):
(WebCore::StyleGeneratedImage::cssValue):
(WebCore::StyleGeneratedImage::imageSize):
(WebCore::StyleGeneratedImage::addClient):
(WebCore::StyleGeneratedImage::removeClient):
(WebCore::StyleGeneratedImage::image):

  • rendering/style/StyleGeneratedImage.h:

(WebCore::StyleGeneratedImage::create):
(WebCore::StyleGeneratedImage::data):

Location:
trunk/Source/WebCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r101175 r101177  
     12011-11-25  Antti Koivisto  <antti@apple.com>
     2
     3        StyleGeneratedImage should ref CSSImageGeneratorValue
     4        https://bugs.webkit.org/show_bug.cgi?id=73074
     5
     6        Reviewed by Andreas Kling and Nikolas Zimmermann.
     7       
     8        RenderStyle owns a bunch of StyleImage objects. However StyleGeneratedImage does not ref the
     9        CSSImageGeneratorValue it holds so we currently rely on the stylesheet to keep the CSSImageGeneratorValues
     10        alive as long as RenderStyle stays alive. While this works (RenderStyles are thrown away if stylesheets
     11        change) it is not particularly robust or nice.
     12
     13        - Use RefPtr<CSSImageGeneratorValue> in StyleGeneratedImage
     14        - Remove the RefPtr<StyleGeneratedImage> from CSSImageGeneratorValue.
     15          There is no good reason to cache StyleGeneratedImage as it is a small and
     16          uncommon object. With that the whole back-reference becomes unnecessary.
     17        - Switch more places to use (Pass)RefPtr<StyleImage> for consistency.
     18
     19        * css/CSSImageGeneratorValue.cpp:
     20        (WebCore::CSSImageGeneratorValue::CSSImageGeneratorValue):
     21        * css/CSSImageGeneratorValue.h:
     22        * css/CSSStyleApplyProperty.cpp:
     23        * css/CSSStyleSelector.cpp:
     24        (WebCore::CSSStyleSelector::applyProperty):
     25        (WebCore::CSSStyleSelector::styleImage):
     26        (WebCore::CSSStyleSelector::cachedOrPendingFromValue):
     27        (WebCore::CSSStyleSelector::generatedOrPendingFromValue):
     28        (WebCore::CSSStyleSelector::loadPendingImage):
     29        (WebCore::CSSStyleSelector::loadPendingImages):
     30        * css/CSSStyleSelector.h:
     31        * rendering/style/FillLayer.h:
     32        (WebCore::FillLayer::setImage):
     33        * rendering/style/NinePieceImage.h:
     34        (WebCore::NinePieceImage::NinePieceImage):
     35        * rendering/style/StyleGeneratedImage.cpp:
     36        (WebCore::StyleGeneratedImage::StyleGeneratedImage):
     37        (WebCore::StyleGeneratedImage::cssValue):
     38        (WebCore::StyleGeneratedImage::imageSize):
     39        (WebCore::StyleGeneratedImage::addClient):
     40        (WebCore::StyleGeneratedImage::removeClient):
     41        (WebCore::StyleGeneratedImage::image):
     42        * rendering/style/StyleGeneratedImage.h:
     43        (WebCore::StyleGeneratedImage::create):
     44        (WebCore::StyleGeneratedImage::data):
     45
    1462011-11-25  Andreas Kling  <kling@webkit.org>
    247

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

    r100535 r101177  
    3232#include "Image.h"
    3333#include "RenderObject.h"
    34 #include "StyleGeneratedImage.h"
    35 #include "StylePendingImage.h"
    3634#include <wtf/text/WTFString.h>
    3735
    … …  
    4038CSSImageGeneratorValue::CSSImageGeneratorValue(ClassType classType)
    4139    : CSSValue(classType)
    42     , m_accessedImage(false)
    4340{
    4441}
    … …  
    110107{
    111108    m_images.add(size, image);
    112 }
    113 
    114 StyleImage* CSSImageGeneratorValue::generatedOrPendingImage()
    115 {
    116     if (isPending())
    117         m_image = StylePendingImage::create(this).get();
    118     else if (!m_accessedImage) {
    119         m_accessedImage = true;
    120         m_image = StyleGeneratedImage::create(this, isFixedSize());
    121     }
    122 
    123     return m_image.get();
    124 }
    125 
    126 StyleGeneratedImage* CSSImageGeneratorValue::generatedImage()
    127 {
    128     if (!m_accessedImage) {
    129         m_accessedImage = true;
    130         m_image = StyleGeneratedImage::create(this, isFixedSize());
    131     }
    132 
    133     return static_cast<StyleGeneratedImage*>(m_image.get());
    134109}
    135110

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

    r100535 r101177  
    3737class Image;
    3838class RenderObject;
    39 class StyleGeneratedImage;
    40 class StyleImage;
    4139
    4240struct SizeAndCount {
    … …  
    6159    PassRefPtr<Image> image(RenderObject*, const IntSize&);
    6260
    63     StyleImage* generatedOrPendingImage();
    64     StyleGeneratedImage* generatedImage();
    65 
    6661    bool isFixedSize() const;
    6762    IntSize fixedSize(const RenderObject*);
    … …  
    7873    const RenderObjectSizeCountMap& clients() const { return m_clients; }
    7974
    80     RefPtr<StyleImage> m_image;
    81     bool m_accessedImage;
    82 
    8375    HashCountedSet<IntSize> m_sizes; // A count of how many times a given image size is in use.
    8476    RenderObjectSizeCountMap m_clients; // A map from RenderObjects (with entry count) to image sizes.

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

    r101078 r101177  
    389389};
    390390
     391template <typename T>
     392struct FillLayerAccessorTypes {
     393    typedef T Setter;
     394    typedef T Getter;
     395};
     396
     397template <>
     398struct FillLayerAccessorTypes<StyleImage*> {
     399    typedef PassRefPtr<StyleImage> Setter;
     400    typedef StyleImage* Getter;
     401};
     402
    391403template <typename T,
    392404          CSSPropertyID propertyId,
    … …  
    395407          const FillLayer* (RenderStyle::*layersFunction)() const,
    396408          bool (FillLayer::*testFunction)() const,
    397           T (FillLayer::*getFunction)() const,
    398           void (FillLayer::*setFunction)(T),
     409          typename FillLayerAccessorTypes<T>::Getter (FillLayer::*getFunction)() const,
     410          void (FillLayer::*setFunction)(typename FillLayerAccessorTypes<T>::Setter),
    399411          void (FillLayer::*clearFunction)(),
    400           T (*initialFunction)(EFillLayerType),
     412          typename FillLayerAccessorTypes<T>::Getter (*initialFunction)(EFillLayerType),
    401413          void (CSSStyleSelector::*mapFillFunction)(CSSPropertyID, FillLayer*, CSSValue*)>
    402414class ApplyPropertyFillLayer {

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

    r101078 r101177  
    28612861            CSSValue* item = i.value();
    28622862            if (item->isImageGeneratorValue()) {
    2863                 m_style->setContent(static_cast<CSSImageGeneratorValue*>(item)->generatedImage(), didSet);
     2863                m_style->setContent(StyleGeneratedImage::create(static_cast<CSSImageGeneratorValue*>(item)), didSet);
    28642864                didSet = true;
    28652865            }
    … …  
    42894289}
    42904290
    4291 StyleImage* CSSStyleSelector::styleImage(CSSPropertyID property, CSSValue* value)
     4291PassRefPtr<StyleImage> CSSStyleSelector::styleImage(CSSPropertyID property, CSSValue* value)
    42924292{
    42934293    if (value->isImageValue())
    … …  
    43004300}
    43014301
    4302 StyleImage* CSSStyleSelector::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value)
    4303 {
    4304     StyleImage* image = value->cachedOrPendingImage();
     4302PassRefPtr<StyleImage> CSSStyleSelector::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue* value)
     4303{
     4304    RefPtr<StyleImage> image = value->cachedOrPendingImage();
    43054305    if (image && image->isPendingImage())
    43064306        m_pendingImageProperties.add(property);
    4307     return image;
    4308 }
    4309 
    4310 StyleImage* CSSStyleSelector::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue* value)
    4311 {
    4312     StyleImage* image = value->generatedOrPendingImage();
    4313     if (image && image->isPendingImage())
     4307    return image.release();
     4308}
     4309
     4310PassRefPtr<StyleImage> CSSStyleSelector::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue* value)
     4311{
     4312    if (value->isPending()) {
    43144313        m_pendingImageProperties.add(property);
    4315     return image;
     4314        return StylePendingImage::create(value);
     4315    }
     4316    return StyleGeneratedImage::create(value);
    43164317}
    43174318
    … …  
    57415742#endif
    57425743
    5743 StyleImage* CSSStyleSelector::loadPendingImage(StylePendingImage* pendingImage)
     5744PassRefPtr<StyleImage> CSSStyleSelector::loadPendingImage(StylePendingImage* pendingImage)
    57445745{
    57455746    CachedResourceLoader* cachedResourceLoader = m_element->document()->cachedResourceLoader();
    … …  
    57535754        CSSImageGeneratorValue* imageGeneratorValue = pendingImage->cssImageGeneratorValue();
    57545755        imageGeneratorValue->loadSubimages(cachedResourceLoader);
    5755         return imageGeneratorValue->generatedImage();
     5756        return StyleGeneratedImage::create(imageGeneratorValue);
    57565757    }
    57575758
    … …  
    57715772            case CSSPropertyBackgroundImage: {
    57725773                for (FillLayer* backgroundLayer = m_style->accessBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next()) {
    5773                     if (backgroundLayer->image() && backgroundLayer->image()->isPendingImage()) {
    5774                         StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(backgroundLayer->image()));
    5775                         backgroundLayer->setImage(loadedImage);
    5776                     }
     5774                    if (backgroundLayer->image() && backgroundLayer->image()->isPendingImage())
     5775                        backgroundLayer->setImage(loadPendingImage(static_cast<StylePendingImage*>(backgroundLayer->image())));
    57775776                }
    57785777                break;
    57795778            }
    5780 
    57815779            case CSSPropertyContent: {
    57825780                for (ContentData* contentData = const_cast<ContentData*>(m_style->contentData()); contentData; contentData = contentData->next()) {
    … …  
    57845782                        StyleImage* image = static_cast<ImageContentData*>(contentData)->image();
    57855783                        if (image->isPendingImage()) {
    5786                             StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(image));
     5784                            RefPtr<StyleImage> loadedImage = loadPendingImage(static_cast<StylePendingImage*>(image));
    57875785                            if (loadedImage)
    5788                                 static_cast<ImageContentData*>(contentData)->setImage(loadedImage);
     5786                                static_cast<ImageContentData*>(contentData)->setImage(loadedImage.release());
    57895787                        }
    57905788                    }
    … …  
    57925790                break;
    57935791            }
    5794 
    57955792            case CSSPropertyCursor: {
    57965793                if (CursorList* cursorList = m_style->cursors()) {
    … …  
    57985795                        CursorData& currentCursor = cursorList->at(i);
    57995796                        if (StyleImage* image = currentCursor.image()) {
    5800                             if (image->isPendingImage()) {
    5801                                 StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(image));
    5802                                 currentCursor.setImage(loadedImage);
    5803                             }
     5797                            if (image->isPendingImage())
     5798                                currentCursor.setImage(loadPendingImage(static_cast<StylePendingImage*>(image)));
    58045799                        }
    58055800                    }
    … …  
    58075802                break;
    58085803            }
    5809 
    58105804            case CSSPropertyListStyleImage: {
    5811                 if (m_style->listStyleImage() && m_style->listStyleImage()->isPendingImage()) {
    5812                     StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(m_style->listStyleImage()));
    5813                     m_style->setListStyleImage(loadedImage);
    5814                 }
     5805                if (m_style->listStyleImage() && m_style->listStyleImage()->isPendingImage())
     5806                    m_style->setListStyleImage(loadPendingImage(static_cast<StylePendingImage*>(m_style->listStyleImage())));
    58155807                break;
    58165808            }
    5817 
    58185809            case CSSPropertyBorderImageSource: {
    5819                 if (m_style->borderImageSource() && m_style->borderImageSource()->isPendingImage()) {
    5820                     StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(m_style->borderImageSource()));
    5821                     m_style->setBorderImageSource(loadedImage);
    5822                 }
     5810                if (m_style->borderImageSource() && m_style->borderImageSource()->isPendingImage())
     5811                    m_style->setBorderImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_style->borderImageSource())));
    58235812                break;
    58245813            }
    5825 
    58265814            case CSSPropertyWebkitBoxReflect: {
    58275815                if (StyleReflection* reflection = m_style->boxReflect()) {
    58285816                    const NinePieceImage& maskImage = reflection->mask();
    58295817                    if (maskImage.image() && maskImage.image()->isPendingImage()) {
    5830                         StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(maskImage.image()));
    5831                         reflection->setMask(NinePieceImage(loadedImage, maskImage.imageSlices(), maskImage.fill(), maskImage.borderSlices(), maskImage.outset(), maskImage.horizontalRule(), maskImage.verticalRule()));
     5818                        RefPtr<StyleImage> loadedImage = loadPendingImage(static_cast<StylePendingImage*>(maskImage.image()));
     5819                        reflection->setMask(NinePieceImage(loadedImage.release(), maskImage.imageSlices(), maskImage.fill(), maskImage.borderSlices(), maskImage.outset(), maskImage.horizontalRule(), maskImage.verticalRule()));
    58325820                    }
    58335821                }
    58345822                break;
    58355823            }
    5836 
    58375824            case CSSPropertyWebkitMaskBoxImageSource: {
    5838                 if (m_style->maskBoxImageSource() && m_style->maskBoxImageSource()->isPendingImage()) {
    5839                     StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(m_style->maskBoxImageSource()));
    5840                     m_style->setMaskBoxImageSource(loadedImage);
    5841                 }
     5825                if (m_style->maskBoxImageSource() && m_style->maskBoxImageSource()->isPendingImage())
     5826                    m_style->setMaskBoxImageSource(loadPendingImage(static_cast<StylePendingImage*>(m_style->maskBoxImageSource())));
    58425827                break;
    58435828            }
    5844 
    58455829            case CSSPropertyWebkitMaskImage: {
    58465830                for (FillLayer* maskLayer = m_style->accessMaskLayers(); maskLayer; maskLayer = maskLayer->next()) {
    5847                     if (maskLayer->image() && maskLayer->image()->isPendingImage()) {
    5848                         StyleImage* loadedImage = loadPendingImage(static_cast<StylePendingImage*>(maskLayer->image()));
    5849                         maskLayer->setImage(loadedImage);
    5850                     }
     5831                    if (maskLayer->image() && maskLayer->image()->isPendingImage())
     5832                        maskLayer->setImage(loadPendingImage(static_cast<StylePendingImage*>(maskLayer->image())));
    58515833                }
    58525834                break;

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

    r100909 r101177  
    295295    static RenderStyle* styleNotYetAvailable() { return s_styleNotYetAvailable; }
    296296
    297     StyleImage* styleImage(CSSPropertyID, CSSValue*);
    298     StyleImage* cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
    299     StyleImage* generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue*);
     297    PassRefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue*);
     298    PassRefPtr<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
     299    PassRefPtr<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue*);
    300300
    301301    bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
    … …  
    344344#endif
    345345
    346     StyleImage* loadPendingImage(StylePendingImage*);
     346    PassRefPtr<StyleImage> loadPendingImage(StylePendingImage*);
    347347    void loadPendingImages();
    348348

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

    r101091 r101177  
    9393    bool isSizeSet() const { return m_sizeType != SizeNone; }
    9494   
    95     void setImage(StyleImage* i) { m_image = i; m_imageSet = true; }
     95    void setImage(PassRefPtr<StyleImage> i) { m_image = i; m_imageSet = true; }
    9696    void setXPosition(Length l) { m_xPosition = l; m_xPosSet = true; }
    9797    void setYPosition(Length l) { m_yPosition = l; m_yPosSet = true; }

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

    r95901 r101177  
    4848    }
    4949
    50     NinePieceImage(StyleImage* image, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule h, ENinePieceImageRule v)
     50    NinePieceImage(PassRefPtr<StyleImage> image, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule h, ENinePieceImageRule v)
    5151      : m_image(image)
    5252      , m_imageSlices(imageSlices)

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

    r97727 r101177  
    3030
    3131namespace WebCore {
     32   
     33StyleGeneratedImage::StyleGeneratedImage(PassRefPtr<CSSImageGeneratorValue> value)
     34    : m_imageGeneratorValue(value) 
     35    , m_fixedSize(m_imageGeneratorValue->isFixedSize())
     36{
     37    m_isGeneratedImage = true;
     38}
    3239
    3340PassRefPtr<CSSValue> StyleGeneratedImage::cssValue() const
    3441{
    35     return m_generator;
     42    return m_imageGeneratorValue;
    3643}
    3744
    … …  
    3946{
    4047    if (m_fixedSize) {
    41         IntSize fixedSize = m_generator->fixedSize(renderer);
     48        IntSize fixedSize = m_imageGeneratorValue->fixedSize(renderer);
    4249        if (multiplier == 1.0f)
    4350            return fixedSize;
    … …  
    6976void StyleGeneratedImage::addClient(RenderObject* renderer)
    7077{
    71     m_generator->addClient(renderer, IntSize());
     78    m_imageGeneratorValue->addClient(renderer, IntSize());
    7279}
    7380
    7481void StyleGeneratedImage::removeClient(RenderObject* renderer)
    7582{
    76     m_generator->removeClient(renderer);
     83    m_imageGeneratorValue->removeClient(renderer);
    7784}
    7885
    … …  
    8087{
    8188    renderer->document()->styleSelector()->setStyle(renderer->style());
    82     return m_generator->image(renderer, size);
     89    return m_imageGeneratorValue->image(renderer, size);
    8390}
    8491

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

    r98852 r101177  
    3434class StyleGeneratedImage : public StyleImage {
    3535public:
    36     static PassRefPtr<StyleGeneratedImage> create(CSSImageGeneratorValue* val, bool fixedSize)
     36    static PassRefPtr<StyleGeneratedImage> create(CSSImageGeneratorValue* value)
    3737    {
    38         return adoptRef(new StyleGeneratedImage(val, fixedSize));
     38        return adoptRef(new StyleGeneratedImage(value));
    3939    }
    4040
    41     virtual WrappedImagePtr data() const { return m_generator; }
     41    virtual WrappedImagePtr data() const { return m_imageGeneratorValue.get(); }
    4242
    4343    virtual PassRefPtr<CSSValue> cssValue() const;
    … …  
    5454   
    5555private:
    56     StyleGeneratedImage(CSSImageGeneratorValue* val, bool fixedSize)
    57         : m_generator(val)
    58         , m_fixedSize(fixedSize)
    59     {
    60          m_isGeneratedImage = true;
    61     }
     56    StyleGeneratedImage(PassRefPtr<CSSImageGeneratorValue>);
    6257   
    63     CSSImageGeneratorValue* m_generator; // The generator holds a reference to us.
     58    RefPtr<CSSImageGeneratorValue> m_imageGeneratorValue;
    6459    IntSize m_containerSize;
    6560    bool m_fixedSize;
Note: See TracChangeset for help on using the changeset viewer.