Changeset 162356 in webkit


Ignore:
Timestamp:
Jan 20, 2014 9:27:08 AM (10 years ago)
Author:
akling@apple.com
Message:

Let RenderImage construct its RenderImageResource.
<​https://webkit.org/b/127290>

Everyone who creates a RenderImage immediately follows up with
creating a RenderImageResource and assigning it to the image.

Let the RenderImage constructor do this instead, and make the
imageResource() accessors return references. This exposed a
number of unnecessary null checks.

Also modernized the touched code with std::unique_ptr.

Reviewed by Antti Koivisto.

  • html/HTMLImageElement.cpp:

(WebCore::HTMLImageElement::createElementRenderer):
(WebCore::HTMLImageElement::didAttachRenderers):

  • html/HTMLPlugInImageElement.cpp:

(WebCore::HTMLPlugInImageElement::createElementRenderer):

  • html/HTMLVideoElement.cpp:

(WebCore::HTMLVideoElement::didAttachRenderers):
(WebCore::HTMLVideoElement::parseAttribute):

  • html/ImageInputType.cpp:

(WebCore::ImageInputType::createInputRenderer):
(WebCore::ImageInputType::attach):

  • loader/ImageLoader.cpp:

(WebCore::ImageLoader::renderImageResource):

  • rendering/RenderElement.cpp:

(WebCore::RenderElement::createFor):

  • rendering/RenderImage.cpp:

(WebCore::RenderImage::RenderImage):
(WebCore::RenderImage::~RenderImage):
(WebCore::RenderImage::styleDidChange):
(WebCore::RenderImage::imageChanged):
(WebCore::RenderImage::updateIntrinsicSizeIfNeeded):
(WebCore::RenderImage::updateInnerContentRect):
(WebCore::RenderImage::imageDimensionsChanged):
(WebCore::RenderImage::notifyFinished):
(WebCore::RenderImage::paintReplaced):
(WebCore::RenderImage::paintIntoRect):
(WebCore::RenderImage::foregroundIsKnownToBeOpaqueInRect):
(WebCore::RenderImage::minimumReplacedHeight):
(WebCore::RenderImage::computeIntrinsicRatioInformation):
(WebCore::RenderImage::embeddedContentBox):

  • rendering/RenderImage.h:

(WebCore::RenderImage::imageResource):
(WebCore::RenderImage::cachedImage):

  • rendering/RenderImageResource.h:
  • rendering/RenderImageResourceStyleImage.h:
  • rendering/RenderMedia.cpp:

(WebCore::RenderMedia::RenderMedia):

  • rendering/RenderSnapshottedPlugIn.cpp:

(WebCore::RenderSnapshottedPlugIn::RenderSnapshottedPlugIn):

  • rendering/RenderSnapshottedPlugIn.h:
  • rendering/RenderVideo.cpp:

(WebCore::RenderVideo::calculateIntrinsicSize):

  • rendering/style/ContentData.cpp:

(WebCore::ImageContentData::createContentRenderer):

  • rendering/svg/RenderSVGImage.cpp:

(WebCore::RenderSVGImage::RenderSVGImage):
(WebCore::RenderSVGImage::~RenderSVGImage):
(WebCore::RenderSVGImage::updateImageViewport):
(WebCore::RenderSVGImage::paint):
(WebCore::RenderSVGImage::paintForeground):

  • rendering/svg/RenderSVGImage.h:
  • svg/SVGImageElement.cpp:

(WebCore::SVGImageElement::didAttachRenderers):

