Changeset 166642 in webkit


Ignore:
Timestamp:
Apr 2, 2014 7:18:58 AM (10 years ago)
Author:
Alan Bujtas
Message:

Subpixel rendering: Transition class CSSImageGeneratorValue/class StyleImage (and its dependencies) from
IntSize to FloatSize to enable subpixel sized (generated)images.
​https://bugs.webkit.org/show_bug.cgi?id=130659

Reviewed by Simon Fraser and Andreas Kling.

This is in preparation to support subpixel positioned/sized background images. Generated images
needs to be able to sized on device pixels.

No change in behavior.

  • WebCore.vcxproj/WebCore.vcxproj:
  • WebCore.vcxproj/WebCore.vcxproj.filters:
  • WebCore.xcodeproj/project.pbxproj:
  • css/CSSCanvasValue.cpp:

(WebCore::CSSCanvasValue::fixedSize):
(WebCore::CSSCanvasValue::image):

  • css/CSSCanvasValue.h:
  • css/CSSCrossfadeValue.cpp:

(WebCore::CSSCrossfadeValue::fixedSize):
(WebCore::CSSCrossfadeValue::image):

  • css/CSSCrossfadeValue.h:
  • css/CSSFilterImageValue.cpp:

(WebCore::CSSFilterImageValue::fixedSize):
(WebCore::CSSFilterImageValue::image):

  • css/CSSFilterImageValue.h:
  • css/CSSGradientValue.cpp:

(WebCore::CSSGradientValue::image):
(WebCore::positionFromValue):
(WebCore::CSSGradientValue::computeEndPoint):
(WebCore::endPointsFromAngle):
(WebCore::CSSLinearGradientValue::createGradient):
(WebCore::CSSRadialGradientValue::createGradient):

  • css/CSSGradientValue.h:

(WebCore::CSSGradientValue::fixedSize):

  • css/CSSImageGeneratorValue.cpp:

(WebCore::CSSImageGeneratorValue::cachedImageForSize):
(WebCore::CSSImageGeneratorValue::saveCachedImageForSize):
(WebCore::CSSImageGeneratorValue::evictCachedGeneratedImage):
(WebCore::CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage):
(WebCore::CSSImageGeneratorValue::image):
(WebCore::CSSImageGeneratorValue::fixedSize):

  • css/CSSImageGeneratorValue.h:
  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::setContainerSizeForRenderer):

  • loader/cache/CachedImage.h:
  • platform/graphics/FloatSizeHash.h: Added.

(WTF::FloatHash<WebCore::FloatSize>::hash):
(WTF::FloatHash<WebCore::FloatSize>::equal):
(WTF::HashTraits<WebCore::FloatSize>::constructDeletedValue):
(WTF::HashTraits<WebCore::FloatSize>::isDeletedValue):

  • platform/graphics/LayoutSize.h:

(WebCore::flooredForPainting):

  • rendering/RenderImageResourceStyleImage.h:
  • rendering/RenderListMarker.cpp:

(WebCore::RenderListMarker::computePreferredLogicalWidths):

  • rendering/style/StyleCachedImage.cpp:

(WebCore::StyleCachedImage::imageSize):
(WebCore::StyleCachedImage::setContainerSizeForRenderer):
(WebCore::StyleCachedImage::image):

  • rendering/style/StyleCachedImage.h:
  • rendering/style/StyleCachedImageSet.cpp:

(WebCore::StyleCachedImageSet::imageSize):
(WebCore::StyleCachedImageSet::setContainerSizeForRenderer):
(WebCore::StyleCachedImageSet::image):

  • rendering/style/StyleCachedImageSet.h:
  • rendering/style/StyleGeneratedImage.cpp:

(WebCore::StyleGeneratedImage::imageSize):
(WebCore::StyleGeneratedImage::computeIntrinsicDimensions):
(WebCore::StyleGeneratedImage::image):

  • rendering/style/StyleGeneratedImage.h:
  • rendering/style/StyleImage.h:
  • rendering/style/StylePendingImage.h:
  • svg/graphics/SVGImageCache.cpp:

(WebCore::SVGImageCache::setContainerSizeForRenderer):

  • svg/graphics/SVGImageCache.h:
