Diff
Modified: trunk/Source/WebCore/ChangeLog (205418 => 205419)
--- trunk/Source/WebCore/ChangeLog 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/ChangeLog 2016-09-04 13:42:42 UTC (rev 205419)
@@ -1,3 +1,85 @@
+2016-09-04 Antti Koivisto <an...@apple.com>
+
+ 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:
+
2016-09-03 Wenson Hsieh <wenson_hs...@apple.com>
Media controls behave strangely when videos mute from within a playing handler
Modified: trunk/Source/WebCore/css/CSSCursorImageValue.cpp (205418 => 205419)
--- trunk/Source/WebCore/css/CSSCursorImageValue.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSCursorImageValue.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -26,8 +26,6 @@
#include "CSSImageValue.h"
#include "CachedImage.h"
#include "CachedResourceLoader.h"
-#include "StyleCachedImage.h"
-#include "StyleImage.h"
#include "SVGCursorElement.h"
#include "SVGLengthContext.h"
#include "SVGNames.h"
@@ -102,32 +100,17 @@
m_hotSpot.setY(static_cast<int>(y));
}
-void CSSCursorImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
+std::pair<CachedImage*, float> CSSCursorImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
{
- if (is<CSSImageSetValue>(m_imageValue.get())) {
- downcast<CSSImageSetValue>(m_imageValue.get()).loadBestFitImage(loader, options);
- return;
- }
+ if (is<CSSImageSetValue>(m_imageValue.get()))
+ return downcast<CSSImageSetValue>(m_imageValue.get()).loadBestFitImage(loader, options);
- downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options);
-}
-
-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()))
- 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();
+ if (auto* cursorElement = updateCursorElement(*loader.document())) {
+ if (cursorElement->href() != downcast<CSSImageValue>(m_imageValue.get()).url())
+ m_imageValue = CSSImageValue::create(cursorElement->href());
}
- styleImage->setCSSValue(*this);
- return *styleImage;
+ return { downcast<CSSImageValue>(m_imageValue.get()).loadImage(loader, options), 1 };
}
bool CSSCursorImageValue::equals(const CSSCursorImageValue& other) const
Modified: trunk/Source/WebCore/css/CSSCursorImageValue.h (205418 => 205419)
--- trunk/Source/WebCore/css/CSSCursorImageValue.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSCursorImageValue.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -31,7 +31,6 @@
class Element;
class SVGCursorElement;
class SVGElement;
-class StyleCachedImage;
class CSSCursorImageValue final : public CSSValue {
public:
@@ -53,8 +52,7 @@
String customCSSText() const;
- void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- StyleCachedImage& styleImage(const Document&);
+ std::pair<CachedImage*, float> loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
void removeReferencedElement(SVGElement*);
Modified: trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp (205418 => 205419)
--- trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -252,8 +252,7 @@
{
if (is<CSSImageValue>(value)) {
auto& imageValue = downcast<CSSImageValue>(value);
- imageValue.loadImage(cachedResourceLoader, options);
- return imageValue.styleImage().cachedImage();
+ return imageValue.loadImage(cachedResourceLoader, options);
}
if (is<CSSImageGeneratorValue>(value)) {
Modified: trunk/Source/WebCore/css/CSSImageSetValue.cpp (205418 => 205419)
--- trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSImageSetValue.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -35,7 +35,6 @@
#include "CrossOriginAccessControl.h"
#include "Document.h"
#include "Page.h"
-#include "StyleCachedImage.h"
#include <wtf/text/StringBuilder.h>
namespace WebCore {
@@ -42,15 +41,11 @@
CSSImageSetValue::CSSImageSetValue()
: CSSValueList(ImageSetClass, CommaSeparator)
- , m_accessedBestFitImage(false)
- , m_scaleFactor(1)
{
}
CSSImageSetValue::~CSSImageSetValue()
{
- if (m_image)
- m_image->detachFromCSSValue();
}
void CSSImageSetValue::fillImageSet()
@@ -79,63 +74,51 @@
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_scaleFactor)
+ if (image.scaleFactor >= m_deviceScaleFactor)
return image;
}
return image;
}
-void CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
+std::pair<CachedImage*, float> CSSImageSetValue::loadBestFitImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
{
Document* document = loader.document();
- if (Page* page = document->page())
- m_scaleFactor = page->deviceScaleFactor();
- else
- m_scaleFactor = 1;
+ updateDeviceScaleFactor(*document);
+
+ if (!m_accessedBestFitImage) {
+ m_accessedBestFitImage = true;
- 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
- ImageWithScale image = bestImageForScaleFactor();
- CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
- request.setInitiator(cachedResourceRequestInitiators().css);
- if (options.mode == FetchOptions::Mode::Cors) {
- ASSERT(document->securityOrigin());
- updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
+ // 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
+ ImageWithScale image = bestImageForScaleFactor();
+ CachedResourceRequest request(ResourceRequest(document->completeURL(image.imageURL)), options);
+ request.setInitiator(cachedResourceRequestInitiators().css);
+ if (options.mode == FetchOptions::Mode::Cors) {
+ ASSERT(document->securityOrigin());
+ updateRequestForAccessControl(request.mutableResourceRequest(), *document->securityOrigin(), options.allowCredentials);
+ }
+ m_cachedImage = loader.requestImage(request);
+ m_bestFitImageScaleFactor = image.scaleFactor;
}
- if (CachedResourceHandle<CachedImage> cachedImage = loader.requestImage(request)) {
- styleImage(*document).setCachedImage(*cachedImage, image.scaleFactor);
- m_accessedBestFitImage = true;
- }
+ return { m_cachedImage.get(), m_bestFitImageScaleFactor };
}
-StyleCachedImage& CSSImageSetValue::styleImage(const Document& document)
+void CSSImageSetValue::updateDeviceScaleFactor(const Document& document)
{
- 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;
+ float deviceScaleFactor = document.page() ? document.page()->deviceScaleFactor() : 1;
+ if (deviceScaleFactor == m_deviceScaleFactor)
+ return;
+ m_deviceScaleFactor = deviceScaleFactor;
+ m_accessedBestFitImage = false;
+ m_cachedImage = nullptr;
}
String CSSImageSetValue::customCSSText() const
@@ -170,18 +153,13 @@
bool CSSImageSetValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- CachedImage* cachedResource = m_image->cachedImage();
- if (!cachedResource)
- return false;
- return handler(*cachedResource);
+ return handler(*m_cachedImage);
}
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 (205418 => 205419)
--- trunk/Source/WebCore/css/CSSImageSetValue.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSImageSetValue.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -27,18 +27,17 @@
#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,13 +44,11 @@
}
~CSSImageSetValue();
- void loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- StyleCachedImage& styleImage(const Document&);
+ std::pair<CachedImage*, float> loadBestFitImage(CachedResourceLoader&, const ResourceLoaderOptions&);
+ CachedImage* cachedImage() const { return m_cachedImage.get(); }
String customCSSText() const;
- bool isPending() const { return !m_accessedBestFitImage; }
-
struct ImageWithScale {
String imageURL;
float scaleFactor;
@@ -61,6 +58,8 @@
Ref<CSSImageSetValue> cloneForCSSOM() const;
+ void updateDeviceScaleFactor(const Document&);
+
protected:
ImageWithScale bestImageForScaleFactor();
@@ -71,13 +70,11 @@
void fillImageSet();
static inline bool compareByScaleFactor(ImageWithScale first, ImageWithScale second) { return first.scaleFactor < second.scaleFactor; }
- RefPtr<StyleCachedImage> m_image;
- bool m_accessedBestFitImage;
+ CachedResourceHandle<CachedImage> m_cachedImage;
+ bool m_accessedBestFitImage { false };
+ float m_bestFitImageScaleFactor { 1 };
+ float m_deviceScaleFactor { 1 };
- // 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 (205418 => 205419)
--- trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSImageValue.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -32,7 +32,6 @@
#include "Document.h"
#include "Element.h"
#include "MemoryCache.h"
-#include "StyleCachedImage.h"
namespace WebCore {
@@ -46,60 +45,46 @@
CSSImageValue::CSSImageValue(CachedImage& image)
: CSSValue(ImageClass)
, m_url(image.url())
- , m_image(StyleCachedImage::create(*this))
+ , m_cachedImage(&image)
, m_accessedImage(true)
{
- m_image->setCachedImage(image);
}
CSSImageValue::~CSSImageValue()
{
- if (m_image)
- m_image->detachFromCSSValue();
}
bool CSSImageValue::isPending() const
{
- return !m_image || !m_image->cachedImage();
+ return !m_accessedImage;
}
-StyleCachedImage& CSSImageValue::styleImage()
+CachedImage* CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
{
- if (!m_image)
- m_image = StyleCachedImage::create(*this);
+ if (!m_accessedImage) {
+ m_accessedImage = true;
- return *m_image;
-}
+ CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
+ if (m_initiatorName.isEmpty())
+ request.setInitiator(cachedResourceRequestInitiators().css);
+ else
+ request.setInitiator(m_initiatorName);
-void CSSImageValue::loadImage(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
-{
- if (m_accessedImage)
- return;
- m_accessedImage = true;
-
- CachedResourceRequest request(ResourceRequest(loader.document()->completeURL(m_url)), options);
- if (m_initiatorName.isEmpty())
- request.setInitiator(cachedResourceRequestInitiators().css);
- else
- request.setInitiator(m_initiatorName);
-
- if (options.mode == FetchOptions::Mode::Cors) {
- ASSERT(loader.document()->securityOrigin());
- updateRequestForAccessControl(request.mutableResourceRequest(), *loader.document()->securityOrigin(), options.allowCredentials);
+ if (options.mode == FetchOptions::Mode::Cors) {
+ 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);
+ return m_cachedImage.get();
}
bool CSSImageValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- CachedResource* cachedResource = m_image->cachedImage();
- if (!cachedResource)
- return false;
- return handler(*cachedResource);
+ return handler(*m_cachedImage);
}
bool CSSImageValue::equals(const CSSImageValue& other) const
@@ -122,7 +107,9 @@
bool CSSImageValue::knownToBeOpaque(const RenderElement* renderer) const
{
- return m_image ? m_image->knownToBeOpaque(renderer) : false;
+ if (!m_cachedImage)
+ return false;
+ return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
}
} // namespace WebCore
Modified: trunk/Source/WebCore/css/CSSImageValue.h (205418 => 205419)
--- trunk/Source/WebCore/css/CSSImageValue.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/CSSImageValue.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -22,6 +22,7 @@
#define CSSImageValue_h
#include "CSSValue.h"
+#include "CachedResourceHandle.h"
#include <wtf/RefPtr.h>
namespace WebCore {
@@ -29,7 +30,6 @@
class CachedImage;
class CachedResourceLoader;
class Element;
-class StyleCachedImage;
class RenderElement;
struct ResourceLoaderOptions;
@@ -40,8 +40,8 @@
~CSSImageValue();
bool isPending() const;
- void loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
- StyleCachedImage& styleImage();
+ CachedImage* loadImage(CachedResourceLoader&, const ResourceLoaderOptions&);
+ CachedImage* cachedImage() const { return m_cachedImage.get(); }
const String& url() const { return m_url; }
@@ -62,7 +62,7 @@
explicit CSSImageValue(CachedImage&);
String m_url;
- RefPtr<StyleCachedImage> m_image;
+ CachedResourceHandle<CachedImage> m_cachedImage;
bool m_accessedImage;
AtomicString m_initiatorName;
};
Modified: trunk/Source/WebCore/css/StyleBuilderCustom.h (205418 => 205419)
--- trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/StyleBuilderCustom.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -46,6 +46,7 @@
#include "SVGElement.h"
#include "SVGRenderStyle.h"
#include "StyleBuilderConverter.h"
+#include "StyleCachedImage.h"
#include "StyleFontSizeFunctions.h"
#include "StyleGeneratedImage.h"
#include "StyleResolver.h"
@@ -1313,12 +1314,12 @@
styleResolver.style()->setContent(StyleGeneratedImage::create(downcast<CSSImageGeneratorValue>(item.get())), didSet);
didSet = true;
} else if (is<CSSImageSetValue>(item.get())) {
- styleResolver.style()->setContent(styleResolver.setOrPendingFromValue(CSSPropertyContent, downcast<CSSImageSetValue>(item.get())), didSet);
+ styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
didSet = true;
}
if (is<CSSImageValue>(item.get())) {
- styleResolver.style()->setContent(styleResolver.cachedOrPendingFromValue(CSSPropertyContent, downcast<CSSImageValue>(item.get())), didSet);
+ styleResolver.style()->setContent(styleResolver.styleCachedImageFromValue(CSSPropertyContent, item), didSet);
didSet = true;
continue;
}
Modified: trunk/Source/WebCore/css/StyleResolver.cpp (205418 => 205419)
--- trunk/Source/WebCore/css/StyleResolver.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/StyleResolver.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -1702,33 +1702,27 @@
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 generatedOrPendingFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
- return generatedOrPendingFromValue(property, downcast<CSSImageGeneratorValue>(value));
+ return styleGeneratedImageFromValue(property, *downcast<CSSGradientValue>(value).gradientWithStylesResolved(this));
+ return styleGeneratedImageFromValue(property, downcast<CSSImageGeneratorValue>(value));
}
- if (is<CSSImageSetValue>(value))
- return setOrPendingFromValue(property, downcast<CSSImageSetValue>(value));
+ if (is<CSSImageValue>(value) || is<CSSImageSetValue>(value) || is<CSSCursorImageValue>(value))
+ return styleCachedImageFromValue(property, value);
- if (is<CSSCursorImageValue>(value))
- return cursorOrPendingFromValue(property, downcast<CSSCursorImageValue>(value));
-
return nullptr;
}
-Ref<StyleImage> StyleResolver::cachedOrPendingFromValue(CSSPropertyID property, CSSImageValue& value)
+Ref<StyleCachedImage> StyleResolver::styleCachedImageFromValue(CSSPropertyID property, CSSValue& value)
{
- Ref<StyleImage> image = value.styleImage();
+ auto image = StyleCachedImage::create(value);
if (image->isPending())
m_state.ensurePendingResources().pendingImages.set(property, &value);
return image;
}
-Ref<StyleImage> StyleResolver::generatedOrPendingFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
+Ref<StyleGeneratedImage> StyleResolver::styleGeneratedImageFromValue(CSSPropertyID property, CSSImageGeneratorValue& value)
{
if (is<CSSFilterImageValue>(value)) {
// FilterImage needs to calculate FilterOperations.
@@ -1740,22 +1734,6 @@
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 (205418 => 205419)
--- trunk/Source/WebCore/css/StyleResolver.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/css/StyleResolver.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -72,6 +72,8 @@
class RuleSet;
class SelectorFilter;
class Settings;
+class StyleCachedImage;
+class StyleGeneratedImage;
class StyleImage;
class StyleKeyframe;
class StylePendingImage;
@@ -458,10 +460,8 @@
const State& state() const { return m_state; }
RefPtr<StyleImage> styleImage(CSSPropertyID, CSSValue&);
- Ref<StyleImage> cachedOrPendingFromValue(CSSPropertyID, CSSImageValue&);
- Ref<StyleImage> generatedOrPendingFromValue(CSSPropertyID, CSSImageGeneratorValue&);
- RefPtr<StyleImage> setOrPendingFromValue(CSSPropertyID, CSSImageSetValue&);
- RefPtr<StyleImage> cursorOrPendingFromValue(CSSPropertyID, CSSCursorImageValue&);
+ Ref<StyleCachedImage> styleCachedImageFromValue(CSSPropertyID, CSSValue&);
+ Ref<StyleGeneratedImage> styleGeneratedImageFromValue(CSSPropertyID, CSSImageGeneratorValue&);
bool applyPropertyToRegularStyle() const { return m_state.applyPropertyToRegularStyle(); }
bool applyPropertyToVisitedLinkStyle() const { return m_state.applyPropertyToVisitedLinkStyle(); }
Modified: trunk/Source/WebCore/page/PageSerializer.cpp (205418 => 205419)
--- trunk/Source/WebCore/page/PageSerializer.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/page/PageSerializer.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -331,9 +331,7 @@
if (!is<CSSImageValue>(*cssValue))
continue;
- auto& styleImage = downcast<CSSImageValue>(*cssValue).styleImage();
-
- auto* image = styleImage.cachedImage();
+ auto* image = downcast<CSSImageValue>(*cssValue).cachedImage();
if (!image)
continue;
Modified: trunk/Source/WebCore/rendering/style/FillLayer.cpp (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/FillLayer.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/FillLayer.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -380,16 +380,10 @@
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 (!layerImagesIdentical(*layer1, *layer2))
+ if (!arePointingToEqualData(layer1->image(), layer2->image()))
return false;
}
Modified: trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -2,7 +2,7 @@
* Copyright (C) 2000 Lars Knoll (kn...@kde.org)
* (C) 2000 Antti Koivisto (koivi...@kde.org)
* (C) 2000 Dirk Mueller (muel...@kde.org)
- * Copyright (C) 2003, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2005-2008, 2016 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
@@ -24,7 +24,9 @@
#include "config.h"
#include "StyleCachedImage.h"
+#include "CSSCursorImageValue.h"
#include "CSSImageSetValue.h"
+#include "CSSImageValue.h"
#include "CachedImage.h"
#include "RenderElement.h"
@@ -31,63 +33,97 @@
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);
}
-void StyleCachedImage::setCachedImage(CachedImage& image, float scaleFactor)
+bool StyleCachedImage::operator==(const StyleImage& other) const
{
- ASSERT(!m_image);
- m_image = ℑ
- m_image->addClient(this);
- m_scaleFactor = scaleFactor;
+ if (!is<StyleCachedImage>(other))
+ return false;
+ auto& otherCached = downcast<StyleCachedImage>(other);
+ if (&otherCached == this)
+ return true;
+ if (m_scaleFactor != otherCached.m_scaleFactor)
+ return false;
+ if (m_cssValue.ptr() == otherCached.m_cssValue.ptr())
+ return true;
+ if (m_cachedImage && m_cachedImage == otherCached.m_cachedImage)
+ return true;
+ return false;
}
+void StyleCachedImage::load(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
+{
+ ASSERT(isPending());
+
+ if (is<CSSImageValue>(m_cssValue)) {
+ auto& imageValue = downcast<CSSImageValue>(m_cssValue.get());
+ m_cachedImage = imageValue.loadImage(loader, options);
+ return;
+ }
+
+ if (is<CSSImageSetValue>(m_cssValue)) {
+ auto& imageSetValue = downcast<CSSImageSetValue>(m_cssValue.get());
+ std::tie(m_cachedImage, m_scaleFactor) = imageSetValue.loadBestFitImage(loader, options);
+ return;
+ }
+
+ if (is<CSSCursorImageValue>(m_cssValue.get())) {
+ auto& cursorValue = downcast<CSSCursorImageValue>(m_cssValue.get());
+ std::tie(m_cachedImage, m_scaleFactor) = cursorValue.loadImage(loader, options);
+ return;
+ }
+}
+
+CachedImage* StyleCachedImage::cachedImage() const
+{
+ return m_cachedImage.get();
+}
+
PassRefPtr<CSSValue> StyleCachedImage::cssValue() const
{
- if (m_cssValue)
- return m_cssValue;
- return CSSPrimitiveValue::create(m_image->url(), CSSPrimitiveValue::CSS_URI);
+ return const_cast<CSSValue*>(m_cssValue.ptr());
}
bool StyleCachedImage::canRender(const RenderObject* renderer, float multiplier) const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->canRender(renderer, multiplier);
+ return m_cachedImage->canRender(renderer, multiplier);
}
bool StyleCachedImage::isPending() const
{
- return !m_image;
+ return !m_cachedImage;
}
bool StyleCachedImage::isLoaded() const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->isLoaded();
+ return m_cachedImage->isLoaded();
}
bool StyleCachedImage::errorOccurred() const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->errorOccurred();
+ return m_cachedImage->errorOccurred();
}
FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
{
- if (!m_image)
+ if (!m_cachedImage)
return { };
- FloatSize size = m_image->imageSizeForRenderer(renderer, multiplier);
+ FloatSize size = m_cachedImage->imageSizeForRenderer(renderer, multiplier);
size.scale(1 / m_scaleFactor);
return size;
}
@@ -94,58 +130,58 @@
bool StyleCachedImage::imageHasRelativeWidth() const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->imageHasRelativeWidth();
+ return m_cachedImage->imageHasRelativeWidth();
}
bool StyleCachedImage::imageHasRelativeHeight() const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->imageHasRelativeHeight();
+ return m_cachedImage->imageHasRelativeHeight();
}
void StyleCachedImage::computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
{
- if (!m_image)
+ if (!m_cachedImage)
return;
- m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
+ m_cachedImage->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
}
bool StyleCachedImage::usesImageContainerSize() const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->usesImageContainerSize();
+ return m_cachedImage->usesImageContainerSize();
}
void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
{
- if (!m_image)
+ if (!m_cachedImage)
return;
- m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
+ m_cachedImage->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
}
void StyleCachedImage::addClient(RenderElement* renderer)
{
- if (!m_image)
+ if (!m_cachedImage)
return;
- m_image->addClient(renderer);
+ m_cachedImage->addClient(renderer);
}
void StyleCachedImage::removeClient(RenderElement* renderer)
{
- if (!m_image)
+ if (!m_cachedImage)
return;
- m_image->removeClient(renderer);
+ m_cachedImage->removeClient(renderer);
}
RefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
{
- if (!m_image)
+ if (!m_cachedImage)
return nullptr;
- return m_image->imageForRenderer(renderer);
+ return m_cachedImage->imageForRenderer(renderer);
}
float StyleCachedImage::imageScaleFactor() const
@@ -155,9 +191,9 @@
bool StyleCachedImage::knownToBeOpaque(const RenderElement* renderer) const
{
- if (!m_image)
+ if (!m_cachedImage)
return false;
- return m_image->currentFrameKnownToBeOpaque(renderer);
+ return m_cachedImage->currentFrameKnownToBeOpaque(renderer);
}
}
Modified: trunk/Source/WebCore/rendering/style/StyleCachedImage.h (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/StyleCachedImage.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/StyleCachedImage.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -32,26 +32,25 @@
class CSSValue;
class CachedImage;
+class Document;
-class StyleCachedImage final : public StyleImage, private CachedImageClient {
+class StyleCachedImage final : public StyleImage {
WTF_MAKE_FAST_ALLOCATED;
public:
static Ref<StyleCachedImage> create(CSSValue& cssValue) { return adoptRef(*new StyleCachedImage(cssValue)); }
virtual ~StyleCachedImage();
- CachedImage* cachedImage() const override { return m_image.get(); }
+ bool operator==(const StyleImage& other) const override;
- void detachFromCSSValue() { m_cssValue = nullptr; }
- void setCSSValue(CSSValue& value) { m_cssValue = &value; }
+ CachedImage* cachedImage() const override;
- void setCachedImage(CachedImage&, float scaleFactor = 1);
+ WrappedImagePtr data() const override { return m_cachedImage.get(); }
- WrappedImagePtr data() const override { return m_image.get(); }
-
PassRefPtr<CSSValue> cssValue() const override;
bool canRender(const RenderObject*, float multiplier) const override;
bool isPending() const override;
+ void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
bool isLoaded() const override;
bool errorOccurred() const override;
FloatSize imageSize(const RenderElement*, float multiplier) const override;
@@ -69,9 +68,9 @@
private:
StyleCachedImage(CSSValue&);
- CSSValue* m_cssValue;
- float m_scaleFactor { 1 };
- CachedResourceHandle<CachedImage> m_image;
+ Ref<CSSValue> m_cssValue;
+ mutable float m_scaleFactor { 1 };
+ mutable CachedResourceHandle<CachedImage> m_cachedImage;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/rendering/style/StyleGeneratedImage.cpp (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/StyleGeneratedImage.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/StyleGeneratedImage.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -47,6 +47,11 @@
return m_imageGeneratorValue->isPending();
}
+void StyleGeneratedImage::load(CachedResourceLoader& loader, const ResourceLoaderOptions& options)
+{
+ m_imageGeneratorValue->loadSubimages(loader, options);
+}
+
FloatSize StyleGeneratedImage::imageSize(const RenderElement* renderer, float multiplier) const
{
if (m_fixedSize) {
Modified: trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -41,11 +41,14 @@
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;
bool isPending() const override;
+ void load(CachedResourceLoader&, const ResourceLoaderOptions&) override;
FloatSize imageSize(const RenderElement*, float multiplier) const override;
bool imageHasRelativeWidth() const override { return !m_fixedSize; }
bool imageHasRelativeHeight() const override { return !m_fixedSize; }
Modified: trunk/Source/WebCore/rendering/style/StyleImage.h (205418 => 205419)
--- trunk/Source/WebCore/rendering/style/StyleImage.h 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/rendering/style/StyleImage.h 2016-09-04 13:42:42 UTC (rev 205419)
@@ -35,9 +35,11 @@
namespace WebCore {
class CachedImage;
+class CachedResourceLoader;
class CSSValue;
class RenderElement;
class RenderObject;
+struct ResourceLoaderOptions;
typedef const void* WrappedImagePtr;
@@ -45,15 +47,13 @@
public:
virtual ~StyleImage() { }
- bool operator==(const StyleImage& other) const
- {
- return &other == this || (data() && data() == other.data());
- }
+ virtual bool operator==(const StyleImage& other) const = 0;
virtual PassRefPtr<CSSValue> cssValue() const = 0;
virtual bool canRender(const RenderObject*, float /*multiplier*/) const { return true; }
virtual bool isPending() const = 0;
+ virtual void load(CachedResourceLoader&, const ResourceLoaderOptions&) = 0;
virtual bool isLoaded() const { return true; }
virtual bool errorOccurred() const { return false; }
virtual FloatSize imageSize(const RenderElement*, float multiplier) const = 0;
Modified: trunk/Source/WebCore/style/StylePendingResources.cpp (205418 => 205419)
--- trunk/Source/WebCore/style/StylePendingResources.cpp 2016-09-04 07:10:53 UTC (rev 205418)
+++ trunk/Source/WebCore/style/StylePendingResources.cpp 2016-09-04 13:42:42 UTC (rev 205419)
@@ -27,9 +27,6 @@
#include "StylePendingResources.h"
#include "CSSCursorImageValue.h"
-#include "CSSImageGeneratorValue.h"
-#include "CSSImageSetValue.h"
-#include "CSSImageValue.h"
#include "CachedResourceLoader.h"
#include "CachedSVGDocumentReference.h"
#include "ContentData.h"
@@ -60,26 +57,7 @@
options.allowCredentials = DoNotAllowStoredCredentials;
}
- auto cssValue = const_cast<StyleImage*>(styleImage)->cssValue();
- if (is<CSSImageValue>(cssValue.get())) {
- downcast<CSSImageValue>(*cssValue).loadImage(document.cachedResourceLoader(), options);
- return;
- };
-
- if (is<CSSImageSetValue>(cssValue.get())) {
- downcast<CSSImageSetValue>(*cssValue).loadBestFitImage(document.cachedResourceLoader(), options);
- return;
- };
-
- if (is<CSSImageGeneratorValue>(cssValue.get())) {
- downcast<CSSImageGeneratorValue>(*cssValue).loadSubimages(document.cachedResourceLoader(), options);
- return;
- };
-
- if (is<CSSCursorImageValue>(cssValue.get())) {
- downcast<CSSCursorImageValue>(*cssValue).loadImage(document.cachedResourceLoader(), options);
- return;
- };
+ const_cast<StyleImage&>(*styleImage).load(document.cachedResourceLoader(), options);
}
static void loadPendingImages(const PendingResources& pendingResources, Document& document, RenderStyle& style, const Element* element)
