Remove more float machinery.

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 163 matching lines @@
 
 // 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
-                && clear == other.clear
                 && position == other.position
-                && floating == other.floating
                 && 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
                 && lastChildState == other.lastChildState
                 && isLink == other.isLink;
         }
 
         bool operator!=(const NonInheritedFlags& other) const { return !(*this == other); }
 
         unsigned effectiveDisplay : 5; // EDisplay
         unsigned originalDisplay : 5; // EDisplay
         unsigned overflowX : 3; // EOverflow
         unsigned overflowY : 3; // EOverflow
         unsigned verticalAlign : 4; // EVerticalAlign
-        unsigned clear : 2; // EClear
         unsigned position : 3; // EPosition
-        unsigned floating : 2; // EFloat
         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
@@ skipping 35 matching lines @@
         inherited_flags._white_space = initialWhiteSpace();
         inherited_flags._border_collapse = initialBorderCollapse();
         inherited_flags.m_rtlOrdering = initialRTLOrdering();
         inherited_flags.m_printColorAdjust = initialPrintColorAdjust();
         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.clear = initialClear();
         noninherited_flags.position = initialPosition();
-        noninherited_flags.floating = initialFloating();
         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;
@@ skipping 42 matching lines @@
     bool affectedByFocus() const { return noninherited_flags.affectedByFocus; }
     bool affectedByHover() const { return noninherited_flags.affectedByHover; }
     bool affectedByActive() const { return noninherited_flags.affectedByActive; }
 
     void setAffectedByFocus() { noninherited_flags.affectedByFocus = true; }
     void setAffectedByHover() { noninherited_flags.affectedByHover = true; }
     void setAffectedByActive() { noninherited_flags.affectedByActive = true; }
 
     bool operator==(const RenderStyle& other) const;
     bool operator!=(const RenderStyle& other) const { return !(*this == other); }
-    bool isFloating() const { return noninherited_flags.floating != NoFloat; }
     bool hasMargin() const { return surround->margin.nonZero(); }
     bool hasBorder() const { return surround->border.hasBorder(); }
     bool hasPadding() const { return surround->padding.nonZero(); }
     bool hasOffset() const { return surround->offset.nonZero(); }
     bool hasMarginBeforeQuirk() const { return marginBefore().quirk(); }
     bool hasMarginAfterQuirk() const { return marginAfter().quirk(); }
 
     bool hasBackgroundImage() const { return m_background->background().hasImage(); }
     bool hasFixedBackgroundImage() const { return m_background->background().hasFixedImage(); }
 
@@ skipping 49 matching lines @@
     // Whether or not a positioned element requires normal flow x/y to be computed
     // to determine its position.
     bool hasAutoLeftAndRight() const { return left().isAuto() && right().isAuto(); }
     bool hasAutoTopAndBottom() const { return top().isAuto() && bottom().isAuto(); }
     bool hasStaticInlinePosition() const { return hasAutoLeftAndRight(); }
     bool hasStaticBlockPosition() const { return hasAutoTopAndBottom(); }
 
     EPosition position() const { return static_cast<EPosition>(noninherited_flags.position); }
     bool hasOutOfFlowPosition() const { return position() == AbsolutePosition; }
     bool hasInFlowPosition() const { return position() == RelativePosition; }
-    EFloat floating() const { return static_cast<EFloat>(noninherited_flags.floating); }
 
     const Length& width() const { return m_box->width(); }
     const Length& height() const { return m_box->height(); }
     const Length& minWidth() const { return m_box->minWidth(); }
     const Length& maxWidth() const { return m_box->maxWidth(); }
     const Length& minHeight() const { return m_box->minHeight(); }
     const Length& maxHeight() const { return m_box->maxHeight(); }
 
     const Length& logicalWidth() const { return width(); }
     const Length& logicalHeight() const { return height(); }
@@ skipping 65 matching lines @@
 
     const Length& clipLeft() const { return visual->clip.left(); }
     const Length& clipRight() const { return visual->clip.right(); }
     const Length& clipTop() const { return visual->clip.top(); }
     const Length& clipBottom() const { return visual->clip.bottom(); }
     const LengthBox& clip() const { return visual->clip; }
     bool hasAutoClip() const { return visual->hasAutoClip; }
 
     EUnicodeBidi unicodeBidi() const { return static_cast<EUnicodeBidi>(noninherited_flags.unicodeBidi); }
 
