Bug 1293604 - Replace NS_STYLE_FLOAT_* with StyleFloat enum class.
MozReview-Commit-ID: 4K6TyIm6cs3
--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -1377,19 +1377,19 @@ nsGenericHTMLElement::MapImageAlignAttri
{
if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Display)) {
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
if (value && value->Type() == nsAttrValue::eEnum) {
int32_t align = value->GetEnumValue();
nsCSSValue* cssFloat = aRuleData->ValueForFloat();
if (cssFloat->GetUnit() == eCSSUnit_Null) {
if (align == NS_STYLE_TEXT_ALIGN_LEFT) {
- cssFloat->SetIntValue(NS_STYLE_FLOAT_LEFT, eCSSUnit_Enumerated);
+ cssFloat->SetIntValue(StyleFloat::Left, eCSSUnit_Enumerated);
} else if (align == NS_STYLE_TEXT_ALIGN_RIGHT) {
- cssFloat->SetIntValue(NS_STYLE_FLOAT_RIGHT, eCSSUnit_Enumerated);
+ cssFloat->SetIntValue(StyleFloat::Right, eCSSUnit_Enumerated);
}
}
nsCSSValue* verticalAlign = aRuleData->ValueForVerticalAlign();
if (verticalAlign->GetUnit() == eCSSUnit_Null) {
switch (align) {
case NS_STYLE_TEXT_ALIGN_LEFT:
case NS_STYLE_TEXT_ALIGN_RIGHT:
break;
--- a/layout/generic/BlockReflowInput.cpp
+++ b/layout/generic/BlockReflowInput.cpp
@@ -774,20 +774,19 @@ BlockReflowInput::FlowAndPlaceFloat(nsIF
"letter frames and orthogonal floats with auto block-size "
"shouldn't break, and if they do now, then they're breaking "
"at the wrong point");
}
// Find a place to place the float. The CSS2 spec doesn't want
// floats overlapping each other or sticking out of the containing
// block if possible (CSS2 spec section 9.5.1, see the rule list).
- uint8_t floatStyle = floatDisplay->PhysicalFloats(wm);
- NS_ASSERTION((NS_STYLE_FLOAT_LEFT == floatStyle) ||
- (NS_STYLE_FLOAT_RIGHT == floatStyle),
- "invalid float type");
+ StyleFloat floatStyle = floatDisplay->PhysicalFloats(wm);
+ MOZ_ASSERT(StyleFloat::Left == floatStyle || StyleFloat::Right == floatStyle,
+ "Invalid float type!");
// Can the float fit here?
bool keepFloatOnSameLine = false;
// Are we required to place at least part of the float because we're
// at the top of the page (to avoid an infinite loop of pushing and
// breaking).
bool mustPlaceFloat =
@@ -871,17 +870,17 @@ BlockReflowInput::FlowAndPlaceFloat(nsIF
// We don't worry about the geometry of the prev in flow, let the continuation
// place and size itself as required.
// Assign inline and block dir coordinates to the float. We don't use
// LineLeft() and LineRight() here, because we would only have to
// convert the result back into this block's writing mode.
LogicalPoint floatPos(wm);
- bool leftFloat = NS_STYLE_FLOAT_LEFT == floatStyle;
+ bool leftFloat = floatStyle == StyleFloat::Left;
if (leftFloat == wm.IsBidiLTR()) {
floatPos.I(wm) = floatAvailableSpace.mRect.IStart(wm);
}
else {
if (!keepFloatOnSameLine) {
floatPos.I(wm) = floatAvailableSpace.mRect.IEnd(wm) - floatMarginISize;
}
@@ -1031,22 +1030,22 @@ BlockReflowInput::FlowAndPlaceFloat(nsIF
void
BlockReflowInput::PushFloatPastBreak(nsIFrame *aFloat)
{
// This ensures that we:
// * don't try to place later but smaller floats (which CSS says
// must have their tops below the top of this float)
// * don't waste much time trying to reflow this float again until
// after the break
- uint8_t floatStyle =
+ StyleFloat floatStyle =
aFloat->StyleDisplay()->PhysicalFloats(mReflowInput.GetWritingMode());
- if (floatStyle == NS_STYLE_FLOAT_LEFT) {
+ if (floatStyle == StyleFloat::Left) {
mFloatManager->SetPushedLeftFloatPastBreak();
} else {
- MOZ_ASSERT(floatStyle == NS_STYLE_FLOAT_RIGHT, "unexpected float value");
+ MOZ_ASSERT(floatStyle == StyleFloat::Right, "Unexpected float value!");
mFloatManager->SetPushedRightFloatPastBreak();
}
// Put the float on the pushed floats list, even though it
// isn't actually a continuation.
DebugOnly<nsresult> rv = mBlock->StealFrame(aFloat);
NS_ASSERTION(NS_SUCCEEDED(rv), "StealFrame should succeed");
AppendPushedFloatChain(aFloat);
--- a/layout/generic/WritingModes.h
+++ b/layout/generic/WritingModes.h
@@ -1996,24 +1996,25 @@ nsStylePosition::MinBSizeDependsOnContai
}
inline bool
nsStylePosition::MaxBSizeDependsOnContainer(mozilla::WritingMode aWM) const
{
return aWM.IsVertical() ? MaxWidthDependsOnContainer()
: MaxHeightDependsOnContainer();
}
-inline uint8_t
+inline mozilla::StyleFloat
nsStyleDisplay::PhysicalFloats(mozilla::WritingMode aWM) const
{
- if (mFloat == NS_STYLE_FLOAT_INLINE_START) {
- return aWM.IsBidiLTR() ? NS_STYLE_FLOAT_LEFT : NS_STYLE_FLOAT_RIGHT;
+ using StyleFloat = mozilla::StyleFloat;
+ if (mFloat == StyleFloat::InlineStart) {
+ return aWM.IsBidiLTR() ? StyleFloat::Left : StyleFloat::Right;
}
- if (mFloat == NS_STYLE_FLOAT_INLINE_END) {
- return aWM.IsBidiLTR() ? NS_STYLE_FLOAT_RIGHT : NS_STYLE_FLOAT_LEFT;
+ if (mFloat == StyleFloat::InlineEnd) {
+ return aWM.IsBidiLTR() ? StyleFloat::Right : StyleFloat::Left;
}
return mFloat;
}
inline uint8_t
nsStyleDisplay::PhysicalBreakType(mozilla::WritingMode aWM) const
{
if (mBreakType == NS_STYLE_CLEAR_INLINE_START) {
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -4250,22 +4250,22 @@ nsBlockFrame::SplitFloat(BlockReflowInpu
} else {
nextInFlow = aState.mPresContext->PresShell()->FrameConstructor()->
CreateContinuingFrame(aState.mPresContext, aFloat, this);
}
if (NS_FRAME_OVERFLOW_IS_INCOMPLETE(aFloatStatus)) {
nextInFlow->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
}
- uint8_t floatStyle =
+ StyleFloat floatStyle =
aFloat->StyleDisplay()->PhysicalFloats(aState.mReflowInput.GetWritingMode());
- if (floatStyle == NS_STYLE_FLOAT_LEFT) {
+ if (floatStyle == StyleFloat::Left) {
aState.mFloatManager->SetSplitLeftFloatAcrossBreak();
} else {
- MOZ_ASSERT(floatStyle == NS_STYLE_FLOAT_RIGHT, "unexpected float side");
+ MOZ_ASSERT(floatStyle == StyleFloat::Right, "Unexpected float side!");
aState.mFloatManager->SetSplitRightFloatAcrossBreak();
}
aState.AppendPushedFloatChain(nextInFlow);
NS_FRAME_SET_OVERFLOW_INCOMPLETE(aState.mReflowStatus);
return NS_OK;
}
--- a/layout/generic/nsFloatManager.cpp
+++ b/layout/generic/nsFloatManager.cpp
@@ -211,18 +211,18 @@ nsFloatManager::GetFlowArea(WritingMode
// This float is in our band.
// Shrink our band's height if needed.
if (floatBEnd < blockEnd && aInfoType == BAND_FROM_POINT) {
blockEnd = floatBEnd;
}
// Shrink our band's width if needed.
- uint8_t floatStyle = fi.mFrame->StyleDisplay()->PhysicalFloats(aWM);
- if (floatStyle == NS_STYLE_FLOAT_LEFT) {
+ StyleFloat floatStyle = fi.mFrame->StyleDisplay()->PhysicalFloats(aWM);
+ if (floatStyle == StyleFloat::Left) {
// A left float
nscoord lineRightEdge = fi.LineRight();
if (lineRightEdge > lineLeft) {
lineLeft = lineRightEdge;
// Only set haveFloats to true if the float is inside our
// containing block. This matches the spec for what some
// callers want and disagrees for other callers, so we should
// probably provide better information at some point.
@@ -270,21 +270,21 @@ nsFloatManager::AddFloat(nsIFrame* aFloa
if (HasAnyFloats()) {
FloatInfo &tail = mFloats[mFloats.Length() - 1];
info.mLeftBEnd = tail.mLeftBEnd;
info.mRightBEnd = tail.mRightBEnd;
} else {
info.mLeftBEnd = nscoord_MIN;
info.mRightBEnd = nscoord_MIN;
}
- uint8_t floatStyle = aFloatFrame->StyleDisplay()->PhysicalFloats(aWM);
- NS_ASSERTION(floatStyle == NS_STYLE_FLOAT_LEFT ||
- floatStyle == NS_STYLE_FLOAT_RIGHT, "unexpected float");
- nscoord& sideBEnd = floatStyle == NS_STYLE_FLOAT_LEFT ? info.mLeftBEnd
- : info.mRightBEnd;
+ StyleFloat floatStyle = aFloatFrame->StyleDisplay()->PhysicalFloats(aWM);
+ MOZ_ASSERT(floatStyle == StyleFloat::Left || floatStyle == StyleFloat::Right,
+ "Unexpected float style!");
+ nscoord& sideBEnd =
+ floatStyle == StyleFloat::Left ? info.mLeftBEnd : info.mRightBEnd;
nscoord thisBEnd = info.BEnd();
if (thisBEnd > sideBEnd)
sideBEnd = thisBEnd;
if (!mFloats.AppendElement(info))
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
@@ -306,18 +306,18 @@ nsFloatManager::CalculateRegionFor(Writi
region.Inflate(aWM, aMargin);
// Don't store rectangles with negative margin-box width or height in
// the float manager; it can't deal with them.
if (region.ISize(aWM) < 0) {
// Preserve the right margin-edge for left floats and the left
// margin-edge for right floats
const nsStyleDisplay* display = aFloat->StyleDisplay();
- uint8_t floatStyle = display->PhysicalFloats(aWM);
- if ((NS_STYLE_FLOAT_LEFT == floatStyle) == aWM.IsBidiLTR()) {
+ StyleFloat floatStyle = display->PhysicalFloats(aWM);
+ if ((StyleFloat::Left == floatStyle) == aWM.IsBidiLTR()) {
region.IStart(aWM) = region.IEnd(aWM);
}
region.ISize(aWM) = 0;
}
if (region.BSize(aWM) < 0) {
region.BSize(aWM) = 0;
}
return region;
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -4491,19 +4491,19 @@ nsIFrame::InlinePrefISizeData::ForceBrea
if (breakType != NS_STYLE_CLEAR_RIGHT) {
floats_cur_left = 0;
}
if (breakType != NS_STYLE_CLEAR_LEFT) {
floats_cur_right = 0;
}
}
- uint8_t floatStyle = floatDisp->PhysicalFloats(mLineContainerWM);
- nscoord& floats_cur = floatStyle == NS_STYLE_FLOAT_LEFT
- ? floats_cur_left : floats_cur_right;
+ StyleFloat floatStyle = floatDisp->PhysicalFloats(mLineContainerWM);
+ nscoord& floats_cur =
+ floatStyle == StyleFloat::Left ? floats_cur_left : floats_cur_right;
nscoord floatWidth = floatInfo.Width();
// Negative-width floats don't change the available space so they
// shouldn't change our intrinsic line width either.
floats_cur =
NSCoordSaturatingAdd(floats_cur, std::max(0, floatWidth));
}
nscoord floats_cur =
--- a/layout/style/nsCSSProps.cpp
+++ b/layout/style/nsCSSProps.cpp
@@ -1474,22 +1474,22 @@ const KTableEntry nsCSSProps::kFlexWrapK
const KTableEntry nsCSSProps::kHyphensKTable[] = {
{ eCSSKeyword_none, NS_STYLE_HYPHENS_NONE },
{ eCSSKeyword_manual, NS_STYLE_HYPHENS_MANUAL },
{ eCSSKeyword_auto, NS_STYLE_HYPHENS_AUTO },
{ eCSSKeyword_UNKNOWN, -1 }
};
KTableEntry nsCSSProps::kFloatKTable[] = {
- { eCSSKeyword_none, NS_STYLE_FLOAT_NONE },
- { eCSSKeyword_left, NS_STYLE_FLOAT_LEFT },
- { eCSSKeyword_right, NS_STYLE_FLOAT_RIGHT },
- { eCSSKeyword_inline_start, NS_STYLE_FLOAT_INLINE_START },
- { eCSSKeyword_inline_end, NS_STYLE_FLOAT_INLINE_END },
- { eCSSKeyword_UNKNOWN, -1 }
+ { eCSSKeyword_none, StyleFloat::None_ },
+ { eCSSKeyword_left, StyleFloat::Left },
+ { eCSSKeyword_right, StyleFloat::Right },
+ { eCSSKeyword_inline_start, StyleFloat::InlineStart },
+ { eCSSKeyword_inline_end, StyleFloat::InlineEnd },
+ { eCSSKeyword_UNKNOWN, -1 }
};
const KTableEntry nsCSSProps::kFloatEdgeKTable[] = {
{ eCSSKeyword_content_box, uint8_t(StyleFloatEdge::ContentBox) },
{ eCSSKeyword_margin_box, uint8_t(StyleFloatEdge::MarginBox) },
{ eCSSKeyword_UNKNOWN, -1 }
};
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -1312,16 +1312,17 @@ struct SetEnumValueHelper
auto value = aValue.GetIntValue(); \
MOZ_ASSERT(value >= static_cast<decltype(value)>(type_::min_) && \
value <= static_cast<decltype(value)>(type_::max_), \
"inappropriate value"); \
aField = static_cast<type_>(value); \
}
DEFINE_ENUM_CLASS_SETTER(StyleBoxSizing, Content, Border)
+ DEFINE_ENUM_CLASS_SETTER(StyleFloat, None_, InlineEnd)
DEFINE_ENUM_CLASS_SETTER(StyleFloatEdge, ContentBox, MarginBox)
DEFINE_ENUM_CLASS_SETTER(StyleUserFocus, None_, SelectMenu)
#undef DEF_SET_ENUMERATED_VALUE
};
template<typename FieldT>
struct SetIntegerValueHelper
@@ -6067,17 +6068,17 @@ nsRuleNode::ComputeDisplayData(void* aSt
/* auto */ NS_STYLE_TOUCH_ACTION_AUTO,
/* none */ NS_STYLE_TOUCH_ACTION_NONE, Unused, Unused);
// float: enum, inherit, initial
SetValue(*aRuleData->ValueForFloat(),
display->mFloat, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mFloat,
- NS_STYLE_FLOAT_NONE);
+ StyleFloat::None_);
// Save mFloat in mOriginalFloat in case we need it later
display->mOriginalFloat = display->mFloat;
// overflow-x: enum, inherit, initial
SetValue(*aRuleData->ValueForOverflowX(),
display->mOverflowX, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mOverflowX,
@@ -6192,25 +6193,25 @@ nsRuleNode::ComputeDisplayData(void* aSt
// property.
conditions.SetUncacheable();
}
if (display->IsAbsolutelyPositionedStyle()) {
// 1) if position is 'absolute' or 'fixed' then display must be
// block-level and float must be 'none'
EnsureBlockDisplay(display->mDisplay);
- display->mFloat = NS_STYLE_FLOAT_NONE;
+ display->mFloat = StyleFloat::None_;
// Note that it's OK to cache this struct in the ruletree
// because it's fine as-is for any style context that points to
// it directly, and any use of it as aStartStruct (e.g. if a
// more specific rule sets "position: static") will use
// mOriginalDisplay and mOriginalFloat, which we have carefully
// not changed.
- } else if (display->mFloat != NS_STYLE_FLOAT_NONE) {
+ } else if (display->mFloat != StyleFloat::None_) {
// 2) if float is not none, and display is not none, then we must
// set a block-level 'display' type per CSS2.1 section 9.7.
EnsureBlockDisplay(display->mDisplay);
// Note that it's OK to cache this struct in the ruletree
// because it's fine as-is for any style context that points to
// it directly, and any use of it as aStartStruct (e.g. if a
// more specific rule sets "float: none") will use
--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -80,16 +80,26 @@ enum class StyleClipPathGeometryBox : ui
Padding,
Border,
Margin,
Fill,
Stroke,
View,
};
+// float
+// https://developer.mozilla.org/en-US/docs/Web/CSS/float
+enum class StyleFloat : uint8_t {
+ None_,
+ Left,
+ Right,
+ InlineStart,
+ InlineEnd
+};
+
// float-edge
enum class StyleFloatEdge : uint8_t {
ContentBox,
MarginBox,
};
// shape-box for shape-outside
enum class StyleShapeOutsideShapeBox : uint8_t {
@@ -579,23 +589,16 @@ enum class FillMode : uint32_t;
// XXX remove in a later patch after updating flexbox code with the new names
#define NS_STYLE_JUSTIFY_CONTENT_FLEX_START NS_STYLE_JUSTIFY_FLEX_START
#define NS_STYLE_JUSTIFY_CONTENT_FLEX_END NS_STYLE_JUSTIFY_FLEX_END
#define NS_STYLE_JUSTIFY_CONTENT_CENTER NS_STYLE_JUSTIFY_CENTER
#define NS_STYLE_JUSTIFY_CONTENT_SPACE_BETWEEN NS_STYLE_JUSTIFY_SPACE_BETWEEN
#define NS_STYLE_JUSTIFY_CONTENT_SPACE_AROUND NS_STYLE_JUSTIFY_SPACE_AROUND
-// See nsStyleDisplay
-#define NS_STYLE_FLOAT_NONE 0
-#define NS_STYLE_FLOAT_LEFT 1
-#define NS_STYLE_FLOAT_RIGHT 2
-#define NS_STYLE_FLOAT_INLINE_START 3
-#define NS_STYLE_FLOAT_INLINE_END 4
-
// See nsStyleFilter
#define NS_STYLE_FILTER_NONE 0
#define NS_STYLE_FILTER_URL 1
#define NS_STYLE_FILTER_BLUR 2
#define NS_STYLE_FILTER_BRIGHTNESS 3
#define NS_STYLE_FILTER_CONTRAST 4
#define NS_STYLE_FILTER_GRAYSCALE 5
#define NS_STYLE_FILTER_INVERT 6
--- a/layout/style/nsStyleStruct.cpp
+++ b/layout/style/nsStyleStruct.cpp
@@ -2972,18 +2972,18 @@ StyleAnimation::operator==(const StyleAn
// nsStyleDisplay
//
nsStyleDisplay::nsStyleDisplay(StyleStructContext aContext)
: mDisplay(NS_STYLE_DISPLAY_INLINE)
, mOriginalDisplay(NS_STYLE_DISPLAY_INLINE)
, mContain(NS_STYLE_CONTAIN_NONE)
, mAppearance(NS_THEME_NONE)
, mPosition(NS_STYLE_POSITION_STATIC)
- , mFloat(NS_STYLE_FLOAT_NONE)
- , mOriginalFloat(NS_STYLE_FLOAT_NONE)
+ , mFloat(StyleFloat::None_)
+ , mOriginalFloat(StyleFloat::None_)
, mBreakType(NS_STYLE_CLEAR_NONE)
, mBreakInside(NS_STYLE_PAGE_BREAK_AUTO)
, mBreakBefore(false)
, mBreakAfter(false)
, mOverflowX(NS_STYLE_OVERFLOW_VISIBLE)
, mOverflowY(NS_STYLE_OVERFLOW_VISIBLE)
, mOverflowClipBox(NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX)
, mResize(NS_STYLE_RESIZE_NONE)
@@ -3098,17 +3098,17 @@ nsChangeHint
nsStyleDisplay::CalcDifference(const nsStyleDisplay& aNewData) const
{
nsChangeHint hint = nsChangeHint(0);
if (!EqualURIs(mBinding, aNewData.mBinding)
|| mPosition != aNewData.mPosition
|| mDisplay != aNewData.mDisplay
|| mContain != aNewData.mContain
- || (mFloat == NS_STYLE_FLOAT_NONE) != (aNewData.mFloat == NS_STYLE_FLOAT_NONE)
+ || (mFloat == StyleFloat::None_) != (aNewData.mFloat == StyleFloat::None_)
|| mOverflowX != aNewData.mOverflowX
|| mOverflowY != aNewData.mOverflowY
|| mScrollBehavior != aNewData.mScrollBehavior
|| mScrollSnapTypeX != aNewData.mScrollSnapTypeX
|| mScrollSnapTypeY != aNewData.mScrollSnapTypeY
|| mScrollSnapPointsX != aNewData.mScrollSnapPointsX
|| mScrollSnapPointsY != aNewData.mScrollSnapPointsY
|| mScrollSnapDestination != aNewData.mScrollSnapDestination
--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -2825,19 +2825,22 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsSt
RefPtr<mozilla::css::URLValue> mBinding; // [reset]
uint8_t mDisplay; // [reset] see nsStyleConsts.h NS_STYLE_DISPLAY_*
uint8_t mOriginalDisplay; // [reset] saved mDisplay for position:absolute/fixed
// and float:left/right; otherwise equal
// to mDisplay
uint8_t mContain; // [reset] see nsStyleConsts.h NS_STYLE_CONTAIN_*
uint8_t mAppearance; // [reset]
uint8_t mPosition; // [reset] see nsStyleConsts.h
- uint8_t mFloat; // [reset] see nsStyleConsts.h NS_STYLE_FLOAT_*
- uint8_t mOriginalFloat; // [reset] saved mFloat for position:absolute/fixed;
- // otherwise equal to mFloat
+
+ // [reset] See StyleFloat in nsStyleConsts.h.
+ mozilla::StyleFloat mFloat;
+ // [reset] Save mFloat for position:absolute/fixed; otherwise equal to mFloat.
+ mozilla::StyleFloat mOriginalFloat;
+
uint8_t mBreakType; // [reset] see nsStyleConsts.h NS_STYLE_CLEAR_*
uint8_t mBreakInside; // [reset] NS_STYLE_PAGE_BREAK_AUTO/AVOID
bool mBreakBefore; // [reset]
bool mBreakAfter; // [reset]
uint8_t mOverflowX; // [reset] see nsStyleConsts.h
uint8_t mOverflowY; // [reset] see nsStyleConsts.h
uint8_t mOverflowClipBox; // [reset] see nsStyleConsts.h
uint8_t mResize; // [reset] see nsStyleConsts.h
@@ -2951,17 +2954,17 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsSt
NS_STYLE_DISPLAY_TABLE_ROW_GROUP == mDisplay ||
NS_STYLE_DISPLAY_TABLE_HEADER_GROUP == mDisplay ||
NS_STYLE_DISPLAY_TABLE_FOOTER_GROUP == mDisplay ||
NS_STYLE_DISPLAY_TABLE_COLUMN == mDisplay ||
NS_STYLE_DISPLAY_TABLE_COLUMN_GROUP == mDisplay;
}
bool IsFloatingStyle() const {
- return NS_STYLE_FLOAT_NONE != mFloat;
+ return mozilla::StyleFloat::None_ != mFloat;
}
bool IsAbsolutelyPositionedStyle() const {
return NS_STYLE_POSITION_ABSOLUTE == mPosition ||
NS_STYLE_POSITION_FIXED == mPosition;
}
bool IsRelativelyPositionedStyle() const {
@@ -3046,17 +3049,17 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsSt
* descendants.
* aContextFrame is the frame for which this is the nsStylePosition.
*/
inline bool IsFixedPosContainingBlock(const nsIFrame* aContextFrame) const;
// Return the 'float' and 'clear' properties, with inline-{start,end} values
// resolved to {left,right} according to the given writing mode. These are
// defined in WritingModes.h.
- inline uint8_t PhysicalFloats(mozilla::WritingMode aWM) const;
+ inline mozilla::StyleFloat PhysicalFloats(mozilla::WritingMode aWM) const;
inline uint8_t PhysicalBreakType(mozilla::WritingMode aWM) const;
};
struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleTable
{
explicit nsStyleTable(StyleStructContext aContext);
nsStyleTable(const nsStyleTable& aOther);
~nsStyleTable();