Remove SVG glyph-orientation-horizontal and glyph-orientation-vertical

third_party/WebKit/Source/core/style/SVGComputedStyle.h

 /*
     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005 Rob Buis <buis@kde.org>
     Copyright (C) 2005, 2006 Apple Computer, Inc.
     Copyright (C) Research In Motion Limited 2010. 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
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 47 matching lines @@
     static EBufferedRendering initialBufferedRendering() { return BR_AUTO; }
     static LineCap initialCapStyle() { return ButtCap; }
     static WindRule initialClipRule() { return RULE_NONZERO; }
     static EColorInterpolation initialColorInterpolation() { return CI_SRGB; }
     static EColorInterpolation initialColorInterpolationFilters() { return CI_LINEARRGB; }
     static EColorRendering initialColorRendering() { return CR_AUTO; }
     static WindRule initialFillRule() { return RULE_NONZERO; }
     static LineJoin initialJoinStyle() { return MiterJoin; }
     static EShapeRendering initialShapeRendering() { return SR_AUTO; }
     static ETextAnchor initialTextAnchor() { return TA_START; }
-    static EGlyphOrientation initialGlyphOrientationHorizontal() { return GO_0DEG; }
-    static EGlyphOrientation initialGlyphOrientationVertical() { return GO_AUTO; }
     static float initialFillOpacity() { return 1; }
     static SVGPaintType initialFillPaintType() { return SVG_PAINTTYPE_RGBCOLOR; }
     static Color initialFillPaintColor() { return Color::black; }
     static String initialFillPaintUri() { return String(); }
     static float initialStrokeOpacity() { return 1; }
     static SVGPaintType initialStrokePaintType() { return SVG_PAINTTYPE_NONE; }
     static Color initialStrokePaintColor() { return Color(); }
     static String initialStrokePaintUri() { return String(); }
     static PassRefPtr<SVGDashArray> initialStrokeDashArray();
     static Length initialStrokeDashOffset() { return Length(Fixed); }
@@ skipping 28 matching lines @@
     void setBufferedRendering(EBufferedRendering val) { svg_noninherited_flags.f.bufferedRendering = val; }
     void setCapStyle(LineCap val) { svg_inherited_flags._capStyle = val; }
     void setClipRule(WindRule val) { svg_inherited_flags._clipRule = val; }
     void setColorInterpolation(EColorInterpolation val) { svg_inherited_flags._colorInterpolation = val; }
     void setColorInterpolationFilters(EColorInterpolation val) { svg_inherited_flags._colorInterpolationFilters = val; }
     void setColorRendering(EColorRendering val) { svg_inherited_flags._colorRendering = val; }
     void setFillRule(WindRule val) { svg_inherited_flags._fillRule = val; }
     void setJoinStyle(LineJoin val) { svg_inherited_flags._joinStyle = val; }
     void setShapeRendering(EShapeRendering val) { svg_inherited_flags._shapeRendering = val; }
     void setTextAnchor(ETextAnchor val) { svg_inherited_flags._textAnchor = val; }
-    void setGlyphOrientationHorizontal(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationHorizontal = val; }
-    void setGlyphOrientationVertical(EGlyphOrientation val) { svg_inherited_flags._glyphOrientationVertical = val; }
     void setMaskType(EMaskType val) { svg_noninherited_flags.f.maskType = val; }
     void setPaintOrder(EPaintOrder val) { svg_inherited_flags.paintOrder = (int)val; }
     void setCx(const Length& obj)
     {
         if (!(layout->cx == obj))
             layout.access()->cx = obj;
     }
     void setCy(const Length& obj)
     {
         if (!(layout->cy == obj))
@@ skipping 182 matching lines @@
     EBufferedRendering bufferedRendering() const { return (EBufferedRendering) svg_noninherited_flags.f.bufferedRendering; }
     LineCap capStyle() const { return (LineCap) svg_inherited_flags._capStyle; }
     WindRule clipRule() const { return (WindRule) svg_inherited_flags._clipRule; }
     EColorInterpolation colorInterpolation() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolation; }
     EColorInterpolation colorInterpolationFilters() const { return (EColorInterpolation) svg_inherited_flags._colorInterpolationFilters; }
     EColorRendering colorRendering() const { return (EColorRendering) svg_inherited_flags._colorRendering; }
     WindRule fillRule() const { return (WindRule) svg_inherited_flags._fillRule; }
     LineJoin joinStyle() const { return (LineJoin) svg_inherited_flags._joinStyle; }
     EShapeRendering shapeRendering() const { return (EShapeRendering) svg_inherited_flags._shapeRendering; }
     ETextAnchor textAnchor() const { return (ETextAnchor) svg_inherited_flags._textAnchor; }
-    EGlyphOrientation glyphOrientationHorizontal() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationHorizontal; }
-    EGlyphOrientation glyphOrientationVertical() const { return (EGlyphOrientation) svg_inherited_flags._glyphOrientationVertical; }
     float fillOpacity() const { return fill->opacity; }
     const SVGPaintType& fillPaintType() const { return fill->paintType; }
     const Color& fillPaintColor() const { return fill->paintColor; }
     const String& fillPaintUri() const { return fill->paintUri; }
     float strokeOpacity() const { return stroke->opacity; }
     const SVGPaintType& strokePaintType() const { return stroke->paintType; }
     const Color& strokePaintColor() const { return stroke->paintColor; }
     const String& strokePaintUri() const { return stroke->paintUri; }
     SVGDashArray* strokeDashArray() const { return stroke->dashArray.get(); }
     float strokeMiterLimit() const { return stroke->miterLimit; }
@@ skipping 47 matching lines @@
         {
             return (_colorRendering == other._colorRendering)
                 && (_shapeRendering == other._shapeRendering)
                 && (_clipRule == other._clipRule)
                 && (_fillRule == other._fillRule)
                 && (_capStyle == other._capStyle)
                 && (_joinStyle == other._joinStyle)
                 && (_textAnchor == other._textAnchor)
                 && (_colorInterpolation == other._colorInterpolation)
                 && (_colorInterpolationFilters == other._colorInterpolationFilters)
-                && (_glyphOrientationHorizontal == other._glyphOrientationHorizontal)
-                && (_glyphOrientationVertical == other._glyphOrientationVertical)
                 && (paintOrder == other.paintOrder)
                 && (dominantBaseline == other.dominantBaseline);
         }
 
         bool operator!=(const InheritedFlags& other) const
         {
             return !(*this == other);
         }
 
         unsigned _colorRendering : 2; // EColorRendering
         unsigned _shapeRendering : 2; // EShapeRendering
         unsigned _clipRule : 1; // WindRule
         unsigned _fillRule : 1; // WindRule
         unsigned _capStyle : 2; // LineCap
         unsigned _joinStyle : 2; // LineJoin
         unsigned _textAnchor : 2; // ETextAnchor
         unsigned _colorInterpolation : 2; // EColorInterpolation
         unsigned _colorInterpolationFilters : 2; // EColorInterpolation
-        unsigned _glyphOrientationHorizontal : 3; // EGlyphOrientation
-        unsigned _glyphOrientationVertical : 3; // EGlyphOrientation
         unsigned paintOrder : 3; // EPaintOrder
         unsigned dominantBaseline : 4; // EDominantBaseline
     } svg_inherited_flags;
 
     // don't inherit
     struct NonInheritedFlags {
         // 32 bit non-inherited, don't add to the struct, or the operator will break.
         bool operator==(const NonInheritedFlags &other) const { return _niflags == other._niflags; }
         bool operator!=(const NonInheritedFlags &other) const { return _niflags != other._niflags; }
 
@@ skipping 35 matching lines @@
     {
         svg_inherited_flags._clipRule = initialClipRule();
         svg_inherited_flags._colorRendering = initialColorRendering();
         svg_inherited_flags._fillRule = initialFillRule();
         svg_inherited_flags._shapeRendering = initialShapeRendering();
         svg_inherited_flags._textAnchor = initialTextAnchor();
         svg_inherited_flags._capStyle = initialCapStyle();
         svg_inherited_flags._joinStyle = initialJoinStyle();
         svg_inherited_flags._colorInterpolation = initialColorInterpolation();
         svg_inherited_flags._colorInterpolationFilters = initialColorInterpolationFilters();
-        svg_inherited_flags._glyphOrientationHorizontal = initialGlyphOrientationHorizontal();
-        svg_inherited_flags._glyphOrientationVertical = initialGlyphOrientationVertical();
         svg_inherited_flags.paintOrder = initialPaintOrder();
         svg_inherited_flags.dominantBaseline = initialDominantBaseline();
 
         svg_noninherited_flags._niflags = 0;
         svg_noninherited_flags.f._alignmentBaseline = initialAlignmentBaseline();
         svg_noninherited_flags.f._baselineShift = initialBaselineShift();
         svg_noninherited_flags.f._vectorEffect = initialVectorEffect();
         svg_noninherited_flags.f.bufferedRendering = initialBufferedRendering();
         svg_noninherited_flags.f.maskType = initialMaskType();
     }
 };
 
 } // namespace blink
 
 #endif // SVGComputedStyle_h