webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 89 insertions, 85 deletions

diff --git a/Source/WebCore/css/CSSImageGeneratorValue.cpp b/Source/WebCore/css/CSSImageGeneratorValue.cpp
index 30ca59c3d..3c7c29956 100644
--- a/Source/WebCore/css/CSSImageGeneratorValue.cpp
+++ b/Source/WebCore/css/CSSImageGeneratorValue.cpp
@@ -11,10 +11,10 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -32,13 +32,30 @@
 #include "CSSFilterImageValue.h"
 #include "CSSGradientValue.h"
 #include "CSSImageValue.h"
+#include "CSSNamedImageValue.h"
 #include "GeneratedImage.h"
 #include "RenderElement.h"
 #include "StyleCachedImage.h"
 
 namespace WebCore {
 
-static const double timeToKeepCachedGeneratedImagesInSeconds = 3;
+static const auto timeToKeepCachedGeneratedImages = std::chrono::seconds { 3 };
+
+class CSSImageGeneratorValue::CachedGeneratedImage {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    CachedGeneratedImage(CSSImageGeneratorValue&, FloatSize, GeneratedImage&);
+    GeneratedImage& image() const { return m_image; }
+    void puntEvictionTimer() { m_evictionTimer.restart(); }
+
+private:
+    void evictionTimerFired();
+
+    CSSImageGeneratorValue& m_owner;
+    const FloatSize m_size;
+    const Ref<GeneratedImage> m_image;
+    DeferrableOneShotTimer m_evictionTimer;
+};
 
 CSSImageGeneratorValue::CSSImageGeneratorValue(ClassType classType)
     : CSSValue(classType)
@@ -49,77 +66,75 @@ CSSImageGeneratorValue::~CSSImageGeneratorValue()
 {
 }
 
-void CSSImageGeneratorValue::addClient(RenderElement* renderer)
+void CSSImageGeneratorValue::addClient(RenderElement& renderer)
 {
-    ASSERT(renderer);
     if (m_clients.isEmpty())
         ref();
-    m_clients.add(renderer);
+    m_clients.add(&renderer);
 }
 
-void CSSImageGeneratorValue::removeClient(RenderElement* renderer)
+void CSSImageGeneratorValue::removeClient(RenderElement& renderer)
 {
-    ASSERT(renderer);
-    ASSERT(m_clients.contains(renderer));
-    if (m_clients.remove(renderer) && m_clients.isEmpty())
+    ASSERT(m_clients.contains(&renderer));
+    if (m_clients.remove(&renderer) && m_clients.isEmpty())
         deref();
 }
 
-GeneratedImage* CSSImageGeneratorValue::cachedImageForSize(IntSize size)
+GeneratedImage* CSSImageGeneratorValue::cachedImageForSize(FloatSize size)
 {
     if (size.isEmpty())
         return nullptr;
 
-    CachedGeneratedImage* cachedGeneratedImage = m_images.get(size);
+    auto* cachedGeneratedImage = m_images.get(size);
     if (!cachedGeneratedImage)
         return nullptr;
 
     cachedGeneratedImage->puntEvictionTimer();
-    return cachedGeneratedImage->image();
+    return &cachedGeneratedImage->image();
 }
 
-void CSSImageGeneratorValue::saveCachedImageForSize(IntSize size, PassRefPtr<GeneratedImage> image)
+void CSSImageGeneratorValue::saveCachedImageForSize(FloatSize size, GeneratedImage& image)
 {
     ASSERT(!m_images.contains(size));
     m_images.add(size, std::make_unique<CachedGeneratedImage>(*this, size, image));
 }
 
-void CSSImageGeneratorValue::evictCachedGeneratedImage(IntSize size)
+void CSSImageGeneratorValue::evictCachedGeneratedImage(FloatSize size)
 {
     ASSERT(m_images.contains(size));
     m_images.remove(size);
 }
 
-CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage(CSSImageGeneratorValue& owner, IntSize size, PassRefPtr<GeneratedImage> image)
+inline CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage(CSSImageGeneratorValue& owner, FloatSize size, GeneratedImage& image)
     : m_owner(owner)
     , m_size(size)
     , m_image(image)
-    , m_evictionTimer(this, &CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired, timeToKeepCachedGeneratedImagesInSeconds)
+    , m_evictionTimer(*this, &CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired, timeToKeepCachedGeneratedImages)
 {
     m_evictionTimer.restart();
 }
 
-void CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired(DeferrableOneShotTimer<CachedGeneratedImage>&)
+void CSSImageGeneratorValue::CachedGeneratedImage::evictionTimerFired()
 {
     // NOTE: This is essentially a "delete this", the object is no longer valid after this line.
     m_owner.evictCachedGeneratedImage(m_size);
 }
 
-PassRefPtr<Image> CSSImageGeneratorValue::image(RenderElement* renderer, const IntSize& size)
+RefPtr<Image> CSSImageGeneratorValue::image(RenderElement& renderer, const FloatSize& size)
 {
     switch (classType()) {
     case CanvasClass:
-        return toCSSCanvasValue(this)->image(renderer, size);
+        return downcast<CSSCanvasValue>(*this).image(&renderer, size);
+    case NamedImageClass:
+        return downcast<CSSNamedImageValue>(*this).image(&renderer, size);
     case CrossfadeClass:
-        return toCSSCrossfadeValue(this)->image(renderer, size);
-#if ENABLE(CSS_FILTERS)
+        return downcast<CSSCrossfadeValue>(*this).image(renderer, size);
     case FilterImageClass:
-        return toCSSFilterImageValue(this)->image(renderer, size);
-#endif
+        return downcast<CSSFilterImageValue>(*this).image(&renderer, size);
     case LinearGradientClass:
-        return toCSSLinearGradientValue(this)->image(renderer, size);
+        return downcast<CSSLinearGradientValue>(*this).image(renderer, size);
     case RadialGradientClass:
-        return toCSSRadialGradientValue(this)->image(renderer, size);
+        return downcast<CSSRadialGradientValue>(*this).image(renderer, size);
     default:
         ASSERT_NOT_REACHED();
     }
@@ -130,151 +145,140 @@ bool CSSImageGeneratorValue::isFixedSize() const
 {
     switch (classType()) {
     case CanvasClass:
-        return toCSSCanvasValue(this)->isFixedSize();
+        return downcast<CSSCanvasValue>(*this).isFixedSize();
+    case NamedImageClass:
+        return downcast<CSSNamedImageValue>(*this).isFixedSize();
     case CrossfadeClass:
-        return toCSSCrossfadeValue(this)->isFixedSize();
-#if ENABLE(CSS_FILTERS)
+        return downcast<CSSCrossfadeValue>(*this).isFixedSize();
     case FilterImageClass:
-        return toCSSFilterImageValue(this)->isFixedSize();
-#endif
+        return downcast<CSSFilterImageValue>(*this).isFixedSize();
     case LinearGradientClass:
-        return toCSSLinearGradientValue(this)->isFixedSize();
+        return downcast<CSSLinearGradientValue>(*this).isFixedSize();
     case RadialGradientClass:
-        return toCSSRadialGradientValue(this)->isFixedSize();
+        return downcast<CSSRadialGradientValue>(*this).isFixedSize();
     default:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
-IntSize CSSImageGeneratorValue::fixedSize(const RenderElement* renderer)
+FloatSize CSSImageGeneratorValue::fixedSize(const RenderElement& renderer)
 {
     switch (classType()) {
     case CanvasClass:
-        return toCSSCanvasValue(this)->fixedSize(renderer);
+        return downcast<CSSCanvasValue>(*this).fixedSize(&renderer);
     case CrossfadeClass:
-        return toCSSCrossfadeValue(this)->fixedSize(renderer);
-#if ENABLE(CSS_FILTERS)
+        return downcast<CSSCrossfadeValue>(*this).fixedSize(renderer);
     case FilterImageClass:
-        return toCSSFilterImageValue(this)->fixedSize(renderer);
-#endif
+        return downcast<CSSFilterImageValue>(*this).fixedSize(&renderer);
     case LinearGradientClass:
-        return toCSSLinearGradientValue(this)->fixedSize(renderer);
+        return downcast<CSSLinearGradientValue>(*this).fixedSize(renderer);
     case RadialGradientClass:
-        return toCSSRadialGradientValue(this)->fixedSize(renderer);
+        return downcast<CSSRadialGradientValue>(*this).fixedSize(renderer);
     default:
         ASSERT_NOT_REACHED();
     }
-    return IntSize();
+    return FloatSize();
 }
 
 bool CSSImageGeneratorValue::isPending() const
 {
     switch (classType()) {
     case CrossfadeClass:
-        return toCSSCrossfadeValue(this)->isPending();
+        return downcast<CSSCrossfadeValue>(*this).isPending();
     case CanvasClass:
-        return toCSSCanvasValue(this)->isPending();
-#if ENABLE(CSS_FILTERS)
+        return downcast<CSSCanvasValue>(*this).isPending();
+    case NamedImageClass:
+        return downcast<CSSNamedImageValue>(*this).isPending();
     case FilterImageClass:
-        return toCSSFilterImageValue(this)->isPending();
-#endif
+        return downcast<CSSFilterImageValue>(*this).isPending();
     case LinearGradientClass:
-        return toCSSLinearGradientValue(this)->isPending();
+        return downcast<CSSLinearGradientValue>(*this).isPending();
     case RadialGradientClass:
-        return toCSSRadialGradientValue(this)->isPending();
+        return downcast<CSSRadialGradientValue>(*this).isPending();
     default:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
-bool CSSImageGeneratorValue::knownToBeOpaque(const RenderElement* renderer) const
+bool CSSImageGeneratorValue::knownToBeOpaque(const RenderElement& renderer) const
 {
     switch (classType()) {
     case CrossfadeClass:
-        return toCSSCrossfadeValue(this)->knownToBeOpaque(renderer);
+        return downcast<CSSCrossfadeValue>(*this).knownToBeOpaque(renderer);
     case CanvasClass:
         return false;
-#if ENABLE(CSS_FILTERS)
+    case NamedImageClass:
+        return false;
     case FilterImageClass:
-        return toCSSFilterImageValue(this)->knownToBeOpaque(renderer);
-#endif
+        return downcast<CSSFilterImageValue>(*this).knownToBeOpaque(&renderer);
     case LinearGradientClass:
-        return toCSSLinearGradientValue(this)->knownToBeOpaque(renderer);
+        return downcast<CSSLinearGradientValue>(*this).knownToBeOpaque();
     case RadialGradientClass:
-        return toCSSRadialGradientValue(this)->knownToBeOpaque(renderer);
+        return downcast<CSSRadialGradientValue>(*this).knownToBeOpaque();
     default:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
-void CSSImageGeneratorValue::loadSubimages(CachedResourceLoader* cachedResourceLoader)
+void CSSImageGeneratorValue::loadSubimages(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
 {
     switch (classType()) {
     case CrossfadeClass:
-        toCSSCrossfadeValue(this)->loadSubimages(cachedResourceLoader);
+        downcast<CSSCrossfadeValue>(*this).loadSubimages(cachedResourceLoader, options);
         break;
     case CanvasClass:
-        toCSSCanvasValue(this)->loadSubimages(cachedResourceLoader);
+        downcast<CSSCanvasValue>(*this).loadSubimages(cachedResourceLoader, options);
         break;
-#if ENABLE(CSS_FILTERS)
     case FilterImageClass:
-        toCSSFilterImageValue(this)->loadSubimages(cachedResourceLoader);
+        downcast<CSSFilterImageValue>(*this).loadSubimages(cachedResourceLoader, options);
         break;
-#endif
     case LinearGradientClass:
-        toCSSLinearGradientValue(this)->loadSubimages(cachedResourceLoader);
+        downcast<CSSLinearGradientValue>(*this).loadSubimages(cachedResourceLoader, options);
         break;
     case RadialGradientClass:
-        toCSSRadialGradientValue(this)->loadSubimages(cachedResourceLoader);
+        downcast<CSSRadialGradientValue>(*this).loadSubimages(cachedResourceLoader, options);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
-bool CSSImageGeneratorValue::subimageIsPending(CSSValue* value)
+bool CSSImageGeneratorValue::subimageIsPending(const CSSValue& value)
 {
-    if (value->isImageValue())
-        return toCSSImageValue(value)->cachedOrPendingImage()->isPendingImage();
+    if (is<CSSImageValue>(value))
+        return downcast<CSSImageValue>(value).isPending();
     
-    if (value->isImageGeneratorValue())
-        return toCSSImageGeneratorValue(value)->isPending();
+    if (is<CSSImageGeneratorValue>(value))
+        return downcast<CSSImageGeneratorValue>(value).isPending();
 
-    if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone)
+    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return false;
 
     ASSERT_NOT_REACHED();
-    
     return false;
 }
 
-CachedImage* CSSImageGeneratorValue::cachedImageForCSSValue(CSSValue* value, CachedResourceLoader* cachedResourceLoader)
+CachedImage* CSSImageGeneratorValue::cachedImageForCSSValue(CSSValue& value, CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
 {
-    if (!value)
-        return nullptr;
-
-    if (value->isImageValue()) {
-        StyleCachedImage* styleCachedImage = toCSSImageValue(value)->cachedImage(cachedResourceLoader);
-        if (!styleCachedImage)
-            return nullptr;
-
-        return styleCachedImage->cachedImage();
+    if (is<CSSImageValue>(value)) {
+        auto& imageValue = downcast<CSSImageValue>(value);
+        return imageValue.loadImage(cachedResourceLoader, options);
     }
     
-    if (value->isImageGeneratorValue()) {
-        toCSSImageGeneratorValue(value)->loadSubimages(cachedResourceLoader);
+    if (is<CSSImageGeneratorValue>(value)) {
+        downcast<CSSImageGeneratorValue>(value).loadSubimages(cachedResourceLoader, options);
         // FIXME: Handle CSSImageGeneratorValue (and thus cross-fades with gradients and canvas).
         return nullptr;
     }
 
-    if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone)
+    if (is<CSSPrimitiveValue>(value) && downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone)
         return nullptr;
 
     ASSERT_NOT_REACHED();
-    
     return nullptr;
 }
+
 } // namespace WebCore