Remove page-break properties and captions

sky/engine/core/rendering/style/RenderStyle.h

 /*
  * 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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 114 matching lines @@
     DataRef<StyleRareInheritedData> rareInheritedData;
     DataRef<StyleInheritedData> inherited;
 
 // !START SYNC!: Keep this in sync with the copy constructor in RenderStyle.cpp and implicitlyInherited() in StyleResolver.cpp
 
     // inherit
     struct InheritedFlags {
         bool operator==(const InheritedFlags& other) const
         {
             return (_empty_cells == other._empty_cells)
-                && (_caption_side == other._caption_side)
                 && (_visibility == other._visibility)
                 && (_text_align == other._text_align)
                 && (m_textUnderline == other.m_textUnderline)
                 && (_direction == other._direction)
                 && (_white_space == other._white_space)
                 && (m_rtlOrdering == other.m_rtlOrdering)
                 && (_pointerEvents == other._pointerEvents);
         }
 
         bool operator!=(const InheritedFlags& other) const { return !(*this == other); }
 
         unsigned _empty_cells : 1; // EEmptyCell
-        unsigned _caption_side : 2; // ECaptionSide
         unsigned _visibility : 2; // EVisibility
         unsigned _text_align : 4; // ETextAlign
         unsigned m_textUnderline : 1;
         unsigned _direction : 1; // TextDirection
         unsigned _white_space : 3; // EWhiteSpace
 
         // non CSS2 inherited
         unsigned m_rtlOrdering : 1; // Order
         unsigned _pointerEvents : 4; // EPointerEvents
 
         // 19 bits
     } inherited_flags;
 
 // don't inherit
     struct NonInheritedFlags {
         bool operator==(const NonInheritedFlags& other) const
         {
             return effectiveDisplay == other.effectiveDisplay
                 && originalDisplay == other.originalDisplay
                 && overflowX == other.overflowX
                 && overflowY == other.overflowY
                 && verticalAlign == other.verticalAlign
                 && position == other.position
                 && tableLayout == other.tableLayout
-                && pageBreakBefore == other.pageBreakBefore
-                && pageBreakAfter == other.pageBreakAfter
-                && pageBreakInside == other.pageBreakInside
                 && styleType == other.styleType
                 && affectedByFocus == other.affectedByFocus
                 && affectedByHover == other.affectedByHover
                 && affectedByActive == other.affectedByActive
                 && unicodeBidi == other.unicodeBidi
                 && explicitInheritance == other.explicitInheritance
                 && currentColor == other.currentColor
                 && unique == other.unique
                 && emptyState == other.emptyState
                 && firstChildState == other.firstChildState
@@ skipping 11 matching lines @@
         unsigned position : 1; // EPosition
         unsigned tableLayout : 1; // ETableLayout
         unsigned unicodeBidi : 3; // EUnicodeBidi
 
         // This is set if we used viewport units when resolving a length.
         // It is mutable so we can pass around const RenderStyles to resolve lengths.
         mutable unsigned hasViewportUnits : 1;
 
         // 32 bits
 
-        unsigned pageBreakBefore : 2; // EPageBreak
-        unsigned pageBreakAfter : 2; // EPageBreak
-        unsigned pageBreakInside : 2; // EPageBreak
-
         unsigned styleType : 6; // PseudoId
         unsigned explicitInheritance : 1; // Explicitly inherits a non-inherited property
         unsigned currentColor : 1; // At least one color has the value 'currentColor'
         unsigned unique : 1; // Style can not be shared.
 
         unsigned emptyState : 1;
         unsigned firstChildState : 1;
         unsigned lastChildState : 1;
 
         unsigned affectedByFocus : 1;
         unsigned affectedByHover : 1;
         unsigned affectedByActive : 1;
 
         unsigned isLink : 1;
         // If you add more style bits here, you will also need to update RenderStyle::copyNonInheritedFrom()
         // 63 bits
     } noninherited_flags;
 
 // !END SYNC!
 
 protected:
     void setBitDefaults()
     {
         inherited_flags._empty_cells = initialEmptyCells();
-        inherited_flags._caption_side = initialCaptionSide();
         inherited_flags._visibility = initialVisibility();
         inherited_flags._text_align = initialTextAlign();
         inherited_flags.m_textUnderline = false;
         inherited_flags._direction = initialDirection();
         inherited_flags._white_space = initialWhiteSpace();
         inherited_flags.m_rtlOrdering = initialRTLOrdering();
         inherited_flags._pointerEvents = initialPointerEvents();
 
         noninherited_flags.effectiveDisplay = noninherited_flags.originalDisplay = initialDisplay();
         noninherited_flags.overflowX = initialOverflowX();
         noninherited_flags.overflowY = initialOverflowY();
         noninherited_flags.verticalAlign = initialVerticalAlign();
         noninherited_flags.position = initialPosition();
         noninherited_flags.tableLayout = initialTableLayout();
         noninherited_flags.unicodeBidi = initialUnicodeBidi();
-        noninherited_flags.pageBreakBefore = initialPageBreak();
-        noninherited_flags.pageBreakAfter = initialPageBreak();
-        noninherited_flags.pageBreakInside = initialPageBreak();
         noninherited_flags.explicitInheritance = false;
         noninherited_flags.currentColor = false;
         noninherited_flags.unique = false;
         noninherited_flags.emptyState = false;
         noninherited_flags.firstChildState = false;
         noninherited_flags.lastChildState = false;
         noninherited_flags.hasViewportUnits = false;
         noninherited_flags.affectedByFocus = false;
         noninherited_flags.affectedByHover = false;
         noninherited_flags.affectedByActive = false;
@@ skipping 283 matching lines @@
     const Length& backgroundXPosition() const { return m_background->background().xPosition(); }
     const Length& backgroundYPosition() const { return m_background->background().yPosition(); }
     EFillSizeType backgroundSizeType() const { return m_background->background().sizeType(); }
     const LengthSize& backgroundSizeLength() const { return m_background->background().sizeLength(); }
     FillLayer& accessBackgroundLayers() { return m_background.access()->m_background; }
     const FillLayer& backgroundLayers() const { return m_background->background(); }
 
     short horizontalBorderSpacing() const;
     short verticalBorderSpacing() const;
     EEmptyCell emptyCells() const { return static_cast<EEmptyCell>(inherited_flags._empty_cells); }
-    ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_flags._caption_side); }
 
     const Length& marginTop() const { return surround->margin.top(); }
     const Length& marginBottom() const { return surround->margin.bottom(); }
     const Length& marginLeft() const { return surround->margin.left(); }
     const Length& marginRight() const { return surround->margin.right(); }
     const Length& marginBefore() const { return surround->margin.before(); }
     const Length& marginAfter() const { return surround->margin.after(); }
     const Length& marginStart() const { return surround->margin.start(direction()); }
     const Length& marginEnd() const { return surround->margin.end(direction()); }
     const Length& marginStartUsing(const RenderStyle* otherStyle) const { return surround->margin.start(otherStyle->direction()); }
     const Length& marginEndUsing(const RenderStyle* otherStyle) const { return surround->margin.end(otherStyle->direction()); }
     const Length& marginBeforeUsing(const RenderStyle* otherStyle) const { return surround->margin.before(); }
     const Length& marginAfterUsing(const RenderStyle* otherStyle) const { return surround->margin.after(); }
 
     const LengthBox& paddingBox() const { return surround->padding; }
     const Length& paddingTop() const { return surround->padding.top(); }
     const Length& paddingBottom() const { return surround->padding.bottom(); }
     const Length& paddingLeft() const { return surround->padding.left(); }
     const Length& paddingRight() const { return surround->padding.right(); }
     const Length& paddingBefore() const { return surround->padding.before(); }
     const Length& paddingAfter() const { return surround->padding.after(); }
     const Length& paddingStart() const { return surround->padding.start(direction()); }
     const Length& paddingEnd() const { return surround->padding.end(direction()); }
 
     bool isLink() const { return noninherited_flags.isLink; }
 
     short widows() const { return rareInheritedData->widows; }
     bool hasAutoWidows() const { return rareInheritedData->m_hasAutoWidows; }
-    EPageBreak pageBreakInside() const { return static_cast<EPageBreak>(noninherited_flags.pageBreakInside); }
-    EPageBreak pageBreakBefore() const { return static_cast<EPageBreak>(noninherited_flags.pageBreakBefore); }
-    EPageBreak pageBreakAfter() const { return static_cast<EPageBreak>(noninherited_flags.pageBreakAfter); }
 
     // CSS3 Getter Methods
 
     int outlineOffset() const
     {
         if (m_background->outline().style() == BNONE)
             return 0;
         return m_background->outline().offset();
     }
 
@@ skipping 279 matching lines @@
     {
         if (backgroundLayers().next()) {
             accessBackgroundLayers().cullEmptyLayers();
             accessBackgroundLayers().fillUnsetProperties();
         }
     }
 
     void setHorizontalBorderSpacing(short);
     void setVerticalBorderSpacing(short);
     void setEmptyCells(EEmptyCell v) { inherited_flags._empty_cells = v; }
-    void setCaptionSide(ECaptionSide v) { inherited_flags._caption_side = v; }
 
     void setHasAspectRatio(bool b) { SET_VAR(rareNonInheritedData, m_hasAspectRatio, b); }
     void setAspectRatioDenominator(float v) { SET_VAR(rareNonInheritedData, m_aspectRatioDenominator, v); }
     void setAspectRatioNumerator(float v) { SET_VAR(rareNonInheritedData, m_aspectRatioNumerator, v); }
 
     void setMarginTop(const Length& v) { SET_VAR(surround, margin.m_top, v); }
     void setMarginBottom(const Length& v) { SET_VAR(surround, margin.m_bottom, v); }
     void setMarginLeft(const Length& v) { SET_VAR(surround, margin.m_left, v); }
     void setMarginRight(const Length& v) { SET_VAR(surround, margin.m_right, v); }
     void setMarginStart(const Length&);
     void setMarginEnd(const Length&);
 
     void resetPadding() { SET_VAR(surround, padding, LengthBox(Auto)); }
     void setPaddingBox(const LengthBox& b) { SET_VAR(surround, padding, b); }
     void setPaddingTop(const Length& v) { SET_VAR(surround, padding.m_top, v); }
     void setPaddingBottom(const Length& v) { SET_VAR(surround, padding.m_bottom, v); }
     void setPaddingLeft(const Length& v) { SET_VAR(surround, padding.m_left, v); }
     void setPaddingRight(const Length& v) { SET_VAR(surround, padding.m_right, v); }
 
     void setIsLink(bool b) { noninherited_flags.isLink = b; }
 
     bool hasAutoZIndex() const { return m_box->hasAutoZIndex(); }
     void setHasAutoZIndex() { SET_VAR(m_box, m_hasAutoZIndex, true); SET_VAR(m_box, m_zIndex, 0); }
     unsigned zIndex() const { return m_box->zIndex(); }
     void setZIndex(unsigned v) { SET_VAR(m_box, m_hasAutoZIndex, false); SET_VAR(m_box, m_zIndex, v); }
 
     void setHasAutoWidows() { SET_VAR(rareInheritedData, m_hasAutoWidows, true); SET_VAR(rareInheritedData, widows, initialWidows()); }
     void setWidows(short w) { SET_VAR(rareInheritedData, m_hasAutoWidows, false); SET_VAR(rareInheritedData, widows, w); }
 
-    // For valid values of page-break-inside see http://www.w3.org/TR/CSS21/page.html#page-break-props
-    void setPageBreakInside(EPageBreak b) { ASSERT(b == PBAUTO || b == PBAVOID); noninherited_flags.pageBreakInside = b; }
-    void setPageBreakBefore(EPageBreak b) { noninherited_flags.pageBreakBefore = b; }
-    void setPageBreakAfter(EPageBreak b) { noninherited_flags.pageBreakAfter = b; }
-
     // CSS3 Setters
     void setOutlineOffset(int v) { SET_VAR(m_background, m_outline.m_offset, v); }
     void setTextShadow(PassRefPtr<ShadowList>);
     void setTextStrokeColor(const StyleColor& c) { SET_VAR_WITH_SETTER(rareInheritedData, textStrokeColor, setTextStrokeColor, c); }
     void setTextStrokeWidth(float w) { SET_VAR(rareInheritedData, textStrokeWidth, w); }
     void setTextFillColor(const StyleColor& c) { SET_VAR_WITH_SETTER(rareInheritedData, textFillColor, setTextFillColor, c); }
     void setOpacity(float f) { float v = clampTo<float>(f, 0, 1); SET_VAR(rareNonInheritedData, opacity, v); }
     // For valid values of box-align see http://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment
     void setBoxDecorationBreak(EBoxDecorationBreak b) { SET_VAR(m_box, m_boxDecorationBreak, b); }
     void setBoxShadow(PassRefPtr<ShadowList>);
@@ skipping 129 matching lines @@
     void setHasCurrentColor() { noninherited_flags.currentColor = true; }
     bool hasCurrentColor() const { return noninherited_flags.currentColor; }
 
     bool hasBoxDecorations() const { return hasBorder() || hasBorderRadius() || hasOutline() || boxShadow() || hasFilter(); }
 
     // Initial values for all the properties
     static EBorderStyle initialBorderStyle() { return BNONE; }
     static OutlineIsAuto initialOutlineStyleIsAuto() { return AUTO_OFF; }
     static NinePieceImage initialNinePieceImage() { return NinePieceImage(); }
     static LengthSize initialBorderRadius() { return LengthSize(Length(0, Fixed), Length(0, Fixed)); }
-    static ECaptionSide initialCaptionSide() { return CAPTOP; }
     static LengthBox initialClip() { return LengthBox(); }
     static TextDirection initialDirection() { return LTR; }
     static TextOrientation initialTextOrientation() { return TextOrientationVerticalRight; }
     static ObjectFit initialObjectFit() { return ObjectFitFill; }
     static LengthPoint initialObjectPosition() { return LengthPoint(Length(50.0, Percent), Length(50.0, Percent)); }
     static EDisplay initialDisplay() { return FLEX; }
     static EEmptyCell initialEmptyCells() { return SHOW; }
     static EOverflow initialOverflowX() { return OVISIBLE; }
     static EOverflow initialOverflowY() { return OVISIBLE; }
-    static EPageBreak initialPageBreak() { return PBAUTO; }
     static EPosition initialPosition() { return StaticPosition; }
     static ETableLayout initialTableLayout() { return TAUTO; }
     static EUnicodeBidi initialUnicodeBidi() { return UBNormal; }
     static EVisibility initialVisibility() { return VISIBLE; }
     static EWhiteSpace initialWhiteSpace() { return NORMAL; }
     static short initialHorizontalBorderSpacing() { return 0; }
     static short initialVerticalBorderSpacing() { return 0; }
     static Color initialColor() { return Color::black; }
     static unsigned initialBorderWidth() { return 3; }
     static unsigned short initialColumnRuleWidth() { return 3; }
@@ skipping 165 matching lines @@
 
     rareInheritedData.access()->m_textOrientation = textOrientation;
     return true;
 }
 
 float calcBorderRadiiConstraintScaleFor(const FloatRect&, const FloatRoundedRect::Radii&);
 
 } // namespace blink
 
 #endif  // SKY_ENGINE_CORE_RENDERING_STYLE_RENDERSTYLE_H_