1 files changed, 127 insertions, 44 deletions

diff --git a/Source/WebCore/rendering/style/NinePieceImage.h b/Source/WebCore/rendering/style/NinePieceImage.h
index e34924147..2b5fe6554 100644
--- a/Source/WebCore/rendering/style/NinePieceImage.h
+++ b/Source/WebCore/rendering/style/NinePieceImage.h
@@ -2,7 +2,7 @@
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2003-2017 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -21,98 +21,140 @@
  *
  */
 
-#ifndef NinePieceImage_h
-#define NinePieceImage_h
+#pragma once
 
 #include "DataRef.h"
-#include "LayoutUnit.h"
 #include "LengthBox.h"
 #include "StyleImage.h"
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
-enum ENinePieceImageRule {
-    StretchImageRule, RoundImageRule, SpaceImageRule, RepeatImageRule
+class LayoutSize;
+class LayoutRect;
+class RenderStyle;
+
+enum ENinePieceImageRule { StretchImageRule, RoundImageRule, SpaceImageRule, RepeatImageRule };
+
+enum ImagePiece {
+    MinPiece = 0,
+    TopLeftPiece = MinPiece,
+    LeftPiece,
+    BottomLeftPiece,
+    TopRightPiece,
+    RightPiece,
+    BottomRightPiece,
+    TopPiece,
+    BottomPiece,
+    MiddlePiece,
+    MaxPiece
 };
 
-class NinePieceImageData : public RefCounted<NinePieceImageData> {
-public:
-    static PassRef<NinePieceImageData> create() { return adoptRef(*new NinePieceImageData); }
-    PassRef<NinePieceImageData> copy() const;
+inline ImagePiece& operator++(ImagePiece& piece)
+{
+    piece = static_cast<ImagePiece>(static_cast<int>(piece) + 1);
+    return piece;
+}
 
-    bool operator==(const NinePieceImageData&) const;
-    bool operator!=(const NinePieceImageData& o) const { return !(*this == o); }
+inline bool isCornerPiece(ImagePiece piece)
+{
+    return piece == TopLeftPiece || piece == TopRightPiece || piece == BottomLeftPiece || piece == BottomRightPiece;
+}
 
-    bool fill : 1;
-    unsigned horizontalRule : 2; // ENinePieceImageRule
-    unsigned verticalRule : 2; // ENinePieceImageRule
-    RefPtr<StyleImage> image;
-    LengthBox imageSlices;
-    LengthBox borderSlices;
-    LengthBox outset;
+inline bool isMiddlePiece(ImagePiece piece)
+{
+    return piece == MiddlePiece;
+}
 
-private:
-    NinePieceImageData();
-    NinePieceImageData(const NinePieceImageData&);
-};
+inline bool isHorizontalPiece(ImagePiece piece)
+{
+    return piece == TopPiece || piece == BottomPiece || piece == MiddlePiece;
+}
+
+inline bool isVerticalPiece(ImagePiece piece)
+{
+    return piece == LeftPiece || piece == RightPiece || piece == MiddlePiece;
+}
+
+inline PhysicalBoxSide imagePieceHorizontalSide(ImagePiece piece)
+{
+    if (piece == TopLeftPiece || piece == TopPiece || piece == TopRightPiece)
+        return TopSide;
+
+    if (piece == BottomLeftPiece || piece == BottomPiece || piece == BottomRightPiece)
+        return BottomSide;
+
+    return NilSide;
+}
+
+inline PhysicalBoxSide imagePieceVerticalSide(ImagePiece piece)
+{
+    if (piece == TopLeftPiece || piece == LeftPiece || piece == BottomLeftPiece)
+        return LeftSide;
+
+    if (piece == TopRightPiece || piece == RightPiece || piece == BottomRightPiece)
+        return RightSide;
+
+    return NilSide;
+}
 
 class NinePieceImage {
 public:
     NinePieceImage();
-    NinePieceImage(PassRefPtr<StyleImage>, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule horizontalRule, ENinePieceImageRule verticalRule);
+    NinePieceImage(RefPtr<StyleImage>&&, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule horizontalRule, ENinePieceImageRule verticalRule);
 
     bool operator==(const NinePieceImage& other) const { return m_data == other.m_data; }
     bool operator!=(const NinePieceImage& other) const { return m_data != other.m_data; }
 
     bool hasImage() const { return m_data->image; }
     StyleImage* image() const { return m_data->image.get(); }
-    void setImage(PassRefPtr<StyleImage> image) { m_data.access()->image = image; }
-    
+    void setImage(RefPtr<StyleImage>&& image) { m_data.access().image = WTFMove(image); }
+
     const LengthBox& imageSlices() const { return m_data->imageSlices; }
-    void setImageSlices(LengthBox slices) { m_data.access()->imageSlices = std::move(slices); }
+    void setImageSlices(LengthBox slices) { m_data.access().imageSlices = WTFMove(slices); }
 
     bool fill() const { return m_data->fill; }
-    void setFill(bool fill) { m_data.access()->fill = fill; }
+    void setFill(bool fill) { m_data.access().fill = fill; }
 
     const LengthBox& borderSlices() const { return m_data->borderSlices; }
-    void setBorderSlices(LengthBox slices) { m_data.access()->borderSlices = std::move(slices); }
+    void setBorderSlices(LengthBox slices) { m_data.access().borderSlices = WTFMove(slices); }
 
     const LengthBox& outset() const { return m_data->outset; }
-    void setOutset(LengthBox outset) { m_data.access()->outset = std::move(outset); }
+    void setOutset(LengthBox outset) { m_data.access().outset = WTFMove(outset); }
 
     ENinePieceImageRule horizontalRule() const { return static_cast<ENinePieceImageRule>(m_data->horizontalRule); }
-    void setHorizontalRule(ENinePieceImageRule rule) { m_data.access()->horizontalRule = rule; }
+    void setHorizontalRule(ENinePieceImageRule rule) { m_data.access().horizontalRule = rule; }
     
     ENinePieceImageRule verticalRule() const { return static_cast<ENinePieceImageRule>(m_data->verticalRule); }
-    void setVerticalRule(ENinePieceImageRule rule) { m_data.access()->verticalRule = rule; }
+    void setVerticalRule(ENinePieceImageRule rule) { m_data.access().verticalRule = rule; }
 
     void copyImageSlicesFrom(const NinePieceImage& other)
     {
-        m_data.access()->imageSlices = other.m_data->imageSlices;
-        m_data.access()->fill = other.m_data->fill;
+        m_data.access().imageSlices = other.m_data->imageSlices;
+        m_data.access().fill = other.m_data->fill;
     }
 
     void copyBorderSlicesFrom(const NinePieceImage& other)
     {
-        m_data.access()->borderSlices = other.m_data->borderSlices;
+        m_data.access().borderSlices = other.m_data->borderSlices;
     }
     
     void copyOutsetFrom(const NinePieceImage& other)
     {
-        m_data.access()->outset = other.m_data->outset;
+        m_data.access().outset = other.m_data->outset;
     }
 
     void copyRepeatFrom(const NinePieceImage& other)
     {
-        m_data.access()->horizontalRule = other.m_data->horizontalRule;
-        m_data.access()->verticalRule = other.m_data->verticalRule;
+        m_data.access().horizontalRule = other.m_data->horizontalRule;
+        m_data.access().verticalRule = other.m_data->verticalRule;
     }
 
     void setMaskDefaults()
     {
-        m_data.access()->imageSlices = LengthBox(0);
-        m_data.access()->fill = true;
-        m_data.access()->borderSlices = LengthBox();
+        m_data.access().imageSlices = LengthBox(0);
+        m_data.access().fill = true;
+        m_data.access().borderSlices = LengthBox();
     }
 
     static LayoutUnit computeOutset(const Length& outsetSide, LayoutUnit borderSide)
@@ -122,10 +164,51 @@ public:
         return outsetSide.value();
     }
 
+    static LayoutUnit computeSlice(Length, LayoutUnit width, LayoutUnit slice, LayoutUnit extent);
+    static LayoutBoxExtent computeSlices(const LayoutSize&, const LengthBox& lengths, int scaleFactor);
+    static LayoutBoxExtent computeSlices(const LayoutSize&, const LengthBox& lengths, const FloatBoxExtent& widths, const LayoutBoxExtent& slices);
+
+    static bool isEmptyPieceRect(ImagePiece, const LayoutBoxExtent& slices);
+    static bool isEmptyPieceRect(ImagePiece, const Vector<FloatRect>& destinationRects, const Vector<FloatRect>& sourceRects);
+
+    static Vector<FloatRect> computeNineRects(const FloatRect& outer, const LayoutBoxExtent& slices, float deviceScaleFactor);
+
+    static void scaleSlicesIfNeeded(const LayoutSize&, LayoutBoxExtent& slices, float deviceScaleFactor);
+
+    static FloatSize computeSideTileScale(ImagePiece, const Vector<FloatRect>& destinationRects, const Vector<FloatRect>& sourceRects);
+    static FloatSize computeMiddleTileScale(const Vector<FloatSize>& scales, const Vector<FloatRect>& destinationRects, const Vector<FloatRect>& sourceRects, ENinePieceImageRule hRule, ENinePieceImageRule vRule);
+    static Vector<FloatSize> computeTileScales(const Vector<FloatRect>& destinationRects, const Vector<FloatRect>& sourceRects, ENinePieceImageRule hRule, ENinePieceImageRule vRule);
+
+    void paint(GraphicsContext&, RenderElement*, const RenderStyle&, const LayoutRect& destination, const LayoutSize& source, float deviceScaleFactor, CompositeOperator) const;
+
 private:
-    DataRef<NinePieceImageData> m_data;
+    struct Data : RefCounted<Data> {
+        static Ref<Data> create();
+        static Ref<Data> create(RefPtr<StyleImage>&&, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule horizontalRule, ENinePieceImageRule verticalRule);
+        Ref<Data> copy() const;
+
+        bool operator==(const Data&) const;
+        bool operator!=(const Data& other) const { return !(*this == other); }
+
+        bool fill : 1;
+        unsigned horizontalRule : 2; // ENinePieceImageRule
+        unsigned verticalRule : 2; // ENinePieceImageRule
+        RefPtr<StyleImage> image;
+        LengthBox imageSlices { { 100, Percent }, { 100, Percent }, { 100, Percent }, { 100, Percent } };
+        LengthBox borderSlices { { 1, Relative }, { 1, Relative }, { 1, Relative }, { 1, Relative } };
+        LengthBox outset { 0 };
+
+    private:
+        Data();
+        Data(RefPtr<StyleImage>&&, LengthBox imageSlices, bool fill, LengthBox borderSlices, LengthBox outset, ENinePieceImageRule horizontalRule, ENinePieceImageRule verticalRule);
+        Data(const Data&);
+    };
+
+    static DataRef<Data>& defaultData();
+
+    DataRef<Data> m_data;
 };
 
-} // namespace WebCore
+TextStream& operator<<(TextStream&, const NinePieceImage&);
 
-#endif // NinePieceImage_h
+} // namespace WebCore