-    EClear clear() const { return static_cast<EClear>(noninherited_flags.clear); }
     ETableLayout tableLayout() const { return static_cast<ETableLayout>(noninherited_flags.tableLayout); }
     bool isFixedTableLayout() const { return tableLayout() == TFIXED && !logicalWidth().isAuto(); }
 
     const Font& font() const;
     const FontMetrics& fontMetrics() const;
     const FontDescription& fontDescription() const;
     float specifiedFontSize() const;
     float computedFontSize() const;
     int fontSize() const;
     FontWeight fontWeight() const;
@@ skipping 327 matching lines @@
     bool willChangeContents() const { return rareNonInheritedData->m_willChange->m_contents; }
     bool willChangeScrollPosition() const { return rareNonInheritedData->m_willChange->m_scrollPosition; }
     bool hasWillChangeCompositingHint() const;
     bool subtreeWillChangeContents() const { return rareInheritedData->m_subtreeWillChangeContents; }
 
 // attribute setter methods
 
     void setDisplay(EDisplay v) { noninherited_flags.effectiveDisplay = v; }
     void setOriginalDisplay(EDisplay v) { noninherited_flags.originalDisplay = v; }
     void setPosition(EPosition v) { noninherited_flags.position = v; }
-    void setFloating(EFloat v) { noninherited_flags.floating = v; }
 
     void setLeft(const Length& v) { SET_VAR(surround, offset.m_left, v); }
     void setRight(const Length& v) { SET_VAR(surround, offset.m_right, v); }
     void setTop(const Length& v) { SET_VAR(surround, offset.m_top, v); }
     void setBottom(const Length& v) { SET_VAR(surround, offset.m_bottom, v); }
 
     void setWidth(const Length& v) { SET_VAR(m_box, m_width, v); }
     void setHeight(const Length& v) { SET_VAR(m_box, m_height, v); }
 
     void setLogicalWidth(const Length& v)
@@ skipping 105 matching lines @@
     void setOverflowY(EOverflow v) { noninherited_flags.overflowY = v; }
     void setVisibility(EVisibility v) { inherited_flags._visibility = v; }
     void setVerticalAlign(EVerticalAlign v) { noninherited_flags.verticalAlign = v; }
     void setVerticalAlignLength(const Length& length) { setVerticalAlign(LENGTH); SET_VAR(m_box, m_verticalAlign, length); }
 
     void setHasAutoClip() { SET_VAR(visual, hasAutoClip, true); SET_VAR(visual, clip, RenderStyle::initialClip()); }
     void setClip(const LengthBox& box) { SET_VAR(visual, hasAutoClip, false); SET_VAR(visual, clip, box); }
 
     void setUnicodeBidi(EUnicodeBidi b) { noninherited_flags.unicodeBidi = b; }
 
-    void setClear(EClear v) { noninherited_flags.clear = v; }
     void setTableLayout(ETableLayout v) { noninherited_flags.tableLayout = v; }
 
     bool setFontDescription(const FontDescription&);
     // Only used for blending font sizes when animating and for text autosizing.
     void setFontSize(float);
     void setFontStretch(FontStretch);
     void setFontWeight(FontWeight);
 
     void setColor(const Color&);
     void setTextIndent(const Length& v) { SET_VAR(rareInheritedData, indent, v); }
@@ skipping 309 matching lines @@
 
     bool hasBoxDecorations() const { return hasBorder() || hasBorderRadius() || hasOutline() || boxShadow() || hasFilter(); }
 
     // Initial values for all the properties
     static EBorderCollapse initialBorderCollapse() { return BSEPARATE; }
     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 EClear initialClear() { return CNONE; }
     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 BLOCK; }
     static EEmptyCell initialEmptyCells() { return SHOW; }
-    static EFloat initialFloating() { return NoFloat; }
     static EListStylePosition initialListStylePosition() { return OUTSIDE; }
     static EListStyleType initialListStyleType() { return Disc; }
     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; }
@@ skipping 245 matching lines @@
 
     rareInheritedData.access()->m_textOrientation = textOrientation;
     return true;
 }
 
 float calcBorderRadiiConstraintScaleFor(const FloatRect&, const FloatRoundedRect::Radii&);
 
 } // namespace blink
 
 #endif // RenderStyle_h