Diff
Modified: trunk/Source/WebCore/ChangeLog (205345 => 205346)
--- trunk/Source/WebCore/ChangeLog 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/ChangeLog 2016-09-02 16:26:40 UTC (rev 205346)
@@ -1,3 +1,18 @@
+2016-09-02 Commit Queue <[email protected]>
+
+ Unreviewed, rolling out r205344.
+ https://bugs.webkit.org/show_bug.cgi?id=161533
+
+ Hitting assertions under CachedResource::removeClient in a few
+ tests (Requested by anttik on #webkit).
+
+ Reverted changeset:
+
+ "Reverse ownership relation of StyleCachedImage and
+ CSSImageValue"
+ https://bugs.webkit.org/show_bug.cgi?id=161447
+ http://trac.webkit.org/changeset/205344
+
2016-09-02 Antti Koivisto <[email protected]>
Reverse ownership relation of StyleCachedImage and CSSImageValue
Modified: trunk/Source/WebCore/css/CSSCursorImageValue.cpp (205345 => 205346)
--- trunk/Source/WebCore/css/CSSCursorImageValue.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSCursorImageValue.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -26,6 +26,8 @@
#include "CSSImageValue.h"
#include "CachedImage.h"
#include "CachedResourceLoader.h"
+#include "StyleCachedImage.h"
+#include "StyleImage.h"
#include "SVGCursorElement.h"
#include "SVGLengthContext.h"
#include "SVGNames.h"
@@ -107,30 +109,27 @@
return;
}
- if (auto* cursorElement = updateCursorElement(*loader.document())) {
- if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
- m_imageValue = CSSImageValue::create(cursorElement->href());
- }
-
downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options);
}
-CachedImage* CSSCursorImageValue::cachedImage() const
+StyleCachedImage& CSSCursorImageValue::styleImage(const Document& document)
{
+ // Need to delegate completely so that changes in device scale factor can be handled appropriately.
+ StyleCachedImage* styleImage;
if (is<CSSImageSetValue>(m_imageValue.get()))
- return downcast<CSSImageSetValue>(m_imageValue.get()).cachedImage();
+ styleImage = &downcast<CSSImageSetValue>(m_imageValue.get()).styleImage(document);
+ else {
+ if (auto* cursorElement = updateCursorElement(document)) {
+ if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
+ m_imageValue = CSSImageValue::create(cursorElement->href());
+ }
+ styleImage = &downcast<CSSImageValue>(m_imageValue.get()).styleImage();
+ }
+ styleImage->setCSSValue(*this);
- return downcast<CSSImageValue>(m_imageValue.get()).cachedImage();
+ return *styleImage;
}
-float CSSCursorImageValue::scaleFactor() const
-{
- if (is<CSSImageSetValue>(m_imageValue.get()))
- return downcast<CSSImageSetValue>(m_imageValue.get()).bestFitScaleFactor();
-
- return 1;
-}
-
bool CSSCursorImageValue::equals(const CSSCursorImageValue& other) const
{
return m_hasHotSpot ? other.m_hasHotSpot && m_hotSpot == other.m_hotSpot : !other.m_hasHotSpot
Modified: trunk/Source/WebCore/css/CSSCursorImageValue.h (205345 => 205346)
--- trunk/Source/WebCore/css/CSSCursorImageValue.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSCursorImageValue.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -31,6 +31,7 @@
class Element;
class SVGCursorElement;
class SVGElement;
+class StyleCachedImage;
class CSSCursorImageValue final : public CSSValue {
public:
@@ -53,10 +54,8 @@
String customCSSText() const;
void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- CachedImage* cachedImage() const;
+ StyleCachedImage& styleImage(const Document&);
- float scaleFactor() const;
-
void removeReferencedElement(SVGElement*);
bool equals(const CSSCursorImageValue&) const;
Modified: trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp (205345 => 205346)
--- trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -253,7 +253,7 @@
if (is<CSSImageValue>(value)) {
auto& imageValue = downcast<CSSImageValue>(value);
imageValue.loadImage(cachedResourceLoader, options);
- return imageValue.cachedImage();
+ return imageValue.styleImage().cachedImage();
}
if (is<CSSImageGeneratorValue>(value)) {
Modified: trunk/Source/WebCore/css/CSSImageSetValue.cpp (205345 => 205346)
--- trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -35,6 +35,7 @@
#include "CrossOriginAccessControl.h"
#include "Document.h"
#include "Page.h"
+#include "StyleCachedImage.h"
#include <wtf/text/StringBuilder.h>
namespace WebCore {
@@ -41,11 +42,15 @@
CSSImageSetValue::CSSImageSetValue()
: CSSValueList(ImageSetClass, CommaSeparator)
+ , m_accessedBestFitImage(false)
+ , m_scaleFactor(1)
{
}
CSSImageSetValue::~CSSImageSetValue()
{
+ if (m_image)
+ m_image->detachFromCSSValue();
}
void CSSImageSetValue::fillImageSet()
@@ -74,14 +79,11 @@
CSSImageSetValue::ImageWithScale CSSImageSetValue::bestImageForScaleFactor()
{
- if (!m_imagesInSet.size())
- fillImageSet();
-
ImageWithScale image;
size_t numberOfImages = m_imagesInSet.size();
for (size_t i = 0; i < numberOfImages; ++i) {
image = m_imagesInSet.at(i);
- if (image.scaleFactor >= m_deviceScaleFactor)
+ if (image.scaleFactor >= m_scaleFactor)
return image;
}
return image;
@@ -90,11 +92,16 @@
void CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
{
Document* document = loader.document();
- updateDeviceScaleFactor(*document);
-
+ if (Page* page = document->page())
+ m_scaleFactor = page->deviceScaleFactor();
+ else
+ m_scaleFactor = 1;
+
+ if (!m_imagesInSet.size())
+ fillImageSet();
+
if (m_accessedBestFitImage)
return;
-
// FIXME: In the future, we want to take much more than deviceScaleFactor into acount here.
// All forms of scale should be included: Page::pageScaleFactor(), Frame::pageZoomFactor(),
// and any CSS transforms. https://bugs.webkit.org/show_bug.cgi?id=81698
@@ -105,19 +112,30 @@
ASSERT(document->securityOrigin());
updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
}
- m_cachedImage = loader.requestImage(request);
- m_bestFitImageScaleFactor = image.scaleFactor;
- m_accessedBestFitImage = true;
+ if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
+ styleImage(*document).setCachedImage(*cachedImage, image.scaleFactor);
+ m_accessedBestFitImage = true;
+ }
}
-void CSSImageSetValue::updateDeviceScaleFactor(const Document& document)
+StyleCachedImage& CSSImageSetValue::styleImage(const Document& document)
{
- float deviceScaleFactor = document.page() ? document.page()->deviceScaleFactor() : 1;
- if (deviceScaleFactor == m_deviceScaleFactor)
- return;
- m_deviceScaleFactor = deviceScaleFactor;
- m_accessedBestFitImage = false;
- m_cachedImage = nullptr;
+ if (!m_image)
+ m_image = StyleCachedImage::create(*this);
+ else if (!m_image->isPending()) {
+ float deviceScaleFactor = 1;
+ if (Page* page = document.page())
+ deviceScaleFactor = page->deviceScaleFactor();
+
+ // If the deviceScaleFactor has changed, we may not have the best image loaded, so we have to re-assess.
+ if (deviceScaleFactor != m_scaleFactor) {
+ m_accessedBestFitImage = false;
+ m_image->detachFromCSSValue();
+ m_image = StyleCachedImage::create(*this);
+ }
+ }
+
+ return *m_image;
}
String CSSImageSetValue::customCSSText() const
@@ -152,13 +170,18 @@
bool CSSImageSetValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
{
- if (!m_cachedImage)
+ if (!m_image)
return false;
- return handler(*m_cachedImage);
+ CachedImage* cachedResource = m_image->cachedImage();
+ if (!cachedResource)
+ return false;
+ return handler(*cachedResource);
}
CSSImageSetValue::CSSImageSetValue(const CSSImageSetValue& cloneFrom)
: CSSValueList(cloneFrom)
+ , m_accessedBestFitImage(false)
+ , m_scaleFactor(1)
{
// Non-CSSValueList data is not accessible through CSS OM, no need to clone.
}
Modified: trunk/Source/WebCore/css/CSSImageSetValue.h (205345 => 205346)
--- trunk/Source/WebCore/css/CSSImageSetValue.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSImageSetValue.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -27,17 +27,18 @@
#define CSSImageSetValue_h
#include "CSSValueList.h"
-#include "CachedImageClient.h"
-#include "CachedResourceHandle.h"
namespace WebCore {
class CachedResourceLoader;
class Document;
+class StyleCachedImage;
+class StyleImage;
struct ResourceLoaderOptions;
class CSSImageSetValue final : public CSSValueList {
public:
+
static Ref<CSSImageSetValue> create()
{
return adoptRef(*new CSSImageSetValue());
@@ -45,11 +46,11 @@
~CSSImageSetValue();
void loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- CachedImage* cachedImage() const { return m_cachedImage.get(); }
+ StyleCachedImage& styleImage(const Document&);
String customCSSText() const;
- float bestFitScaleFactor() const { return m_bestFitImageScaleFactor; };
+ bool isPending() const { return !m_accessedBestFitImage; }
struct ImageWithScale {
String imageURL;
@@ -60,8 +61,6 @@
Ref<CSSImageSetValue> cloneForCSSOM() const;
- void updateDeviceScaleFactor(const Document&);
-
protected:
ImageWithScale bestImageForScaleFactor();
@@ -72,11 +71,13 @@
void fillImageSet();
static inline bool compareByScaleFactor(ImageWithScale first, ImageWithScale second) { return first.scaleFactor < second.scaleFactor; }
- CachedResourceHandle<CachedImage> m_cachedImage;
- bool m_accessedBestFitImage { false };
- float m_bestFitImageScaleFactor { 1 };
- float m_deviceScaleFactor { 1 };
+ RefPtr<StyleCachedImage> m_image;
+ bool m_accessedBestFitImage;
+ // This represents the scale factor that we used to find the best fit image. It does not necessarily
+ // correspond to the scale factor of the best fit image.
+ float m_scaleFactor;
+
Vector<ImageWithScale> m_imagesInSet;
};
Modified: trunk/Source/WebCore/css/CSSImageValue.cpp (205345 => 205346)
--- trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -32,6 +32,7 @@
#include "Document.h"
#include "Element.h"
#include "MemoryCache.h"
+#include "StyleCachedImage.h"
namespace WebCore {
@@ -45,21 +46,32 @@
CSSImageValue::CSSImageValue(CachedImage& image)
: CSSValue(ImageClass)
, m_url(image.url())
- , m_cachedImage(&image)
+ , m_image(StyleCachedImage::create(*this))
, m_accessedImage(true)
{
+ m_image->setCachedImage(image);
}
CSSImageValue::~CSSImageValue()
{
+ if (m_image)
+ m_image->detachFromCSSValue();
}
bool CSSImageValue::isPending() const
{
- return !m_accessedImage;
+ return !m_image || !m_image->cachedImage();
}
+StyleCachedImage& CSSImageValue::styleImage()
+{
+ if (!m_image)
+ m_image = StyleCachedImage::create(*this);
+
+ return *m_image;
+}
+
void CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
{
if (m_accessedImage)
@@ -76,14 +88,18 @@
ASSERT(loader.document()->securityOrigin());
updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
}
- m_cachedImage = loader.requestImage(request);
+ if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request))
+ styleImage().setCachedImage(*cachedImage);
}
bool CSSImageValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
{
- if (!m_cachedImage)
+ if (!m_image)
return false;
- return handler(*m_cachedImage);
+ CachedResource* cachedResource = m_image->cachedImage();
+ if (!cachedResource)
+ return false;
+ return handler(*cachedResource);
}
bool CSSImageValue::equals(const CSSImageValue& other) const
@@ -106,9 +122,7 @@
bool CSSImageValue::knownToBeOpaque(const RenderElement* renderer) const
{
- if (!m_cachedImage)
- return false;
- return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
+ return m_image ? m_image->knownToBeOpaque(renderer) : false;
}
} // namespace WebCore
Modified: trunk/Source/WebCore/css/CSSImageValue.h (205345 => 205346)
--- trunk/Source/WebCore/css/CSSImageValue.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/CSSImageValue.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -22,7 +22,6 @@
#define CSSImageValue_h
#include "CSSValue.h"
-#include "CachedResourceHandle.h"
#include <wtf/RefPtr.h>
namespace WebCore {
@@ -30,6 +29,7 @@
class CachedImage;
class CachedResourceLoader;
class Element;
+class StyleCachedImage;
class RenderElement;
struct ResourceLoaderOptions;
@@ -41,7 +41,7 @@
bool isPending() const;
void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- CachedImage* cachedImage() const { return m_cachedImage.get(); }
+ StyleCachedImage& styleImage();
const String& url() const { return m_url; }
@@ -62,7 +62,7 @@
explicit CSSImageValue(CachedImage&);
String m_url;
- CachedResourceHandle<CachedImage> m_cachedImage;
+ RefPtr<StyleCachedImage> m_image;
bool m_accessedImage;
AtomicString m_initiatorName;
};
Modified: trunk/Source/WebCore/css/StyleBuilderCustom.h (205345 => 205346)
--- trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -46,7 +46,6 @@
#include "SVGElement.h"
#include "SVGRenderStyle.h"
#include "StyleBuilderConverter.h"
-#include "StyleCachedImage.h"
#include "StyleFontSizeFunctions.h"
#include "StyleGeneratedImage.h"
#include "StyleResolver.h"
@@ -1314,12 +1313,12 @@
styleResolver.style()->setContent(StyleGeneratedImage::create(downcast<CSSImageGeneratorValue>(item.get())), didSet);
didSet = true;
} else if (is<CSSImageSetValue>(item.get())) {
- styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
+ styleResolver.style()->setContent(styleResolver.setOrPendingFromValue(CSSPropertyContent, downcast<CSSImageSetValue>(item.get())), didSet);
didSet = true;
}
if (is<CSSImageValue>(item.get())) {
- styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
+ styleResolver.style()->setContent(styleResolver.cachedOrPendingFromValue(CSSPropertyContent, downcast<CSSImageValue>(item.get())), didSet);
didSet = true;
continue;
}
Modified: trunk/Source/WebCore/css/StyleResolver.cpp (205345 => 205346)
--- trunk/Source/WebCore/css/StyleResolver.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/StyleResolver.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -1702,27 +1702,33 @@
RefPtr<StyleImage> StyleResolver::styleImage(CSSPropertyID property, CSSValue& value)
{
+ if (is<CSSImageValue>(value))
+ return cachedOrPendingFromValue(property, downcast<CSSImageValue>(value));
+
if (is<CSSImageGeneratorValue>(value)) {
if (is<CSSGradientValue>(value))
- return styleGeneratedImageFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
- return styleGeneratedImageFromValue(property, downcast<CSSImageGeneratorValue>(value));
+ return generatedOrPendingFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
+ return generatedOrPendingFromValue(property, downcast<CSSImageGeneratorValue>(value));
}
- if (is<CSSImageValue>(value) || is<CSSImageSetValue>(value) || is<CSSCursorImageValue>(value))
- return styleCachedImageFromValue(property, value);
+ if (is<CSSImageSetValue>(value))
+ return setOrPendingFromValue(property, downcast<CSSImageSetValue>(value));
+ if (is<CSSCursorImageValue>(value))
+ return cursorOrPendingFromValue(property, downcast<CSSCursorImageValue>(value));
+
return nullptr;
}
-Ref<StyleCachedImage> StyleResolver::styleCachedImageFromValue(CSSPropertyID property, CSSValue& value)
+Ref<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue& value)
{
- auto image = StyleCachedImage::create(value);
+ Ref<StyleImage> image = value.styleImage();
if (image->isPending())
m_state.ensurePendingResources().pendingImages.set(property, &value);
return image;
}
-Ref<StyleGeneratedImage> StyleResolver::styleGeneratedImageFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
+Ref<StyleImage> StyleResolver::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
{
if (is<CSSFilterImageValue>(value)) {
// FilterImage needs to calculate FilterOperations.
@@ -1734,6 +1740,22 @@
return StyleGeneratedImage::create(value);
}
+RefPtr<StyleImage> StyleResolver::setOrPendingFromValue(CSSPropertyID property, CSSImageSetValue& value)
+{
+ auto& image = value.styleImage(document());
+ if (image.isPending())
+ m_state.ensurePendingResources().pendingImages.set(property, &value);
+ return ℑ
+}
+
+RefPtr<StyleImage> StyleResolver::cursorOrPendingFromValue(CSSPropertyID property, CSSCursorImageValue& value)
+{
+ auto& image = value.styleImage(document());
+ if (image.isPending())
+ m_state.ensurePendingResources().pendingImages.set(property, &value);
+ return ℑ
+}
+
#if ENABLE(IOS_TEXT_AUTOSIZING)
void StyleResolver::checkForTextSizeAdjust(RenderStyle* style)
{
Modified: trunk/Source/WebCore/css/StyleResolver.h (205345 => 205346)
--- trunk/Source/WebCore/css/StyleResolver.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/css/StyleResolver.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -72,8 +72,6 @@
class RuleSet;
class SelectorFilter;
class Settings;
-class StyleCachedImage;
-class StyleGeneratedImage;
class StyleImage;
class StyleKeyframe;
class StylePendingImage;
@@ -460,8 +458,10 @@
const State& state() const { return m_state; }
RefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue&);
- Ref<StyleCachedImage> styleCachedImageFromValue(CSSPropertyID, CSSValue&);
- Ref<StyleGeneratedImage> styleGeneratedImageFromValue(CSSPropertyID, CSSImageGeneratorValue&);
+ Ref<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue&);
+ Ref<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue&);
+ RefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue&);
+ RefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue&);
bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
Modified: trunk/Source/WebCore/page/PageSerializer.cpp (205345 => 205346)
--- trunk/Source/WebCore/page/PageSerializer.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/page/PageSerializer.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -331,7 +331,9 @@
if (!is<CSSImageValue>(*cssValue))
continue;
- auto* image = downcast<CSSImageValue>(*cssValue).cachedImage();
+ auto& styleImage = downcast<CSSImageValue>(*cssValue).styleImage();
+
+ auto* image = styleImage.cachedImage();
if (!image)
continue;
Modified: trunk/Source/WebCore/rendering/style/FillLayer.cpp (205345 => 205346)
--- trunk/Source/WebCore/rendering/style/FillLayer.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/rendering/style/FillLayer.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -380,10 +380,16 @@
return false;
}
+static inline bool layerImagesIdentical(const FillLayer& layer1, const FillLayer& layer2)
+{
+ // We just care about pointer equivalency.
+ return layer1.image() == layer2.image();
+}
+
bool FillLayer::imagesIdentical(const FillLayer* layer1, const FillLayer* layer2)
{
for (; layer1 && layer2; layer1 = layer1->next(), layer2 = layer2->next()) {
- if (!arePointingToEqualData(layer1->image(), layer2->image()))
+ if (!layerImagesIdentical(*layer1, *layer2))
return false;
}
Modified: trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp (205345 => 205346)
--- trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp 2016-09-02 16:26:40 UTC (rev 205346)
@@ -24,9 +24,7 @@
#include "config.h"
#include "StyleCachedImage.h"
-#include "CSSCursorImageValue.h"
#include "CSSImageSetValue.h"
-#include "CSSImageValue.h"
#include "CachedImage.h"
#include "RenderElement.h"
@@ -33,90 +31,63 @@
namespace WebCore {
StyleCachedImage::StyleCachedImage(CSSValue& cssValue)
- : m_cssValue(cssValue)
+ : m_cssValue(&cssValue)
{
- ASSERT(is<CSSImageValue>(m_cssValue) || is<CSSImageSetValue>(m_cssValue) || is<CSSCursorImageValue>(m_cssValue));
-
m_isCachedImage = true;
}
StyleCachedImage::~StyleCachedImage()
{
+ if (m_image)
+ m_image->removeClient(this);
}
-bool StyleCachedImage::operator==(const StyleImage& other) const
+void StyleCachedImage::setCachedImage(CachedImage& image, float scaleFactor)
{
- if (!is<StyleCachedImage>(other))
- return false;
- auto& otherCached = downcast<StyleCachedImage>(other);
- if (&otherCached == this)
- return true;
- if (m_cssValue.ptr() == otherCached.m_cssValue.ptr())
- return true;
- if (m_cachedImage && m_cachedImage == otherCached.m_cachedImage)
- return true;
- return false;
+ ASSERT(!m_image);
+ m_image = ℑ
+ m_image->addClient(this);
+ m_scaleFactor = scaleFactor;
}
-CachedImage* StyleCachedImage::cachedImage() const
-{
- if (!m_cachedImage) {
- if (is<CSSImageValue>(m_cssValue)) {
- auto& imageValue = downcast<CSSImageValue>(m_cssValue.get());
- m_cachedImage = imageValue.cachedImage();
- } else if (is<CSSImageSetValue>(m_cssValue)) {
- auto& imageSetValue = downcast<CSSImageSetValue>(m_cssValue.get());
- m_cachedImage = imageSetValue.cachedImage();
- m_scaleFactor = imageSetValue.bestFitScaleFactor();
- } else if (is<CSSCursorImageValue>(m_cssValue.get())) {
- auto& cursorValue = downcast<CSSCursorImageValue>(m_cssValue.get());
- m_cachedImage = cursorValue.cachedImage();
- m_scaleFactor = cursorValue.scaleFactor();
- }
- }
- return m_cachedImage.get();
-}
-
PassRefPtr<CSSValue> StyleCachedImage::cssValue() const
{
- return const_cast<CSSValue*>(m_cssValue.ptr());
+ if (m_cssValue)
+ return m_cssValue;
+ return CSSPrimitiveValue::create(m_image->url(), CSSPrimitiveValue::CSS_URI);
}
bool StyleCachedImage::canRender(const RenderObject* renderer, float multiplier) const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->canRender(renderer, multiplier);
+ return m_image->canRender(renderer, multiplier);
}
bool StyleCachedImage::isPending() const
{
- return !m_cachedImage;
+ return !m_image;
}
bool StyleCachedImage::isLoaded() const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->isLoaded();
+ return m_image->isLoaded();
}
bool StyleCachedImage::errorOccurred() const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->errorOccurred();
+ return m_image->errorOccurred();
}
FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return { };
- FloatSize size = image->imageSizeForRenderer(renderer, multiplier);
+ FloatSize size = m_image->imageSizeForRenderer(renderer, multiplier);
size.scale(1 / m_scaleFactor);
return size;
}
@@ -123,66 +94,58 @@
bool StyleCachedImage::imageHasRelativeWidth() const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->imageHasRelativeWidth();
+ return m_image->imageHasRelativeWidth();
}
bool StyleCachedImage::imageHasRelativeHeight() const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->imageHasRelativeHeight();
+ return m_image->imageHasRelativeHeight();
}
void StyleCachedImage::computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return;
- image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
+ m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
}
bool StyleCachedImage::usesImageContainerSize() const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->usesImageContainerSize();
+ return m_image->usesImageContainerSize();
}
void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return;
- image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
+ m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
}
void StyleCachedImage::addClient(RenderElement* renderer)
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return;
- image->addClient(renderer);
+ m_image->addClient(renderer);
}
void StyleCachedImage::removeClient(RenderElement* renderer)
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return;
- image->removeClient(renderer);
+ m_image->removeClient(renderer);
}
RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return nullptr;
- return image->imageForRenderer(renderer);
+ return m_image->imageForRenderer(renderer);
}
float StyleCachedImage::imageScaleFactor() const
@@ -192,10 +155,9 @@
bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const
{
- auto* image = cachedImage();
- if (!image)
+ if (!m_image)
return false;
- return image->currentFrameKnownToBeOpaque(renderer);
+ return m_image->currentFrameKnownToBeOpaque(renderer);
}
}
Modified: trunk/Source/WebCore/rendering/style/StyleCachedImage.h (205345 => 205346)
--- trunk/Source/WebCore/rendering/style/StyleCachedImage.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/rendering/style/StyleCachedImage.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -32,20 +32,22 @@
class CSSValue;
class CachedImage;
-class Document;
-class StyleCachedImage final : public StyleImage {
+class StyleCachedImage final : public StyleImage, private CachedImageClient {
WTF_MAKE_FAST_ALLOCATED;
public:
static Ref<StyleCachedImage> create(CSSValue& cssValue) { return adoptRef(*new StyleCachedImage(cssValue)); }
virtual ~StyleCachedImage();
- bool operator==(const StyleImage& other) const override;
+ CachedImage* cachedImage() const override { return m_image.get(); }
- CachedImage* cachedImage() const override;
+ void detachFromCSSValue() { m_cssValue = nullptr; }
+ void setCSSValue(CSSValue& value) { m_cssValue = &value; }
- WrappedImagePtr data() const override { return m_cachedImage.get(); }
+ void setCachedImage(CachedImage&, float scaleFactor = 1);
+ WrappedImagePtr data() const override { return m_image.get(); }
+
PassRefPtr<CSSValue> cssValue() const override;
bool canRender(const RenderObject*, float multiplier) const override;
@@ -67,9 +69,9 @@
private:
StyleCachedImage(CSSValue&);
- Ref<CSSValue> m_cssValue;
- mutable float m_scaleFactor { 1 };
- mutable CachedResourceHandle<CachedImage> m_cachedImage;
+ CSSValue* m_cssValue;
+ float m_scaleFactor { 1 };
+ CachedResourceHandle<CachedImage> m_image;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h (205345 => 205346)
--- trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -41,8 +41,6 @@
CSSImageGeneratorValue& imageValue() { return m_imageGeneratorValue; }
private:
- bool operator==(const StyleImage& other) const override { return data() == other.data(); }
-
WrappedImagePtr data() const override { return m_imageGeneratorValue.ptr(); }
PassRefPtr<CSSValue> cssValue() const override;
Modified: trunk/Source/WebCore/rendering/style/StyleImage.h (205345 => 205346)
--- trunk/Source/WebCore/rendering/style/StyleImage.h 2016-09-02 15:54:20 UTC (rev 205345)
+++ trunk/Source/WebCore/rendering/style/StyleImage.h 2016-09-02 16:26:40 UTC (rev 205346)
@@ -45,7 +45,10 @@
public:
virtual ~StyleImage() { }
- virtual bool operator==(const StyleImage& other) const = 0;
+ bool operator==(const StyleImage& other) const
+ {
+ return &other == this || (data() && data() == other.data());
+ }
virtual PassRefPtr<CSSValue> cssValue() const = 0;
