src/third_party/WebKit/Source/core/css/CSSCrossfadeValue.cpp

   1 /*
   2  * Copyright (C) 2011 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "core/css/CSSCrossfadeValue.h"
  28
  29 #include "core/css/CSSImageValue.h"
  30 #include "core/rendering/RenderObject.h"
  31 #include "core/rendering/style/StyleFetchedImage.h"
  32 #include "platform/graphics/CrossfadeGeneratedImage.h"
  33 #include "wtf/text/StringBuilder.h"
  34
  35 namespace blink {
  36
  37 static bool subimageIsPending(CSSValue* value)
  38 {
  39     if (value->isImageValue())
  40         return toCSSImageValue(value)->cachedOrPendingImage()->isPendingImage();
  41
  42     if (value->isImageGeneratorValue())
  43         return toCSSImageGeneratorValue(value)->isPending();
  44
  45     ASSERT_NOT_REACHED();
  46
  47     return false;
  48 }
  49
  50 static bool subimageKnownToBeOpaque(CSSValue* value, const RenderObject* renderer)
  51 {
  52     if (value->isImageValue())
  53         return toCSSImageValue(value)->knownToBeOpaque(renderer);
  54
  55     if (value->isImageGeneratorValue())
  56         return toCSSImageGeneratorValue(value)->knownToBeOpaque(renderer);
  57
  58     ASSERT_NOT_REACHED();
  59
  60     return false;
  61 }
  62
  63 static ImageResource* cachedImageForCSSValue(CSSValue* value, ResourceFetcher* fetcher)
  64 {
  65     if (!value)
  66         return 0;
  67
  68     if (value->isImageValue()) {
  69         StyleFetchedImage* styleImageResource = toCSSImageValue(value)->cachedImage(fetcher);
  70         if (!styleImageResource)
  71             return 0;
  72
  73         return styleImageResource->cachedImage();
  74     }
  75
  76     if (value->isImageGeneratorValue()) {
  77         toCSSImageGeneratorValue(value)->loadSubimages(fetcher);
  78         // FIXME: Handle CSSImageGeneratorValue (and thus cross-fades with gradients and canvas).
  79         return 0;
  80     }
  81
  82     ASSERT_NOT_REACHED();
  83
  84     return 0;
  85 }
  86
  87 CSSCrossfadeValue::~CSSCrossfadeValue()
  88 {
  89     if (m_cachedFromImage)
  90         m_cachedFromImage->removeClient(&m_crossfadeSubimageObserver);
  91     if (m_cachedToImage)
  92         m_cachedToImage->removeClient(&m_crossfadeSubimageObserver);
  93 }
  94
  95 String CSSCrossfadeValue::customCSSText() const
  96 {
  97     StringBuilder result;
  98     result.appendLiteral("-webkit-cross-fade(");
  99     result.append(m_fromValue->cssText());
 100     result.appendLiteral(", ");
 101     result.append(m_toValue->cssText());
 102     result.appendLiteral(", ");
 103     result.append(m_percentageValue->cssText());
 104     result.append(')');
 105     return result.toString();
 106 }
 107
 108 IntSize CSSCrossfadeValue::fixedSize(const RenderObject* renderer)
 109 {
 110     float percentage = m_percentageValue->getFloatValue();
 111     float inversePercentage = 1 - percentage;
 112
 113     ResourceFetcher* fetcher = renderer->document().fetcher();
 114     ImageResource* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), fetcher);
 115     ImageResource* cachedToImage = cachedImageForCSSValue(m_toValue.get(), fetcher);
 116
 117     if (!cachedFromImage || !cachedToImage)
 118         return IntSize();
 119
 120     IntSize fromImageSize = cachedFromImage->imageForRenderer(renderer)->size();
 121     IntSize toImageSize = cachedToImage->imageForRenderer(renderer)->size();
 122
 123     // Rounding issues can cause transitions between images of equal size to return
 124     // a different fixed size; avoid performing the interpolation if the images are the same size.
 125     if (fromImageSize == toImageSize)
 126         return fromImageSize;
 127
 128     return IntSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
 129         fromImageSize.height() * inversePercentage + toImageSize.height() * percentage);
 130 }
 131
 132 bool CSSCrossfadeValue::isPending() const
 133 {
 134     return subimageIsPending(m_fromValue.get()) || subimageIsPending(m_toValue.get());
 135 }
 136
 137 bool CSSCrossfadeValue::knownToBeOpaque(const RenderObject* renderer) const
 138 {
 139     return subimageKnownToBeOpaque(m_fromValue.get(), renderer) && subimageKnownToBeOpaque(m_toValue.get(), renderer);
 140 }
 141
 142 void CSSCrossfadeValue::loadSubimages(ResourceFetcher* fetcher)
 143 {
 144     ResourcePtr<ImageResource> oldCachedFromImage = m_cachedFromImage;
 145     ResourcePtr<ImageResource> oldCachedToImage = m_cachedToImage;
 146
 147     m_cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), fetcher);
 148     m_cachedToImage = cachedImageForCSSValue(m_toValue.get(), fetcher);
 149
 150     if (m_cachedFromImage != oldCachedFromImage) {
 151         if (oldCachedFromImage)
 152             oldCachedFromImage->removeClient(&m_crossfadeSubimageObserver);
 153         if (m_cachedFromImage)
 154             m_cachedFromImage->addClient(&m_crossfadeSubimageObserver);
 155     }
 156
 157     if (m_cachedToImage != oldCachedToImage) {
 158         if (oldCachedToImage)
 159             oldCachedToImage->removeClient(&m_crossfadeSubimageObserver);
 160         if (m_cachedToImage)
 161             m_cachedToImage->addClient(&m_crossfadeSubimageObserver);
 162     }
 163
 164     m_crossfadeSubimageObserver.setReady(true);
 165 }
 166
 167 PassRefPtr<Image> CSSCrossfadeValue::image(RenderObject* renderer, const IntSize& size)
 168 {
 169     if (size.isEmpty())
 170         return nullptr;
 171
 172     ResourceFetcher* fetcher = renderer->document().fetcher();
 173     ImageResource* cachedFromImage = cachedImageForCSSValue(m_fromValue.get(), fetcher);
 174     ImageResource* cachedToImage = cachedImageForCSSValue(m_toValue.get(), fetcher);
 175
 176     if (!cachedFromImage || !cachedToImage)
 177         return Image::nullImage();
 178
 179     Image* fromImage = cachedFromImage->imageForRenderer(renderer);
 180     Image* toImage = cachedToImage->imageForRenderer(renderer);
 181
 182     if (!fromImage || !toImage)
 183         return Image::nullImage();
 184
 185     m_generatedImage = CrossfadeGeneratedImage::create(fromImage, toImage, m_percentageValue->getFloatValue(), fixedSize(renderer), size);
 186
 187     return m_generatedImage.release();
 188 }
 189
 190 void CSSCrossfadeValue::crossfadeChanged(const IntRect&)
 191 {
 192     RenderObjectSizeCountMap::const_iterator end = clients().end();
 193     for (RenderObjectSizeCountMap::const_iterator curr = clients().begin(); curr != end; ++curr) {
 194         RenderObject* client = const_cast<RenderObject*>(curr->key);
 195         client->imageChanged(static_cast<WrappedImagePtr>(this));
 196     }
 197 }
 198
 199 void CSSCrossfadeValue::CrossfadeSubimageObserverProxy::imageChanged(ImageResource*, const IntRect* rect)
 200 {
 201     if (m_ready)
 202         m_ownerValue->crossfadeChanged(*rect);
 203 }
 204
 205 bool CSSCrossfadeValue::hasFailedOrCanceledSubresources() const
 206 {
 207     if (m_cachedFromImage && m_cachedFromImage->loadFailedOrCanceled())
 208         return true;
 209     if (m_cachedToImage && m_cachedToImage->loadFailedOrCanceled())
 210         return true;
 211     return false;
 212 }
 213
 214 bool CSSCrossfadeValue::equals(const CSSCrossfadeValue& other) const
 215 {
 216     return compareCSSValuePtr(m_fromValue, other.m_fromValue)
 217         && compareCSSValuePtr(m_toValue, other.m_toValue)
 218         && compareCSSValuePtr(m_percentageValue, other.m_percentageValue);
 219 }
 220
 221 void CSSCrossfadeValue::traceAfterDispatch(Visitor* visitor)
 222 {
 223     visitor->trace(m_fromValue);
 224     visitor->trace(m_toValue);
 225     visitor->trace(m_percentageValue);
 226     CSSImageGeneratorValue::traceAfterDispatch(visitor);
 227 }
 228
 229 } // namespace blink