Location:
trunk/Source/WebCore
Files:
1 added
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r166641 r166642  
     12014-04-02  Zalan Bujtas  <zalan@apple.com>
     2
     3        Subpixel rendering: Transition class CSSImageGeneratorValue/class StyleImage (and its dependencies) from
     4        IntSize to FloatSize to enable subpixel sized (generated)images.
     5        https://bugs.webkit.org/show_bug.cgi?id=130659
     6
     7        Reviewed by Simon Fraser and Andreas Kling.
     8
     9        This is in preparation to support subpixel positioned/sized background images. Generated images
     10        needs to be able to sized on device pixels.
     11
     12        No change in behavior.
     13
     14        * WebCore.vcxproj/WebCore.vcxproj:
     15        * WebCore.vcxproj/WebCore.vcxproj.filters:
     16        * WebCore.xcodeproj/project.pbxproj:
     17        * css/CSSCanvasValue.cpp:
     18        (WebCore::CSSCanvasValue::fixedSize):
     19        (WebCore::CSSCanvasValue::image):
     20        * css/CSSCanvasValue.h:
     21        * css/CSSCrossfadeValue.cpp:
     22        (WebCore::CSSCrossfadeValue::fixedSize):
     23        (WebCore::CSSCrossfadeValue::image):
     24        * css/CSSCrossfadeValue.h:
     25        * css/CSSFilterImageValue.cpp:
     26        (WebCore::CSSFilterImageValue::fixedSize):
     27        (WebCore::CSSFilterImageValue::image):
     28        * css/CSSFilterImageValue.h:
     29        * css/CSSGradientValue.cpp:
     30        (WebCore::CSSGradientValue::image):
     31        (WebCore::positionFromValue):
     32        (WebCore::CSSGradientValue::computeEndPoint):
     33        (WebCore::endPointsFromAngle):
     34        (WebCore::CSSLinearGradientValue::createGradient):
     35        (WebCore::CSSRadialGradientValue::createGradient):
     36        * css/CSSGradientValue.h:
     37        (WebCore::CSSGradientValue::fixedSize):
     38        * css/CSSImageGeneratorValue.cpp:
     39        (WebCore::CSSImageGeneratorValue::cachedImageForSize):
     40        (WebCore::CSSImageGeneratorValue::saveCachedImageForSize):
     41        (WebCore::CSSImageGeneratorValue::evictCachedGeneratedImage):
     42        (WebCore::CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage):
     43        (WebCore::CSSImageGeneratorValue::image):
     44        (WebCore::CSSImageGeneratorValue::fixedSize):
     45        * css/CSSImageGeneratorValue.h:
     46        * loader/cache/CachedImage.cpp:
     47        (WebCore::CachedImage::setContainerSizeForRenderer):
     48        * loader/cache/CachedImage.h:
     49        * platform/graphics/FloatSizeHash.h: Added.
     50        (WTF::FloatHash<WebCore::FloatSize>::hash):
     51        (WTF::FloatHash<WebCore::FloatSize>::equal):
     52        (WTF::HashTraits<WebCore::FloatSize>::constructDeletedValue):
     53        (WTF::HashTraits<WebCore::FloatSize>::isDeletedValue):
     54        * platform/graphics/LayoutSize.h:
     55        (WebCore::flooredForPainting):
     56        * rendering/RenderImageResourceStyleImage.h:
     57        * rendering/RenderListMarker.cpp:
     58        (WebCore::RenderListMarker::computePreferredLogicalWidths):
     59        * rendering/style/StyleCachedImage.cpp:
     60        (WebCore::StyleCachedImage::imageSize):
     61        (WebCore::StyleCachedImage::setContainerSizeForRenderer):
     62        (WebCore::StyleCachedImage::image):
     63        * rendering/style/StyleCachedImage.h:
     64        * rendering/style/StyleCachedImageSet.cpp:
     65        (WebCore::StyleCachedImageSet::imageSize):
     66        (WebCore::StyleCachedImageSet::setContainerSizeForRenderer):
     67        (WebCore::StyleCachedImageSet::image):
     68        * rendering/style/StyleCachedImageSet.h:
     69        * rendering/style/StyleGeneratedImage.cpp:
     70        (WebCore::StyleGeneratedImage::imageSize):
     71        (WebCore::StyleGeneratedImage::computeIntrinsicDimensions):
     72        (WebCore::StyleGeneratedImage::image):
     73        * rendering/style/StyleGeneratedImage.h:
     74        * rendering/style/StyleImage.h:
     75        * rendering/style/StylePendingImage.h:
     76        * svg/graphics/SVGImageCache.cpp:
     77        (WebCore::SVGImageCache::setContainerSizeForRenderer):
     78        * svg/graphics/SVGImageCache.h:
     79
    1802014-04-02  Gergo Balogh  <gbalogh.u-szeged@partner.samsung.com>
    281

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r166633 r166642  
    1934419344    <ClInclude Include="..\platform\graphics\FloatRoundedRect.h" />
    1934519345    <ClInclude Include="..\platform\graphics\FloatSize.h" />
     19346    <ClInclude Include="..\platform\graphics\FloatSizeHash.h" />
    1934619347    <ClInclude Include="..\platform\graphics\Font.h" />
    1934719348    <ClInclude Include="..\platform\graphics\FontCache.h" />

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r166633 r166642  
    1277412774      <Filter>platform\graphics</Filter>
    1277512775    </ClInclude>
     12776    <ClInclude Include="..\platform\graphics\FloatSizeHash.h">
     12777      <Filter>platform\graphics</Filter>
     12778    </ClInclude>
    1277612779    <ClInclude Include="..\platform\graphics\Font.h">
    1277712780      <Filter>platform\graphics</Filter>

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r166640 r166642  
    20022002                589556ED18D4A44000764B03 /* BorderEdge.h in Headers */ = {isa = PBXBuildFile; fileRef = 589556EC18D4A44000764B03 /* BorderEdge.h */; };
    20032003                58AEE2F418D4BCCF0022E7FE /* BorderEdge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 58AEE2F318D4BCCF0022E7FE /* BorderEdge.cpp */; };
     2004                58CD35CB18EB4C3900B9F3AC /* FloatSizeHash.h in Headers */ = {isa = PBXBuildFile; fileRef = 58CD35CA18EB4C3900B9F3AC /* FloatSizeHash.h */; };
    20042005                5905ADBF1302F3CE00F116DF /* XMLTreeViewer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5905ADBD1302F3CE00F116DF /* XMLTreeViewer.cpp */; };
    20052006                5905ADC01302F3CE00F116DF /* XMLTreeViewer.h in Headers */ = {isa = PBXBuildFile; fileRef = 5905ADBE1302F3CE00F116DF /* XMLTreeViewer.h */; };
    … …  
    89978998                589556EC18D4A44000764B03 /* BorderEdge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BorderEdge.h; sourceTree = "<group>"; };
    89988999                58AEE2F318D4BCCF0022E7FE /* BorderEdge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BorderEdge.cpp; sourceTree = "<group>"; };
     9000                58CD35CA18EB4C3900B9F3AC /* FloatSizeHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FloatSizeHash.h; sourceTree = "<group>"; };
    89999001                5905ADBD1302F3CE00F116DF /* XMLTreeViewer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = XMLTreeViewer.cpp; sourceTree = "<group>"; };
    90009002                5905ADBE1302F3CE00F116DF /* XMLTreeViewer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMLTreeViewer.h; sourceTree = "<group>"; };
    … …  
    2003520037                                B275353E0B053814002CE64F /* FloatSize.cpp */,
    2003620038                                B275353F0B053814002CE64F /* FloatSize.h */,
     20039                                58CD35CA18EB4C3900B9F3AC /* FloatSizeHash.h */,
    2003720040                                B2C3DA4F0D006CD600EF6F26 /* Font.cpp */,
    2003820041                                B2C3DA500D006CD600EF6F26 /* Font.h */,
    … …  
    2517525178                                A72EA3BB1585CF55004FAA26 /* RefCountedSupplement.h in Headers */,
    2517625179                                9831AE4A154225C900FE2644 /* ReferrerPolicy.h in Headers */,
     25180                                58CD35CB18EB4C3900B9F3AC /* FloatSizeHash.h in Headers */,
    2517725181                                BCAB418213E356E800D8AAF3 /* Region.h in Headers */,
    2517825182                                6CDDE8D01770BB220016E072 /* RegionOversetState.h in Headers */,

  • trunk/Source/WebCore/css/CSSCanvasValue.cpp

    r165676 r166642  
    6767}
    6868
    69 IntSize CSSCanvasValue::fixedSize(const RenderElement* renderer)
     69FloatSize CSSCanvasValue::fixedSize(const RenderElement* renderer)
    7070{
    7171    if (HTMLCanvasElement* elt = element(renderer->document()))
    72         return IntSize(elt->width(), elt->height());
    73     return IntSize();
     72        return FloatSize(elt->width(), elt->height());
     73    return FloatSize();
    7474}
    7575
    … …  
    8585}
    8686
    87 PassRefPtr<Image> CSSCanvasValue::image(RenderElement* renderer, const IntSize& /*size*/)
     87PassRefPtr<Image> CSSCanvasValue::image(RenderElement* renderer, const FloatSize& /*size*/)
    8888{
    8989    ASSERT(clients().contains(renderer));

  • trunk/Source/WebCore/css/CSSCanvasValue.h

    r165676 r166642  
    4141    String customCSSText() const;
    4242
    43     PassRefPtr<Image> image(RenderElement*, const IntSize&);
     43    PassRefPtr<Image> image(RenderElement*, const FloatSize&);
    4444    bool isFixedSize() const { return true; }
    45     IntSize fixedSize(const RenderElement*);
     45    FloatSize fixedSize(const RenderElement*);
    4646
    4747    bool isPending() const { return false; }

  • trunk/Source/WebCore/css/CSSCrossfadeValue.cpp

    r166582 r166642  
    7979}
    8080
    81 IntSize CSSCrossfadeValue::fixedSize(const RenderElement* renderer)
     81FloatSize CSSCrossfadeValue::fixedSize(const RenderElement* renderer)
    8282{
    8383    float percentage = m_percentageValue->getFloatValue();
    … …  
    8989
    9090    if (!cachedFromImage || !cachedToImage)
    91         return IntSize();
     91        return FloatSize();
    9292
    9393    FloatSize fromImageSize = cachedFromImage->imageForRenderer(renderer)->size();
    … …  
    9797    // a different fixed size; avoid performing the interpolation if the images are the same size.
    9898    if (fromImageSize == toImageSize)
    99         return IntSize(fromImageSize);
    100 
    101     return IntSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
     99        return fromImageSize;
     100
     101    return FloatSize(fromImageSize.width() * inversePercentage + toImageSize.width() * percentage,
    102102        fromImageSize.height() * inversePercentage + toImageSize.height() * percentage);
    103103}
    … …  
    139139}
    140140
    141 PassRefPtr<Image> CSSCrossfadeValue::image(RenderElement* renderer, const IntSize& size)
     141PassRefPtr<Image> CSSCrossfadeValue::image(RenderElement* renderer, const FloatSize& size)
    142142{
    143143    if (size.isEmpty())

  • trunk/Source/WebCore/css/CSSCrossfadeValue.h

    r165676 r166642  
    5353    String customCSSText() const;
    5454
    55     PassRefPtr<Image> image(RenderElement*, const IntSize&);
     55    PassRefPtr<Image> image(RenderElement*, const FloatSize&);
    5656    bool isFixedSize() const { return true; }
    57     IntSize fixedSize(const RenderElement*);
     57    FloatSize fixedSize(const RenderElement*);
    5858
    5959    bool isPending() const;

  • trunk/Source/WebCore/css/CSSFilterImageValue.cpp

    r166582 r166642  
    6060}
    6161
    62 IntSize CSSFilterImageValue::fixedSize(const RenderElement* renderer)
     62FloatSize CSSFilterImageValue::fixedSize(const RenderElement* renderer)
    6363{
    6464    CachedResourceLoader* cachedResourceLoader = renderer->document().cachedResourceLoader();
    … …  
    6666
    6767    if (!cachedImage)
    68         return IntSize();
     68        return FloatSize();
    6969
    70     return IntSize(cachedImage->imageForRenderer(renderer)->size());
     70    return cachedImage->imageForRenderer(renderer)->size();
    7171}
    7272
    … …  
    9797}
    9898
    99 PassRefPtr<Image> CSSFilterImageValue::image(RenderElement* renderer, const IntSize& size)
     99PassRefPtr<Image> CSSFilterImageValue::image(RenderElement* renderer, const FloatSize& size)
    100100{
    101101    if (size.isEmpty())

  • trunk/Source/WebCore/css/CSSFilterImageValue.h

    r162139 r166642  
    5858    String customCSSText() const;
    5959
    60     PassRefPtr<Image> image(RenderElement*, const IntSize&);
     60    PassRefPtr<Image> image(RenderElement*, const FloatSize&);
    6161    bool isFixedSize() const { return true; }
    62     IntSize fixedSize(const RenderElement*);
     62    FloatSize fixedSize(const RenderElement*);
    6363
    6464    bool isPending() const;

  • trunk/Source/WebCore/css/CSSGradientValue.cpp

    r165676 r166642  
    2929#include "CSSCalculationValue.h"
    3030#include "CSSValueKeywords.h"
     31#include "FloatSize.h"
     32#include "FloatSizeHash.h"
    3133#include "Gradient.h"
    3234#include "GradientImage.h"
    3335#include "Image.h"
    34 #include "IntSize.h"
    35 #include "IntSizeHash.h"
    3636#include "NodeRenderStyle.h"
    3737#include "RenderElement.h"
    … …  
    4242namespace WebCore {
    4343
    44 PassRefPtr<Image> CSSGradientValue::image(RenderElement* renderer, const IntSize& size)
     44PassRefPtr<Image> CSSGradientValue::image(RenderElement* renderer, const FloatSize& size)
    4545{
    4646    if (size.isEmpty())
    … …  
    391391}
    392392
    393 static float positionFromValue(CSSPrimitiveValue* value, const RenderStyle& style, const RenderStyle& rootStyle, const IntSize& size, bool isHorizontal)
     393static float positionFromValue(CSSPrimitiveValue* value, const RenderStyle& style, const RenderStyle& rootStyle, const FloatSize& size, bool isHorizontal)
    394394{
    395395    float zoomFactor = style.effectiveZoom();
    … …  
    425425}
    426426
    427 FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, const RenderStyle& style, const RenderStyle& rootStyle, const IntSize& size)
     427FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, const RenderStyle& style, const RenderStyle& rootStyle, const FloatSize& size)
    428428{
    429429    FloatPoint result;
    … …  
    573573
    574574// Compute the endpoints so that a gradient of the given angle covers a box of the given size.
    575 static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint& firstPoint, FloatPoint& secondPoint, CSSGradientType type)
     575static void endPointsFromAngle(float angleDeg, const FloatSize& size, FloatPoint& firstPoint, FloatPoint& secondPoint, CSSGradientType type)
    576576{
    577577    // Prefixed gradients use "polar coordinate" angles, rather than "bearing" angles.
    … …  
    640640}
    641641
    642 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderElement* renderer, const IntSize& size)
     642PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderElement* renderer, const FloatSize& size)
    643643{
    644644    ASSERT(!size.isEmpty());
    … …  
    980980
    981981// FIXME: share code with the linear version
    982 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderElement* renderer, const IntSize& size)
     982PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderElement* renderer, const FloatSize& size)
    983983{
    984984    ASSERT(!size.isEmpty());

  • trunk/Source/WebCore/css/CSSGradientValue.h

    r165676 r166642  
    6262class CSSGradientValue : public CSSImageGeneratorValue {
    6363public:
    64     PassRefPtr<Image> image(RenderElement*, const IntSize&);
     64    PassRefPtr<Image> image(RenderElement*, const FloatSize&);
    6565
    6666    void setFirstX(PassRefPtr<CSSPrimitiveValue> val) { m_firstX = val; }
    … …  
    8080
    8181    bool isFixedSize() const { return false; }
    82     IntSize fixedSize(const RenderElement*) const { return IntSize(); }
     82    FloatSize fixedSize(const RenderElement*) const { return FloatSize(); }
    8383
    8484    bool isPending() const { return false; }
    … …  
    113113
    114114    // Resolve points/radii to front end values.
    115     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, const IntSize&);
     115    FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, const RenderStyle&, const RenderStyle& rootStyle, const FloatSize&);
    116116
    117117    bool isCacheable() const;
    … …  
    146146
    147147    // Create the gradient for a given size.
    148     PassRefPtr<Gradient> createGradient(RenderElement*, const IntSize&);
     148    PassRefPtr<Gradient> createGradient(RenderElement*, const FloatSize&);
    149149
    150150    PassRef<CSSLinearGradientValue> clone() const
    … …  
    196196
    197197    // Create the gradient for a given size.
    198     PassRefPtr<Gradient> createGradient(RenderElement*, const IntSize&);
     198    PassRefPtr<Gradient> createGradient(RenderElement*, const FloatSize&);
    199199
    200200    bool equals(const CSSRadialGradientValue&) const;

  • trunk/Source/WebCore/css/CSSImageGeneratorValue.cpp

    r165676 r166642  
    6666}
    6767
    68 GeneratedImage* CSSImageGeneratorValue::cachedImageForSize(IntSize size)
     68GeneratedImage* CSSImageGeneratorValue::cachedImageForSize(FloatSize size)
    6969{
    7070    if (size.isEmpty())
    … …  
    7979}
    8080
    81 void CSSImageGeneratorValue::saveCachedImageForSize(IntSize size, PassRefPtr<GeneratedImage> image)
     81void CSSImageGeneratorValue::saveCachedImageForSize(FloatSize size, PassRefPtr<GeneratedImage> image)
    8282{
    8383    ASSERT(!m_images.contains(size));
    … …  
    8585}
    8686
    87 void CSSImageGeneratorValue::evictCachedGeneratedImage(IntSize size)
     87void CSSImageGeneratorValue::evictCachedGeneratedImage(FloatSize size)
    8888{
    8989    ASSERT(m_images.contains(size));
    … …  
    9191}
    9292
    93 CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage(CSSImageGeneratorValue& owner, IntSize size, PassRefPtr<GeneratedImage> image)
     93CSSImageGeneratorValue::CachedGeneratedImage::CachedGeneratedImage(CSSImageGeneratorValue& owner, FloatSize size, PassRefPtr<GeneratedImage> image)
    9494    : m_owner(owner)
    9595    , m_size(size)
    … …  
    106106}
    107107
    108 PassRefPtr<Image> CSSImageGeneratorValue::image(RenderElement* renderer, const IntSize& size)
     108PassRefPtr<Image> CSSImageGeneratorValue::image(RenderElement* renderer, const FloatSize& size)
    109109{
    110110    switch (classType()) {
    … …  
    148148}
    149149
    150 IntSize CSSImageGeneratorValue::fixedSize(const RenderElement* renderer)
     150FloatSize CSSImageGeneratorValue::fixedSize(const RenderElement* renderer)
    151151{
    152152    switch (classType()) {
    … …  
    166166        ASSERT_NOT_REACHED();
    167167    }
    168     return IntSize();
     168    return FloatSize();
    169169}
    170170

  • trunk/Source/WebCore/css/CSSImageGeneratorValue.h

    r165676 r166642  
    2828
    2929#include "CSSValue.h"
    30 #include "IntSizeHash.h"
     30#include "FloatSize.h"
     31#include "FloatSizeHash.h"
    3132#include "Timer.h"
    3233#include <wtf/HashCountedSet.h>
    … …  
    4849    void removeClient(RenderElement*);
    4950
    50     PassRefPtr<Image> image(RenderElement*, const IntSize&);
     51    PassRefPtr<Image> image(RenderElement*, const FloatSize&);
    5152
    5253    bool isFixedSize() const;
    53     IntSize fixedSize(const RenderElement*);
     54    FloatSize fixedSize(const RenderElement*);
    5455
    5556    bool isPending() const;
    … …  
    6162    CSSImageGeneratorValue(ClassType);
    6263
    63     GeneratedImage* cachedImageForSize(IntSize);
    64     void saveCachedImageForSize(IntSize, PassRefPtr<GeneratedImage>);
     64    GeneratedImage* cachedImageForSize(FloatSize);
     65    void saveCachedImageForSize(FloatSize, PassRefPtr<GeneratedImage>);
    6566    const HashCountedSet<RenderElement*>& clients() const { return m_clients; }
    6667
    … …  
    7273    class CachedGeneratedImage {
    7374    public:
    74         CachedGeneratedImage(CSSImageGeneratorValue&, IntSize, PassRefPtr<GeneratedImage>);
     75        CachedGeneratedImage(CSSImageGeneratorValue&, FloatSize, PassRefPtr<GeneratedImage>);
    7576        GeneratedImage* image() { return m_image.get(); }
    7677        void puntEvictionTimer() { m_evictionTimer.restart(); }
    … …  
    8081
    8182        CSSImageGeneratorValue& m_owner;
    82         IntSize m_size;
     83        FloatSize m_size;
    8384        RefPtr<GeneratedImage> m_image;
    8485        DeferrableOneShotTimer<CachedGeneratedImage> m_evictionTimer;
    … …  
    8687
    8788    friend class CachedGeneratedImage;
    88     void evictCachedGeneratedImage(IntSize);
     89    void evictCachedGeneratedImage(FloatSize);
    8990
    9091    HashCountedSet<RenderElement*> m_clients;
    91     HashMap<IntSize, std::unique_ptr<CachedGeneratedImage>> m_images;
     92    HashMap<FloatSize, std::unique_ptr<CachedGeneratedImage>> m_images;
    9293};
    9394

  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r166582 r166642  
    229229}
    230230
    231 void CachedImage::setContainerSizeForRenderer(const CachedImageClient* renderer, const IntSize& containerSize, float containerZoom)
     231void CachedImage::setContainerSizeForRenderer(const CachedImageClient* renderer, const LayoutSize& containerSize, float containerZoom)
    232232{
    233233    if (containerSize.isEmpty())

  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r165117 r166642  
    6767    bool canRender(const RenderObject* renderer, float multiplier) { return !errorOccurred() && !imageSizeForRenderer(renderer, multiplier).isEmpty(); }
    6868
    69     void setContainerSizeForRenderer(const CachedImageClient*, const IntSize&, float);
     69    void setContainerSizeForRenderer(const CachedImageClient*, const LayoutSize&, float);
    7070    bool usesImageContainerSize() const;
    7171    bool imageHasRelativeWidth() const;
    … …  
    133133    void addIncrementalDataBuffer(ResourceBuffer*);
    134134
    135     typedef std::pair<IntSize, float> SizeAndZoom;
     135    typedef std::pair<LayoutSize, float> SizeAndZoom;
    136136    typedef HashMap<const CachedImageClient*, SizeAndZoom> ContainerSizeRequests;
    137137    ContainerSizeRequests m_pendingContainerSizeRequests;

  • trunk/Source/WebCore/platform/graphics/LayoutSize.h

    r154858 r166642  
    193193}
    194194
     195inline FloatSize flooredForPainting(const LayoutSize& size, float pixelSnappingFactor)
     196{
     197#if ENABLE(SUBPIXEL_LAYOUT)
     198    return FloatSize(floorToDevicePixel(size.width(), pixelSnappingFactor), floorToDevicePixel(size.height(), pixelSnappingFactor));
     199#else
     200    UNUSED_PARAM(pixelSnappingFactor);
     201    return FloatSize(point);
     202#endif
     203}
     204
    195205} // namespace WebCore
    196206

  • trunk/Source/WebCore/rendering/RenderImageResourceStyleImage.h

    r162356 r166642  
    5252    virtual bool imageHasRelativeHeight() const override { return m_styleImage->imageHasRelativeHeight(); }
    5353
    54     virtual LayoutSize imageSize(float multiplier) const override { return m_styleImage->imageSize(m_renderer, multiplier); }
    55     virtual LayoutSize intrinsicSize(float multiplier) const override { return m_styleImage->imageSize(m_renderer, multiplier); }
     54    virtual LayoutSize imageSize(float multiplier) const override { return LayoutSize(m_styleImage->imageSize(m_renderer, multiplier)); }
     55    virtual LayoutSize intrinsicSize(float multiplier) const override { return LayoutSize(m_styleImage->imageSize(m_renderer, multiplier)); }
    5656
    5757    virtual WrappedImagePtr imagePtr() const override { return m_styleImage->data(); }

  • trunk/Source/WebCore/rendering/RenderListMarker.cpp

    r166120 r166642  
    15221522
    15231523    if (isImage()) {
    1524         LayoutSize imageSize = m_image->imageSize(this, style().effectiveZoom());
     1524        LayoutSize imageSize = LayoutSize(m_image->imageSize(this, style().effectiveZoom()));
    15251525        m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = style().isHorizontalWritingMode() ? imageSize.width() : imageSize.height();
    15261526        setPreferredLogicalWidthsDirty(false);

  • trunk/Source/WebCore/rendering/style/StyleCachedImage.cpp

    r156622 r166642  
    6262}
    6363
    64 LayoutSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
     64FloatSize StyleCachedImage::imageSize(const RenderElement* renderer, float multiplier) const
    6565{
    6666    return m_image->imageSizeForRenderer(renderer, multiplier);
    … …  
    8787}
    8888
    89 void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const IntSize& imageContainerSize, float imageContainerZoomFactor)
     89void StyleCachedImage::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
    9090{
    91     m_image->setContainerSizeForRenderer(renderer, imageContainerSize, imageContainerZoomFactor);
     91    m_image->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
    9292}
    9393
    … …  
    102102}
    103103
    104 PassRefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const IntSize&) const
     104PassRefPtr<Image> StyleCachedImage::image(RenderElement* renderer, const FloatSize&) const
    105105{
    106106    return m_image->imageForRenderer(renderer);

  • trunk/Source/WebCore/rendering/style/StyleCachedImage.h

    r164298 r166642  
    4949    virtual bool isLoaded() const override;
    5050    virtual bool errorOccurred() const override;
    51     virtual LayoutSize imageSize(const RenderElement*, float multiplier) const override;
     51    virtual FloatSize imageSize(const RenderElement*, float multiplier) const override;
    5252    virtual bool imageHasRelativeWidth() const override;
    5353    virtual bool imageHasRelativeHeight() const override;
    5454    virtual void computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio) override;
    5555    virtual bool usesImageContainerSize() const override;
    56     virtual void setContainerSizeForRenderer(const RenderElement*, const IntSize&, float) override;
     56    virtual void setContainerSizeForRenderer(const RenderElement*, const FloatSize&, float) override;
    5757    virtual void addClient(RenderElement*) override;
    5858    virtual void removeClient(RenderElement*) override;
    59     virtual PassRefPtr<Image> image(RenderElement*, const IntSize&) const override;
     59    virtual PassRefPtr<Image> image(RenderElement*, const FloatSize&) const override;
    6060    virtual bool knownToBeOpaque(const RenderElement*) const override;
    6161

  • trunk/Source/WebCore/rendering/style/StyleCachedImageSet.cpp

    r156622 r166642  
    7070}
    7171
    72 LayoutSize StyleCachedImageSet::imageSize(const RenderElement* renderer, float multiplier) const
     72FloatSize StyleCachedImageSet::imageSize(const RenderElement* renderer, float multiplier) const
    7373{
    74     LayoutSize scaledImageSize = m_bestFitImage->imageSizeForRenderer(renderer, multiplier);
     74    FloatSize scaledImageSize = m_bestFitImage->imageSizeForRenderer(renderer, multiplier);
    7575    scaledImageSize.scale(1 / m_imageScaleFactor);
    7676    return scaledImageSize;
    … …  
    9797}
    9898
    99 void StyleCachedImageSet::setContainerSizeForRenderer(const RenderElement* renderer, const IntSize& imageContainerSize, float imageContainerZoomFactor)
     99void StyleCachedImageSet::setContainerSizeForRenderer(const RenderElement* renderer, const FloatSize& imageContainerSize, float imageContainerZoomFactor)
    100100{
    101     m_bestFitImage->setContainerSizeForRenderer(renderer, imageContainerSize, imageContainerZoomFactor);
     101    m_bestFitImage->setContainerSizeForRenderer(renderer, LayoutSize(imageContainerSize), imageContainerZoomFactor);
    102102}
    103103
    … …  
    112112}
    113113
    114 PassRefPtr<Image> StyleCachedImageSet::image(RenderElement* renderer, const IntSize&) const
     114PassRefPtr<Image> StyleCachedImageSet::image(RenderElement* renderer, const FloatSize&) const
    115115{
    116116    return m_bestFitImage->imageForRenderer(renderer);

  • trunk/Source/WebCore/rendering/style/StyleCachedImageSet.h

    r164298 r166642  
    6565    virtual bool isLoaded() const override;
    6666    virtual bool errorOccurred() const override;
    67     virtual LayoutSize imageSize(const RenderElement*, float multiplier) const override;
     67    virtual FloatSize imageSize(const RenderElement*, float multiplier) const override;
    6868    virtual bool imageHasRelativeWidth() const override;
    6969    virtual bool imageHasRelativeHeight() const override;
    7070    virtual void computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio) override;
    7171    virtual bool usesImageContainerSize() const override;
    72     virtual void setContainerSizeForRenderer(const RenderElement*, const IntSize&, float) override;
     72    virtual void setContainerSizeForRenderer(const RenderElement*, const FloatSize&, float) override;
    7373    virtual void addClient(RenderElement*) override;
    7474    virtual void removeClient(RenderElement*) override;
    75     virtual PassRefPtr<Image> image(RenderElement*, const IntSize&) const override;
     75    virtual PassRefPtr<Image> image(RenderElement*, const FloatSize&) const override;
    7676    virtual float imageScaleFactor() const override { return m_imageScaleFactor; }
    7777    virtual bool knownToBeOpaque(const RenderElement*) const override;

  • trunk/Source/WebCore/rendering/style/StyleGeneratedImage.cpp

    r160528 r166642  
    4343}
    4444
    45 LayoutSize StyleGeneratedImage::imageSize(const RenderElement* renderer, float multiplier) const
     45FloatSize StyleGeneratedImage::imageSize(const RenderElement* renderer, float multiplier) const
    4646{
    4747    if (m_fixedSize) {
    48         IntSize fixedSize = const_cast<CSSImageGeneratorValue&>(m_imageGeneratorValue.get()).fixedSize(renderer);
     48        FloatSize fixedSize = const_cast<CSSImageGeneratorValue&>(m_imageGeneratorValue.get()).fixedSize(renderer);
    4949        if (multiplier == 1.0f)
    5050            return fixedSize;
    5151
    52         LayoutUnit width = fixedSize.width() * multiplier;
    53         LayoutUnit height = fixedSize.height() * multiplier;
     52        float width = fixedSize.width() * multiplier;
     53        float height = fixedSize.height() * multiplier;
    5454
    55         // Don't let images that have a width/height >= 1 shrink below 1 when zoomed.
     55        // Don't let images that have a width/height >= 1 shrink below 1 device pixel when zoomed.
     56        float deviceScaleFactor = renderer ? renderer->document().deviceScaleFactor() : 1;
    5657        if (fixedSize.width() > 0)
    57             width = std::max<LayoutUnit>(1, width);
     58            width = std::max<float>(1 / deviceScaleFactor, width);
    5859
    5960        if (fixedSize.height() > 0)
    60             height = std::max<LayoutUnit>(1, height);
     61            height = std::max<float>(1 / deviceScaleFactor, height);
    6162
    62         return LayoutSize(width, height);
     63        return FloatSize(width, height);
    6364    }
    6465   
    … …  
    6869void StyleGeneratedImage::computeIntrinsicDimensions(const RenderElement* renderer, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
    6970{
    70     // At a zoom level of 1 the image is guaranteed to have an integer size.
    71     IntSize size = flooredIntSize(imageSize(renderer, 1));
     71    // At a zoom level of 1 the image is guaranteed to have a device pixel size.
     72    FloatSize size = flooredForPainting(LayoutSize(imageSize(renderer, 1)), renderer ? renderer->document().deviceScaleFactor() : 1);
    7273    intrinsicWidth = Length(size.width(), Fixed);
    7374    intrinsicHeight = Length(size.height(), Fixed);
    … …  
    8586}
    8687
    87 PassRefPtr<Image> StyleGeneratedImage::image(RenderElement* renderer, const IntSize& size) const
     88PassRefPtr<Image> StyleGeneratedImage::image(RenderElement* renderer, const FloatSize& size) const
    8889{
    8990    return const_cast<CSSImageGeneratorValue&>(m_imageGeneratorValue.get()).image(renderer, size);

  • trunk/Source/WebCore/rendering/style/StyleGeneratedImage.h

    r164298 r166642  
    4646    virtual PassRefPtr<CSSValue> cssValue() const override;
    4747
    48     virtual LayoutSize imageSize(const RenderElement*, float multiplier) const override;
     48    virtual FloatSize imageSize(const RenderElement*, float multiplier) const override;
    4949    virtual bool imageHasRelativeWidth() const override { return !m_fixedSize; }
    5050    virtual bool imageHasRelativeHeight() const override { return !m_fixedSize; }
    5151    virtual void computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio) override;
    5252    virtual bool usesImageContainerSize() const override { return !m_fixedSize; }
    53     virtual void setContainerSizeForRenderer(const RenderElement*, const IntSize& containerSize, float) override { m_containerSize = containerSize; }
     53    virtual void setContainerSizeForRenderer(const RenderElement*, const FloatSize& containerSize, float) override { m_containerSize = containerSize; }
    5454    virtual void addClient(RenderElement*) override;
    5555    virtual void removeClient(RenderElement*) override;
    56     virtual PassRefPtr<Image> image(RenderElement*, const IntSize&) const override;
     56    virtual PassRefPtr<Image> image(RenderElement*, const FloatSize&) const override;
    5757    virtual bool knownToBeOpaque(const RenderElement*) const override;
    5858
    … …  
    6060   
    6161    Ref<CSSImageGeneratorValue> m_imageGeneratorValue;
    62     IntSize m_containerSize;
     62    FloatSize m_containerSize;
    6363    bool m_fixedSize;
    6464};

  • trunk/Source/WebCore/rendering/style/StyleImage.h

    r164310 r166642  
    2626
    2727#include "CSSValue.h"
     28#include "FloatSize.h"
    2829#include "Image.h"
    29 #include "IntSize.h"
    30 #include "LayoutSize.h"
    3130#include <wtf/PassRefPtr.h>
    3231#include <wtf/RefCounted.h>
    … …  
    5655    virtual bool isLoaded() const { return true; }
    5756    virtual bool errorOccurred() const { return false; }
    58     virtual LayoutSize imageSize(const RenderElement*, float multiplier) const = 0;
     57    virtual FloatSize imageSize(const RenderElement*, float multiplier) const = 0;
    5958    virtual void computeIntrinsicDimensions(const RenderElement*, Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio) = 0;
    6059    virtual bool imageHasRelativeWidth() const = 0;
    6160    virtual bool imageHasRelativeHeight() const = 0;
    6261    virtual bool usesImageContainerSize() const = 0;
    63     virtual void setContainerSizeForRenderer(const RenderElement*, const IntSize&, float) = 0;
     62    virtual void setContainerSizeForRenderer(const RenderElement*, const FloatSize&, float) = 0;
    6463    virtual void addClient(RenderElement*) = 0;
    6564    virtual void removeClient(RenderElement*) = 0;
    66     virtual PassRefPtr<Image> image(RenderElement*, const IntSize&) const = 0;
     65    virtual PassRefPtr<Image> image(RenderElement*, const FloatSize&) const = 0;
    6766    virtual WrappedImagePtr data() const = 0;
    6867    virtual float imageScaleFactor() const { return 1; }

  • trunk/Source/WebCore/rendering/style/StylePendingImage.h

    r165676 r166642  
    6161    virtual PassRefPtr<CSSValue> cssValue() const override { return m_value; }
    6262   
    63     virtual LayoutSize imageSize(const RenderElement*, float /*multiplier*/) const override { return LayoutSize(); }
     63    virtual FloatSize imageSize(const RenderElement*, float /*multiplier*/) const override { return FloatSize(); }
    6464    virtual bool imageHasRelativeWidth() const override { return false; }
    6565    virtual bool imageHasRelativeHeight() const override { return false; }
    6666    virtual void computeIntrinsicDimensions(const RenderElement*, Length& /* intrinsicWidth */ , Length& /* intrinsicHeight */, FloatSize& /* intrinsicRatio */) { }
    6767    virtual bool usesImageContainerSize() const override { return false; }
    68     virtual void setContainerSizeForRenderer(const RenderElement*, const IntSize&, float) override { }
     68    virtual void setContainerSizeForRenderer(const RenderElement*, const FloatSize&, float) override { }
    6969    virtual void addClient(RenderElement*) override { }
    7070    virtual void removeClient(RenderElement*) override { }
    7171
    72     virtual PassRefPtr<Image> image(RenderElement*, const IntSize&) const override
     72    virtual PassRefPtr<Image> image(RenderElement*, const FloatSize&) const override
    7373    {
    7474        ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/svg/graphics/SVGImageCache.cpp

    r166582 r166642  
    2626#include "HTMLImageElement.h"
    2727#include "ImageBuffer.h"
     28#include "LayoutSize.h"
    2829#include "Page.h"
    2930#include "RenderSVGRoot.h"
    … …  
    5152}
    5253
    53 void SVGImageCache::setContainerSizeForRenderer(const CachedImageClient* client, const IntSize& containerSize, float containerZoom)
     54void SVGImageCache::setContainerSizeForRenderer(const CachedImageClient* client, const LayoutSize& containerSize, float containerZoom)
    5455{
    5556    ASSERT(client);

  • trunk/Source/WebCore/svg/graphics/SVGImageCache.h

    r166582 r166642  
    3232class CachedImageClient;
    3333class ImageBuffer;
     34class LayoutSize;
    3435class SVGImage;
    3536class SVGImageForContainer;
    … …  
    4445    void removeClientFromCache(const CachedImageClient*);
    4546
    46     void setContainerSizeForRenderer(const CachedImageClient*, const IntSize&, float);
     47    void setContainerSizeForRenderer(const CachedImageClient*, const LayoutSize&, float);
    4748    FloatSize imageSizeForRenderer(const RenderObject*) const;
    4849
Note: See TracChangeset for help on using the changeset viewer.