blob: 172c9458d1342d6a85e2310970cc6017da9be09e [file] [log] [blame]
/*
* Copyright (C) 2011 Apple Inc. All rights reserved.
* Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* 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 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 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
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "CSSCrossfadeValue.h"
#include "AnimationUtilities.h"
#include "CSSImageValue.h"
#include "CachedImage.h"
#include "CachedResourceLoader.h"
#include "CrossfadeGeneratedImage.h"
#include "RenderElement.h"
#include "StyleCachedImage.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(const 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;
}
inline CSSCrossfadeValue::SubimageObserver::SubimageObserver(CSSCrossfadeValue& owner)
: m_owner(owner)
{
}
void CSSCrossfadeValue::SubimageObserver::imageChanged(CachedImage*, const IntRect*)
{
m_owner.crossfadeChanged();
}
inline CSSCrossfadeValue::CSSCrossfadeValue(Ref<CSSValue>&& fromValue, Ref<CSSValue>&& toValue, Ref<CSSPrimitiveValue>&& percentageValue, bool prefixed)
: CSSImageGeneratorValue(CrossfadeClass)
, m_fromValue(WTFMove(fromValue))
, m_toValue(WTFMove(toValue))
, m_percentageValue(WTFMove(percentageValue))
, m_subimageObserver(*this)
, m_isPrefixed(prefixed)
{
}
Ref<CSSCrossfadeValue> CSSCrossfadeValue::create(Ref<CSSValue>&& fromValue, Ref<CSSValue>&& toValue, Ref<CSSPrimitiveValue>&& percentageValue, bool prefixed)
{
return adoptRef(*new CSSCrossfadeValue(WTFMove(fromValue), WTFMove(toValue), WTFMove(percentageValue), prefixed));
}
CSSCrossfadeValue::~CSSCrossfadeValue()
{
if (m_cachedFromImage)
m_cachedFromImage->removeClient(m_subimageObserver);
if (m_cachedToImage)
m_cachedToImage->removeClient(m_subimageObserver);
}
String CSSCrossfadeValue::customCSSText() const
{
StringBuilder result;
if (m_isPrefixed)
result.appendLiteral("-webkit-cross-fade(");
else
result.appendLiteral("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->floatValue();
float inversePercentage = 1 - percentage;
// FIXME: Skip Content Security Policy check when cross fade is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
auto options = CachedResourceLoader::defaultCachedResourceOptions();
auto& cachedResourceLoader = renderer.document().cachedResourceLoader();
auto* cachedFromImage = cachedImageForCSSValue(m_fromValue, cachedResourceLoader, options);
auto* cachedToImage = cachedImageForCSSValue(m_toValue, cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return FloatSize();
FloatSize fromImageSize = cachedFromImage->imageForRenderer(&renderer)->size();
FloatSize toImageSize = cachedToImage->imageForRenderer(&renderer)->size();
// Rounding issues can cause transitions between images of equal size to return
// a different fixed size; avoid performing the interpolation if the images are the same size.
if (fromImageSize == toImageSize)
return fromImageSize;
return fromImageSize * inversePercentage + toImageSize * percentage;
}
bool CSSCrossfadeValue::isPending() const
{
return CSSImageGeneratorValue::subimageIsPending(m_fromValue)
|| CSSImageGeneratorValue::subimageIsPending(m_toValue);
}
bool CSSCrossfadeValue::knownToBeOpaque(const RenderElement& renderer) const
{
return subimageKnownToBeOpaque(m_fromValue, renderer)
&& subimageKnownToBeOpaque(m_toValue, renderer);
}
void CSSCrossfadeValue::loadSubimages(CachedResourceLoader& cachedResourceLoader, const ResourceLoaderOptions& options)
{
auto oldCachedFromImage = m_cachedFromImage;
auto oldCachedToImage = m_cachedToImage;
m_cachedFromImage = CSSImageGeneratorValue::cachedImageForCSSValue(m_fromValue, cachedResourceLoader, options);
m_cachedToImage = CSSImageGeneratorValue::cachedImageForCSSValue(m_toValue, cachedResourceLoader, options);
if (m_cachedFromImage != oldCachedFromImage) {
if (oldCachedFromImage)
oldCachedFromImage->removeClient(m_subimageObserver);
if (m_cachedFromImage)
m_cachedFromImage->addClient(m_subimageObserver);
}
if (m_cachedToImage != oldCachedToImage) {
if (oldCachedToImage)
oldCachedToImage->removeClient(m_subimageObserver);
if (m_cachedToImage)
m_cachedToImage->addClient(m_subimageObserver);
}
// FIXME: Unclear why this boolean adds any value; for now keeping it around to avoid changing semantics.
m_subimagesAreReady = true;
}
Image* CSSCrossfadeValue::image(RenderElement& renderer, const FloatSize& size)
{
if (size.isEmpty())
return nullptr;
// FIXME: Skip Content Security Policy check when cross fade is applied to an element in a user agent shadow tree.
// See <https://bugs.webkit.org/show_bug.cgi?id=146663>.
auto options = CachedResourceLoader::defaultCachedResourceOptions();
auto& cachedResourceLoader = renderer.document().cachedResourceLoader();
auto* cachedFromImage = cachedImageForCSSValue(m_fromValue, cachedResourceLoader, options);
auto* cachedToImage = cachedImageForCSSValue(m_toValue, cachedResourceLoader, options);
if (!cachedFromImage || !cachedToImage)
return &Image::nullImage();
auto* fromImage = cachedFromImage->imageForRenderer(&renderer);
auto* toImage = cachedToImage->imageForRenderer(&renderer);
if (!fromImage || !toImage)
return &Image::nullImage();
m_generatedImage = CrossfadeGeneratedImage::create(*fromImage, *toImage, m_percentageValue->floatValue(), fixedSize(renderer), size);
return m_generatedImage.get();
}
inline void CSSCrossfadeValue::crossfadeChanged()
{
if (!m_subimagesAreReady)
return;
for (auto& client : clients())
client.key->imageChanged(this);
}
bool CSSCrossfadeValue::traverseSubresources(const WTF::Function<bool (const CachedResource&)>& handler) const
{
if (m_cachedFromImage && handler(*m_cachedFromImage))
return true;
if (m_cachedToImage && handler(*m_cachedToImage))
return true;
return false;
}
RefPtr<CSSCrossfadeValue> CSSCrossfadeValue::blend(const CSSCrossfadeValue& from, double progress) const
{
ASSERT(equalInputImages(from));
if (!m_cachedToImage || !m_cachedFromImage)
return nullptr;
auto fromImageValue = CSSImageValue::create(*m_cachedFromImage);
auto toImageValue = CSSImageValue::create(*m_cachedToImage);
double fromPercentage = from.m_percentageValue->doubleValue();
if (from.m_percentageValue->isPercentage())
fromPercentage /= 100.0;
double toPercentage = m_percentageValue->doubleValue();
if (m_percentageValue->isPercentage())
toPercentage /= 100.0;
auto percentageValue = CSSPrimitiveValue::create(blendFunc(fromPercentage, toPercentage, progress), CSSPrimitiveValue::CSS_NUMBER);
return CSSCrossfadeValue::create(WTFMove(fromImageValue), WTFMove(toImageValue), WTFMove(percentageValue), from.isPrefixed() && isPrefixed());
}
bool CSSCrossfadeValue::equals(const CSSCrossfadeValue& other) const
{
return equalInputImages(other) && compareCSSValue(m_percentageValue, other.m_percentageValue);
}
bool CSSCrossfadeValue::equalInputImages(const CSSCrossfadeValue& other) const
{
return compareCSSValue(m_fromValue, other.m_fromValue) && compareCSSValue(m_toValue, other.m_toValue);
}
} // namespace WebCore