CSSCrossfadeValue.cpp [plain text]
#include "config.h"
#include "CSSCrossfadeValue.h"
#include "AnimationUtilities.h"
#include "CSSImageValue.h"
#include "CachedImage.h"
#include "CachedResourceLoader.h"
#include "CrossfadeGeneratedImage.h"
#include "ImageBuffer.h"
#include "RenderElement.h"
#include "StyleCachedImage.h"
#include "StyleGeneratedImage.h"
#include <wtf/text/StringBuilder.h>
namespace WebCore {
static inline double blendFunc(double from, double to, double progress)
{
return blend(from, to, progress);
}
static bool subimageKnownToBeOpaque(CSSValue& value, const RenderElement* renderer)
{
if (is<CSSImageValue>(value))
return downcast<CSSImageValue>(value).knownToBeOpaque(renderer);
if (is<CSSImageGeneratorValue>(value))
return downcast<CSSImageGeneratorValue>(value).knownToBeOpaque(renderer);
ASSERT_NOT_REACHED();
return false;
}
CSSCrossfadeValue::~CSSCrossfadeValue()
{
if (m_cachedFromImage)
m_cachedFromImage->removeClient(&m_crossfadeSubimageObserver);
if (m_cachedToImage)
m_cachedToImage->removeClient(&m_crossfadeSubimageObserver);
}
String CSSCrossfadeValue::customCSSText() const
{
StringBuilder result;
result.appendLiteral("-webkit-cross-fade(");
result.append(m_fromValue->cssText());
result.appendLiteral(", ");
result.append(m_toValue->cssText());
result.appendLiteral(", ");
result.append(m_percentageValue->cssText());
result.append(')');
return result.toString();
}
FloatSize CSSCrossfadeValue::fixedSize(const RenderElement* renderer)
{
float percentage = m_percentageValue->getFloatValue();
float inversePercentage = 1 - percentage;
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), cachedResourceLoader, options);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue.get(), cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return FloatSize();
FloatSize fromImageSize = cachedFromImage->imageForRenderer(renderer)->size();
FloatSize toImageSize = cachedToImage->imageForRenderer(renderer)->size();
if (fromImageSize == toImageSize)
return fromImageSize;
return FloatSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
fromImageSize.height() * inversePercentage + toImageSize.height() * percentage);
}
bool CSSCrossfadeValue::isPending() const
{
return CSSImageGeneratorValue::subimageIsPending(m_fromValue.get())
|| CSSImageGeneratorValue::subimageIsPending(m_toValue.get());
}
bool CSSCrossfadeValue::knownToBeOpaque(const RenderElement* renderer) const
{
return subimageKnownToBeOpaque(*m_fromValue, renderer) && subimageKnownToBeOpaque(*m_toValue, renderer);
}
void CSSCrossfadeValue::loadSubimages(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
{
CachedResourceHandle<CachedImage> oldCachedFromImage = m_cachedFromImage;
CachedResourceHandle<CachedImage> oldCachedToImage = m_cachedToImage;
m_cachedFromImage = CSSImageGeneratorValue::cachedImageForCSSValue(m_fromValue.get(), cachedResourceLoader, options);
m_cachedToImage = CSSImageGeneratorValue::cachedImageForCSSValue(m_toValue.get(), cachedResourceLoader, options);
if (m_cachedFromImage != oldCachedFromImage) {
if (oldCachedFromImage)
oldCachedFromImage->removeClient(&m_crossfadeSubimageObserver);
if (m_cachedFromImage)
m_cachedFromImage->addClient(&m_crossfadeSubimageObserver);
}
if (m_cachedToImage != oldCachedToImage) {
if (oldCachedToImage)
oldCachedToImage->removeClient(&m_crossfadeSubimageObserver);
if (m_cachedToImage)
m_cachedToImage->addClient(&m_crossfadeSubimageObserver);
}
m_crossfadeSubimageObserver.setReady(true);
}
PassRefPtr<Image> CSSCrossfadeValue::image(RenderElement* renderer, const FloatSize& size)
{
if (size.isEmpty())
return nullptr;
ResourceLoaderOptions options = CachedResourceLoader::defaultCachedResourceOptions();
CachedResourceLoader& cachedResourceLoader = renderer->document().cachedResourceLoader();
CachedImage* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), cachedResourceLoader, options);
CachedImage* cachedToImage = cachedImageForCSSValue(m_toValue.get(), cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return Image::nullImage();
Image* fromImage = cachedFromImage->imageForRenderer(renderer);
Image* toImage = cachedToImage->imageForRenderer(renderer);
if (!fromImage || !toImage)
return Image::nullImage();
m_generatedImage = CrossfadeGeneratedImage::create(fromImage, toImage, m_percentageValue->getFloatValue(), fixedSize(renderer), size);
return m_generatedImage.release();
}
void CSSCrossfadeValue::crossfadeChanged(const IntRect&)
{
for (auto it = clients().begin(), end = clients().end(); it != end; ++it)
it->key->imageChanged(static_cast<WrappedImagePtr>(this));
}
void CSSCrossfadeValue::CrossfadeSubimageObserverProxy::imageChanged(CachedImage*, const IntRect* rect)
{
if (m_ready)
m_ownerValue->crossfadeChanged(*rect);
}
bool CSSCrossfadeValue::traverseSubresources(const std::function<bool (const CachedResource&)>& handler) const
{
if (m_cachedFromImage && handler(*m_cachedFromImage))
return true;
if (m_cachedToImage && handler(*m_cachedToImage))
return true;
return false;
}
PassRefPtr<CSSCrossfadeValue> CSSCrossfadeValue::blend(const CSSCrossfadeValue& from, double progress) const
{
ASSERT(equalInputImages(from));
RefPtr<StyleCachedImage> toStyledImage = StyleCachedImage::create(m_cachedToImage.get());
RefPtr<StyleCachedImage> fromStyledImage = StyleCachedImage::create(m_cachedFromImage.get());
auto fromImageValue = CSSImageValue::create(m_cachedFromImage->url(), fromStyledImage.get());
auto toImageValue = CSSImageValue::create(m_cachedToImage->url(), toStyledImage.get());
RefPtr<CSSCrossfadeValue> crossfadeValue = CSSCrossfadeValue::create(WTF::move(fromImageValue), WTF::move(toImageValue));
double fromPercentage = from.m_percentageValue->getDoubleValue();
if (from.m_percentageValue->isPercentage())
fromPercentage /= 100.0;
double toPercentage = m_percentageValue->getDoubleValue();
if (m_percentageValue->isPercentage())
toPercentage /= 100.0;
crossfadeValue->setPercentage(CSSPrimitiveValue::create(blendFunc(fromPercentage, toPercentage, progress), CSSPrimitiveValue::CSS_NUMBER));
return crossfadeValue.release();
}
bool CSSCrossfadeValue::equals(const CSSCrossfadeValue& other) const
{
return equalInputImages(other)
&& compareCSSValuePtr(m_percentageValue, other.m_percentageValue);
}
bool CSSCrossfadeValue::equalInputImages(const CSSCrossfadeValue& other) const
{
return compareCSSValuePtr(m_fromValue, other.m_fromValue)
&& compareCSSValuePtr(m_toValue, other.m_toValue);
}
}