src/third_party/WebKit/Source/core/rendering/style/SVGRenderStyle.h

   1 /*
   2     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
   3                   2004, 2005 Rob Buis <buis@kde.org>
   4     Copyright (C) 2005, 2006 Apple Computer, Inc.
   5     Copyright (C) Research In Motion Limited 2010. All rights reserved.
   6
   7     This library is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Library General Public
   9     License as published by the Free Software Foundation; either
  10     version 2 of the License, or (at your option) any later version.
  11
  12     This library is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Library General Public License for more details.
  16
  17     You should have received a copy of the GNU Library General Public License
  18     along with this library; see the file COPYING.LIB.  If not, write to
  19     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20     Boston, MA 02110-1301, USA.
  21 */
  22
  23 #ifndef SVGRenderStyle_h
  24 #define SVGRenderStyle_h
  25
  26 #include "bindings/v8/ExceptionStatePlaceholder.h"
  27 #include "core/css/CSSValueList.h"
  28 #include "core/rendering/style/DataRef.h"
  29 #include "core/rendering/style/RenderStyleConstants.h"
  30 #include "core/rendering/style/SVGRenderStyleDefs.h"
  31 #include "core/svg/SVGPaint.h"
  32 #include "platform/graphics/GraphicsTypes.h"
  33 #include "platform/graphics/Path.h"
  34
  35 namespace WebCore {
  36
  37 class FloatRect;
  38 class IntRect;
  39 class RenderObject;
  40
  41 class SVGRenderStyle : public RefCounted<SVGRenderStyle> {
  42 public:
  43     static PassRefPtr<SVGRenderStyle> create() { return adoptRef(new SVGRenderStyle); }
  44     PassRefPtr<SVGRenderStyle> copy() const { return adoptRef(new SVGRenderStyle(*this));}
  45     ~SVGRenderStyle();
  46
  47     bool inheritedNotEqual(const SVGRenderStyle*) const;
  48     void inheritFrom(const SVGRenderStyle*);
  49     void copyNonInheritedFrom(const SVGRenderStyle*);
  50
  51     StyleDifference diff(const SVGRenderStyle*) const;
  52
  53     bool operator==(const SVGRenderStyle&) const;
  54     bool operator!=(const SVGRenderStyle& o) const { return !(*this == o); }
  55
  56     // Initial values for all the properties
  57     static EAlignmentBaseline initialAlignmentBaseline() { return AB_AUTO; }
  58     static EDominantBaseline initialDominantBaseline() { return DB_AUTO; }
  59     static EBaselineShift initialBaselineShift() { return BS_BASELINE; }
  60     static EVectorEffect initialVectorEffect() { return VE_NONE; }
  61     static EBufferedRendering initialBufferedRendering() { return BR_AUTO; }
  62     static LineCap initialCapStyle() { return ButtCap; }
  63     static WindRule initialClipRule() { return RULE_NONZERO; }
  64     static EColorInterpolation initialColorInterpolation() { return CI_SRGB; }
  65     static EColorInterpolation initialColorInterpolationFilters() { return CI_LINEARRGB; }
  66     static EColorRendering initialColorRendering() { return CR_AUTO; }
  67     static WindRule initialFillRule() { return RULE_NONZERO; }
  68     static LineJoin initialJoinStyle() { return MiterJoin; }
  69     static EShapeRendering initialShapeRendering() { return SR_AUTO; }
  70     static ETextAnchor initialTextAnchor() { return TA_START; }
  71     static SVGWritingMode initialWritingMode() { return WM_LRTB; }
  72     static EGlyphOrientation initialGlyphOrientationHorizontal() { return GO_0DEG; }
  73     static EGlyphOrientation initialGlyphOrientationVertical() { return GO_AUTO; }
  74     static float initialFillOpacity() { return 1; }
  75     static SVGPaint::SVGPaintType initialFillPaintType() { return SVGPaint::SVG_PAINTTYPE_RGBCOLOR; }
  76     static Color initialFillPaintColor() { return Color::black; }
  77     static String initialFillPaintUri() { return String(); }
  78     static float initialStrokeOpacity() { return 1; }
  79     static SVGPaint::SVGPaintType initialStrokePaintType() { return SVGPaint::SVG_PAINTTYPE_NONE; }
  80     static Color initialStrokePaintColor() { return Color(); }
  81     static String initialStrokePaintUri() { return String(); }
  82     static PassRefPtr<SVGLengthList> initialStrokeDashArray() { return SVGLengthList::create(); }
  83     static float initialStrokeMiterLimit() { return 4; }
  84     static float initialStopOpacity() { return 1; }
  85     static Color initialStopColor() { return Color(0, 0, 0); }
  86     static float initialFloodOpacity() { return 1; }
  87     static Color initialFloodColor() { return Color(0, 0, 0); }
  88     static Color initialLightingColor() { return Color(255, 255, 255); }
  89     static const AtomicString& initialClipperResource() { return nullAtom; }
  90     static const AtomicString& initialFilterResource() { return nullAtom; }
  91     static const AtomicString& initialMaskerResource() { return nullAtom; }
  92     static const AtomicString& initialMarkerStartResource() { return nullAtom; }
  93     static const AtomicString& initialMarkerMidResource() { return nullAtom; }
  94     static const AtomicString& initialMarkerEndResource() { return nullAtom; }
  95     static EMaskType initialMaskType() { return MT_LUMINANCE; }
  96     static EPaintOrder initialPaintOrder() { return PO_NORMAL; }
  97
  98     static PassRefPtr<SVGLength> initialBaselineShiftValue()
  99     {
 100         RefPtr<SVGLength> length = SVGLength::create();
 101         length->newValueSpecifiedUnits(LengthTypeNumber, 0);
 102         return length.release();
 103     }
 104
 105     static PassRefPtr<SVGLength> initialKerning()
 106     {
 107         RefPtr<SVGLength> length = SVGLength::create();
 108         length->newValueSpecifiedUnits(LengthTypeNumber, 0);
 109         return length.release();
 110     }
 111
 112     static PassRefPtr<SVGLength> initialStrokeDashOffset()
 113     {
 114         RefPtr<SVGLength> length = SVGLength::create();
 115         length->newValueSpecifiedUnits(LengthTypeNumber, 0);
 116         return length.release();
 117     }
 118
 119     static PassRefPtr<SVGLength> initialStrokeWidth()
 120     {
 121         RefPtr<SVGLength> length = SVGLength::create();
 122         length->newValueSpecifiedUnits(LengthTypeNumber, 1);
 123         return length.release();
 124     }
 125
 126     // SVG CSS Property setters
 127     void setAlignmentBaseline(EAlignmentBaseline val) { svg_noninherited_flags.f._alignmentBaseline = val; }
 128     void setDominantBaseline(EDominantBaseline val) { svg_noninherited_flags.f._dominantBaseline = val; }
 129     void setBaselineShift(EBaselineShift val) { svg_noninherited_flags.f._baselineShift = val; }
 130     void setVectorEffect(EVectorEffect val) { svg_noninherited_flags.f._vectorEffect = val; }
 131     void setBufferedRendering(EBufferedRendering val) { svg_noninherited_flags.f.bufferedRendering = val; }
 132     void setCapStyle(LineCap val) { svg_inherited_flags._capStyle = val; }
 133     void setClipRule(WindRule val) { svg_inherited_flags._clipRule = val; }
 134     void setColorInterpolation(EColorInterpolation val) { svg_inherited_flags._colorInterpolation = val; }
 135     void setColorInterpolationFilters(EColorInterpolation val) { svg_inherited_flags._colorInterpolationFilters = val; }
 136     void setColorRendering(EColorRendering val) { svg_inherited_flags._colorRendering = val; }
 137     void setFillRule(WindRule val) { svg_inherited_flags._fillRule = val; }
 138     void setJoinStyle(LineJoin val) { svg_inherited_flags._joinStyle = val; }
 139     void setShapeRendering(EShapeRendering val) { svg_inherited_flags._shapeRendering = val; }
 140     void setTextAnchor(ETextAnchor val) { svg_inherited_flags._textAnchor = val; }
 141     void setWritingMode(SVGWritingMode val) { svg_inherited_flags._writingMode = val; }
 142     void setGlyphOrientationHorizontal(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationHorizontal = val; }
 143     void setGlyphOrientationVertical(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationVertical = val; }
 144     void setMaskType(EMaskType val) { svg_noninherited_flags.f.maskType = val; }
 145     void setPaintOrder(EPaintOrder val) { svg_inherited_flags._paintOrder = (int)val; }
 146
 147     void setFillOpacity(float obj)
 148     {
 149         if (!(fill->opacity == obj))
 150             fill.access()->opacity = obj;
 151     }
 152
 153     void setFillPaint(SVGPaint::SVGPaintType type, const Color& color, const String& uri, bool applyToRegularStyle = true, bool applyToVisitedLinkStyle = false)
 154     {
 155         if (applyToRegularStyle) {
 156             if (!(fill->paintType == type))
 157                 fill.access()->paintType = type;
 158             if (!(fill->paintColor == color))
 159                 fill.access()->paintColor = color;
 160             if (!(fill->paintUri == uri))
 161                 fill.access()->paintUri = uri;
 162         }
 163         if (applyToVisitedLinkStyle) {
 164             if (!(fill->visitedLinkPaintType == type))
 165                 fill.access()->visitedLinkPaintType = type;
 166             if (!(fill->visitedLinkPaintColor == color))
 167                 fill.access()->visitedLinkPaintColor = color;
 168             if (!(fill->visitedLinkPaintUri == uri))
 169                 fill.access()->visitedLinkPaintUri = uri;
 170         }
 171     }
 172
 173     void setStrokeOpacity(float obj)
 174     {
 175         if (!(stroke->opacity == obj))
 176             stroke.access()->opacity = obj;
 177     }
 178
 179     void setStrokePaint(SVGPaint::SVGPaintType type, const Color& color, const String& uri, bool applyToRegularStyle = true, bool applyToVisitedLinkStyle = false)
 180     {
 181         if (applyToRegularStyle) {
 182             if (!(stroke->paintType == type))
 183                 stroke.access()->paintType = type;
 184             if (!(stroke->paintColor == color))
 185                 stroke.access()->paintColor = color;
 186             if (!(stroke->paintUri == uri))
 187                 stroke.access()->paintUri = uri;
 188         }
 189         if (applyToVisitedLinkStyle) {
 190             if (!(stroke->visitedLinkPaintType == type))
 191                 stroke.access()->visitedLinkPaintType = type;
 192             if (!(stroke->visitedLinkPaintColor == color))
 193                 stroke.access()->visitedLinkPaintColor = color;
 194             if (!(stroke->visitedLinkPaintUri == uri))
 195                 stroke.access()->visitedLinkPaintUri = uri;
 196         }
 197     }
 198
 199     void setStrokeDashArray(PassRefPtr<SVGLengthList> obj)
 200     {
 201         if (!(stroke->dashArray == obj))
 202             stroke.access()->dashArray = obj;
 203     }
 204
 205     void setStrokeMiterLimit(float obj)
 206     {
 207         if (!(stroke->miterLimit == obj))
 208             stroke.access()->miterLimit = obj;
 209     }
 210
 211     void setStrokeWidth(PassRefPtr<SVGLength> obj)
 212     {
 213         if (!(stroke->width == obj))
 214             stroke.access()->width = obj;
 215     }
 216
 217     void setStrokeDashOffset(PassRefPtr<SVGLength> obj)
 218     {
 219         if (!(stroke->dashOffset == obj))
 220             stroke.access()->dashOffset = obj;
 221     }
 222
 223     void setKerning(PassRefPtr<SVGLength> obj)
 224     {
 225         if (!(text->kerning == obj))
 226             text.access()->kerning = obj;
 227     }
 228
 229     void setStopOpacity(float obj)
 230     {
 231         if (!(stops->opacity == obj))
 232             stops.access()->opacity = obj;
 233     }
 234
 235     void setStopColor(const Color& obj)
 236     {
 237         if (!(stops->color == obj))
 238             stops.access()->color = obj;
 239     }
 240
 241     void setFloodOpacity(float obj)
 242     {
 243         if (!(misc->floodOpacity == obj))
 244             misc.access()->floodOpacity = obj;
 245     }
 246
 247     void setFloodColor(const Color& obj)
 248     {
 249         if (!(misc->floodColor == obj))
 250             misc.access()->floodColor = obj;
 251     }
 252
 253     void setLightingColor(const Color& obj)
 254     {
 255         if (!(misc->lightingColor == obj))
 256             misc.access()->lightingColor = obj;
 257     }
 258
 259     void setBaselineShiftValue(PassRefPtr<SVGLength> obj)
 260     {
 261         if (!(misc->baselineShiftValue == obj))
 262             misc.access()->baselineShiftValue = obj;
 263     }
 264
 265     // Setters for non-inherited resources
 266     void setClipperResource(const AtomicString& obj)
 267     {
 268         if (!(resources->clipper == obj))
 269             resources.access()->clipper = obj;
 270     }
 271
 272     void setFilterResource(const AtomicString& obj)
 273     {
 274         if (!(resources->filter == obj))
 275             resources.access()->filter = obj;
 276     }
 277
 278     void setMaskerResource(const AtomicString& obj)
 279     {
 280         if (!(resources->masker == obj))
 281             resources.access()->masker = obj;
 282     }
 283
 284     // Setters for inherited resources
 285     void setMarkerStartResource(const AtomicString& obj)
 286     {
 287         if (!(inheritedResources->markerStart == obj))
 288             inheritedResources.access()->markerStart = obj;
 289     }
 290
 291     void setMarkerMidResource(const AtomicString& obj)
 292     {
 293         if (!(inheritedResources->markerMid == obj))
 294             inheritedResources.access()->markerMid = obj;
 295     }
 296
 297     void setMarkerEndResource(const AtomicString& obj)
 298     {
 299         if (!(inheritedResources->markerEnd == obj))
 300             inheritedResources.access()->markerEnd = obj;
 301     }
 302
 303     // Read accessors for all the properties
 304     EAlignmentBaseline alignmentBaseline() const { return (EAlignmentBaseline) svg_noninherited_flags.f._alignmentBaseline; }
 305     EDominantBaseline dominantBaseline() const { return (EDominantBaseline) svg_noninherited_flags.f._dominantBaseline; }
 306     EBaselineShift baselineShift() const { return (EBaselineShift) svg_noninherited_flags.f._baselineShift; }
 307     EVectorEffect vectorEffect() const { return (EVectorEffect) svg_noninherited_flags.f._vectorEffect; }
 308     EBufferedRendering bufferedRendering() const { return (EBufferedRendering) svg_noninherited_flags.f.bufferedRendering; }
 309     LineCap capStyle() const { return (LineCap) svg_inherited_flags._capStyle; }
 310     WindRule clipRule() const { return (WindRule) svg_inherited_flags._clipRule; }
 311     EColorInterpolation colorInterpolation() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolation; }
 312     EColorInterpolation colorInterpolationFilters() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolationFilters; }
 313     EColorRendering colorRendering() const { return (EColorRendering) svg_inherited_flags._colorRendering; }
 314     WindRule fillRule() const { return (WindRule) svg_inherited_flags._fillRule; }
 315     LineJoin joinStyle() const { return (LineJoin) svg_inherited_flags._joinStyle; }
 316     EShapeRendering shapeRendering() const { return (EShapeRendering) svg_inherited_flags._shapeRendering; }
 317     ETextAnchor textAnchor() const { return (ETextAnchor) svg_inherited_flags._textAnchor; }
 318     SVGWritingMode writingMode() const { return (SVGWritingMode) svg_inherited_flags._writingMode; }
 319     EGlyphOrientation glyphOrientationHorizontal() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationHorizontal; }
 320     EGlyphOrientation glyphOrientationVertical() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationVertical; }
 321     float fillOpacity() const { return fill->opacity; }
 322     const SVGPaint::SVGPaintType& fillPaintType() const { return fill->paintType; }
 323     const Color& fillPaintColor() const { return fill->paintColor; }
 324     const String& fillPaintUri() const { return fill->paintUri; }
 325     float strokeOpacity() const { return stroke->opacity; }
 326     const SVGPaint::SVGPaintType& strokePaintType() const { return stroke->paintType; }
 327     const Color& strokePaintColor() const { return stroke->paintColor; }
 328     const String& strokePaintUri() const { return stroke->paintUri; }
 329     PassRefPtr<SVGLengthList> strokeDashArray() const { return stroke->dashArray; }
 330     float strokeMiterLimit() const { return stroke->miterLimit; }
 331     PassRefPtr<SVGLength> strokeWidth() const { return stroke->width; }
 332     PassRefPtr<SVGLength> strokeDashOffset() const { return stroke->dashOffset; }
 333     PassRefPtr<SVGLength> kerning() const { return text->kerning; }
 334     float stopOpacity() const { return stops->opacity; }
 335     const Color& stopColor() const { return stops->color; }
 336     float floodOpacity() const { return misc->floodOpacity; }
 337     const Color& floodColor() const { return misc->floodColor; }
 338     const Color& lightingColor() const { return misc->lightingColor; }
 339     PassRefPtr<SVGLength> baselineShiftValue() const { return misc->baselineShiftValue; }
 340     const AtomicString& clipperResource() const { return resources->clipper; }
 341     const AtomicString& filterResource() const { return resources->filter; }
 342     const AtomicString& maskerResource() const { return resources->masker; }
 343     const AtomicString& markerStartResource() const { return inheritedResources->markerStart; }
 344     const AtomicString& markerMidResource() const { return inheritedResources->markerMid; }
 345     const AtomicString& markerEndResource() const { return inheritedResources->markerEnd; }
 346     EMaskType maskType() const { return (EMaskType) svg_noninherited_flags.f.maskType; }
 347     EPaintOrder paintOrder() const { return (EPaintOrder) svg_inherited_flags._paintOrder; }
 348     EPaintOrderType paintOrderType(unsigned index) const;
 349
 350     const SVGPaint::SVGPaintType& visitedLinkFillPaintType() const { return fill->visitedLinkPaintType; }
 351     const Color& visitedLinkFillPaintColor() const { return fill->visitedLinkPaintColor; }
 352     const String& visitedLinkFillPaintUri() const { return fill->visitedLinkPaintUri; }
 353     const SVGPaint::SVGPaintType& visitedLinkStrokePaintType() const { return stroke->visitedLinkPaintType; }
 354     const Color& visitedLinkStrokePaintColor() const { return stroke->visitedLinkPaintColor; }
 355     const String& visitedLinkStrokePaintUri() const { return stroke->visitedLinkPaintUri; }
 356
 357     // convenience
 358     bool hasClipper() const { return !clipperResource().isEmpty(); }
 359     bool hasMasker() const { return !maskerResource().isEmpty(); }
 360     bool hasFilter() const { return !filterResource().isEmpty(); }
 361     bool hasMarkers() const { return !markerStartResource().isEmpty() || !markerMidResource().isEmpty() || !markerEndResource().isEmpty(); }
 362     bool hasStroke() const { return strokePaintType() != SVGPaint::SVG_PAINTTYPE_NONE; }
 363     bool hasVisibleStroke() const { return hasStroke() && !strokeWidth()->isZero(); }
 364     bool hasFill() const { return fillPaintType() != SVGPaint::SVG_PAINTTYPE_NONE; }
 365     bool isVerticalWritingMode() const { return writingMode() == WM_TBRL || writingMode() == WM_TB; }
 366
 367 protected:
 368     // inherit
 369     struct InheritedFlags {
 370         bool operator==(const InheritedFlags& other) const
 371         {
 372             return (_colorRendering == other._colorRendering)
 373                 && (_shapeRendering == other._shapeRendering)
 374                 && (_clipRule == other._clipRule)
 375                 && (_fillRule == other._fillRule)
 376                 && (_capStyle == other._capStyle)
 377                 && (_joinStyle == other._joinStyle)
 378                 && (_textAnchor == other._textAnchor)
 379                 && (_colorInterpolation == other._colorInterpolation)
 380                 && (_colorInterpolationFilters == other._colorInterpolationFilters)
 381                 && (_writingMode == other._writingMode)
 382                 && (_glyphOrientationHorizontal == other._glyphOrientationHorizontal)
 383                 && (_glyphOrientationVertical == other._glyphOrientationVertical)
 384                 && (_paintOrder == other._paintOrder);
 385         }
 386
 387         bool operator!=(const InheritedFlags& other) const
 388         {
 389             return !(*this == other);
 390         }
 391
 392         unsigned _colorRendering : 2; // EColorRendering
 393         unsigned _shapeRendering : 2; // EShapeRendering
 394         unsigned _clipRule : 1; // WindRule
 395         unsigned _fillRule : 1; // WindRule
 396         unsigned _capStyle : 2; // LineCap
 397         unsigned _joinStyle : 2; // LineJoin
 398         unsigned _textAnchor : 2; // ETextAnchor
 399         unsigned _colorInterpolation : 2; // EColorInterpolation
 400         unsigned _colorInterpolationFilters : 2; // EColorInterpolation
 401         unsigned _writingMode : 3; // SVGWritingMode
 402         unsigned _glyphOrientationHorizontal : 3; // EGlyphOrientation
 403         unsigned _glyphOrientationVertical : 3; // EGlyphOrientation
 404         unsigned _paintOrder : 6; // EPaintOrder
 405     } svg_inherited_flags;
 406
 407     // don't inherit
 408     struct NonInheritedFlags {
 409         // 32 bit non-inherited, don't add to the struct, or the operator will break.
 410         bool operator==(const NonInheritedFlags &other) const { return _niflags == other._niflags; }
 411         bool operator!=(const NonInheritedFlags &other) const { return _niflags != other._niflags; }
 412
 413         union {
 414             struct {
 415                 unsigned _alignmentBaseline : 4; // EAlignmentBaseline
 416                 unsigned _dominantBaseline : 4; // EDominantBaseline
 417                 unsigned _baselineShift : 2; // EBaselineShift
 418                 unsigned _vectorEffect: 1; // EVectorEffect
 419                 unsigned bufferedRendering: 2; // EBufferedRendering
 420                 unsigned maskType: 1; // EMaskType
 421                 // 18 bits unused
 422             } f;
 423             uint32_t _niflags;
 424         };
 425     } svg_noninherited_flags;
 426
 427     // inherited attributes
 428     DataRef<StyleFillData> fill;
 429     DataRef<StyleStrokeData> stroke;
 430     DataRef<StyleTextData> text;
 431     DataRef<StyleInheritedResourceData> inheritedResources;
 432
 433     // non-inherited attributes
 434     DataRef<StyleStopData> stops;
 435     DataRef<StyleMiscData> misc;
 436     DataRef<StyleResourceData> resources;
 437
 438 private:
 439     enum CreateDefaultType { CreateDefault };
 440
 441     SVGRenderStyle();
 442     SVGRenderStyle(const SVGRenderStyle&);
 443     SVGRenderStyle(CreateDefaultType); // Used to create the default style.
 444
 445     void setBitDefaults()
 446     {
 447         svg_inherited_flags._clipRule = initialClipRule();
 448         svg_inherited_flags._colorRendering = initialColorRendering();
 449         svg_inherited_flags._fillRule = initialFillRule();
 450         svg_inherited_flags._shapeRendering = initialShapeRendering();
 451         svg_inherited_flags._textAnchor = initialTextAnchor();
 452         svg_inherited_flags._capStyle = initialCapStyle();
 453         svg_inherited_flags._joinStyle = initialJoinStyle();
 454         svg_inherited_flags._colorInterpolation = initialColorInterpolation();
 455         svg_inherited_flags._colorInterpolationFilters = initialColorInterpolationFilters();
 456         svg_inherited_flags._writingMode = initialWritingMode();
 457         svg_inherited_flags._glyphOrientationHorizontal = initialGlyphOrientationHorizontal();
 458         svg_inherited_flags._glyphOrientationVertical = initialGlyphOrientationVertical();
 459         svg_inherited_flags._paintOrder = initialPaintOrder();
 460
 461         svg_noninherited_flags._niflags = 0;
 462         svg_noninherited_flags.f._alignmentBaseline = initialAlignmentBaseline();
 463         svg_noninherited_flags.f._dominantBaseline = initialDominantBaseline();
 464         svg_noninherited_flags.f._baselineShift = initialBaselineShift();
 465         svg_noninherited_flags.f._vectorEffect = initialVectorEffect();
 466         svg_noninherited_flags.f.bufferedRendering = initialBufferedRendering();
 467         svg_noninherited_flags.f.maskType = initialMaskType();
 468     }
 469 };
 470
 471 } // namespace WebCore
 472
 473 #endif // SVGRenderStyle_h