Location:
trunk/Source/WebCore
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r162354 r162356  
     12014-01-20  Andreas Kling  <akling@apple.com>
     2
     3        Let RenderImage construct its RenderImageResource.
     4        <https://webkit.org/b/127290>
     5
     6        Everyone who creates a RenderImage immediately follows up with
     7        creating a RenderImageResource and assigning it to the image.
     8
     9        Let the RenderImage constructor do this instead, and make the
     10        imageResource() accessors return references. This exposed a
     11        number of unnecessary null checks.
     12
     13        Also modernized the touched code with std::unique_ptr.
     14
     15        Reviewed by Antti Koivisto.
     16
     17        * html/HTMLImageElement.cpp:
     18        (WebCore::HTMLImageElement::createElementRenderer):
     19        (WebCore::HTMLImageElement::didAttachRenderers):
     20        * html/HTMLPlugInImageElement.cpp:
     21        (WebCore::HTMLPlugInImageElement::createElementRenderer):
     22        * html/HTMLVideoElement.cpp:
     23        (WebCore::HTMLVideoElement::didAttachRenderers):
     24        (WebCore::HTMLVideoElement::parseAttribute):
     25        * html/ImageInputType.cpp:
     26        (WebCore::ImageInputType::createInputRenderer):
     27        (WebCore::ImageInputType::attach):
     28        * loader/ImageLoader.cpp:
     29        (WebCore::ImageLoader::renderImageResource):
     30        * rendering/RenderElement.cpp:
     31        (WebCore::RenderElement::createFor):
     32        * rendering/RenderImage.cpp:
     33        (WebCore::RenderImage::RenderImage):
     34        (WebCore::RenderImage::~RenderImage):
     35        (WebCore::RenderImage::styleDidChange):
     36        (WebCore::RenderImage::imageChanged):
     37        (WebCore::RenderImage::updateIntrinsicSizeIfNeeded):
     38        (WebCore::RenderImage::updateInnerContentRect):
     39        (WebCore::RenderImage::imageDimensionsChanged):
     40        (WebCore::RenderImage::notifyFinished):
     41        (WebCore::RenderImage::paintReplaced):
     42        (WebCore::RenderImage::paintIntoRect):
     43        (WebCore::RenderImage::foregroundIsKnownToBeOpaqueInRect):
     44        (WebCore::RenderImage::minimumReplacedHeight):
     45        (WebCore::RenderImage::computeIntrinsicRatioInformation):
     46        (WebCore::RenderImage::embeddedContentBox):
     47        * rendering/RenderImage.h:
     48        (WebCore::RenderImage::imageResource):
     49        (WebCore::RenderImage::cachedImage):
     50        * rendering/RenderImageResource.h:
     51        * rendering/RenderImageResourceStyleImage.h:
     52        * rendering/RenderMedia.cpp:
     53        (WebCore::RenderMedia::RenderMedia):
     54        * rendering/RenderSnapshottedPlugIn.cpp:
     55        (WebCore::RenderSnapshottedPlugIn::RenderSnapshottedPlugIn):
     56        * rendering/RenderSnapshottedPlugIn.h:
     57        * rendering/RenderVideo.cpp:
     58        (WebCore::RenderVideo::calculateIntrinsicSize):
     59        * rendering/style/ContentData.cpp:
     60        (WebCore::ImageContentData::createContentRenderer):
     61        * rendering/svg/RenderSVGImage.cpp:
     62        (WebCore::RenderSVGImage::RenderSVGImage):
     63        (WebCore::RenderSVGImage::~RenderSVGImage):
     64        (WebCore::RenderSVGImage::updateImageViewport):
     65        (WebCore::RenderSVGImage::paint):
     66        (WebCore::RenderSVGImage::paintForeground):
     67        * rendering/svg/RenderSVGImage.h:
     68        * svg/SVGImageElement.cpp:
     69        (WebCore::SVGImageElement::didAttachRenderers):
     70
    1712014-01-20  Antti Koivisto  <antti@apple.com>
    272

  • trunk/Source/WebCore/html/HTMLImageElement.cpp

    r161754 r162356  
    180180        return RenderElement::createFor(*this, std::move(style));
    181181
    182     auto image = createRenderer<RenderImage>(*this, std::move(style));
    183     image->setImageResource(RenderImageResource::create());
    184     return std::move(image);
     182    return createRenderer<RenderImage>(*this, std::move(style));
    185183}
    186184
    … …  
    200198        return;
    201199    RenderImage* renderImage = toRenderImage(renderer());
    202     RenderImageResource* renderImageResource = renderImage->imageResource();
    203     if (renderImageResource->hasImage())
     200    RenderImageResource& renderImageResource = renderImage->imageResource();
     201    if (renderImageResource.hasImage())
    204202        return;
    205     renderImageResource->setCachedImage(m_imageLoader.image());
     203    renderImageResource.setCachedImage(m_imageLoader.image());
    206204
    207205    // If we have no image at all because we have no src attribute, set
    208206    // image height and width for the alt text instead.
    209     if (!m_imageLoader.image() && !renderImageResource->cachedImage())
     207    if (!m_imageLoader.image() && !renderImageResource.cachedImage())
    210208        renderImage->setImageSizeForAltText();
    211209}

  • trunk/Source/WebCore/html/HTMLPlugInImageElement.cpp

    r161768 r162356  
    223223        return RenderElement::createFor(*this, std::move(style));
    224224
    225     if (isImageType()) {
    226         auto image = createRenderer<RenderImage>(*this, std::move(style));
    227         image->setImageResource(RenderImageResource::create());
    228         return std::move(image);
    229     }
     225    if (isImageType())
     226        return createRenderer<RenderImage>(*this, std::move(style));
    230227
    231228#if PLATFORM(IOS)

  • trunk/Source/WebCore/html/HTMLVideoElement.cpp

    r161899 r162356  
    9090            m_imageLoader->updateFromElement();
    9191            if (renderer())
    92                 toRenderImage(renderer())->imageResource()->setCachedImage(m_imageLoader->image());
     92                toRenderImage(renderer())->imageResource().setCachedImage(m_imageLoader->image());
    9393        }
    9494#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
    … …  
    130130        } else {
    131131            if (renderer())
    132                 toRenderImage(renderer())->imageResource()->setCachedImage(0);
     132                toRenderImage(renderer())->imageResource().setCachedImage(0);
    133133        }
    134134    }

  • trunk/Source/WebCore/html/ImageInputType.cpp

    r161167 r162356  
    104104RenderPtr<RenderElement> ImageInputType::createInputRenderer(PassRef<RenderStyle> style)
    105105{
    106     auto image = createRenderer<RenderImage>(element(), std::move(style));
    107     image->setImageResource(RenderImageResource::create());
    108     return std::move(image);
     106    return createRenderer<RenderImage>(element(), std::move(style));
    109107}
    110108
    … …  
    138136        return;
    139137
    140     RenderImageResource* imageResource = renderer->imageResource();
    141     imageResource->setCachedImage(imageLoader->image());
     138    auto& imageResource = renderer->imageResource();
     139    imageResource.setCachedImage(imageLoader->image());
    142140
    143141    // If we have no image at all because we have no src attribute, set
    144142    // image height and width for the alt text instead.
    145     if (!imageLoader->image() && !imageResource->cachedImage())
     143    if (!imageLoader->image() && !imageResource.cachedImage())
    146144        renderer->setImageSizeForAltText();
    147145}

  • trunk/Source/WebCore/loader/ImageLoader.cpp

    r161768 r162356  
    327327    // See <https://bugs.webkit.org/show_bug.cgi?id=42840>
    328328    if (renderer->isImage() && !toRenderImage(*renderer).isGeneratedContent())
    329         return toRenderImage(*renderer).imageResource();
     329        return &toRenderImage(*renderer).imageResource();
    330330
    331331#if ENABLE(SVG)
    332332    if (renderer->isSVGImage())
    333         return toRenderSVGImage(renderer)->imageResource();
     333        return &toRenderSVGImage(renderer)->imageResource();
    334334#endif
    335335
    336336#if ENABLE(VIDEO)
    337337    if (renderer->isVideo())
    338         return toRenderVideo(*renderer).imageResource();
     338        return &toRenderVideo(*renderer).imageResource();
    339339#endif
    340340

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

    r162132 r162356  
    132132    const ContentData* contentData = style.get().contentData();
    133133    if (contentData && !contentData->next() && contentData->isImage() && !element.isPseudoElement()) {
    134         auto image = createRenderer<RenderImage>(element, std::move(style));
    135         if (const StyleImage* styleImage = static_cast<const ImageContentData*>(contentData)->image()) {
    136             image->setImageResource(RenderImageResourceStyleImage::create(const_cast<StyleImage&>(*styleImage)));
     134        auto styleImage = const_cast<StyleImage*>(static_cast<const ImageContentData*>(contentData)->image());
     135        auto image = createRenderer<RenderImage>(element, std::move(style), styleImage);
     136        if (styleImage)
    137137            image->setIsGeneratedContent();
    138         } else
    139             image->setImageResource(RenderImageResource::create());
    140138        return std::move(image);
    141139    }

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

    r161740 r162356  
    4545#include "Page.h"
    4646#include "PaintInfo.h"
     47#include "RenderImageResourceStyleImage.h"
    4748#include "RenderView.h"
    4849#include "SVGImage.h"
    … …  
    116117using namespace HTMLNames;
    117118
    118 RenderImage::RenderImage(Element& element, PassRef<RenderStyle> style)
     119RenderImage::RenderImage(Element& element, PassRef<RenderStyle> style, StyleImage* styleImage)
    119120    : RenderReplaced(element, std::move(style), IntSize())
     121    , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
    120122    , m_needsToSetSizeForAltText(false)
    121123    , m_didIncrementVisuallyNonEmptyPixelCount(false)
    … …  
    123125{
    124126    updateAltText();
    125 }
    126 
    127 RenderImage::RenderImage(Document& document, PassRef<RenderStyle> style)
     127    imageResource().initialize(this);
     128}
     129
     130RenderImage::RenderImage(Document& document, PassRef<RenderStyle> style, StyleImage* styleImage)
    128131    : RenderReplaced(document, std::move(style), IntSize())
     132    , m_imageResource(styleImage ? std::make_unique<RenderImageResourceStyleImage>(*styleImage) : std::make_unique<RenderImageResource>())
    129133    , m_needsToSetSizeForAltText(false)
    130134    , m_didIncrementVisuallyNonEmptyPixelCount(false)
    131135    , m_isGeneratedContent(false)
    132136{
     137    imageResource().initialize(this);
    133138}
    134139
    135140RenderImage::~RenderImage()
    136141{
    137     ASSERT(m_imageResource);
    138     m_imageResource->shutdown();
     142    imageResource().shutdown();
    139143}
    140144
    … …  
    149153    style.get().inheritFrom(&pseudoStyle);
    150154    return style;
    151 }
    152 
    153 void RenderImage::setImageResource(PassOwnPtr<RenderImageResource> imageResource)
    154 {
    155     ASSERT(!m_imageResource);
    156     m_imageResource = imageResource;
    157     m_imageResource->initialize(this);
    158155}
    159156
    … …  
    218215    RenderReplaced::styleDidChange(diff, oldStyle);
    219216    if (m_needsToSetSizeForAltText) {
    220         if (!m_altText.isEmpty() && setImageSizeForAltText(m_imageResource->cachedImage()))
     217        if (!m_altText.isEmpty() && setImageSizeForAltText(imageResource().cachedImage()))
    221218            imageDimensionsChanged(true /* imageSizeChanged */);
    222219        m_needsToSetSizeForAltText = false;
    … …  
    247244        RenderReplaced::imageChanged(newImage, rect);
    248245
    249     if (!m_imageResource)
    250         return;
    251 
    252     if (newImage != m_imageResource->imagePtr() || !newImage)
     246    if (newImage != imageResource().imagePtr() || !newImage)
    253247        return;
    254248   
    255249    if (!m_didIncrementVisuallyNonEmptyPixelCount) {
    256250        // At a zoom level of 1 the image is guaranteed to have an integer size.
    257         view().frameView().incrementVisuallyNonEmptyPixelCount(flooredIntSize(m_imageResource->imageSize(1.0f)));
     251        view().frameView().incrementVisuallyNonEmptyPixelCount(flooredIntSize(imageResource().imageSize(1.0f)));
    258252        m_didIncrementVisuallyNonEmptyPixelCount = true;
    259253    }
    … …  
    262256
    263257    // Set image dimensions, taking into account the size of the alt text.
    264     if (m_imageResource->errorOccurred()) {
     258    if (imageResource().errorOccurred()) {
    265259        if (!m_altText.isEmpty() && document().hasPendingStyleRecalc()) {
    266260            ASSERT(element());
    … …  
    271265            return;
    272266        }
    273         imageSizeChanged = setImageSizeForAltText(m_imageResource->cachedImage());
     267        imageSizeChanged = setImageSizeForAltText(imageResource().cachedImage());
    274268    }
    275269
    … …  
    281275    if (newSize == intrinsicSize() && !imageSizeChanged)
    282276        return false;
    283     if (m_imageResource->errorOccurred())
     277    if (imageResource().errorOccurred())
    284278        return imageSizeChanged;
    285279    setIntrinsicSize(newSize);
    … …  
    293287    IntSize containerSize(paintRect.width(), paintRect.height());
    294288    if (!containerSize.isEmpty())
    295         m_imageResource->setContainerSizeForRenderer(containerSize);
     289        imageResource().setContainerSizeForRenderer(containerSize);
    296290}
    297291
    … …  
    304298    if (scale <= 0)
    305299        scale = 1;
    306     bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(m_imageResource->intrinsicSize(style().effectiveZoom() / scale), imageSizeChanged);
     300    bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(imageResource().intrinsicSize(style().effectiveZoom() / scale), imageSizeChanged);
    307301#else
    308     bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(m_imageResource->intrinsicSize(style().effectiveZoom()), imageSizeChanged);
     302    bool intrinsicSizeChanged = updateIntrinsicSizeIfNeeded(imageResource().intrinsicSize(style().effectiveZoom()), imageSizeChanged);
    309303#endif
    310304
    … …  
    363357            // The image changed rect is in source image coordinates (pre-zooming),
    364358            // so map from the bounds of the image to the contentsBox.
    365             repaintRect = enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), m_imageResource->imageSize(1.0f)), contentBoxRect()));
     359            repaintRect = enclosingIntRect(mapRect(*rect, FloatRect(FloatPoint(), imageResource().imageSize(1.0f)), contentBoxRect()));
    366360            // Guard against too-large changed rects.
    367361            repaintRect.intersect(contentBoxRect());
    … …  
    380374void RenderImage::notifyFinished(CachedResource* newImage)
    381375{
    382     if (!m_imageResource)
    383         return;
    384    
    385376    if (documentBeingDestroyed())
    386377        return;
    … …  
    389380
    390381#if USE(ACCELERATED_COMPOSITING)
    391     if (newImage == m_imageResource->cachedImage()) {
     382    if (newImage == imageResource().cachedImage()) {
    392383        // tell any potential compositing layers
    393384        // that the image is done and they can reference it directly.
    … …  
    412403    Page* page = frame().page();
    413404
    414     if (!m_imageResource->hasImage() || m_imageResource->errorOccurred()) {
     405    if (!imageResource().hasImage() || imageResource().errorOccurred()) {
    415406        if (paintInfo.phase == PaintPhaseSelection)
    416407            return;
    … …  
    435426            LayoutUnit usableHeight = cHeight - 2 * borderWidth;
    436427
    437             RefPtr<Image> image = m_imageResource->image();
    438 
    439             if (m_imageResource->errorOccurred() && !image->isNull() && usableWidth >= image->width() && usableHeight >= image->height()) {
     428            RefPtr<Image> image = imageResource().image();
     429
     430            if (imageResource().errorOccurred() && !image->isNull() && usableWidth >= image->width() && usableHeight >= image->height()) {
    440431                float deviceScaleFactor = WebCore::deviceScaleFactor(&frame());
    441432                // Call brokenImage() explicitly to ensure we get the broken image icon at the appropriate resolution.
    442                 std::pair<Image*, float> brokenImageAndImageScaleFactor = m_imageResource->cachedImage()->brokenImage(deviceScaleFactor);
     433                std::pair<Image*, float> brokenImageAndImageScaleFactor = imageResource().cachedImage()->brokenImage(deviceScaleFactor);
    443434                image = brokenImageAndImageScaleFactor.first;
    444435                IntSize imageSize = image->size();
    … …  
    481472            }
    482473        }
    483     } else if (m_imageResource->hasImage() && cWidth > 0 && cHeight > 0) {
    484         RefPtr<Image> img = m_imageResource->image(cWidth, cHeight);
     474    } else if (imageResource().hasImage() && cWidth > 0 && cHeight > 0) {
     475        RefPtr<Image> img = imageResource().image(cWidth, cHeight);
    485476        if (!img || img->isNull()) {
    486477            if (page && paintInfo.phase == PaintPhaseForeground)
    … …  
    577568{
    578569    IntRect alignedRect = pixelSnappedIntRect(rect);
    579     if (!m_imageResource->hasImage() || m_imageResource->errorOccurred() || alignedRect.width() <= 0 || alignedRect.height() <= 0)
    580         return;
    581 
    582     RefPtr<Image> img = m_imageResource->image(alignedRect.width(), alignedRect.height());
     570    if (!imageResource().hasImage() || imageResource().errorOccurred() || alignedRect.width() <= 0 || alignedRect.height() <= 0)
     571        return;
     572
     573    RefPtr<Image> img = imageResource().image(alignedRect.width(), alignedRect.height());
    583574    if (!img || img->isNull())
    584575        return;
    … …  
    586577    HTMLImageElement* imageElt = (element() && isHTMLImageElement(element())) ? toHTMLImageElement(element()) : 0;
    587578    CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
    588     Image* image = m_imageResource->image().get();
     579    Image* image = imageResource().image().get();
    589580    bool useLowQualityScaling = shouldPaintAtLowQuality(context, image, image, alignedRect.size());
    590581    ImageOrientationDescription orientationDescription(shouldRespectImageOrientation());
    … …  
    592583    orientationDescription.setImageOrientationEnum(style().imageOrientation());
    593584#endif
    594     context->drawImage(m_imageResource->image(alignedRect.width(), alignedRect.height()).get(), style().colorSpace(), alignedRect, compositeOperator, orientationDescription, useLowQualityScaling);
     585    context->drawImage(imageResource().image(alignedRect.width(), alignedRect.height()).get(), style().colorSpace(), alignedRect, compositeOperator, orientationDescription, useLowQualityScaling);
    595586}
    596587
    … …  
    606597{
    607598    UNUSED_PARAM(maxDepthToTest);
    608     if (!m_imageResource->hasImage() || m_imageResource->errorOccurred())
    609         return false;
    610     if (m_imageResource->cachedImage() && !m_imageResource->cachedImage()->isLoaded())
     599    if (!imageResource().hasImage() || imageResource().errorOccurred())
     600        return false;
     601    if (imageResource().cachedImage() && !imageResource().cachedImage()->isLoaded())
    611602        return false;
    612603    if (!contentBoxRect().contains(localRect))
    … …  
    624615        return false;
    625616    // Check for image with alpha.
    626     return m_imageResource->cachedImage() && m_imageResource->cachedImage()->currentFrameKnownToBeOpaque(this);
     617    return imageResource().cachedImage() && imageResource().cachedImage()->currentFrameKnownToBeOpaque(this);
    627618}
    628619
    … …  
    640631LayoutUnit RenderImage::minimumReplacedHeight() const
    641632{
    642     return m_imageResource->errorOccurred() ? intrinsicSize().height() : LayoutUnit();
     633    return imageResource().errorOccurred() ? intrinsicSize().height() : LayoutUnit();
    643634}
    644635
    … …  
    696687
    697688    // Our intrinsicSize is empty if we're rendering generated images with relative width/height. Figure out the right intrinsic size to use.
    698     if (intrinsicSize.isEmpty() && (m_imageResource->imageHasRelativeWidth() || m_imageResource->imageHasRelativeHeight())) {
     689    if (intrinsicSize.isEmpty() && (imageResource().imageHasRelativeWidth() || imageResource().imageHasRelativeHeight())) {
    699690        RenderObject* containingBlock = isOutOfFlowPositioned() ? container() : this->containingBlock();
    700691        if (containingBlock->isBox()) {
    … …  
    705696    }
    706697    // Don't compute an intrinsic ratio to preserve historical WebKit behavior if we're painting alt text and/or a broken image.
    707     if (m_imageResource && m_imageResource->errorOccurred()) {
     698    if (imageResource().errorOccurred()) {
    708699        intrinsicRatio = 1;
    709700        return;
    … …  
    720711RenderBox* RenderImage::embeddedContentBox() const
    721712{
    722     if (!m_imageResource)
    723         return 0;
    724 
    725713#if ENABLE(SVG)
    726     CachedImage* cachedImage = m_imageResource->cachedImage();
     714    CachedImage* cachedImage = imageResource().cachedImage();
    727715    if (cachedImage && cachedImage->image() && cachedImage->image()->isSVGImage())
    728716        return static_cast<SVGImage*>(cachedImage->image())->embeddedContentBox();

  • trunk/Source/WebCore/rendering/RenderImage.h

    r162158 r162356  
    3636class RenderImage : public RenderReplaced {
    3737public:
    38     explicit RenderImage(Element&, PassRef<RenderStyle>);
    39     explicit RenderImage(Document&, PassRef<RenderStyle>);
     38    RenderImage(Element&, PassRef<RenderStyle>, StyleImage* = nullptr);
     39    RenderImage(Document&, PassRef<RenderStyle>, StyleImage* = nullptr);
    4040    virtual ~RenderImage();
    4141
    … …  
    4343    static PassRef<RenderStyle> createStyleInheritingFromPseudoStyle(const RenderStyle&);
    4444
    45     void setImageResource(PassOwnPtr<RenderImageResource>);
    46 
    47     RenderImageResource* imageResource() { return m_imageResource.get(); }
    48     const RenderImageResource* imageResource() const { return m_imageResource.get(); }
    49     CachedImage* cachedImage() const { return m_imageResource ? m_imageResource->cachedImage() : 0; }
     45    RenderImageResource& imageResource() { return *m_imageResource; }
     46    const RenderImageResource& imageResource() const { return *m_imageResource; }
     47    CachedImage* cachedImage() const { return imageResource().cachedImage(); }
    5048
    5149    bool setImageSizeForAltText(CachedImage* newImage = 0);
    … …  
    8583    virtual void intrinsicSizeChanged() override
    8684    {
    87         if (m_imageResource)
    88             imageChanged(m_imageResource->imagePtr());
     85        imageChanged(imageResource().imagePtr());
    8986    }
    9087
    … …  
    116113    // Text to display as long as the image isn't available.
    117114    String m_altText;
    118     OwnPtr<RenderImageResource> m_imageResource;
     115    std::unique_ptr<RenderImageResource> m_imageResource;
    119116    bool m_needsToSetSizeForAltText;
    120117    bool m_didIncrementVisuallyNonEmptyPixelCount;

  • trunk/Source/WebCore/rendering/RenderImageResource.h

    r160478 r162356  
    3939    WTF_MAKE_NONCOPYABLE(RenderImageResource); WTF_MAKE_FAST_ALLOCATED;
    4040public:
     41    RenderImageResource();
    4142    virtual ~RenderImageResource();
    42 
    43     static PassOwnPtr<RenderImageResource> create()
    44     {
    45         return adoptPtr(new RenderImageResource);
    46     }
    4743
    4844    virtual void initialize(RenderElement*);
    … …  
    6864
    6965protected:
    70     RenderImageResource();
    71 
    7266    RenderElement* m_renderer;
    7367    CachedResourceHandle<CachedImage> m_cachedImage;

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

    r162139 r162356  
    3535class RenderElement;
    3636
    37 class RenderImageResourceStyleImage : public RenderImageResource {
     37class RenderImageResourceStyleImage final : public RenderImageResource {
    3838public:
     39    explicit RenderImageResourceStyleImage(StyleImage&);
    3940    virtual ~RenderImageResourceStyleImage();
    40 
    41     static PassOwnPtr<RenderImageResource> create(StyleImage& styleImage)
    42     {
    43         return adoptPtr(new RenderImageResourceStyleImage(styleImage));
    44     }
    4541
    4642private:
    … …  
    6157    virtual WrappedImagePtr imagePtr() const override { return m_styleImage->data(); }
    6258
    63     explicit RenderImageResourceStyleImage(StyleImage&);
    6459    Ref<StyleImage> m_styleImage;
    6560};

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

    r159391 r162356  
    3838    : RenderImage(element, std::move(style))
    3939{
    40     setImageResource(RenderImageResource::create());
    4140}
    4241
    … …  
    4443    : RenderImage(element, std::move(style))
    4544{
    46     setImageResource(RenderImageResource::create());
    4745    setIntrinsicSize(intrinsicSize);
    4846}

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

    r158163 r162356  
    4949RenderSnapshottedPlugIn::RenderSnapshottedPlugIn(HTMLPlugInImageElement& element, PassRef<RenderStyle> style)
    5050    : RenderEmbeddedObject(element, std::move(style))
    51     , m_snapshotResource(RenderImageResource::create())
     51    , m_snapshotResource(std::make_unique<RenderImageResource>())
    5252    , m_isPotentialMouseActivation(false)
    5353{

  • trunk/Source/WebCore/rendering/RenderSnapshottedPlugIn.h

    r162198 r162356  
    6060    virtual void layout() override;
    6161
    62     OwnPtr<RenderImageResource> m_snapshotResource;
     62    std::unique_ptr<RenderImageResource> m_snapshotResource;
    6363    bool m_isPotentialMouseActivation;
    6464};

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

    r160734 r162356  
    114114    }
    115115
    116     if (videoElement().shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource()->errorOccurred())
     116    if (videoElement().shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource().errorOccurred())
    117117        return m_cachedImageSize;
    118118

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

    r161153 r162356  
    5050RenderPtr<RenderObject> ImageContentData::createContentRenderer(Document& document, const RenderStyle& pseudoStyle) const
    5151{
    52     auto image = createRenderer<RenderImage>(document, RenderImage::createStyleInheritingFromPseudoStyle(pseudoStyle));
     52    auto image = createRenderer<RenderImage>(document, RenderImage::createStyleInheritingFromPseudoStyle(pseudoStyle), m_image.get());
    5353    image->initializeStyle();
    5454    image->setAltText(altText());
    55     if (m_image)
    56         image->setImageResource(RenderImageResourceStyleImage::create(*m_image));
    57     else
    58         image->setImageResource(RenderImageResource::create());
    5955    return std::move(image);
    6056}

  • trunk/Source/WebCore/rendering/svg/RenderSVGImage.cpp

    r161418 r162356  
    5050    , m_needsBoundariesUpdate(true)
    5151    , m_needsTransformUpdate(true)
    52     , m_imageResource(RenderImageResource::create())
    53 {
    54     m_imageResource->initialize(this);
     52    , m_imageResource(std::make_unique<RenderImageResource>())
     53{
     54    imageResource().initialize(this);
    5555}
    5656
    5757RenderSVGImage::~RenderSVGImage()
    5858{
    59     m_imageResource->shutdown();
     59    imageResource().shutdown();
    6060}
    6161
    … …  
    7575        return false;
    7676
    77     m_imageResource->setContainerSizeForRenderer(enclosingIntRect(m_objectBoundingBox).size());
     77    imageResource().setContainerSizeForRenderer(enclosingIntRect(m_objectBoundingBox).size());
    7878    m_needsBoundariesUpdate = true;
    7979    return true;
    … …  
    118118void RenderSVGImage::paint(PaintInfo& paintInfo, const LayoutPoint&)
    119119{
    120     if (paintInfo.context->paintingDisabled() || style().visibility() == HIDDEN || !m_imageResource->hasImage())
     120    if (paintInfo.context->paintingDisabled() || style().visibility() == HIDDEN || !imageResource().hasImage())
    121121        return;
    122122
    … …  
    149149void RenderSVGImage::paintForeground(PaintInfo& paintInfo)
    150150{
    151     RefPtr<Image> image = m_imageResource->image();
     151    RefPtr<Image> image = imageResource().image();
    152152    FloatRect destRect = m_objectBoundingBox;
    153153    FloatRect srcRect(0, 0, image->width(), image->height());

  • trunk/Source/WebCore/rendering/svg/RenderSVGImage.h

    r162198 r162356  
    4848    virtual void setNeedsTransformUpdate() { m_needsTransformUpdate = true; }
    4949
    50     RenderImageResource* imageResource() { return m_imageResource.get(); }
    51     const RenderImageResource* imageResource() const { return m_imageResource.get(); }
     50    RenderImageResource& imageResource() { return *m_imageResource; }
     51    const RenderImageResource& imageResource() const { return *m_imageResource; }
    5252
    5353    // Note: Assumes the PaintInfo context has had all local transforms applied.
    … …  
    8888    FloatRect m_repaintBoundingBox;
    8989    FloatRect m_repaintBoundingBoxExcludingShadow;
    90     OwnPtr<RenderImageResource> m_imageResource;
    91 
     90    std::unique_ptr<RenderImageResource> m_imageResource;
    9291    std::unique_ptr<ImageBuffer> m_bufferedForeground;
    9392};

  • trunk/Source/WebCore/svg/SVGImageElement.cpp

    r161181 r162356  
    196196{
    197197    if (RenderSVGImage* imageObj = toRenderSVGImage(renderer())) {
    198         if (imageObj->imageResource()->hasImage())
     198        if (imageObj->imageResource().hasImage())
    199199            return;
    200200
    201         imageObj->imageResource()->setCachedImage(m_imageLoader.image());
     201        imageObj->imageResource().setCachedImage(m_imageLoader.image());
    202202    }
    203203}
Note: See TracChangeset for help on using the changeset viewer.