--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -393,26 +393,26 @@ public:
AbsolutelyPositionDropDown();
}
return NS_OK;
}
nsWeakFrame mFrame;
};
-nsresult
+void
nsComboboxControlFrame::ReflowDropdown(nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState)
{
// All we want out of it later on, really, is the height of a row, so we
// don't even need to cache mDropdownFrame's ascent or anything. If we don't
// need to reflow it, just bail out here.
if (!aReflowState.ShouldReflowAllKids() &&
!NS_SUBTREE_DIRTY(mDropdownFrame)) {
- return NS_OK;
+ return;
}
// XXXbz this will, for small-height dropdowns, have extra space on the right
// edge for the scrollbar we don't show... but that's the best we can do here
// for now.
nsSize availSize(aReflowState.AvailableWidth(), NS_UNCONSTRAINEDSIZE);
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, mDropdownFrame,
availSize);
@@ -439,24 +439,22 @@ nsComboboxControlFrame::ReflowDropdown(n
// dropped down
int32_t flags = NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_VISIBILITY | NS_FRAME_NO_SIZE_VIEW;
if (mDroppedDown) {
flags = 0;
}
nsRect rect = mDropdownFrame->GetRect();
nsHTMLReflowMetrics desiredSize(aReflowState);
nsReflowStatus ignoredStatus;
- nsresult rv = ReflowChild(mDropdownFrame, aPresContext, desiredSize,
- kidReflowState, rect.x, rect.y, flags,
- ignoredStatus);
+ ReflowChild(mDropdownFrame, aPresContext, desiredSize,
+ kidReflowState, rect.x, rect.y, flags, ignoredStatus);
// Set the child's width and height to its desired size
FinishReflowChild(mDropdownFrame, aPresContext, desiredSize,
&kidReflowState, rect.x, rect.y, flags);
- return rv;
}
nsPoint
nsComboboxControlFrame::GetCSSTransformTranslation()
{
nsIFrame* frame = this;
bool is3DTransform = false;
gfxMatrix transform;
@@ -754,17 +752,17 @@ nscoord
nsComboboxControlFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)
{
nscoord prefWidth;
DISPLAY_PREF_WIDTH(this, prefWidth);
prefWidth = GetIntrinsicWidth(aRenderingContext, nsLayoutUtils::PREF_WIDTH);
return prefWidth;
}
-nsresult
+void
nsComboboxControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// Constraints we try to satisfy:
// 1) Default width of button is the vertical scrollbar size
@@ -773,17 +771,17 @@ nsComboboxControlFrame::Reflow(nsPresCon
// 3) Default height of button is height of display area
// 4) Width of display area is whatever is left over from our width after
// allocating width for the button.
// 5) Height of display area is GetHeightOfARow() on the
// mListControlFrame.
if (!mDisplayFrame || !mButtonFrame || !mDropdownFrame) {
NS_ERROR("Why did the frame constructor allow this to happen? Fix it!!");
- return NS_ERROR_UNEXPECTED;
+ return;
}
// Make sure the displayed text is the same as the selected option, bug 297389.
int32_t selectedIndex;
nsAutoString selectedOptionText;
if (!mDroppedDown) {
selectedIndex = mListControlFrame->GetSelectedIndex();
}
@@ -823,19 +821,17 @@ nsComboboxControlFrame::Reflow(nsPresCon
PresContext(), aReflowState.rendContext);
if (buttonWidth > aReflowState.ComputedWidth()) {
buttonWidth = 0;
}
}
mDisplayWidth = aReflowState.ComputedWidth() - buttonWidth;
- nsresult rv = nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState,
- aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
// The button should occupy the same space as a scrollbar
nsRect buttonRect = mButtonFrame->GetRect();
if (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) {
buttonRect.x = aReflowState.ComputedPhysicalBorderPadding().left -
aReflowState.ComputedPhysicalPadding().left;
}
@@ -854,17 +850,16 @@ nsComboboxControlFrame::Reflow(nsPresCon
mButtonFrame->SetRect(buttonRect);
if (!NS_INLINE_IS_BREAK_BEFORE(aStatus) &&
!NS_FRAME_IS_FULLY_COMPLETE(aStatus)) {
// This frame didn't fit inside a fragmentation container. Splitting
// a nsComboboxControlFrame makes no sense, so we override the status here.
aStatus = NS_FRAME_COMPLETE;
}
- return rv;
}
//--------------------------------------------------------------
nsIAtom*
nsComboboxControlFrame::GetType() const
{
return nsGkAtoms::comboboxControlFrame;
@@ -1208,17 +1203,17 @@ public:
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
{
return nsBlockFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplacedContainsBlock));
}
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
@@ -1229,17 +1224,17 @@ protected:
NS_IMPL_FRAMEARENA_HELPERS(nsComboboxDisplayFrame)
nsIAtom*
nsComboboxDisplayFrame::GetType() const
{
return nsGkAtoms::comboboxDisplayFrame;
}
-nsresult
+void
nsComboboxDisplayFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
nsHTMLReflowState state(aReflowState);
if (state.ComputedHeight() == NS_INTRINSICSIZE) {
// Note that the only way we can have a computed height here is if the
--- a/layout/forms/nsComboboxControlFrame.h
+++ b/layout/forms/nsComboboxControlFrame.h
@@ -64,20 +64,20 @@ public:
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
@@ -196,18 +196,18 @@ public:
static bool ToolkitHasNativePopup();
protected:
friend class RedisplayTextEvent;
friend class nsAsyncResize;
friend class nsResizeDropdownAtFinalPosition;
// Utilities
- nsresult ReflowDropdown(nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState);
+ void ReflowDropdown(nsPresContext* aPresContext,
+ const nsHTMLReflowState& aReflowState);
enum DropDownPositionState {
// can't show the dropdown at its current position
eDropDownPositionSuppressed,
// a resize reflow is pending, don't show it yet
eDropDownPositionPendingResize,
// the dropdown has its final size and position and can be displayed here
eDropDownPositionFinal
--- a/layout/forms/nsFieldSetFrame.cpp
+++ b/layout/forms/nsFieldSetFrame.cpp
@@ -334,17 +334,17 @@ nsFieldSetFrame::ComputeSize(nsRendering
nscoord minWidth = GetMinWidth(aRenderingContext);
if (minWidth > result.width)
result.width = minWidth;
return result;
}
-nsresult
+void
nsFieldSetFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -549,17 +549,16 @@ nsFieldSetFrame::Reflow(nsPresContext*
aDesiredSize.mOverflowAreas.UnionWith(ocBounds);
NS_MergeReflowStatusInto(&aStatus, ocStatus);
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);
InvalidateFrame();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsresult
nsFieldSetFrame::AppendFrames(ChildListID aListID,
nsFrameList& aFrameList)
{
MOZ_CRASH("nsFieldSetFrame::AppendFrames not supported");
return NS_ERROR_NOT_IMPLEMENTED;
--- a/layout/forms/nsFieldSetFrame.h
+++ b/layout/forms/nsFieldSetFrame.h
@@ -28,20 +28,20 @@ public:
virtual nscoord GetBaseline() const MOZ_OVERRIDE;
/**
* The area to paint box-shadows around. It's the border rect except
* when there's a <legend> we offset the y-position to the center of it.
*/
virtual nsRect VisualBorderRectRelativeToSelf() const MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
void PaintBorderBackground(nsRenderingContext& aRenderingContext,
nsPoint aPt, const nsRect& aDirtyRect, uint32_t aBGFlags);
--- a/layout/forms/nsFormControlFrame.cpp
+++ b/layout/forms/nsFormControlFrame.cpp
@@ -68,43 +68,38 @@ nsFormControlFrame::GetBaseline() const
NS_ASSERTION(!NS_SUBTREE_DIRTY(this),
"frame must not be dirty");
// Treat radio buttons and checkboxes as having an intrinsic baseline
// at the bottom of the control (use the bottom content edge rather
// than the bottom margin edge).
return mRect.height - GetUsedBorderAndPadding().bottom;
}
-nsresult
+void
nsFormControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFormControlFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (mState & NS_FRAME_FIRST_REFLOW) {
RegUnRegAccessKey(static_cast<nsIFrame*>(this), true);
}
- nsresult rv = nsLeafFrame::Reflow(aPresContext, aDesiredSize, aReflowState,
- aStatus);
- if (NS_FAILED(rv)) {
- return rv;
- }
+ nsLeafFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
if (nsLayoutUtils::FontSizeInflationEnabled(aPresContext)) {
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
aDesiredSize.Width() *= inflation;
aDesiredSize.Height() *= inflation;
aDesiredSize.UnionOverflowAreasWithDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
}
- return NS_OK;
}
nsresult
nsFormControlFrame::RegUnRegAccessKey(nsIFrame * aFrame, bool aDoReg)
{
NS_ENSURE_ARG_POINTER(aFrame);
nsPresContext* presContext = aFrame->PresContext();
--- a/layout/forms/nsFormControlFrame.h
+++ b/layout/forms/nsFormControlFrame.h
@@ -46,20 +46,20 @@ public:
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual nscoord GetBaseline() const MOZ_OVERRIDE;
/**
* Respond to the request to resize and/or reflow
* @see nsIFrame::Reflow
*/
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
// new behavior
virtual void SetFocus(bool aOn = true, bool aRepaint = false) MOZ_OVERRIDE;
// nsIFormControlFrame
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -157,17 +157,17 @@ nsHTMLButtonControlFrame::GetPrefWidth(n
nsIFrame* kid = mFrames.FirstChild();
result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
kid,
nsLayoutUtils::PREF_WIDTH);
result += mRenderer.GetAddedButtonBorderAndPadding().LeftRight();
return result;
}
-nsresult
+void
nsHTMLButtonControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLButtonControlFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -200,17 +200,16 @@ nsHTMLButtonControlFrame::Reflow(nsPresC
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, firstKid);
aStatus = NS_FRAME_COMPLETE;
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize,
aReflowState, aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
// Helper-function that lets us clone the button's reflow state, but with its
// ComputedWidth and ComputedHeight reduced by the amount of renderer-specific
// focus border and padding that we're using. (This lets us provide a more
// appropriate content-box size for descendents' percent sizes to resolve
// against.)
static nsHTMLReflowState
--- a/layout/forms/nsHTMLButtonControlFrame.h
+++ b/layout/forms/nsHTMLButtonControlFrame.h
@@ -29,20 +29,20 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
--- a/layout/forms/nsImageControlFrame.cpp
+++ b/layout/forms/nsImageControlFrame.cpp
@@ -24,17 +24,17 @@ public:
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
@@ -119,17 +119,17 @@ nsImageControlFrame::AccessibleType()
#endif
nsIAtom*
nsImageControlFrame::GetType() const
{
return nsGkAtoms::imageControlFrame;
}
-nsresult
+void
nsImageControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsImageControlFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (!GetPrevInFlow() && (mState & NS_FRAME_FIRST_REFLOW)) {
--- a/layout/forms/nsLegendFrame.cpp
+++ b/layout/forms/nsLegendFrame.cpp
@@ -42,17 +42,17 @@ nsLegendFrame::DestroyFrom(nsIFrame* aDe
nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
nsBlockFrame::DestroyFrom(aDestructRoot);
}
NS_QUERYFRAME_HEAD(nsLegendFrame)
NS_QUERYFRAME_ENTRY(nsLegendFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsBlockFrame)
-nsresult
+void
nsLegendFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsLegendFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (mState & NS_FRAME_FIRST_REFLOW) {
--- a/layout/forms/nsLegendFrame.h
+++ b/layout/forms/nsLegendFrame.h
@@ -12,20 +12,20 @@
class nsLegendFrame : public nsBlockFrame {
public:
NS_DECL_QUERYFRAME_TARGET(nsLegendFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
nsLegendFrame(nsStyleContext* aContext) : nsBlockFrame(aContext) {}
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -324,17 +324,17 @@ nsListControlFrame::GetMinWidth(nsRender
// content. Combobox frames depend on this happening in the dropdown,
// and standalone listboxes are overflow:scroll so they need it too.
result = GetScrolledFrame()->GetMinWidth(aRenderingContext);
result += GetDesiredScrollbarSizes(PresContext(), aRenderingContext).LeftRight();
return result;
}
-nsresult
+void
nsListControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
NS_PRECONDITION(aReflowState.ComputedWidth() != NS_UNCONSTRAINEDSIZE,
"Must have a computed width");
@@ -353,17 +353,18 @@ nsListControlFrame::Reflow(nsPresContext
}
}
if (GetStateBits() & NS_FRAME_FIRST_REFLOW) {
nsFormControlFrame::RegUnRegAccessKey(this, true);
}
if (IsInDropDownMode()) {
- return ReflowAsDropdown(aPresContext, aDesiredSize, aReflowState, aStatus);
+ ReflowAsDropdown(aPresContext, aDesiredSize, aReflowState, aStatus);
+ return;
}
/*
* Due to the fact that our intrinsic height depends on the heights of our
* kids, we end up having to do two-pass reflow, in general -- the first pass
* to find the intrinsic height and a second pass to reflow the scrollframe
* at that height (which will size the scrollbars correctly, etc).
*
@@ -393,19 +394,17 @@ nsListControlFrame::Reflow(nsPresContext
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW) && autoHeight) {
// When not doing an initial reflow, and when the height is auto, start off
// with our computed height set to what we'd expect our height to be.
nscoord computedHeight = CalcIntrinsicHeight(oldHeightOfARow, length);
computedHeight = state.ApplyMinMaxHeight(computedHeight);
state.SetComputedHeight(computedHeight);
}
- nsresult rv = nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize,
- state, aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
if (!mMightNeedSecondPass) {
NS_ASSERTION(!autoHeight || HeightOfARow() == oldHeightOfARow,
"How did our height of a row change if nothing was dirty?");
NS_ASSERTION(!autoHeight ||
!(GetStateBits() & NS_FRAME_FIRST_REFLOW),
"How do we not need a second pass during initial reflow at "
"auto height?");
@@ -421,29 +420,29 @@ nsListControlFrame::Reflow(nsPresContext
if (rowHeight == 0) {
// Just pick something
mNumDisplayRows = 1;
} else {
mNumDisplayRows = std::max(1, state.ComputedHeight() / rowHeight);
}
}
- return rv;
+ return;
}
mMightNeedSecondPass = false;
// Now see whether we need a second pass. If we do, our nsSelectsAreaFrame
// will have suppressed the scrollbar update.
if (!IsScrollbarUpdateSuppressed()) {
// All done. No need to do more reflow.
NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
"Shouldn't be suppressing if the height of a row has not "
"changed!");
- return rv;
+ return;
}
SetSuppressScrollbarUpdate(false);
// Gotta reflow again.
// XXXbz We're just changing the height here; do we need to dirty ourselves
// or anything like that? We might need to, per the letter of the reflow
// protocol, but things seem to work fine without it... Is that just an
@@ -456,20 +455,20 @@ nsListControlFrame::Reflow(nsPresContext
computedHeight = state.ApplyMinMaxHeight(computedHeight);
state.SetComputedHeight(computedHeight);
nsHTMLScrollFrame::WillReflow(aPresContext);
// XXXbz to make the ascent really correct, we should add our
// mComputedPadding.top to it (and subtract it from descent). Need that
// because nsGfxScrollFrame just adds in the border....
- return nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
+ nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
}
-nsresult
+void
nsListControlFrame::ReflowAsDropdown(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
NS_PRECONDITION(aReflowState.ComputedHeight() == NS_UNCONSTRAINEDSIZE,
"We should not have a computed height here!");
@@ -488,41 +487,39 @@ nsListControlFrame::ReflowAsDropdown(nsP
// When not doing an initial reflow, and when the height is auto, start off
// with our computed height set to what we'd expect our height to be.
// Note: At this point, mLastDropdownComputedHeight can be
// NS_UNCONSTRAINEDSIZE in cases when last time we didn't have to constrain
// the height. That's fine; just do the same thing as last time.
state.SetComputedHeight(mLastDropdownComputedHeight);
}
- nsresult rv = nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize,
- state, aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
if (!mMightNeedSecondPass) {
NS_ASSERTION(oldVisibleHeight == GetScrolledFrame()->GetSize().height,
"How did our kid's height change if nothing was dirty?");
NS_ASSERTION(HeightOfARow() == oldHeightOfARow,
"How did our height of a row change if nothing was dirty?");
NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
"Shouldn't be suppressing if we don't need a second pass!");
NS_ASSERTION(!(GetStateBits() & NS_FRAME_FIRST_REFLOW),
"How can we avoid a second pass during first reflow?");
- return rv;
+ return;
}
mMightNeedSecondPass = false;
// Now see whether we need a second pass. If we do, our nsSelectsAreaFrame
// will have suppressed the scrollbar update.
if (!IsScrollbarUpdateSuppressed()) {
// All done. No need to do more reflow.
NS_ASSERTION(!(GetStateBits() & NS_FRAME_FIRST_REFLOW),
"How can we avoid a second pass during first reflow?");
- return rv;
+ return;
}
SetSuppressScrollbarUpdate(false);
nscoord visibleHeight = GetScrolledFrame()->GetSize().height;
nscoord heightOfARow = HeightOfARow();
// Gotta reflow again.
@@ -574,17 +571,17 @@ nsListControlFrame::ReflowAsDropdown(nsP
mDropdownCanGrow = visibleHeight - newHeight >= heightOfARow &&
mNumDisplayRows != kMaxDropDownRows;
}
}
mLastDropdownComputedHeight = state.ComputedHeight();
nsHTMLScrollFrame::WillReflow(aPresContext);
- return nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
+ nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
}
ScrollbarStyles
nsListControlFrame::GetScrollbarStyles() const
{
// We can't express this in the style system yet; when we can, this can go away
// and GetScrollbarStyles can be devirtualized
int32_t verticalStyle = IsInDropDownMode() ? NS_STYLE_OVERFLOW_AUTO
--- a/layout/forms/nsListControlFrame.h
+++ b/layout/forms/nsListControlFrame.h
@@ -63,20 +63,20 @@ public:
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual nsresult SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nsresult DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus) MOZ_OVERRIDE;
@@ -338,20 +338,20 @@ protected:
// Dropped down stuff
void SetComboboxItem(int32_t aIndex);
/**
* Method to reflow ourselves as a dropdown list. This differs from
* reflow as a listbox because the criteria for needing a second
* pass are different. This will be called from Reflow() as needed.
*/
- nsresult ReflowAsDropdown(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus);
+ void ReflowAsDropdown(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus);
// Selection
bool SetOptionsSelectedFromFrame(int32_t aStartIndex,
int32_t aEndIndex,
bool aValue,
bool aClearAll);
bool ToggleOptionSelectedFromFrame(int32_t aIndex);
/**
--- a/layout/forms/nsMeterFrame.cpp
+++ b/layout/forms/nsMeterFrame.cpp
@@ -86,17 +86,18 @@ nsMeterFrame::AppendAnonymousContentTo(n
}
NS_QUERYFRAME_HEAD(nsMeterFrame)
NS_QUERYFRAME_ENTRY(nsMeterFrame)
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
-nsresult nsMeterFrame::Reflow(nsPresContext* aPresContext,
+void
+nsMeterFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsMeterFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_ASSERTION(mBarDiv, "Meter bar div must exist!");
@@ -120,18 +121,16 @@ nsresult nsMeterFrame::Reflow(nsPresCont
aDesiredSize.SetOverflowAreasToDesiredBounds();
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, barFrame);
FinishAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
-
- return NS_OK;
}
void
nsMeterFrame::ReflowBarFrame(nsIFrame* aBarFrame,
nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
--- a/layout/forms/nsMeterFrame.h
+++ b/layout/forms/nsMeterFrame.h
@@ -22,20 +22,20 @@ public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
nsMeterFrame(nsStyleContext* aContext);
virtual ~nsMeterFrame();
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE {
return MakeFrameName(NS_LITERAL_STRING("Meter"), aResult);
}
#endif
virtual bool IsLeaf() const MOZ_OVERRIDE { return true; }
--- a/layout/forms/nsNumberControlFrame.cpp
+++ b/layout/forms/nsNumberControlFrame.cpp
@@ -94,17 +94,17 @@ nsNumberControlFrame::GetPrefWidth(nsRen
nsLayoutUtils::PREF_WIDTH);
} else {
result = 0;
}
return result;
}
-nsresult
+void
nsNumberControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsNumberControlFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -145,20 +145,18 @@ nsNumberControlFrame::Reflow(nsPresConte
// offsets of wrapper frame
nscoord xoffset = aReflowState.ComputedPhysicalBorderPadding().left +
wrapperReflowState.ComputedPhysicalMargin().left;
nscoord yoffset = aReflowState.ComputedPhysicalBorderPadding().top +
wrapperReflowState.ComputedPhysicalMargin().top;
nsReflowStatus childStatus;
- nsresult rv = ReflowChild(outerWrapperFrame, aPresContext,
- wrappersDesiredSize, wrapperReflowState,
- xoffset, yoffset, 0, childStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowChild(outerWrapperFrame, aPresContext, wrappersDesiredSize,
+ wrapperReflowState, xoffset, yoffset, 0, childStatus);
MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(childStatus),
"We gave our child unconstrained height, so it should be complete");
nscoord wrappersMarginBoxHeight = wrappersDesiredSize.Height() +
wrapperReflowState.ComputedPhysicalMargin().TopBottom();
if (contentBoxHeight == NS_INTRINSICSIZE) {
// We are intrinsically sized -- we should shrinkwrap the outer wrapper's
@@ -176,20 +174,18 @@ nsNumberControlFrame::Reflow(nsPresConte
aReflowState.ComputedMaxHeight());
}
// Center child vertically
nscoord extraSpace = contentBoxHeight - wrappersMarginBoxHeight;
yoffset += std::max(0, extraSpace / 2);
// Place the child
- rv = FinishReflowChild(outerWrapperFrame, aPresContext,
- wrappersDesiredSize, &wrapperReflowState,
- xoffset, yoffset, 0);
- NS_ENSURE_SUCCESS(rv, rv);
+ FinishReflowChild(outerWrapperFrame, aPresContext, wrappersDesiredSize,
+ &wrapperReflowState, xoffset, yoffset, 0);
aDesiredSize.SetTopAscent(wrappersDesiredSize.TopAscent() +
outerWrapperFrame->GetPosition().y);
}
aDesiredSize.Width() = contentBoxWidth +
aReflowState.ComputedPhysicalBorderPadding().LeftRight();
aDesiredSize.Height() = contentBoxHeight +
@@ -201,18 +197,16 @@ nsNumberControlFrame::Reflow(nsPresConte
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, outerWrapperFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
-
- return NS_OK;
}
void
nsNumberControlFrame::SyncDisabledState()
{
EventStates eventStates = mContent->AsElement()->State();
if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
mTextField->SetAttr(kNameSpaceID_None, nsGkAtoms::disabled, EmptyString(),
--- a/layout/forms/nsNumberControlFrame.h
+++ b/layout/forms/nsNumberControlFrame.h
@@ -52,20 +52,20 @@ public:
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
virtual nscoord GetMinWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
// nsIAnonymousContentCreator
virtual nsresult CreateAnonymousContent(nsTArray<ContentInfo>& aElements) MOZ_OVERRIDE;
virtual void AppendAnonymousContentTo(nsBaseContentList& aElements,
--- a/layout/forms/nsProgressFrame.cpp
+++ b/layout/forms/nsProgressFrame.cpp
@@ -91,17 +91,18 @@ NS_QUERYFRAME_TAIL_INHERITING(nsContaine
void
nsProgressFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
BuildDisplayListForInline(aBuilder, aDirtyRect, aLists);
}
-nsresult nsProgressFrame::Reflow(nsPresContext* aPresContext,
+void
+nsProgressFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsProgressFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_ASSERTION(mBarDiv, "Progress bar div must exist!");
@@ -125,18 +126,16 @@ nsresult nsProgressFrame::Reflow(nsPresC
aDesiredSize.SetOverflowAreasToDesiredBounds();
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, barFrame);
FinishAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
-
- return NS_OK;
}
void
nsProgressFrame::ReflowBarFrame(nsIFrame* aBarFrame,
nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
--- a/layout/forms/nsProgressFrame.h
+++ b/layout/forms/nsProgressFrame.h
@@ -27,20 +27,20 @@ public:
virtual ~nsProgressFrame();
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE {
return MakeFrameName(NS_LITERAL_STRING("Progress"), aResult);
}
#endif
virtual bool IsLeaf() const MOZ_OVERRIDE { return true; }
--- a/layout/forms/nsRangeFrame.cpp
+++ b/layout/forms/nsRangeFrame.cpp
@@ -260,17 +260,17 @@ nsRangeFrame::BuildDisplayList(nsDisplay
PresContext()->GetTheme()->ThemeDrawsFocusForWidget(disp->mAppearance)) {
return; // the native theme displays its own visual indication of focus
}
aLists.Content()->AppendNewToTop(
new (aBuilder) nsDisplayRangeFocusRing(aBuilder, this));
}
-nsresult
+void
nsRangeFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRangeFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -289,19 +289,17 @@ nsRangeFrame::Reflow(nsPresContext*
if (computedHeight == NS_AUTOHEIGHT) {
computedHeight = 0;
}
aDesiredSize.Width() = aReflowState.ComputedWidth() +
aReflowState.ComputedPhysicalBorderPadding().LeftRight();
aDesiredSize.Height() = computedHeight +
aReflowState.ComputedPhysicalBorderPadding().TopBottom();
- nsresult rv =
- ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowState);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowState);
aDesiredSize.SetOverflowAreasToDesiredBounds();
nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
if (trackFrame) {
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, trackFrame);
}
@@ -315,21 +313,19 @@ nsRangeFrame::Reflow(nsPresContext*
ConsiderChildOverflow(aDesiredSize.mOverflowAreas, thumbFrame);
}
FinishAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
-
- return NS_OK;
}
-nsresult
+void
nsRangeFrame::ReflowAnonymousContent(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState)
{
// The width/height of our content box, which is the available width/height
// for our anonymous content:
nscoord rangeFrameContentBoxWidth = aReflowState.ComputedWidth();
nscoord rangeFrameContentBoxHeight = aReflowState.ComputedHeight();
@@ -365,47 +361,42 @@ nsRangeFrame::ReflowAnonymousContent(nsP
trackReflowState.ComputedHeight() / 2;
// Make relative to our border box instead of our content box:
trackX += aReflowState.ComputedPhysicalBorderPadding().left;
trackY += aReflowState.ComputedPhysicalBorderPadding().top;
nsReflowStatus frameStatus;
nsHTMLReflowMetrics trackDesiredSize(aReflowState);
- nsresult rv = ReflowChild(trackFrame, aPresContext, trackDesiredSize,
- trackReflowState, trackX, trackY, 0, frameStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowChild(trackFrame, aPresContext, trackDesiredSize,
+ trackReflowState, trackX, trackY, 0, frameStatus);
MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
"We gave our child unconstrained height, so it should be complete");
- rv = FinishReflowChild(trackFrame, aPresContext, trackDesiredSize,
- &trackReflowState, trackX, trackY, 0);
- NS_ENSURE_SUCCESS(rv, rv);
+ FinishReflowChild(trackFrame, aPresContext, trackDesiredSize,
+ &trackReflowState, trackX, trackY, 0);
}
nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
if (thumbFrame) { // display:none?
nsHTMLReflowState thumbReflowState(aPresContext, aReflowState, thumbFrame,
nsSize(aReflowState.ComputedWidth(),
NS_UNCONSTRAINEDSIZE));
// Where we position the thumb depends on its size, so we first reflow
// the thumb at {0,0} to obtain its size, then position it afterwards.
nsReflowStatus frameStatus;
nsHTMLReflowMetrics thumbDesiredSize(aReflowState);
- nsresult rv = ReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
- thumbReflowState, 0, 0, 0, frameStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
+ thumbReflowState, 0, 0, 0, frameStatus);
MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
"We gave our child unconstrained height, so it should be complete");
- rv = FinishReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
- &thumbReflowState, 0, 0, 0);
- NS_ENSURE_SUCCESS(rv, rv);
-
+ FinishReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
+ &thumbReflowState, 0, 0, 0);
DoUpdateThumbPosition(thumbFrame, nsSize(aDesiredSize.Width(),
aDesiredSize.Height()));
}
nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
if (rangeProgressFrame) { // display:none?
nsHTMLReflowState progressReflowState(aPresContext, aReflowState,
@@ -414,31 +405,26 @@ nsRangeFrame::ReflowAnonymousContent(nsP
NS_UNCONSTRAINEDSIZE));
// We first reflow the range-progress frame at {0,0} to obtain its
// unadjusted dimensions, then we adjust it to so that the appropriate edge
// ends at the thumb.
nsReflowStatus frameStatus;
nsHTMLReflowMetrics progressDesiredSize(aReflowState);
- nsresult rv = ReflowChild(rangeProgressFrame, aPresContext,
- progressDesiredSize, progressReflowState, 0, 0,
- 0, frameStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowChild(rangeProgressFrame, aPresContext,
+ progressDesiredSize, progressReflowState, 0, 0,
+ 0, frameStatus);
MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
"We gave our child unconstrained height, so it should be complete");
- rv = FinishReflowChild(rangeProgressFrame, aPresContext,
- progressDesiredSize, &progressReflowState, 0, 0, 0);
- NS_ENSURE_SUCCESS(rv, rv);
-
+ FinishReflowChild(rangeProgressFrame, aPresContext,
+ progressDesiredSize, &progressReflowState, 0, 0, 0);
DoUpdateRangeProgressFrame(rangeProgressFrame, nsSize(aDesiredSize.Width(),
aDesiredSize.Height()));
}
-
- return NS_OK;
}
#ifdef ACCESSIBILITY
a11y::AccType
nsRangeFrame::AccessibleType()
{
return a11y::eHTMLRangeType;
}
--- a/layout/forms/nsRangeFrame.h
+++ b/layout/forms/nsRangeFrame.h
@@ -40,20 +40,20 @@ public:
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE {
return MakeFrameName(NS_LITERAL_STRING("Range"), aResult);
}
#endif
virtual bool IsLeaf() const MOZ_OVERRIDE { return true; }
@@ -135,19 +135,19 @@ public:
private:
nsresult MakeAnonymousDiv(Element** aResult,
nsCSSPseudoElements::Type aPseudoType,
nsTArray<ContentInfo>& aElements);
// Helper function which reflows the anonymous div frames.
- nsresult ReflowAnonymousContent(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState);
+ void ReflowAnonymousContent(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState);
void DoUpdateThumbPosition(nsIFrame* aThumbFrame,
const nsSize& aRangeSize);
void DoUpdateRangeProgressFrame(nsIFrame* aProgressFrame,
const nsSize& aRangeSize);
/**
--- a/layout/forms/nsSelectsAreaFrame.cpp
+++ b/layout/forms/nsSelectsAreaFrame.cpp
@@ -146,17 +146,17 @@ nsSelectsAreaFrame::BuildDisplayListInte
// we can't just associate the display item with the list frame,
// because then the list's scrollframe won't clip it (the scrollframe
// only clips contained descendants).
aLists.Outlines()->AppendNewToTop(new (aBuilder)
nsDisplayListFocus(aBuilder, this));
}
}
-nsresult
+void
nsSelectsAreaFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
nsListControlFrame* list = GetEnclosingListFrame(this);
NS_ASSERTION(list,
"Must have an nsListControlFrame! Frame constructor is "
@@ -172,29 +172,25 @@ nsSelectsAreaFrame::Reflow(nsPresContext
// nsBlockFrame::Reflow for some odd reason.
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
oldHeight = GetSize().height;
} else {
oldHeight = NS_UNCONSTRAINEDSIZE;
}
}
- nsresult rv = nsBlockFrame::Reflow(aPresContext, aDesiredSize,
- aReflowState, aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
// Check whether we need to suppress scrollbar updates. We want to do that if
// we're in a possible first pass and our height of a row has changed.
if (list->MightNeedSecondPass()) {
nscoord newHeightOfARow = list->CalcHeightOfARow();
// We'll need a second pass if our height of a row changed. For
// comboboxes, we'll also need it if our height changed. If we're going
// to do a second pass, suppress scrollbar updates for this pass.
if (newHeightOfARow != mHeightOfARow ||
(isInDropdownMode && (oldHeight != aDesiredSize.Height() ||
oldHeight != GetSize().height))) {
mHeightOfARow = newHeightOfARow;
list->SetSuppressScrollbarUpdate(true);
}
}
-
- return rv;
}
--- a/layout/forms/nsSelectsAreaFrame.h
+++ b/layout/forms/nsSelectsAreaFrame.h
@@ -18,20 +18,20 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
void BuildDisplayListInternal(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists);
- virtual nsresult Reflow(nsPresContext* aCX,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aCX,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
nscoord HeightOfARow() const { return mHeightOfARow; }
protected:
nsSelectsAreaFrame(nsStyleContext* aContext) :
nsBlockFrame(aContext),
mHeightOfARow(0)
{}
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -457,17 +457,17 @@ nsTextControlFrame::ComputeAutoSize(nsRe
NS_ASSERTION(inflation != 1.0f || ancestorAutoSize.width == autoSize.width,
"Incorrect size computed by ComputeAutoSize?");
}
#endif
return autoSize;
}
-nsresult
+void
nsTextControlFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTextControlFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -485,20 +485,18 @@ nsTextControlFrame::Reflow(nsPresContext
// computation of the ascent wrt the input height
nscoord lineHeight = aReflowState.ComputedHeight();
float inflation = nsLayoutUtils::FontSizeInflationFor(this);
if (!IsSingleLineTextControl()) {
lineHeight = nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(),
NS_AUTOHEIGHT, inflation);
}
nsRefPtr<nsFontMetrics> fontMet;
- nsresult rv = nsLayoutUtils::GetFontMetricsForFrame(this,
- getter_AddRefs(fontMet),
- inflation);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet),
+ inflation);
// now adjust for our borders and padding
aDesiredSize.SetTopAscent(
nsLayoutUtils::GetCenteredFontBaseline(fontMet, lineHeight)
+ aReflowState.ComputedPhysicalBorderPadding().top);
// overflow handling
aDesiredSize.SetOverflowAreasToDesiredBounds();
// perform reflow on all kids
@@ -508,17 +506,16 @@ nsTextControlFrame::Reflow(nsPresContext
kid = kid->GetNextSibling();
}
// take into account css properties that affect overflow handling
FinishAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
void
nsTextControlFrame::ReflowTextControlChild(nsIFrame* aKid,
nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus,
nsHTMLReflowMetrics& aParentDesiredSize)
--- a/layout/forms/nsTextControlFrame.h
+++ b/layout/forms/nsTextControlFrame.h
@@ -45,20 +45,20 @@ public:
virtual nscoord GetMinWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
virtual nsSize ComputeAutoSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsSize GetMinSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual bool IsCollapsed() MOZ_OVERRIDE;
virtual bool IsLeaf() const MOZ_OVERRIDE;
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
--- a/layout/generic/nsAbsoluteContainingBlock.cpp
+++ b/layout/generic/nsAbsoluteContainingBlock.cpp
@@ -338,17 +338,17 @@ nsAbsoluteContainingBlock::DoMarkFramesD
// XXX Optimize the case where it's a resize reflow and the absolutely
// positioned child has the exact same size and position and skip the
// reflow...
// When bug 154892 is checked in, make sure that when
// mChildListID == kFixedList, the height is unconstrained.
// since we don't allow replicated frames to split.
-nsresult
+void
nsAbsoluteContainingBlock::ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame,
nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
const nsRect& aContainingBlock,
bool aConstrainHeight,
nsIFrame* aKidFrame,
nsReflowStatus& aStatus,
nsOverflowAreas* aOverflowAreas)
@@ -407,17 +407,17 @@ nsAbsoluteContainingBlock::ReflowAbsolut
if (constrainHeight) {
kidReflowState.AvailableHeight() = aReflowState.AvailableHeight() - border.top
- kidReflowState.ComputedPhysicalMargin().top;
if (NS_AUTOOFFSET != kidReflowState.ComputedPhysicalOffsets().top)
kidReflowState.AvailableHeight() -= kidReflowState.ComputedPhysicalOffsets().top;
}
// Do the reflow
- nsresult rv = aKidFrame->Reflow(aPresContext, kidDesiredSize, kidReflowState, aStatus);
+ aKidFrame->Reflow(aPresContext, kidDesiredSize, kidReflowState, aStatus);
// If we're solving for 'left' or 'top', then compute it now that we know the
// width/height
if ((NS_AUTOOFFSET == kidReflowState.ComputedPhysicalOffsets().left) ||
(NS_AUTOOFFSET == kidReflowState.ComputedPhysicalOffsets().top)) {
nscoord aContainingBlockWidth = aContainingBlock.width;
nscoord aContainingBlockHeight = aContainingBlock.height;
@@ -492,11 +492,9 @@ nsAbsoluteContainingBlock::ReflowAbsolut
printf("%p rect=%d,%d,%d,%d\n", static_cast<void*>(aKidFrame),
rect.x, rect.y, rect.width, rect.height);
}
#endif
if (aOverflowAreas) {
aOverflowAreas->UnionWith(kidDesiredSize.mOverflowAreas + rect.TopLeft());
}
-
- return rv;
}
--- a/layout/generic/nsAbsoluteContainingBlock.h
+++ b/layout/generic/nsAbsoluteContainingBlock.h
@@ -112,24 +112,24 @@ protected:
/**
* Returns true if the position of aFrame depends on the position of
* its placeholder or if the position or size of aFrame depends on a
* containing block dimension that changed.
*/
bool FrameDependsOnContainer(nsIFrame* aFrame, bool aCBWidthChanged,
bool aCBHeightChanged);
- nsresult ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame,
- nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState,
- const nsRect& aContainingBlockRect,
- bool aConstrainHeight,
- nsIFrame* aKidFrame,
- nsReflowStatus& aStatus,
- nsOverflowAreas* aOverflowAreas);
+ void ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame,
+ nsPresContext* aPresContext,
+ const nsHTMLReflowState& aReflowState,
+ const nsRect& aContainingBlockRect,
+ bool aConstrainHeight,
+ nsIFrame* aKidFrame,
+ nsReflowStatus& aStatus,
+ nsOverflowAreas* aOverflowAreas);
/**
* Mark our absolute frames dirty.
* @param aMarkAllDirty if true, all will be marked with NS_FRAME_IS_DIRTY.
* Otherwise, the size-dependant ones will be marked with
* NS_FRAME_HAS_DIRTY_CHILDREN.
*/
void DoMarkFramesDirty(bool aMarkAllDirty);
--- a/layout/generic/nsBRFrame.cpp
+++ b/layout/generic/nsBRFrame.cpp
@@ -30,17 +30,17 @@ public:
virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) MOZ_OVERRIDE;
virtual FrameSearchResult PeekOffsetCharacter(bool aForward, int32_t* aOffset,
bool aRespectClusters = true) MOZ_OVERRIDE;
virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace,
bool aIsKeyboardSelect, int32_t* aOffset,
PeekWordState* aState) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void AddInlineMinWidth(nsRenderingContext *aRenderingContext,
InlineMinWidthData *aData) MOZ_OVERRIDE;
virtual void AddInlinePrefWidth(nsRenderingContext *aRenderingContext,
InlinePrefWidthData *aData) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
@@ -72,17 +72,17 @@ NS_NewBRFrame(nsIPresShell* aPresShell,
}
NS_IMPL_FRAMEARENA_HELPERS(BRFrame)
BRFrame::~BRFrame()
{
}
-nsresult
+void
BRFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("BRFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
aMetrics.Height() = 0; // BR frames with height 0 are ignored in quirks
@@ -149,17 +149,16 @@ BRFrame::Reflow(nsPresContext* aPresCont
aStatus = NS_FRAME_COMPLETE;
}
aMetrics.SetOverflowAreasToDesiredBounds();
mAscent = aMetrics.TopAscent();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return NS_OK;
}
/* virtual */ void
BRFrame::AddInlineMinWidth(nsRenderingContext *aRenderingContext,
nsIFrame::InlineMinWidthData *aData)
{
aData->ForceBreak(aRenderingContext);
}
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -928,17 +928,17 @@ CalculateContainingBlockSizeForAbsolutes
aLastRS->ComputedHeight() + aLastRS->ComputedPhysicalPadding().TopBottom() - scrollbars.TopBottom());
}
}
}
return cbSize;
}
-nsresult
+void
nsBlockFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsBlockFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
#ifdef DEBUG
@@ -1004,17 +1004,17 @@ nsBlockFrame::Reflow(nsPresContext*
// OK, some lines may be reflowed. Blow away any saved line cursor
// because we may invalidate the nondecreasing
// overflowArea.VisualOverflow().y/yMost invariant, and we may even
// delete the line with the line cursor.
ClearLineCursor();
if (IsFrameTreeTooDeep(*reflowState, aMetrics, aStatus)) {
- return NS_OK;
+ return;
}
bool topMarginRoot, bottomMarginRoot;
IsMarginRoot(&topMarginRoot, &bottomMarginRoot);
// Cache the consumed height in the block reflow state so that we don't have
// to continually recompute it.
nsBlockReflowState state(*reflowState, aPresContext, this,
@@ -1023,18 +1023,16 @@ nsBlockFrame::Reflow(nsPresContext*
if (GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)
static_cast<nsBlockFrame*>(FirstContinuation())->ResolveBidi();
if (RenumberLists(aPresContext)) {
AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
}
- nsresult rv = NS_OK;
-
// ALWAYS drain overflow. We never want to leave the previnflow's
// overflow lines hanging around; block reflow depends on the
// overflow line lists being cleared out between reflow passes.
DrainOverflowLines();
// Handle paginated overflow (see nsContainerFrame.h)
nsOverflowAreas ocBounds;
nsReflowStatus ocStatus = NS_FRAME_COMPLETE;
@@ -1061,17 +1059,17 @@ nsBlockFrame::Reflow(nsPresContext*
PrepareResizeReflow(state);
}
LazyMarkLinesDirty();
mState &= ~NS_FRAME_FIRST_REFLOW;
// Now reflow...
- rv = ReflowDirtyLines(state);
+ ReflowDirtyLines(state);
// If we have a next-in-flow, and that next-in-flow has pushed floats from
// this frame from a previous iteration of reflow, then we should not return
// a status of NS_FRAME_COMPLETE, since we actually have overflow, it's just
// already been handled.
// NOTE: This really shouldn't happen, since we _should_ pull back our floats
// and reflow them, but just in case it does, this is a safety precaution so
@@ -1083,19 +1081,16 @@ nsBlockFrame::Reflow(nsPresContext*
if (nif->HasPushedFloatsFromPrevContinuation()) {
NS_MergeReflowStatusInto(&state.mReflowStatus, NS_FRAME_NOT_COMPLETE);
}
nif = static_cast<nsBlockFrame*>(nif->GetNextInFlow());
}
}
- NS_ASSERTION(NS_SUCCEEDED(rv), "reflow dirty lines failed");
- if (NS_FAILED(rv)) return rv;
-
NS_MergeReflowStatusInto(&state.mReflowStatus, ocStatus);
NS_MergeReflowStatusInto(&state.mReflowStatus, fcStatus);
// If we end in a BR with clear and affected floats continue,
// we need to continue, too.
if (NS_UNCONSTRAINEDSIZE != reflowState->AvailableHeight() &&
NS_FRAME_IS_COMPLETE(state.mReflowStatus) &&
state.mFloatManager->ClearContinues(FindTrailingClear())) {
@@ -1290,17 +1285,16 @@ nsBlockFrame::Reflow(nsPresContext*
PR_snprintf(buf, sizeof(buf),
": %lld elapsed (%lld per line) (%d lines; %d new lines)",
delta, perLineDelta, numLines, ectc - ctc);
printf("%s\n", buf);
}
#endif
NS_FRAME_SET_TRUNCATION(aStatus, (*reflowState), aMetrics);
- return rv;
}
bool
nsBlockFrame::CheckForCollapsedBottomMarginFromClearanceLine()
{
line_iterator begin = begin_lines();
line_iterator line = end_lines();
@@ -2068,18 +2062,17 @@ nsBlockFrame::ReflowDirtyLines(nsBlockRe
nscoord oldY = line->BStart();
nscoord oldYMost = line->BEnd();
NS_ASSERTION(!willReflowAgain || !line->IsBlock(),
"Don't reflow blocks while willReflowAgain is true, reflow of block abs-pos children depends on this");
// Reflow the dirty line. If it's an incremental reflow, then force
// it to invalidate the dirty area if necessary
- rv = ReflowLine(aState, line, &keepGoing);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowLine(aState, line, &keepGoing);
if (aState.mReflowState.WillReflowAgainForClearance()) {
line->MarkDirty();
willReflowAgain = true;
// Note that once we've entered this state, every line that gets here
// (e.g. because it has floats) gets marked dirty and reflowed again.
// in the next pass. This is important, see above.
}
@@ -2354,18 +2347,17 @@ nsBlockFrame::ReflowDirtyLines(nsBlockRe
if (aState.mPresContext->HasPendingInterrupt()) {
MarkLineDirtyForInterrupt(line);
} else {
// Now reflow it and any lines that it makes during it's reflow
// (we have to loop here because reflowing the line may cause a new
// line to be created; see SplitLine's callers for examples of
// when this happens).
while (line != end_lines()) {
- rv = ReflowLine(aState, line, &keepGoing);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowLine(aState, line, &keepGoing);
if (aState.mReflowState.WillReflowAgainForClearance()) {
line->MarkDirty();
keepGoing = false;
NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
break;
}
@@ -2533,40 +2525,36 @@ nsBlockFrame::DeleteLine(nsBlockReflowSt
}
}
/**
* Reflow a line. The line will either contain a single block frame
* or contain 1 or more inline frames. aKeepReflowGoing indicates
* whether or not the caller should continue to reflow more lines.
*/
-nsresult
+void
nsBlockFrame::ReflowLine(nsBlockReflowState& aState,
line_iterator aLine,
bool* aKeepReflowGoing)
{
- nsresult rv = NS_OK;
-
NS_ABORT_IF_FALSE(aLine->GetChildCount(), "reflowing empty line");
// Setup the line-layout for the new line
aState.mCurrentLine = aLine;
aLine->ClearDirty();
aLine->InvalidateCachedIsEmpty();
aLine->ClearHadFloatPushed();
// Now that we know what kind of line we have, reflow it
if (aLine->IsBlock()) {
- rv = ReflowBlockFrame(aState, aLine, aKeepReflowGoing);
+ ReflowBlockFrame(aState, aLine, aKeepReflowGoing);
} else {
aLine->SetLineWrapped(false);
- rv = ReflowInlineFrames(aState, aLine, aKeepReflowGoing);
- }
-
- return rv;
+ ReflowInlineFrames(aState, aLine, aKeepReflowGoing);
+ }
}
nsIFrame*
nsBlockFrame::PullFrame(nsBlockReflowState& aState,
line_iterator aLine)
{
// First check our remaining lines.
if (end_lines() != aLine.next()) {
@@ -2870,29 +2858,27 @@ nsBlockFrame::ShouldApplyTopMargin(nsBlo
}
// The line being reflowed is "essentially" the first line in the
// block. Therefore its top-margin will be collapsed by the
// generational collapsing logic with its parent (us).
return false;
}
-nsresult
+void
nsBlockFrame::ReflowBlockFrame(nsBlockReflowState& aState,
line_iterator aLine,
bool* aKeepReflowGoing)
{
NS_PRECONDITION(*aKeepReflowGoing, "bad caller");
- nsresult rv = NS_OK;
-
nsIFrame* frame = aLine->mFirstChild;
if (!frame) {
NS_ASSERTION(false, "program error - unexpected empty line");
- return NS_ERROR_NULL_POINTER;
+ return;
}
// Prepare the block reflow engine
const nsStyleDisplay* display = frame->StyleDisplay();
nsBlockReflowContext brc(aState.mPresContext, aState.mReflowState);
uint8_t breakType = display->mBreakType;
if (NS_STYLE_CLEAR_NONE != aState.mFloatBreakType) {
@@ -2943,17 +2929,17 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
treatWithClearance = true;
// Only record the first frame that requires clearance
if (!*aState.mReflowState.mDiscoveredClearance) {
*aState.mReflowState.mDiscoveredClearance = frame;
}
aState.mPrevChild = frame;
// Exactly what we do now is flexible since we'll definitely be
// reflowed.
- return NS_OK;
+ return;
}
}
if (treatWithClearance) {
applyTopMargin = true;
}
nsIFrame* clearanceFrame = nullptr;
nscoord startingY = aState.mY;
@@ -3097,17 +3083,17 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
aState.mPrevBottomMargin = incomingMargin;
*aKeepReflowGoing = false;
if (ShouldAvoidBreakInside(aState.mReflowState)) {
aState.mReflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
} else {
PushLines(aState, aLine.prev());
NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);
}
- return NS_OK;
+ return;
}
// Now put the Y coordinate back to the top of the top-margin +
// clearance, and flow the block.
aState.mY -= topMargin;
availSpace.y -= topMargin;
if (NS_UNCONSTRAINEDSIZE != availSpace.height) {
availSpace.height += topMargin;
@@ -3124,21 +3110,19 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
if (mayNeedRetry) {
blockHtmlRS.mDiscoveredClearance = &clearanceFrame;
aState.mFloatManager->PushState(&floatManagerState);
} else if (!applyTopMargin) {
blockHtmlRS.mDiscoveredClearance = aState.mReflowState.mDiscoveredClearance;
}
nsReflowStatus frameReflowStatus = NS_FRAME_COMPLETE;
- rv = brc.ReflowBlock(availSpace, applyTopMargin, aState.mPrevBottomMargin,
+ brc.ReflowBlock(availSpace, applyTopMargin, aState.mPrevBottomMargin,
clearance, aState.IsAdjacentWithTop(),
aLine.get(), blockHtmlRS, frameReflowStatus, aState);
-
- NS_ENSURE_SUCCESS(rv, rv);
if (mayNeedRetry && clearanceFrame) {
aState.mFloatManager->PopState(&floatManagerState);
aState.mY = startingY;
aState.mPrevBottomMargin = incomingMargin;
continue;
}
@@ -3147,17 +3131,17 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
if (blockHtmlRS.WillReflowAgainForClearance()) {
// If an ancestor of ours is going to reflow for clearance, we
// need to avoid calling PlaceBlock, because it unsets dirty bits
// on the child block (both itself, and through its call to
// nsFrame::DidReflow), and those dirty bits imply dirtiness for
// all of the child block, including the lines it didn't reflow.
NS_ASSERTION(originalPosition == frame->GetPosition(),
"we need to call PositionChildViews");
- return NS_OK;
+ return;
}
#if defined(REFLOW_STATUS_COVERAGE)
RecordReflowStatus(true, frameReflowStatus);
#endif
if (NS_INLINE_IS_BREAK_BEFORE(frameReflowStatus)) {
// None of the child block fits.
@@ -3219,18 +3203,20 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
if (NS_FRAME_IS_NOT_COMPLETE(frameReflowStatus)) {
// If nextFrame used to be an overflow container, make it a normal block
if (!madeContinuation &&
(NS_FRAME_IS_OVERFLOW_CONTAINER & nextFrame->GetStateBits())) {
nsOverflowContinuationTracker::AutoFinish fini(aState.mOverflowTracker, frame);
nsContainerFrame* parent =
static_cast<nsContainerFrame*>(nextFrame->GetParent());
- rv = parent->StealFrame(nextFrame);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsresult rv = parent->StealFrame(nextFrame);
+ if (NS_FAILED(rv)) {
+ return;
+ }
if (parent != this)
ReparentFrame(nextFrame, parent, this);
mFrames.InsertFrame(nullptr, frame, nextFrame);
madeContinuation = true; // needs to be added to mLines
nextFrame->RemoveStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
frameReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;
}
@@ -3286,18 +3272,20 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
else { // frame is complete but its overflow is not complete
// Disconnect the next-in-flow and put it in our overflow tracker
if (!madeContinuation &&
!(NS_FRAME_IS_OVERFLOW_CONTAINER & nextFrame->GetStateBits())) {
// It already exists, but as a normal next-in-flow, so we need
// to dig it out of the child lists.
nsContainerFrame* parent = static_cast<nsContainerFrame*>
(nextFrame->GetParent());
- rv = parent->StealFrame(nextFrame);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsresult rv = parent->StealFrame(nextFrame);
+ if (NS_FAILED(rv)) {
+ return;
+ }
}
else if (madeContinuation) {
mFrames.RemoveFrame(nextFrame);
}
// Put it in our overflow list
aState.mOverflowTracker->Insert(nextFrame, frameReflowStatus);
NS_MergeReflowStatusInto(&aState.mReflowStatus, frameReflowStatus);
@@ -3354,25 +3342,23 @@ nsBlockFrame::ReflowBlockFrame(nsBlockRe
// to correctly decide whether to reposition child views.
if (originalPosition != frame->GetPosition() && !frame->HasView()) {
nsContainerFrame::PositionChildViews(frame);
}
#ifdef DEBUG
VerifyLines(true);
#endif
- return rv;
-}
-
-nsresult
+}
+
+void
nsBlockFrame::ReflowInlineFrames(nsBlockReflowState& aState,
line_iterator aLine,
bool* aKeepReflowGoing)
{
- nsresult rv = NS_OK;
*aKeepReflowGoing = true;
aLine->SetLineIsImpactedByFloat(false);
// Setup initial coordinate system for reflowing the inline frames
// into. Apply a previous block frame's bottom margin first.
if (ShouldApplyTopMargin(aState, aLine)) {
aState.mY += aState.mPrevBottomMargin.get();
@@ -3400,26 +3386,22 @@ nsBlockFrame::ReflowInlineFrames(nsBlock
// no longer makes sense. Now we always allocate on the stack.
nsLineLayout lineLayout(aState.mPresContext,
aState.mReflowState.mFloatManager,
&aState.mReflowState, &aLine);
lineLayout.Init(&aState, aState.mMinLineHeight, aState.mLineNumber);
if (forceBreakInContent) {
lineLayout.ForceBreakAtPosition(forceBreakInContent, forceBreakOffset);
}
- rv = DoReflowInlineFrames(aState, lineLayout, aLine,
- floatAvailableSpace, availableSpaceHeight,
- &floatManagerState, aKeepReflowGoing,
- &lineReflowStatus, allowPullUp);
+ DoReflowInlineFrames(aState, lineLayout, aLine,
+ floatAvailableSpace, availableSpaceHeight,
+ &floatManagerState, aKeepReflowGoing,
+ &lineReflowStatus, allowPullUp);
lineLayout.EndLineReflow();
- if (NS_FAILED(rv)) {
- return rv;
- }
-
if (LINE_REFLOW_REDO_NO_PULL == lineReflowStatus ||
LINE_REFLOW_REDO_MORE_FLOATS == lineReflowStatus ||
LINE_REFLOW_REDO_NEXT_BAND == lineReflowStatus) {
if (lineLayout.NeedsBackup()) {
NS_ASSERTION(!forceBreakInContent, "Backing up twice; this should never be necessary");
// If there is no saved break position, then this will set
// set forceBreakInContent to null and we won't back up, which is
// correct.
@@ -3434,18 +3416,16 @@ nsBlockFrame::ReflowInlineFrames(nsBlock
aState.mBelowCurrentLineFloats.DeleteAll();
}
// Don't allow pullup on a subsequent LINE_REFLOW_REDO_NO_PULL pass
allowPullUp = false;
} while (LINE_REFLOW_REDO_NO_PULL == lineReflowStatus);
} while (LINE_REFLOW_REDO_MORE_FLOATS == lineReflowStatus);
} while (LINE_REFLOW_REDO_NEXT_BAND == lineReflowStatus);
-
- return rv;
}
void
nsBlockFrame::PushTruncatedLine(nsBlockReflowState& aState,
line_iterator aLine,
bool* aKeepReflowGoing)
{
PushLines(aState, aLine.prev());
@@ -3456,17 +3436,17 @@ nsBlockFrame::PushTruncatedLine(nsBlockR
#ifdef DEBUG
static const char* LineReflowStatusNames[] = {
"LINE_REFLOW_OK", "LINE_REFLOW_STOP", "LINE_REFLOW_REDO_NO_PULL",
"LINE_REFLOW_REDO_MORE_FLOATS",
"LINE_REFLOW_REDO_NEXT_BAND", "LINE_REFLOW_TRUNCATED"
};
#endif
-nsresult
+void
nsBlockFrame::DoReflowInlineFrames(nsBlockReflowState& aState,
nsLineLayout& aLineLayout,
line_iterator aLine,
nsFlowAreaRect& aFloatAvailableSpace,
nscoord& aAvailableSpaceHeight,
nsFloatManager::SavedState*
aFloatStateBeforeLine,
bool* aKeepReflowGoing,
@@ -3520,36 +3500,33 @@ nsBlockFrame::DoReflowInlineFrames(nsBlo
(NS_BLOCK_HAS_FIRST_LETTER_STYLE & mState)) {
aLineLayout.SetFirstLetterStyleOK(true);
}
NS_ASSERTION(!((NS_BLOCK_HAS_FIRST_LETTER_CHILD & mState) &&
GetPrevContinuation()),
"first letter child bit should only be on first continuation");
// Reflow the frames that are already on the line first
- nsresult rv = NS_OK;
LineReflowStatus lineReflowStatus = LINE_REFLOW_OK;
int32_t i;
nsIFrame* frame = aLine->mFirstChild;
if (aFloatAvailableSpace.mHasFloats) {
// There is a soft break opportunity at the start of the line, because
// we can always move this line down below float(s).
if (aLineLayout.NotifyOptionalBreakPosition(frame->GetContent(), 0, true, gfxBreakPriority::eNormalBreak)) {
lineReflowStatus = LINE_REFLOW_REDO_NEXT_BAND;
}
}
// need to repeatedly call GetChildCount here, because the child
// count can change during the loop!
for (i = 0; LINE_REFLOW_OK == lineReflowStatus && i < aLine->GetChildCount();
i++, frame = frame->GetNextSibling()) {
- rv = ReflowInlineFrame(aState, aLineLayout, aLine, frame,
- &lineReflowStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowInlineFrame(aState, aLineLayout, aLine, frame, &lineReflowStatus);
if (LINE_REFLOW_OK != lineReflowStatus) {
// It is possible that one or more of next lines are empty
// (because of DeleteNextInFlowChild). If so, delete them now
// in case we are finished.
++aLine;
while ((aLine != end_lines()) && (0 == aLine->GetChildCount())) {
// XXX Is this still necessary now that DeleteNextInFlowChild
// uses DoRemoveFrame?
@@ -3572,19 +3549,17 @@ nsBlockFrame::DoReflowInlineFrames(nsBlo
while (LINE_REFLOW_OK == lineReflowStatus) {
frame = PullFrame(aState, aLine);
if (!frame) {
break;
}
while (LINE_REFLOW_OK == lineReflowStatus) {
int32_t oldCount = aLine->GetChildCount();
- rv = ReflowInlineFrame(aState, aLineLayout, aLine, frame,
- &lineReflowStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowInlineFrame(aState, aLineLayout, aLine, frame, &lineReflowStatus);
if (aLine->GetChildCount() != oldCount) {
// We just created a continuation for aFrame AND its going
// to end up on this line (e.g. :first-letter
// situation). Therefore we have to loop here before trying
// to pull another frame.
frame = frame->GetNextSibling();
}
else {
@@ -3706,59 +3681,57 @@ nsBlockFrame::DoReflowInlineFrames(nsBlo
iter.GetLine()->MarkDirty();
if (iter.GetContainer() != this) {
aState.mReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;
}
}
}
*aLineReflowStatus = lineReflowStatus;
-
- return rv;
}
/**
* Reflow an inline frame. The reflow status is mapped from the frames
* reflow status to the lines reflow status (not to our reflow status).
* The line reflow status is simple: true means keep placing frames
* on the line; false means don't (the line is done). If the line
* has some sort of breaking affect then aLine's break-type will be set
* to something other than NS_STYLE_CLEAR_NONE.
*/
-nsresult
+void
nsBlockFrame::ReflowInlineFrame(nsBlockReflowState& aState,
nsLineLayout& aLineLayout,
line_iterator aLine,
nsIFrame* aFrame,
LineReflowStatus* aLineReflowStatus)
{
- NS_ENSURE_ARG_POINTER(aFrame);
+ if (!aFrame) { // XXX change to MOZ_ASSERT(aFrame)
+ NS_ERROR("why call me?");
+ return;
+ }
*aLineReflowStatus = LINE_REFLOW_OK;
#ifdef NOISY_FIRST_LETTER
ListTag(stdout);
printf(": reflowing ");
nsFrame::ListTag(stdout, aFrame);
printf(" reflowingFirstLetter=%s\n",
aLineLayout.GetFirstLetterStyleOK() ? "on" : "off");
#endif
// Reflow the inline frame
nsReflowStatus frameReflowStatus;
bool pushedFrame;
- nsresult rv = aLineLayout.ReflowFrame(aFrame, frameReflowStatus,
- nullptr, pushedFrame);
- NS_ENSURE_SUCCESS(rv, rv);
+ aLineLayout.ReflowFrame(aFrame, frameReflowStatus, nullptr, pushedFrame);
if (frameReflowStatus & NS_FRAME_REFLOW_NEXTINFLOW) {
aLineLayout.SetDirtyNextLine();
}
- NS_ENSURE_SUCCESS(rv, rv);
#ifdef REALLY_NOISY_REFLOW_CHILD
nsFrame::ListTag(stdout, aFrame);
printf(": status=%x\n", frameReflowStatus);
#endif
#if defined(REFLOW_STATUS_COVERAGE)
RecordReflowStatus(false, frameReflowStatus);
#endif
@@ -3857,18 +3830,16 @@ nsBlockFrame::ReflowInlineFrame(nsBlockR
if ((!(frameReflowStatus & NS_INLINE_BREAK_FIRST_LETTER_COMPLETE) &&
nsGkAtoms::placeholderFrame != aFrame->GetType()) ||
*aLineReflowStatus == LINE_REFLOW_STOP) {
// Split line after the current frame
*aLineReflowStatus = LINE_REFLOW_STOP;
SplitLine(aState, aLineLayout, aLine, aFrame->GetNextSibling(), aLineReflowStatus);
}
}
-
- return NS_OK;
}
bool
nsBlockFrame::CreateContinuationFor(nsBlockReflowState& aState,
nsLineBox* aLine,
nsIFrame* aFrame)
{
nsIFrame* newFrame = nullptr;
@@ -5784,17 +5755,17 @@ nsBlockFrame::ComputeFloatWidth(nsBlockR
aFloat);
nsHTMLReflowState floatRS(aState.mPresContext, aState.mReflowState, aFloat,
availSpace.Size());
return floatRS.ComputedWidth() + floatRS.ComputedPhysicalBorderPadding().LeftRight() +
floatRS.ComputedPhysicalMargin().LeftRight();
}
-nsresult
+void
nsBlockFrame::ReflowFloat(nsBlockReflowState& aState,
const nsRect& aAdjustedAvailableSpace,
nsIFrame* aFloat,
nsMargin& aFloatMargin,
nsMargin& aFloatOffsets,
bool aFloatPushedDown,
nsReflowStatus& aReflowStatus)
{
@@ -5831,38 +5802,37 @@ nsBlockFrame::ReflowFloat(nsBlockReflowS
// Setup a block reflow context to reflow the float.
nsBlockReflowContext brc(aState.mPresContext, aState.mReflowState);
// Reflow the float
bool isAdjacentWithTop = aState.IsAdjacentWithTop();
nsIFrame* clearanceFrame = nullptr;
- nsresult rv;
do {
nsCollapsingMargin margin;
bool mayNeedRetry = false;
floatRS.mDiscoveredClearance = nullptr;
// Only first in flow gets a top margin.
if (!aFloat->GetPrevInFlow()) {
nsBlockReflowContext::ComputeCollapsedTopMargin(floatRS, &margin,
clearanceFrame, &mayNeedRetry);
if (mayNeedRetry && !clearanceFrame) {
floatRS.mDiscoveredClearance = &clearanceFrame;
// We don't need to push the float manager state because the the block has its own
// float manager that will be destroyed and recreated
}
}
- rv = brc.ReflowBlock(aAdjustedAvailableSpace, true, margin,
- 0, isAdjacentWithTop,
- nullptr, floatRS,
- aReflowStatus, aState);
- } while (NS_SUCCEEDED(rv) && clearanceFrame);
+ brc.ReflowBlock(aAdjustedAvailableSpace, true, margin,
+ 0, isAdjacentWithTop,
+ nullptr, floatRS,
+ aReflowStatus, aState);
+ } while (clearanceFrame);
if (!NS_FRAME_IS_FULLY_COMPLETE(aReflowStatus) &&
ShouldAvoidBreakInside(floatRS)) {
aReflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
} else if (NS_FRAME_IS_NOT_COMPLETE(aReflowStatus) &&
(NS_UNCONSTRAINEDSIZE == aAdjustedAvailableSpace.height)) {
// An incomplete reflow status means we should split the float
// if the height is constrained (bug 145305).
@@ -5876,20 +5846,16 @@ nsBlockFrame::ReflowFloat(nsBlockReflowS
if (aFloat->GetType() == nsGkAtoms::letterFrame) {
// We never split floating first letters; an incomplete state for
// such frames simply means that there is more content to be
// reflowed on the line.
if (NS_FRAME_IS_NOT_COMPLETE(aReflowStatus))
aReflowStatus = NS_FRAME_COMPLETE;
}
- if (NS_FAILED(rv)) {
- return rv;
- }
-
// Capture the margin and offsets information for the caller
aFloatMargin = floatRS.ComputedPhysicalMargin(); // float margins don't collapse
aFloatOffsets = floatRS.ComputedPhysicalOffsets();
const nsHTMLReflowMetrics& metrics = brc.GetMetrics();
// Set the rect, make sure the view is properly sized and positioned,
// and tell the frame we're done reflowing it
@@ -5907,18 +5873,16 @@ nsBlockFrame::ReflowFloat(nsBlockReflowS
// Pass floatRS so the frame hierarchy can be used (redoFloatRS has the same hierarchy)
aFloat->DidReflow(aState.mPresContext, &floatRS,
nsDidReflowStatus::FINISHED);
#ifdef NOISY_FLOAT
printf("end ReflowFloat %p, sized to %d,%d\n",
aFloat, metrics.Width(), metrics.Height());
#endif
-
- return NS_OK;
}
uint8_t
nsBlockFrame::FindTrailingClear()
{
// find the break type of the last line
for (nsIFrame* b = this; b; b = b->GetPrevInFlow()) {
nsBlockFrame* block = static_cast<nsBlockFrame*>(b);
--- a/layout/generic/nsBlockFrame.h
+++ b/layout/generic/nsBlockFrame.h
@@ -256,20 +256,20 @@ public:
*/
void ComputeFinalHeight(const nsHTMLReflowState& aReflowState,
nsReflowStatus* aStatus,
nscoord aContentHeight,
const nsMargin& aBorderPadding,
nsHTMLReflowMetrics& aMetrics,
nscoord aConsumed);
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
/**
* Move any frames on our overflow list to the end of our principal list.
* @return true if there were any overflow frames
@@ -589,19 +589,19 @@ protected:
// Methods for line reflow
/**
* Reflow a line.
* @param aState the current reflow state
* @param aLine the line to reflow. can contain a single block frame
* or contain 1 or more inline frames.
* @param aKeepReflowGoing [OUT] indicates whether the caller should continue to reflow more lines
*/
- nsresult ReflowLine(nsBlockReflowState& aState,
- line_iterator aLine,
- bool* aKeepReflowGoing);
+ void ReflowLine(nsBlockReflowState& aState,
+ line_iterator aLine,
+ bool* aKeepReflowGoing);
// Return false if it needs another reflow because of reduced space
// between floats that are next to it (but not next to its top), and
// return true otherwise.
bool PlaceLine(nsBlockReflowState& aState,
nsLineLayout& aLineLayout,
line_iterator aLine,
nsFloatManager::SavedState* aFloatStateBeforeLine,
@@ -634,63 +634,63 @@ protected:
nsLineList::iterator aLineEnd);
//----------------------------------------
// Methods for individual frame reflow
bool ShouldApplyTopMargin(nsBlockReflowState& aState,
nsLineBox* aLine);
- nsresult ReflowBlockFrame(nsBlockReflowState& aState,
- line_iterator aLine,
- bool* aKeepGoing);
+ void ReflowBlockFrame(nsBlockReflowState& aState,
+ line_iterator aLine,
+ bool* aKeepGoing);
- nsresult ReflowInlineFrames(nsBlockReflowState& aState,
- line_iterator aLine,
- bool* aKeepLineGoing);
+ void ReflowInlineFrames(nsBlockReflowState& aState,
+ line_iterator aLine,
+ bool* aKeepLineGoing);
- nsresult DoReflowInlineFrames(nsBlockReflowState& aState,
- nsLineLayout& aLineLayout,
- line_iterator aLine,
- nsFlowAreaRect& aFloatAvailableSpace,
- nscoord& aAvailableSpaceHeight,
- nsFloatManager::SavedState*
- aFloatStateBeforeLine,
- bool* aKeepReflowGoing,
- LineReflowStatus* aLineReflowStatus,
- bool aAllowPullUp);
+ void DoReflowInlineFrames(nsBlockReflowState& aState,
+ nsLineLayout& aLineLayout,
+ line_iterator aLine,
+ nsFlowAreaRect& aFloatAvailableSpace,
+ nscoord& aAvailableSpaceHeight,
+ nsFloatManager::SavedState*
+ aFloatStateBeforeLine,
+ bool* aKeepReflowGoing,
+ LineReflowStatus* aLineReflowStatus,
+ bool aAllowPullUp);
- nsresult ReflowInlineFrame(nsBlockReflowState& aState,
- nsLineLayout& aLineLayout,
- line_iterator aLine,
- nsIFrame* aFrame,
- LineReflowStatus* aLineReflowStatus);
+ void ReflowInlineFrame(nsBlockReflowState& aState,
+ nsLineLayout& aLineLayout,
+ line_iterator aLine,
+ nsIFrame* aFrame,
+ LineReflowStatus* aLineReflowStatus);
// Compute the available width for a float.
nsRect AdjustFloatAvailableSpace(nsBlockReflowState& aState,
const nsRect& aFloatAvailableSpace,
nsIFrame* aFloatFrame);
// Computes the border-box width of the float
nscoord ComputeFloatWidth(nsBlockReflowState& aState,
const nsRect& aFloatAvailableSpace,
nsIFrame* aFloat);
// An incomplete aReflowStatus indicates the float should be split
// but only if the available height is constrained.
// aAdjustedAvailableSpace is the result of calling
// nsBlockFrame::AdjustFloatAvailableSpace.
- nsresult ReflowFloat(nsBlockReflowState& aState,
- const nsRect& aAdjustedAvailableSpace,
- nsIFrame* aFloat,
- nsMargin& aFloatMargin,
- nsMargin& aFloatOffsets,
- // Whether the float's position
- // (aAdjustedAvailableSpace) has been pushed down
- // due to the presence of other floats.
- bool aFloatPushedDown,
- nsReflowStatus& aReflowStatus);
+ void ReflowFloat(nsBlockReflowState& aState,
+ const nsRect& aAdjustedAvailableSpace,
+ nsIFrame* aFloat,
+ nsMargin& aFloatMargin,
+ nsMargin& aFloatOffsets,
+ // Whether the float's position
+ // (aAdjustedAvailableSpace) has been pushed down
+ // due to the presence of other floats.
+ bool aFloatPushedDown,
+ nsReflowStatus& aReflowStatus);
//----------------------------------------
// Methods for pushing/pulling lines/frames
/**
* Create a next-in-flow, if necessary, for aFrame. If a new frame is
* created, place it in aLine if aLine is not null.
* @param aState the block reflow state
--- a/layout/generic/nsBlockReflowContext.cpp
+++ b/layout/generic/nsBlockReflowContext.cpp
@@ -190,28 +190,27 @@ nsBlockReflowContext::ComputeCollapsedTo
#ifdef NOISY_VERTICAL_MARGINS
nsFrame::ListTag(stdout, aRS.frame);
printf(": => %d\n", aMargin->get());
#endif
return dirtiedLine;
}
-nsresult
+void
nsBlockReflowContext::ReflowBlock(const nsRect& aSpace,
bool aApplyTopMargin,
nsCollapsingMargin& aPrevMargin,
nscoord aClearance,
bool aIsAdjacentWithTop,
nsLineBox* aLine,
nsHTMLReflowState& aFrameRS,
nsReflowStatus& aFrameReflowStatus,
nsBlockReflowState& aState)
{
- nsresult rv = NS_OK;
mFrame = aFrameRS.frame;
mSpace = aSpace;
if (!aIsAdjacentWithTop) {
aFrameRS.mFlags.mIsTopOfPage = false; // make sure this is cleared
}
if (aApplyTopMargin) {
@@ -253,17 +252,17 @@ nsBlockReflowContext::ReflowBlock(const
mFrame->WillReflow(mPresContext);
#ifdef DEBUG
mMetrics.Width() = nscoord(0xdeadbeef);
mMetrics.Height() = nscoord(0xdeadbeef);
#endif
mOuterReflowState.mFloatManager->Translate(tx, ty);
- rv = mFrame->Reflow(mPresContext, mMetrics, aFrameRS, aFrameReflowStatus);
+ mFrame->Reflow(mPresContext, mMetrics, aFrameRS, aFrameReflowStatus);
mOuterReflowState.mFloatManager->Translate(-tx, -ty);
#ifdef DEBUG
if (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {
if (CRAZY_SIZE(mMetrics.Width()) || CRAZY_SIZE(mMetrics.Height())) {
printf("nsBlockReflowContext: ");
nsFrame::ListTag(stdout, mFrame);
printf(" metrics=%d,%d!\n", mMetrics.Width(), mMetrics.Height());
@@ -296,18 +295,16 @@ nsBlockReflowContext::ReflowBlock(const
// Floats will eventually be removed via nsBlockFrame::RemoveFloat
// which detaches the placeholder from the float.
nsOverflowContinuationTracker::AutoFinish fini(aState.mOverflowTracker, mFrame);
static_cast<nsContainerFrame*>(kidNextInFlow->GetParent())
->DeleteNextInFlowChild(kidNextInFlow, true);
}
}
}
-
- return rv;
}
/**
* Attempt to place the block frame within the available space. If
* it fits, apply horizontal positioning (CSS 10.3.3), collapse
* margins (CSS2 8.3.1). Also apply relative positioning.
*/
bool
--- a/layout/generic/nsBlockReflowContext.h
+++ b/layout/generic/nsBlockReflowContext.h
@@ -23,25 +23,25 @@ struct nsBlockHorizontalAlign;
* An encapsulation of the state and algorithm for reflowing block frames.
*/
class nsBlockReflowContext {
public:
nsBlockReflowContext(nsPresContext* aPresContext,
const nsHTMLReflowState& aParentRS);
~nsBlockReflowContext() { }
- nsresult ReflowBlock(const nsRect& aSpace,
- bool aApplyTopMargin,
- nsCollapsingMargin& aPrevMargin,
- nscoord aClearance,
- bool aIsAdjacentWithTop,
- nsLineBox* aLine,
- nsHTMLReflowState& aReflowState,
- nsReflowStatus& aReflowStatus,
- nsBlockReflowState& aState);
+ void ReflowBlock(const nsRect& aSpace,
+ bool aApplyTopMargin,
+ nsCollapsingMargin& aPrevMargin,
+ nscoord aClearance,
+ bool aIsAdjacentWithTop,
+ nsLineBox* aLine,
+ nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aReflowStatus,
+ nsBlockReflowState& aState);
bool PlaceBlock(const nsHTMLReflowState& aReflowState,
bool aForceFit,
nsLineBox* aLine,
nsCollapsingMargin& aBottomMarginResult /* out */,
nsOverflowAreas& aOverflowAreas,
nsReflowStatus aReflowStatus,
nscoord aContainerWidth);
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -1648,17 +1648,17 @@ nsBulletFrame::GetDesiredSize(nsPresCont
aMetrics.Width() =
nsLayoutUtils::GetStringWidth(this, aRenderingContext,
text.get(), text.Length());
aMetrics.SetTopAscent(fm->MaxAscent());
break;
}
}
-nsresult
+void
nsBulletFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsBulletFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
@@ -1689,17 +1689,16 @@ nsBulletFrame::Reflow(nsPresContext* aPr
// XXX this is a bit of a hack, we're assuming that no glyphs used for bullets
// overflow their font-boxes. It'll do for now; to fix it for real, we really
// should rewrite all the text-handling code here to use gfxTextRun (bug
// 397294).
aMetrics.SetOverflowAreasToDesiredBounds();
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return NS_OK;
}
/* virtual */ nscoord
nsBulletFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
{
nsHTMLReflowMetrics metrics(GetWritingMode());
DISPLAY_MIN_WIDTH(this, metrics.Width());
GetDesiredSize(PresContext(), aRenderingContext, metrics, 1.0f);
--- a/layout/generic/nsBulletFrame.h
+++ b/layout/generic/nsBulletFrame.h
@@ -60,20 +60,20 @@ public:
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
// nsIHTMLReflow
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aMetrics,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aMetrics,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
// nsBulletFrame
int32_t SetListItemOrdinal(int32_t aNextOrdinal, bool* aChanged,
int32_t aIncrement);
--- a/layout/generic/nsCanvasFrame.cpp
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -448,17 +448,17 @@ nsCanvasFrame::GetPrefWidth(nsRenderingC
DISPLAY_PREF_WIDTH(this, result);
if (mFrames.IsEmpty())
result = 0;
else
result = mFrames.FirstChild()->GetPrefWidth(aRenderingContext);
return result;
}
-nsresult
+void
nsCanvasFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");
@@ -580,17 +580,16 @@ nsCanvasFrame::Reflow(nsPresContext*
aDesiredSize.mOverflowAreas, 0,
aStatus);
}
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);
NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsIAtom*
nsCanvasFrame::GetType() const
{
return nsGkAtoms::canvasFrame;
}
--- a/layout/generic/nsCanvasFrame.h
+++ b/layout/generic/nsCanvasFrame.h
@@ -47,20 +47,20 @@ public:
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
{
return nsContainerFrame::IsFrameOfType(aFlags &
~(nsIFrame::eCanContainOverflowContainers));
}
/** SetHasFocus tells the CanvasFrame to draw with focus ring
* @param aHasFocus true to show focus ring, false to hide it
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -944,17 +944,17 @@ nsColumnSetFrame::FindBestBalanceHeight(
availableContentHeight == NS_UNCONSTRAINEDSIZE,
&aOutMargin, aColData);
}
}
aRunWasFeasible = feasible;
}
-nsresult
+void
nsColumnSetFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// Don't support interruption in columns
nsPresContext::InterruptPreventer noInterrupts(aPresContext);
@@ -1014,18 +1014,16 @@ nsColumnSetFrame::Reflow(nsPresContext*
aDesiredSize.mCarriedOutBottomMargin = carriedOutBottomMargin;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
NS_ASSERTION(NS_FRAME_IS_FULLY_COMPLETE(aStatus) ||
aReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE,
"Column set should be complete if the available height is unconstrained");
-
- return NS_OK;
}
void
nsColumnSetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) {
DisplayBorderBackgroundOutline(aBuilder, aLists);
--- a/layout/generic/nsColumnSetFrame.h
+++ b/layout/generic/nsColumnSetFrame.h
@@ -12,20 +12,20 @@ class nsColumnSetFrame : public nsContai
public:
NS_DECL_FRAMEARENA_HELPERS
nsColumnSetFrame(nsStyleContext* aContext);
virtual nsresult SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -940,49 +940,46 @@ nsContainerFrame::ReflowChild(nsIFrame*
nscoord aX,
nscoord aY,
uint32_t aFlags,
nsReflowStatus& aStatus,
nsOverflowContinuationTracker* aTracker)
{
NS_PRECONDITION(aReflowState.frame == aKidFrame, "bad reflow state");
- nsresult result;
-
// Send the WillReflow() notification, and position the child frame
// and its view if requested
aKidFrame->WillReflow(aPresContext);
if (NS_FRAME_NO_MOVE_FRAME != (aFlags & NS_FRAME_NO_MOVE_FRAME)) {
aKidFrame->SetPosition(nsPoint(aX, aY));
}
if (0 == (aFlags & NS_FRAME_NO_MOVE_VIEW)) {
PositionFrameView(aKidFrame);
}
// Reflow the child frame
- result = aKidFrame->Reflow(aPresContext, aDesiredSize, aReflowState,
- aStatus);
+ aKidFrame->Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
- // If the reflow was successful and the child frame is complete, delete any
- // next-in-flows, but only if the NO_DELETE_NEXT_IN_FLOW flag isn't set.
- if (NS_SUCCEEDED(result) && NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
+ // If the child frame is complete, delete any next-in-flows,
+ // but only if the NO_DELETE_NEXT_IN_FLOW flag isn't set.
+ if (NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
!(aFlags & NS_FRAME_NO_DELETE_NEXT_IN_FLOW_CHILD)) {
nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow();
if (kidNextInFlow) {
// Remove all of the childs next-in-flows. Make sure that we ask
// the right parent to do the removal (it's possible that the
// parent is not this because we are executing pullup code)
nsOverflowContinuationTracker::AutoFinish fini(aTracker, aKidFrame);
static_cast<nsContainerFrame*>(kidNextInFlow->GetParent())
->DeleteNextInFlowChild(kidNextInFlow, true);
}
}
- return result;
+ return NS_OK;
}
/**
* Position the views of |aFrame|'s descendants. A container frame
* should call this method if it moves a frame after |Reflow|.
*/
void
--- a/layout/generic/nsFirstLetterFrame.cpp
+++ b/layout/generic/nsFirstLetterFrame.cpp
@@ -149,17 +149,17 @@ nsFirstLetterFrame::ComputeSize(nsRender
// We're wrapping the text *after* the first letter, so behave like an
// inline frame.
return nsSize(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
}
return nsContainerFrame::ComputeSize(aRenderingContext,
aCBSize, aAvailableWidth, aMargin, aBorder, aPadding, aFlags);
}
-nsresult
+void
nsFirstLetterFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aReflowStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFirstLetterFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aReflowStatus);
nsresult rv = NS_OK;
@@ -251,39 +251,38 @@ nsFirstLetterFrame::Reflow(nsPresContext
}
else {
// Create a continuation for the child frame if it doesn't already
// have one.
if (!IsFloating()) {
nsIFrame* nextInFlow;
rv = CreateNextInFlow(kid, nextInFlow);
if (NS_FAILED(rv)) {
- return rv;
+ return;
}
// And then push it to our overflow list
const nsFrameList& overflow = mFrames.RemoveFramesAfter(kid);
if (overflow.NotEmpty()) {
SetOverflowFrames(overflow);
}
} else if (!kid->GetNextInFlow()) {
// For floating first letter frames (if a continuation wasn't already
// created for us) we need to put the continuation with the rest of the
// text that the first letter frame was made out of.
nsIFrame* continuation;
- rv = CreateContinuationForFloatingParent(aPresContext, kid,
- &continuation, true);
+ CreateContinuationForFloatingParent(aPresContext, kid,
+ &continuation, true);
}
}
}
FinishAndStoreOverflow(&aMetrics);
NS_FRAME_SET_TRUNCATION(aReflowStatus, aReflowState, aMetrics);
- return rv;
}
/* virtual */ bool
nsFirstLetterFrame::CanContinueTextRun() const
{
// We can continue a text run through a first-letter frame.
return true;
}
--- a/layout/generic/nsFirstLetterFrame.h
+++ b/layout/generic/nsFirstLetterFrame.h
@@ -48,20 +48,20 @@ public:
virtual void AddInlineMinWidth(nsRenderingContext *aRenderingContext,
InlineMinWidthData *aData) MOZ_OVERRIDE;
virtual void AddInlinePrefWidth(nsRenderingContext *aRenderingContext,
InlinePrefWidthData *aData) MOZ_OVERRIDE;
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool CanContinueTextRun() const MOZ_OVERRIDE;
virtual nscoord GetBaseline() const MOZ_OVERRIDE;
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
//override of nsFrame method
virtual nsresult GetChildFrameContainingOffset(int32_t inContentOffset,
bool inHint,
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -2983,29 +2983,29 @@ FlexLine::PositionItemsInCrossAxis(nscoo
item->SetCrossPosition(aLineStartPosition +
lineCrossAxisPosnTracker.GetPosition());
// Back out to cross-axis edge of the line.
lineCrossAxisPosnTracker.ResetPosition();
}
}
-nsresult
+void
nsFlexContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFlexContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
PR_LOG(GetFlexContainerLog(), PR_LOG_DEBUG,
("Reflow() for nsFlexContainerFrame %p\n", this));
if (IsFrameTreeTooDeep(aReflowState, aDesiredSize, aStatus)) {
- return NS_OK;
+ return;
}
// We (and our children) can only depend on our ancestor's height if we have
// a percent-height, or if we're positioned and we have "top" and "bottom"
// set and have height:auto. (There are actually other cases, too -- e.g. if
// our parent is itself a vertical flex container and we're flexible -- but
// we'll let our ancestors handle those sorts of cases.)
const nsStylePosition* stylePos = StylePosition();
@@ -3058,22 +3058,20 @@ nsFlexContainerFrame::Reflow(nsPresConte
nsAutoTArray<StrutInfo, 1> struts;
nsresult rv = DoFlexLayout(aPresContext, aDesiredSize, aReflowState, aStatus,
contentBoxMainSize, availableHeightForContent,
struts, axisTracker);
if (NS_SUCCEEDED(rv) && !struts.IsEmpty()) {
// We're restarting flex layout, with new knowledge of collapsed items.
- rv = DoFlexLayout(aPresContext, aDesiredSize, aReflowState, aStatus,
- contentBoxMainSize, availableHeightForContent,
- struts, axisTracker);
+ DoFlexLayout(aPresContext, aDesiredSize, aReflowState, aStatus,
+ contentBoxMainSize, availableHeightForContent,
+ struts, axisTracker);
}
-
- return rv;
}
// RAII class to clean up a list of FlexLines.
// Specifically, this removes each line from the list, deletes all the
// FlexItems in its list, and deletes the FlexLine.
class MOZ_STACK_CLASS AutoFlexLineListClearer
{
public:
--- a/layout/generic/nsFlexContainerFrame.h
+++ b/layout/generic/nsFlexContainerFrame.h
@@ -37,20 +37,20 @@ public:
class FlexboxAxisTracker;
class StrutInfo;
// nsIFrame overrides
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nscoord
GetMinWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
virtual nscoord
GetPrefWidth(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -4359,28 +4359,27 @@ nsFrame::ReflowAbsoluteFrames(nsPresCont
/* virtual */ bool
nsFrame::CanContinueTextRun() const
{
// By default, a frame will *not* allow a text run to be continued
// through it.
return false;
}
-nsresult
+void
nsFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsFrame");
aDesiredSize.Width() = 0;
aDesiredSize.Height() = 0;
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsresult
nsFrame::CharacterDataChanged(CharacterDataChangeInfo* aInfo)
{
NS_NOTREACHED("should only be called for text frames");
return NS_OK;
}
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -313,20 +313,20 @@ public:
* them), whereas a change in its height might not.
* (nsHTMLReflowState::ShouldReflowAllKids may be helpful in deciding whether
* to reflow all the children, but for some frame types it might result in
* over-reflow.)
*
* Note: if it's only the overflow rect(s) of a frame that need to be
* updated, then UpdateOverflow should be called instead of Reflow.
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus) MOZ_OVERRIDE;
/**
* NOTE: aStatus is assumed to be already-initialized. The reflow statuses of
* any reflowed absolute children will be merged into aStatus; aside from
* that, this method won't modify aStatus.
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -92,17 +92,17 @@ public:
virtual nsresult GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
bool GetVisibility() { return mVisibility || mVisibilityOverride; }
void SetVisibility(bool aVisibility);
void SetColor(nscolor aColor);
@@ -142,17 +142,17 @@ public:
return MakeFrameName(NS_LITERAL_STRING("FramesetBlank"), aResult);
}
#endif
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
protected:
nsHTMLFramesetBlankFrame(nsStyleContext* aContext) : nsLeafFrame(aContext) {}
virtual ~nsHTMLFramesetBlankFrame();
virtual nscoord GetIntrinsicWidth() MOZ_OVERRIDE;
@@ -834,17 +834,17 @@ nscolor nsHTMLFramesetFrame::GetBorderCo
if (attr->GetColorValue(color)) {
return color;
}
}
}
return GetBorderColor();
}
-nsresult
+void
nsHTMLFramesetFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
nsIPresShell *shell = aPresContext->PresShell();
@@ -888,17 +888,17 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
ourContent->GetRowSpec(&rows, &rowSpecs);
ourContent->GetColSpec(&cols, &colSpecs);
// If the number of cols or rows has changed, the frame for the frameset
// will be re-created.
if (mNumRows != rows || mNumCols != cols) {
aStatus = NS_FRAME_COMPLETE;
mDrag.UnSet();
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
+ return;
}
CalculateRowCol(aPresContext, width, mNumCols, colSpecs, mColSizes);
CalculateRowCol(aPresContext, height, mNumRows, rowSpecs, mRowSizes);
nsAutoArrayPtr<bool> verBordersVis; // vertical borders visibility
nsAutoArrayPtr<nscolor> verBorderColors;
nsAutoArrayPtr<bool> horBordersVis; // horizontal borders visibility
@@ -908,28 +908,24 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
if (firstTime) {
// Check for overflow in memory allocations using mNumCols and mNumRows
// which have a maxium value of NS_MAX_FRAMESET_SPEC_COUNT.
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(bool));
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscolor));
verBordersVis = new bool[mNumCols];
- NS_ENSURE_TRUE(verBordersVis, NS_ERROR_OUT_OF_MEMORY);
verBorderColors = new nscolor[mNumCols];
- NS_ENSURE_TRUE(verBorderColors, NS_ERROR_OUT_OF_MEMORY);
for (int verX = 0; verX < mNumCols; verX++) {
verBordersVis[verX] = false;
verBorderColors[verX] = NO_COLOR;
}
horBordersVis = new bool[mNumRows];
- NS_ENSURE_TRUE(horBordersVis, NS_ERROR_OUT_OF_MEMORY);
horBorderColors = new nscolor[mNumRows];
- NS_ENSURE_TRUE(horBorderColors, NS_ERROR_OUT_OF_MEMORY);
for (int horX = 0; horX < mNumRows; horX++) {
horBordersVis[horX] = false;
horBorderColors[horX] = NO_COLOR;
}
}
// reflow the children
int32_t lastRow = 0;
@@ -1135,17 +1131,16 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
aStatus = NS_FRAME_COMPLETE;
mDrag.UnSet();
aDesiredSize.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsIAtom*
nsHTMLFramesetFrame::GetType() const
{
return nsGkAtoms::frameSetFrame;
}
@@ -1432,32 +1427,31 @@ void nsHTMLFramesetBorderFrame::SetVisib
}
void nsHTMLFramesetBorderFrame::SetColor(nscolor aColor)
{
mColor = aColor;
}
-nsresult
+void
nsHTMLFramesetBorderFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBorderFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
// Override Reflow(), since we don't want to deal with what our
// computed values are.
SizeToAvailSize(aReflowState, aDesiredSize);
aDesiredSize.SetOverflowAreasToDesiredBounds();
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
}
class nsDisplayFramesetBorder : public nsDisplayItem {
public:
nsDisplayFramesetBorder(nsDisplayListBuilder* aBuilder,
nsHTMLFramesetBorderFrame* aFrame)
: nsDisplayItem(aBuilder, aFrame) {
MOZ_COUNT_CTOR(nsDisplayFramesetBorder);
@@ -1640,31 +1634,30 @@ nscoord nsHTMLFramesetBlankFrame::GetInt
}
nscoord nsHTMLFramesetBlankFrame::GetIntrinsicHeight()
{
// No intrinsic height
return 0;
}
-nsresult
+void
nsHTMLFramesetBlankFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLFramesetBlankFrame");
// Override Reflow(), since we don't want to deal with what our
// computed values are.
SizeToAvailSize(aReflowState, aDesiredSize);
aDesiredSize.SetOverflowAreasToDesiredBounds();
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
}
class nsDisplayFramesetBlank : public nsDisplayItem {
public:
nsDisplayFramesetBlank(nsDisplayListBuilder* aBuilder,
nsIFrame* aFrame) :
nsDisplayItem(aBuilder, aFrame) {
MOZ_COUNT_CTOR(nsDisplayFramesetBlank);
--- a/layout/generic/nsFrameSetFrame.h
+++ b/layout/generic/nsFrameSetFrame.h
@@ -93,20 +93,20 @@ public:
virtual nsresult GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
virtual bool IsLeaf() const MOZ_OVERRIDE;
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -281,35 +281,29 @@ GetScrollbarMetrics(nsBoxLayoutState& aS
* greater than the scrollport width
*
* @param aForce if true, then we just assume the layout is consistent.
*/
bool
nsHTMLScrollFrame::TryLayout(ScrollReflowState* aState,
nsHTMLReflowMetrics* aKidMetrics,
bool aAssumeHScroll, bool aAssumeVScroll,
- bool aForce, nsresult* aResult)
+ bool aForce)
{
- *aResult = NS_OK;
-
if ((aState->mStyles.mVertical == NS_STYLE_OVERFLOW_HIDDEN && aAssumeVScroll) ||
(aState->mStyles.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN && aAssumeHScroll)) {
NS_ASSERTION(!aForce, "Shouldn't be forcing a hidden scrollbar to show!");
return false;
}
if (aAssumeVScroll != aState->mReflowedContentsWithVScrollbar ||
(aAssumeHScroll != aState->mReflowedContentsWithHScrollbar &&
ScrolledContentDependsOnHeight(aState))) {
- nsresult rv = ReflowScrolledFrame(aState, aAssumeHScroll, aAssumeVScroll,
- aKidMetrics, false);
- if (NS_FAILED(rv)) {
- *aResult = rv;
- return false;
- }
+ ReflowScrolledFrame(aState, aAssumeHScroll, aAssumeVScroll, aKidMetrics,
+ false);
}
nsSize vScrollbarMinSize(0, 0);
nsSize vScrollbarPrefSize(0, 0);
if (mHelper.mVScrollbarBox) {
GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox,
&vScrollbarMinSize,
aAssumeVScroll ? &vScrollbarPrefSize : nullptr, true);
@@ -389,17 +383,17 @@ nsHTMLScrollFrame::ScrolledContentDepend
// Return true if ReflowScrolledFrame is going to do something different
// based on the presence of a horizontal scrollbar.
return (mHelper.mScrolledFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT) ||
aState->mReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE ||
aState->mReflowState.ComputedMinHeight() > 0 ||
aState->mReflowState.ComputedMaxHeight() != NS_UNCONSTRAINEDSIZE;
}
-nsresult
+void
nsHTMLScrollFrame::ReflowScrolledFrame(ScrollReflowState* aState,
bool aAssumeHScroll,
bool aAssumeVScroll,
nsHTMLReflowMetrics* aMetrics,
bool aFirstPass)
{
// these could be NS_UNCONSTRAINEDSIZE ... std::min arithmetic should
// be OK
@@ -452,19 +446,19 @@ nsHTMLScrollFrame::ReflowScrolledFrame(S
// Temporarily set mHasHorizontalScrollbar/mHasVerticalScrollbar to
// reflect our assumptions while we reflow the child.
bool didHaveHorizontalScrollbar = mHelper.mHasHorizontalScrollbar;
bool didHaveVerticalScrollbar = mHelper.mHasVerticalScrollbar;
mHelper.mHasHorizontalScrollbar = aAssumeHScroll;
mHelper.mHasVerticalScrollbar = aAssumeVScroll;
nsReflowStatus status;
- nsresult rv = ReflowChild(mHelper.mScrolledFrame, presContext, *aMetrics,
- kidReflowState, 0, 0,
- NS_FRAME_NO_MOVE_FRAME, status);
+ ReflowChild(mHelper.mScrolledFrame, presContext, *aMetrics,
+ kidReflowState, 0, 0,
+ NS_FRAME_NO_MOVE_FRAME, status);
mHelper.mHasHorizontalScrollbar = didHaveHorizontalScrollbar;
mHelper.mHasVerticalScrollbar = didHaveVerticalScrollbar;
// Don't resize or position the view (if any) because we're going to resize
// it to the correct size anyway in PlaceScrollArea. Allowing it to
// resize here would size it to the natural height of the frame,
// which will usually be different from the scrollport height;
@@ -492,18 +486,16 @@ nsHTMLScrollFrame::ReflowScrolledFrame(S
if (!contentArea.Contains(childScrollableOverflow)) {
aMetrics->mOverflowAreas.ScrollableOverflow() = childScrollableOverflow;
}
}
aState->mContentsOverflowAreas = aMetrics->mOverflowAreas;
aState->mReflowedContentsWithHScrollbar = aAssumeHScroll;
aState->mReflowedContentsWithVScrollbar = aAssumeVScroll;
-
- return rv;
}
bool
nsHTMLScrollFrame::GuessHScrollbarNeeded(const ScrollReflowState& aState)
{
if (aState.mStyles.mHorizontal != NS_STYLE_OVERFLOW_AUTO)
// no guessing required
return aState.mStyles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL;
@@ -558,24 +550,23 @@ nsHTMLScrollFrame::InInitialReflow() con
// root scrollframe. In that case we want to skip this clause altogether.
// The guess here is that there are lots of overflow:auto divs out there that
// end up auto-sizing so they don't overflow, and that the root basically
// always needs a scrollbar if it did last time we loaded this page (good
// assumption, because our initial reflow is no longer synchronous).
return !mHelper.mIsRoot && (GetStateBits() & NS_FRAME_FIRST_REFLOW);
}
-nsresult
+void
nsHTMLScrollFrame::ReflowContents(ScrollReflowState* aState,
const nsHTMLReflowMetrics& aDesiredSize)
{
nsHTMLReflowMetrics kidDesiredSize(aDesiredSize.GetWritingMode(), aDesiredSize.mFlags);
- nsresult rv = ReflowScrolledFrame(aState, GuessHScrollbarNeeded(*aState),
- GuessVScrollbarNeeded(*aState), &kidDesiredSize, true);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowScrolledFrame(aState, GuessHScrollbarNeeded(*aState),
+ GuessVScrollbarNeeded(*aState), &kidDesiredSize, true);
// There's an important special case ... if the child appears to fit
// in the inside-border rect (but overflows the scrollport), we
// should try laying it out without a vertical scrollbar. It will
// usually fit because making the available-width wider will not
// normally make the child taller. (The only situation I can think
// of is when you have a line containing %-width inline replaced
// elements whose percentages sum to more than 100%, so increasing
@@ -597,53 +588,50 @@ nsHTMLScrollFrame::ReflowContents(Scroll
nsSize insideBorderSize =
ComputeInsideBorderSize(aState,
nsSize(kidDesiredSize.Width(), kidDesiredSize.Height()));
nsRect scrolledRect =
mHelper.GetScrolledRectInternal(kidDesiredSize.ScrollableOverflow(),
insideBorderSize);
if (nsRect(nsPoint(0, 0), insideBorderSize).Contains(scrolledRect)) {
// Let's pretend we had no scrollbars coming in here
- rv = ReflowScrolledFrame(aState, false, false,
- &kidDesiredSize, false);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowScrolledFrame(aState, false, false, &kidDesiredSize, false);
}
}
// Try vertical scrollbar settings that leave the vertical scrollbar unchanged.
// Do this first because changing the vertical scrollbar setting is expensive,
// forcing a reflow always.
// Try leaving the horizontal scrollbar unchanged first. This will be more
// efficient.
if (TryLayout(aState, &kidDesiredSize, aState->mReflowedContentsWithHScrollbar,
- aState->mReflowedContentsWithVScrollbar, false, &rv))
- return NS_OK;
+ aState->mReflowedContentsWithVScrollbar, false))
+ return;
if (TryLayout(aState, &kidDesiredSize, !aState->mReflowedContentsWithHScrollbar,
- aState->mReflowedContentsWithVScrollbar, false, &rv))
- return NS_OK;
+ aState->mReflowedContentsWithVScrollbar, false))
+ return;
// OK, now try toggling the vertical scrollbar. The performance advantage
// of trying the status-quo horizontal scrollbar state
// does not exist here (we'll have to reflow due to the vertical scrollbar
// change), so always try no horizontal scrollbar first.
bool newVScrollbarState = !aState->mReflowedContentsWithVScrollbar;
- if (TryLayout(aState, &kidDesiredSize, false, newVScrollbarState, false, &rv))
- return NS_OK;
- if (TryLayout(aState, &kidDesiredSize, true, newVScrollbarState, false, &rv))
- return NS_OK;
+ if (TryLayout(aState, &kidDesiredSize, false, newVScrollbarState, false))
+ return;
+ if (TryLayout(aState, &kidDesiredSize, true, newVScrollbarState, false))
+ return;
// OK, we're out of ideas. Try again enabling whatever scrollbars we can
// enable and force the layout to stick even if it's inconsistent.
// This just happens sometimes.
TryLayout(aState, &kidDesiredSize,
aState->mStyles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN,
aState->mStyles.mVertical != NS_STYLE_OVERFLOW_HIDDEN,
- true, &rv);
- return rv;
+ true);
}
void
nsHTMLScrollFrame::PlaceScrollArea(const ScrollReflowState& aState,
const nsPoint& aScrollPosition)
{
nsIFrame *scrolledFrame = mHelper.mScrolledFrame;
// Set the x,y of the scrolled frame to the correct value
@@ -748,17 +736,17 @@ GetBrowserRoot(nsIContent* aContent)
frameContent->NodeInfo()->Equals(nsGkAtoms::browser, kNameSpaceID_XUL))
return frameContent;
}
}
return nullptr;
}
-nsresult
+void
nsHTMLScrollFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLScrollFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -802,19 +790,17 @@ nsHTMLScrollFrame::Reflow(nsPresContext*
nsRect oldScrollAreaBounds = mHelper.mScrollPort;
nsRect oldScrolledAreaBounds =
mHelper.mScrolledFrame->GetScrollableOverflowRectRelativeToParent();
nsPoint oldScrollPosition = mHelper.GetScrollPosition();
state.mComputedBorder = aReflowState.ComputedPhysicalBorderPadding() -
aReflowState.ComputedPhysicalPadding();
- nsresult rv = ReflowContents(&state, aDesiredSize);
- if (NS_FAILED(rv))
- return rv;
+ ReflowContents(&state, aDesiredSize);
// Restore the old scroll position, for now, even if that's not valid anymore
// because we changed size. We'll fix it up in a post-reflow callback, because
// our current size may only be temporary (e.g. we're compute XUL desired sizes).
PlaceScrollArea(state, oldScrollPosition);
if (!mHelper.mPostedReflowCallback) {
// Make sure we'll try scrolling to restored position
PresContext()->PresShell()->PostReflowCallback(&mHelper);
@@ -870,17 +856,16 @@ nsHTMLScrollFrame::Reflow(nsPresContext*
if (mHelper.mIsRoot && !oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {
mHelper.PostScrolledAreaEvent();
}
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
mHelper.PostOverflowEvent();
- return rv;
}
////////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG_FRAME_DUMP
nsresult
nsHTMLScrollFrame::GetFrameName(nsAString& aResult) const
--- a/layout/generic/nsGfxScrollFrame.h
+++ b/layout/generic/nsGfxScrollFrame.h
@@ -460,43 +460,43 @@ public:
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {
mHelper.BuildDisplayList(aBuilder, aDirtyRect, aLists);
}
bool TryLayout(ScrollReflowState* aState,
nsHTMLReflowMetrics* aKidMetrics,
bool aAssumeVScroll, bool aAssumeHScroll,
- bool aForce, nsresult* aResult);
+ bool aForce);
bool ScrolledContentDependsOnHeight(ScrollReflowState* aState);
- nsresult ReflowScrolledFrame(ScrollReflowState* aState,
- bool aAssumeHScroll,
- bool aAssumeVScroll,
- nsHTMLReflowMetrics* aMetrics,
- bool aFirstPass);
- nsresult ReflowContents(ScrollReflowState* aState,
- const nsHTMLReflowMetrics& aDesiredSize);
+ void ReflowScrolledFrame(ScrollReflowState* aState,
+ bool aAssumeHScroll,
+ bool aAssumeVScroll,
+ nsHTMLReflowMetrics* aMetrics,
+ bool aFirstPass);
+ void ReflowContents(ScrollReflowState* aState,
+ const nsHTMLReflowMetrics& aDesiredSize);
void PlaceScrollArea(const ScrollReflowState& aState,
const nsPoint& aScrollPosition);
nscoord GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext);
virtual bool GetBorderRadii(const nsSize& aFrameSize, const nsSize& aBorderArea,
int aSkipSides, nscoord aRadii[8]) const MOZ_OVERRIDE {
return mHelper.GetBorderRadii(aFrameSize, aBorderArea, aSkipSides, aRadii);
}
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nsresult GetPadding(nsMargin& aPadding) MOZ_OVERRIDE;
virtual bool IsCollapsed() MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool UpdateOverflow() MOZ_OVERRIDE {
return mHelper.UpdateOverflow();
}
// Because there can be only one child frame, these two function return
// NS_ERROR_FAILURE
virtual nsresult AppendFrames(ChildListID aListID,
--- a/layout/generic/nsHTMLCanvasFrame.cpp
+++ b/layout/generic/nsHTMLCanvasFrame.cpp
@@ -166,17 +166,17 @@ nsHTMLCanvasFrame::ComputeSize(nsRenderi
nsSize intrinsicRatio = GetIntrinsicRatio(); // won't actually be used
return nsLayoutUtils::ComputeSizeWithIntrinsicDimensions(
aRenderingContext, this,
intrinsicSize, intrinsicRatio, aCBSize,
aMargin, aBorder, aPadding);
}
-nsresult
+void
nsHTMLCanvasFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsHTMLCanvasFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
@@ -217,18 +217,16 @@ nsHTMLCanvasFrame::Reflow(nsPresContext*
0, 0, 0, childStatus, nullptr);
FinishReflowChild(childFrame, aPresContext, childDesiredSize,
&childReflowState, 0, 0, 0);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsHTMLCanvasFrame::Reflow: size=%d,%d",
aMetrics.Width(), aMetrics.Height()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
-
- return NS_OK;
}
// FIXME taken from nsImageFrame, but then had splittable frame stuff
// removed. That needs to be fixed.
nsRect
nsHTMLCanvasFrame::GetInnerArea() const
{
nsRect r;
--- a/layout/generic/nsHTMLCanvasFrame.h
+++ b/layout/generic/nsHTMLCanvasFrame.h
@@ -58,20 +58,20 @@ public:
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nsSize GetIntrinsicRatio() MOZ_OVERRIDE;
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
nsRect GetInnerArea() const;
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -1860,20 +1860,20 @@ public:
* Note that the available space can be negative. In this case you
* still must return an accurate desired size. If you're a container
* you must <b>always</b> reflow at least one frame regardless of the
* available space
*
* @param aStatus a return value indicating whether the frame is complete
* and whether the next-in-flow is dirty and needs to be reflowed
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aReflowMetrics,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) = 0;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aReflowMetrics,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) = 0;
/**
* Post-reflow hook. After a frame is reflowed this method will be called
* informing the frame that this reflow process is complete, and telling the
* frame the status returned by the Reflow member function.
*
* This call may be invoked many times, while NS_FRAME_IN_REFLOW is set, before
* it is finally called once with a NS_FRAME_REFLOW_COMPLETE value. When called
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -792,17 +792,17 @@ nsImageFrame::GetIntrinsicSize()
}
/* virtual */ nsSize
nsImageFrame::GetIntrinsicRatio()
{
return mIntrinsicRatio;
}
-nsresult
+void
nsImageFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsImageFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
@@ -895,17 +895,16 @@ nsImageFrame::Reflow(nsPresContext*
mReflowCallbackPosted = true;
shell->PostReflowCallback(this);
}
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsImageFrame::Reflow: size=%d,%d",
aMetrics.Width(), aMetrics.Height()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return NS_OK;
}
bool
nsImageFrame::ReflowFinished()
{
mReflowCallbackPosted = false;
nsLayoutUtils::UpdateImageVisibilityForFrame(this);
--- a/layout/generic/nsImageFrame.h
+++ b/layout/generic/nsImageFrame.h
@@ -76,20 +76,20 @@ public:
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual mozilla::IntrinsicSize GetIntrinsicSize() MOZ_OVERRIDE;
virtual nsSize GetIntrinsicRatio() MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult GetContentForEvent(mozilla::WidgetEvent* aEvent,
nsIContent** aContent) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual nsresult GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor) MOZ_OVERRIDE;
--- a/layout/generic/nsInlineFrame.cpp
+++ b/layout/generic/nsInlineFrame.cpp
@@ -289,29 +289,30 @@ ReparentChildListStyle(nsPresContext* aP
for (nsFrameList::Enumerator e(aFrames); !e.AtEnd(); e.Next()) {
NS_ASSERTION(e.get()->GetParent() == aParentFrame, "Bogus parentage");
restyleManager->ReparentStyleContext(e.get());
nsLayoutUtils::MarkDescendantsDirty(e.get());
}
}
-nsresult
+void
nsInlineFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsInlineFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
if (nullptr == aReflowState.mLineLayout) {
- return NS_ERROR_INVALID_ARG;
+ NS_ERROR("must have non-null aReflowState.mLineLayout");
+ return;
}
if (IsFrameTreeTooDeep(aReflowState, aMetrics, aStatus)) {
- return NS_OK;
+ return;
}
bool lazilySetParentPointer = false;
nsIFrame* lineContainer = aReflowState.mLineLayout->LineContainerFrame();
// Check for an overflow list with our prev-in-flow
nsInlineFrame* prevInFlow = (nsInlineFrame*)GetPrevInFlow();
@@ -384,33 +385,31 @@ nsInlineFrame::Reflow(nsPresContext*
// aReflowState)
InlineReflowState irs;
irs.mPrevFrame = nullptr;
irs.mLineContainer = lineContainer;
irs.mLineLayout = aReflowState.mLineLayout;
irs.mNextInFlow = (nsInlineFrame*) GetNextInFlow();
irs.mSetParentPointer = lazilySetParentPointer;
- nsresult rv;
if (mFrames.IsEmpty()) {
// Try to pull over one frame before starting so that we know
// whether we have an anonymous block or not.
bool complete;
(void) PullOneFrame(aPresContext, irs, &complete);
}
- rv = ReflowFrames(aPresContext, aReflowState, irs, aMetrics, aStatus);
+ ReflowFrames(aPresContext, aReflowState, irs, aMetrics, aStatus);
ReflowAbsoluteFrames(aPresContext, aMetrics, aReflowState, aStatus);
// Note: the line layout code will properly compute our
// overflow-rect state for us.
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return rv;
}
bool
nsInlineFrame::DrainSelfOverflowListInternal(DrainFlags aFlags,
nsIFrame* aLineContainer)
{
AutoFrameListPtr overflowFrames(PresContext(), StealOverflowFrames());
if (overflowFrames) {
@@ -475,24 +474,23 @@ nsInlineFrame::PullOverflowsFromPrevInFl
// Assume that our prev-in-flow has the same line container that we do.
nsContainerFrame::ReparentFrameViewList(*prevOverflowFrames, prevInFlow,
this);
mFrames.InsertFrames(this, nullptr, *prevOverflowFrames);
}
}
}
-nsresult
+void
nsInlineFrame::ReflowFrames(nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
InlineReflowState& irs,
nsHTMLReflowMetrics& aMetrics,
nsReflowStatus& aStatus)
{
- nsresult rv = NS_OK;
aStatus = NS_FRAME_COMPLETE;
nsLineLayout* lineLayout = aReflowState.mLineLayout;
bool inFirstLine = aReflowState.mLineLayout->GetInFirstLine();
RestyleManager* restyleManager = aPresContext->RestyleManager();
WritingMode wm = aReflowState.GetWritingMode();
nscoord startEdge = 0;
const bool boxDecorationBreakClone =
@@ -593,19 +591,18 @@ nsInlineFrame::ReflowFrames(nsPresContex
}
}
}
}
MOZ_ASSERT(frame->GetParent() == this);
if (!done) {
bool reflowingFirstLetter = lineLayout->GetFirstLetterStyleOK();
- rv = ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
- done = NS_FAILED(rv) ||
- NS_INLINE_IS_BREAK(aStatus) ||
+ ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
+ done = NS_INLINE_IS_BREAK(aStatus) ||
(!reflowingFirstLetter && NS_FRAME_IS_NOT_COMPLETE(aStatus));
if (done) {
if (!irs.mSetParentPointer) {
break;
}
// Keep reparenting the remaining siblings, but don't reflow them.
nsFrameList* pushedFrames = GetOverflowFrames();
if (pushedFrames && pushedFrames->FirstChild() == frame) {
@@ -632,19 +629,18 @@ nsInlineFrame::ReflowFrames(nsPresContex
printf("%p pulled up %p\n", this, frame);
#endif
if (nullptr == frame) {
if (!isComplete) {
aStatus = NS_FRAME_NOT_COMPLETE;
}
break;
}
- rv = ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
- if (NS_FAILED(rv) ||
- NS_INLINE_IS_BREAK(aStatus) ||
+ ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
+ if (NS_INLINE_IS_BREAK(aStatus) ||
(!reflowingFirstLetter && NS_FRAME_IS_NOT_COMPLETE(aStatus))) {
break;
}
irs.mPrevFrame = frame;
frame = frame->GetNextSibling();
}
}
@@ -716,60 +712,53 @@ nsInlineFrame::ReflowFrames(nsPresContex
// computed in |nsLineLayout::RelativePositionFrames|.
aMetrics.mOverflowAreas.Clear();
#ifdef NOISY_FINAL_SIZE
ListTag(stdout);
printf(": metrics=%d,%d ascent=%d\n",
aMetrics.Width(), aMetrics.Height(), aMetrics.TopAscent());
#endif
-
- return rv;
}
-nsresult
+void
nsInlineFrame::ReflowInlineFrame(nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
InlineReflowState& irs,
nsIFrame* aFrame,
nsReflowStatus& aStatus)
{
nsLineLayout* lineLayout = aReflowState.mLineLayout;
bool reflowingFirstLetter = lineLayout->GetFirstLetterStyleOK();
bool pushedFrame;
- nsresult rv =
- lineLayout->ReflowFrame(aFrame, aStatus, nullptr, pushedFrame);
+ lineLayout->ReflowFrame(aFrame, aStatus, nullptr, pushedFrame);
- if (NS_FAILED(rv)) {
- return rv;
- }
-
if (NS_INLINE_IS_BREAK_BEFORE(aStatus)) {
if (aFrame != mFrames.FirstChild()) {
// Change break-before status into break-after since we have
// already placed at least one child frame. This preserves the
// break-type so that it can be propagated upward.
aStatus = NS_FRAME_NOT_COMPLETE |
NS_INLINE_BREAK | NS_INLINE_BREAK_AFTER |
(aStatus & NS_INLINE_BREAK_TYPE_MASK);
PushFrames(aPresContext, aFrame, irs.mPrevFrame, irs);
}
else {
// Preserve reflow status when breaking-before our first child
// and propagate it upward without modification.
}
- return NS_OK;
+ return;
}
// Create a next-in-flow if needed.
if (!NS_FRAME_IS_FULLY_COMPLETE(aStatus)) {
nsIFrame* newFrame;
- rv = CreateNextInFlow(aFrame, newFrame);
+ nsresult rv = CreateNextInFlow(aFrame, newFrame);
if (NS_FAILED(rv)) {
- return rv;
+ return;
}
}
if (NS_INLINE_IS_BREAK_AFTER(aStatus)) {
nsIFrame* nextFrame = aFrame->GetNextSibling();
if (nextFrame) {
NS_FRAME_SET_INCOMPLETE(aStatus);
PushFrames(aPresContext, nextFrame, aFrame, irs);
@@ -781,26 +770,25 @@ nsInlineFrame::ReflowInlineFrame(nsPresC
while (nextInFlow) {
if (nextInFlow->mFrames.NotEmpty()) {
NS_FRAME_SET_INCOMPLETE(aStatus);
break;
}
nextInFlow = static_cast<nsInlineFrame*>(nextInFlow->GetNextInFlow());
}
}
- return NS_OK;
+ return;
}
if (!NS_FRAME_IS_FULLY_COMPLETE(aStatus) && !reflowingFirstLetter) {
nsIFrame* nextFrame = aFrame->GetNextSibling();
if (nextFrame) {
PushFrames(aPresContext, nextFrame, aFrame, irs);
}
}
- return NS_OK;
}
nsIFrame*
nsInlineFrame::PullOneFrame(nsPresContext* aPresContext,
InlineReflowState& irs,
bool* aIsComplete)
{
bool isComplete = true;
@@ -1028,24 +1016,24 @@ nsFirstLineFrame::PullOneFrame(nsPresCon
// style-context that we just pulled.
NS_ASSERTION(frame->GetParent() == this, "Incorrect parent?");
aPresContext->RestyleManager()->ReparentStyleContext(frame);
nsLayoutUtils::MarkDescendantsDirty(frame);
}
return frame;
}
-nsresult
+void
nsFirstLineFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
if (nullptr == aReflowState.mLineLayout) {
- return NS_ERROR_INVALID_ARG;
+ return; // XXX does this happen? why?
}
nsIFrame* lineContainer = aReflowState.mLineLayout->LineContainerFrame();
// Check for an overflow list with our prev-in-flow
nsFirstLineFrame* prevInFlow = (nsFirstLineFrame*)GetPrevInFlow();
if (prevInFlow) {
AutoFrameListPtr prevOverflowFrames(aPresContext,
@@ -1069,17 +1057,16 @@ nsFirstLineFrame::Reflow(nsPresContext*
// Set our own reflow state (additional state above and beyond
// aReflowState)
InlineReflowState irs;
irs.mPrevFrame = nullptr;
irs.mLineContainer = lineContainer;
irs.mLineLayout = aReflowState.mLineLayout;
irs.mNextInFlow = (nsInlineFrame*) GetNextInFlow();
- nsresult rv;
bool wasEmpty = mFrames.IsEmpty();
if (wasEmpty) {
// Try to pull over one frame before starting so that we know
// whether we have an anonymous block or not.
bool complete;
PullOneFrame(aPresContext, irs, &complete);
}
@@ -1100,24 +1087,22 @@ nsFirstLineFrame::Reflow(nsPresContext*
irs.mPrevFrame = frame;
}
irs.mPrevFrame = nullptr;
}
NS_ASSERTION(!aReflowState.mLineLayout->GetInFirstLine(),
"Nested first-line frames? BOGUS");
aReflowState.mLineLayout->SetInFirstLine(true);
- rv = ReflowFrames(aPresContext, aReflowState, irs, aMetrics, aStatus);
+ ReflowFrames(aPresContext, aReflowState, irs, aMetrics, aStatus);
aReflowState.mLineLayout->SetInFirstLine(false);
ReflowAbsoluteFrames(aPresContext, aMetrics, aReflowState, aStatus);
// Note: the line layout code will properly compute our overflow state for us
-
- return rv;
}
/* virtual */ void
nsFirstLineFrame::PullOverflowsFromPrevInFlow()
{
nsFirstLineFrame* prevInFlow = static_cast<nsFirstLineFrame*>(GetPrevInFlow());
if (prevInFlow) {
nsPresContext* presContext = PresContext();
--- a/layout/generic/nsInlineFrame.h
+++ b/layout/generic/nsInlineFrame.h
@@ -67,20 +67,20 @@ public:
InlineMinWidthData *aData) MOZ_OVERRIDE;
virtual void AddInlinePrefWidth(nsRenderingContext *aRenderingContext,
InlinePrefWidthData *aData) MOZ_OVERRIDE;
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
virtual nsRect ComputeTightBounds(gfxContext* aContext) const MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool CanContinueTextRun() const MOZ_OVERRIDE;
virtual void PullOverflowsFromPrevInFlow() MOZ_OVERRIDE;
virtual nscoord GetBaseline() const MOZ_OVERRIDE;
virtual bool DrainSelfOverflowList() MOZ_OVERRIDE;
/**
@@ -123,27 +123,27 @@ protected:
mSetParentPointer = false;
}
};
nsInlineFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) {}
virtual int GetLogicalSkipSides(const nsHTMLReflowState* aReflowState = nullptr) const MOZ_OVERRIDE;
- nsresult ReflowFrames(nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState,
- InlineReflowState& rs,
- nsHTMLReflowMetrics& aMetrics,
- nsReflowStatus& aStatus);
+ void ReflowFrames(nsPresContext* aPresContext,
+ const nsHTMLReflowState& aReflowState,
+ InlineReflowState& rs,
+ nsHTMLReflowMetrics& aMetrics,
+ nsReflowStatus& aStatus);
- nsresult ReflowInlineFrame(nsPresContext* aPresContext,
- const nsHTMLReflowState& aReflowState,
- InlineReflowState& rs,
- nsIFrame* aFrame,
- nsReflowStatus& aStatus);
+ void ReflowInlineFrame(nsPresContext* aPresContext,
+ const nsHTMLReflowState& aReflowState,
+ InlineReflowState& rs,
+ nsIFrame* aFrame,
+ nsReflowStatus& aStatus);
/**
* Reparent floats whose placeholders are inline descendants of aFrame from
* whatever block they're currently parented by to aOurBlock.
* @param aReparentSiblings if this is true, we follow aFrame's
* GetNextSibling chain reparenting them all
*/
void ReparentFloatsForInlineChild(nsIFrame* aOurBlock, nsIFrame* aFrame,
@@ -188,20 +188,20 @@ public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewFirstLineFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent, nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void PullOverflowsFromPrevInFlow() MOZ_OVERRIDE;
virtual bool DrainSelfOverflowList() MOZ_OVERRIDE;
protected:
nsFirstLineFrame(nsStyleContext* aContext) : nsInlineFrame(aContext) {}
--- a/layout/generic/nsLeafFrame.cpp
+++ b/layout/generic/nsLeafFrame.cpp
@@ -37,33 +37,32 @@ nsLeafFrame::GetPrefWidth(nsRenderingCon
nsLeafFrame::ComputeAutoSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap)
{
return nsSize(GetIntrinsicWidth(), GetIntrinsicHeight());
}
-nsresult
+void
nsLeafFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsLeafFrame");
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("enter nsLeafFrame::Reflow: aMaxSize=%d,%d",
aReflowState.AvailableWidth(), aReflowState.AvailableHeight()));
NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
DoReflow(aPresContext, aMetrics, aReflowState, aStatus);
FinishAndStoreOverflow(&aMetrics);
- return NS_OK;
}
nsresult
nsLeafFrame::DoReflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
--- a/layout/generic/nsLeafFrame.h
+++ b/layout/generic/nsLeafFrame.h
@@ -46,20 +46,20 @@ public:
nsSize aPadding, bool aShrinkWrap) MOZ_OVERRIDE;
/**
* Reflow our frame. This will use the computed width plus borderpadding for
* the desired width, and use the return value of GetIntrinsicHeight plus
* borderpadding for the desired height. Ascent will be set to the height,
* and descent will be set to 0.
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* This method does most of the work that Reflow() above need done.
*/
virtual nsresult DoReflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -834,22 +834,18 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra
int32_t savedOptionalBreakOffset;
gfxBreakPriority savedOptionalBreakPriority;
nsIContent* savedOptionalBreakContent =
GetLastOptionalBreakPosition(&savedOptionalBreakOffset,
&savedOptionalBreakPriority);
if (!isText) {
- nsresult rv = aFrame->Reflow(mPresContext, metrics, reflowStateHolder.ref(),
- aReflowStatus);
- if (NS_FAILED(rv)) {
- NS_WARNING( "Reflow of frame failed in nsLineLayout" );
- return rv;
- }
+ aFrame->Reflow(mPresContext, metrics, reflowStateHolder.ref(),
+ aReflowStatus);
} else {
static_cast<nsTextFrame*>(aFrame)->
ReflowText(*this, availableSpaceOnLine, psd->mReflowState->rendContext,
metrics, aReflowStatus);
}
pfd->mJustificationNumSpaces = mTextJustificationNumSpaces;
pfd->mJustificationNumLetters = mTextJustificationNumLetters;
--- a/layout/generic/nsObjectFrame.cpp
+++ b/layout/generic/nsObjectFrame.cpp
@@ -492,17 +492,17 @@ nsObjectFrame::GetDesiredSize(nsPresCont
// XXXbz don't add in the border and padding, because we screw up our
// plugin's size and positioning if we do... Eventually we _do_ want to
// paint borders, though! At that point, we will need to adjust the desired
// size either here or in Reflow.... Further, we will need to fix Paint() to
// call the superclass in all cases.
}
-nsresult
+void
nsObjectFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsObjectFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
@@ -511,23 +511,23 @@ nsObjectFrame::Reflow(nsPresContext*
aMetrics.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aMetrics);
// delay plugin instantiation until all children have
// arrived. Otherwise there may be PARAMs or other stuff that the
// plugin needs to see that haven't arrived yet.
if (!GetContent()->IsDoneAddingChildren()) {
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
+ return;
}
// if we are printing or print previewing, bail for now
if (aPresContext->Medium() == nsGkAtoms::print) {
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
+ return;
}
nsRect r(0, 0, aMetrics.Width(), aMetrics.Height());
r.Deflate(aReflowState.ComputedPhysicalBorderPadding());
if (mInnerView) {
nsViewManager* vm = mInnerView->GetViewManager();
vm->MoveViewTo(mInnerView, r.x, r.y);
@@ -538,17 +538,16 @@ nsObjectFrame::Reflow(nsPresContext*
if (!mReflowCallbackPosted) {
mReflowCallbackPosted = true;
aPresContext->PresShell()->PostReflowCallback(this);
}
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return NS_OK;
}
///////////// nsIReflowCallback ///////////////
bool
nsObjectFrame::ReflowFinished()
{
mReflowCallbackPosted = false;
--- a/layout/generic/nsObjectFrame.h
+++ b/layout/generic/nsObjectFrame.h
@@ -53,20 +53,20 @@ public:
NS_DECL_QUERYFRAME
NS_DECL_QUERYFRAME_TARGET(nsObjectFrame)
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
--- a/layout/generic/nsPageContentFrame.cpp
+++ b/layout/generic/nsPageContentFrame.cpp
@@ -12,31 +12,32 @@
nsIFrame*
NS_NewPageContentFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsPageContentFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsPageContentFrame)
-nsresult
+void
nsPageContentFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsPageContentFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aStatus = NS_FRAME_COMPLETE; // initialize out parameter
- nsresult rv = NS_OK;
if (GetPrevInFlow() && (GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
nsresult rv = aPresContext->PresShell()->FrameConstructor()
->ReplicateFixedFrames(this);
- NS_ENSURE_SUCCESS(rv, rv);
+ if (NS_FAILED(rv)) {
+ return;
+ }
}
// Set our size up front, since some parts of reflow depend on it
// being already set. Note that the computed height may be
// unconstrained; that's ok. Consumers should watch out for that.
nsSize maxSize(aReflowState.ComputedWidth(),
aReflowState.ComputedHeight());
SetSize(maxSize);
@@ -45,18 +46,17 @@ nsPageContentFrame::Reflow(nsPresContext
// Resize our frame allowing it only to be as big as we are
// XXX Pay attention to the page's border and padding...
if (mFrames.NotEmpty()) {
nsIFrame* frame = mFrames.FirstChild();
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, frame, maxSize);
kidReflowState.SetComputedHeight(maxSize.height);
// Reflow the page content area
- rv = ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, 0, 0, 0, aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, 0, 0, 0, aStatus);
// The document element's background should cover the entire canvas, so
// take into account the combined area and any space taken up by
// absolutely positioned elements
nsMargin padding(0,0,0,0);
// XXXbz this screws up percentage padding (sets padding to zero
// in the percentage padding case)
@@ -95,17 +95,16 @@ nsPageContentFrame::Reflow(nsPresContext
aDesiredSize.Width() = aReflowState.ComputedWidth();
if (aReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE) {
aDesiredSize.Height() = aReflowState.ComputedHeight();
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsIAtom*
nsPageContentFrame::GetType() const
{
return nsGkAtoms::pageContentFrame;
}
--- a/layout/generic/nsPageContentFrame.h
+++ b/layout/generic/nsPageContentFrame.h
@@ -15,20 +15,20 @@ class nsPageContentFrame : public Viewpo
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewPageContentFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
friend class nsPageFrame;
// nsIFrame
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aMaxSize,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aMaxSize,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
{
return ViewportFrame::IsFrameOfType(aFlags &
~(nsIFrame::eCanContainOverflowContainers));
}
virtual void SetSharedPageData(nsSharedPageData* aPD) { mPD = aPD; }
--- a/layout/generic/nsPageFrame.cpp
+++ b/layout/generic/nsPageFrame.cpp
@@ -38,17 +38,18 @@ nsPageFrame::nsPageFrame(nsStyleContext*
: nsContainerFrame(aContext)
{
}
nsPageFrame::~nsPageFrame()
{
}
-nsresult nsPageFrame::Reflow(nsPresContext* aPresContext,
+void
+nsPageFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsPageFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aStatus = NS_FRAME_COMPLETE; // initialize out parameter
@@ -79,17 +80,17 @@ nsresult nsPageFrame::Reflow(nsPresConte
nscoord onePixelInTwips = nsPresContext::CSSPixelsToAppUnits(1);
// insurance against infinite reflow, when reflowing less than a pixel
// XXX Shouldn't we do something more friendly when invalid margins
// are set?
if (maxSize.width < onePixelInTwips || maxSize.height < onePixelInTwips) {
aDesiredSize.Width() = 0;
aDesiredSize.Height() = 0;
NS_WARNING("Reflow aborted; no space for content");
- return NS_OK;
+ return;
}
nsHTMLReflowState kidReflowState(aPresContext, aReflowState, frame, maxSize);
kidReflowState.mFlags.mIsTopOfPage = true;
kidReflowState.mFlags.mTableIsSplittable = true;
// Use the margins given in the @page rule.
// If a margin is 'auto', use the margin from the print settings for that side.
@@ -152,17 +153,16 @@ nsresult nsPageFrame::Reflow(nsPresConte
aDesiredSize.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
PR_PL(("PageFrame::Reflow %p ", this));
PR_PL(("[%d,%d]\n", aReflowState.AvailableWidth(), aReflowState.AvailableHeight()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsIAtom*
nsPageFrame::GetType() const
{
return nsGkAtoms::pageFrame;
}
@@ -643,17 +643,17 @@ nsPageBreakFrame::GetIntrinsicWidth()
}
nscoord
nsPageBreakFrame::GetIntrinsicHeight()
{
return 0;
}
-nsresult
+void
nsPageBreakFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsPageBreakFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
@@ -665,17 +665,16 @@ nsPageBreakFrame::Reflow(nsPresContext*
// round the height down to the nearest pixel
aDesiredSize.Height() -=
aDesiredSize.Height() % nsPresContext::CSSPixelsToAppUnits(1);
// Note: not using NS_FRAME_FIRST_REFLOW here, since it's not clear whether
// DidReflow will always get called before the next Reflow() call.
mHaveReflowed = true;
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
}
nsIAtom*
nsPageBreakFrame::GetType() const
{
return nsGkAtoms::pageBreakFrame;
}
--- a/layout/generic/nsPageFrame.h
+++ b/layout/generic/nsPageFrame.h
@@ -14,20 +14,20 @@ class nsSharedPageData;
// Page frame class used by the simple page sequence frame
class nsPageFrame : public nsContainerFrame {
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewPageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aMaxSize,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aMaxSize,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
@@ -98,17 +98,17 @@ protected:
class nsPageBreakFrame : public nsLeafFrame
{
NS_DECL_FRAMEARENA_HELPERS
nsPageBreakFrame(nsStyleContext* aContext);
~nsPageBreakFrame();
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
--- a/layout/generic/nsPlaceholderFrame.cpp
+++ b/layout/generic/nsPlaceholderFrame.cpp
@@ -93,17 +93,17 @@ nsPlaceholderFrame::AddInlinePrefWidth(n
nsLayoutUtils::IntrinsicForContainer(aRenderingContext,
mOutOfFlowFrame,
nsLayoutUtils::PREF_WIDTH);
aData->floats.AppendElement(
InlineIntrinsicWidthData::FloatInfo(mOutOfFlowFrame, floatWidth));
}
}
-nsresult
+void
nsPlaceholderFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
#ifdef DEBUG
// We should be getting reflowed before our out-of-flow.
// If this is our first reflow, and our out-of-flow has already received its
@@ -138,17 +138,16 @@ nsPlaceholderFrame::Reflow(nsPresContext
DO_GLOBAL_REFLOW_COUNT("nsPlaceholderFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aDesiredSize.Width() = 0;
aDesiredSize.Height() = 0;
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
void
nsPlaceholderFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
nsIFrame* oof = mOutOfFlowFrame;
if (oof) {
// Unregister out-of-flow frame
--- a/layout/generic/nsPlaceholderFrame.h
+++ b/layout/generic/nsPlaceholderFrame.h
@@ -91,20 +91,20 @@ public:
virtual void AddInlineMinWidth(nsRenderingContext* aRenderingContext,
InlineMinWidthData* aData) MOZ_OVERRIDE;
virtual void AddInlinePrefWidth(nsRenderingContext* aRenderingContext,
InlinePrefWidthData* aData) MOZ_OVERRIDE;
virtual nsSize GetMinSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetPrefSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetMaxSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
#if defined(DEBUG) || (defined(MOZ_REFLOW_PERF_DSP) && defined(MOZ_REFLOW_PERF))
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
#endif // DEBUG || (MOZ_REFLOW_PERF_DSP && MOZ_REFLOW_PERF)
--- a/layout/generic/nsSimplePageSequenceFrame.cpp
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -112,17 +112,17 @@ nsSimplePageSequenceFrame::SetDesiredSiz
// in child page frames correctly.
// Use availableWidth so we don't cause a needless horizontal scrollbar.
aDesiredSize.Width() = std::max(aReflowState.AvailableWidth(),
nscoord(aWidth * PresContext()->GetPrintPreviewScale()));
aDesiredSize.Height() = std::max(aReflowState.ComputedHeight(),
nscoord(aHeight * PresContext()->GetPrintPreviewScale()));
}
-nsresult
+void
nsSimplePageSequenceFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
NS_PRECONDITION(aPresContext->IsRootPaginatedDocument(),
"A Page Sequence is only for real pages");
DO_GLOBAL_REFLOW_COUNT("nsSimplePageSequenceFrame");
@@ -133,17 +133,17 @@ nsSimplePageSequenceFrame::Reflow(nsPres
// Don't do incremental reflow until we've taught tables how to do
// it right in paginated mode.
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
// Return our desired size
SetDesiredSize(aDesiredSize, aReflowState, mSize.width, mSize.height);
aDesiredSize.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
- return NS_OK;
+ return;
}
// See if we can get a Print Settings from the Context
if (!mPageData->mPrintSettings &&
aPresContext->Medium() == nsGkAtoms::print) {
mPageData->mPrintSettings = aPresContext->GetPrintSettings();
}
@@ -261,21 +261,22 @@ nsSimplePageSequenceFrame::Reflow(nsPres
nsPageFrame * pf = static_cast<nsPageFrame*>(page);
if (pf != nullptr) {
pf->SetPageNumInfo(pageNum, pageTot);
}
pageNum++;
}
// Create current Date/Time String
- if (!mDateFormatter)
+ if (!mDateFormatter) {
mDateFormatter = do_CreateInstance(NS_DATETIMEFORMAT_CONTRACTID);
-
- NS_ENSURE_TRUE(mDateFormatter, NS_ERROR_FAILURE);
-
+ }
+ if (!mDateFormatter) {
+ return;
+ }
nsAutoString formattedDateString;
time_t ltime;
time( <ime );
if (NS_SUCCEEDED(mDateFormatter->FormatTime(nullptr /* nsILocale* locale */,
kDateFormatShort,
kTimeFormatNoSeconds,
ltime,
formattedDateString))) {
@@ -292,17 +293,16 @@ nsSimplePageSequenceFrame::Reflow(nsPres
// cache the size so we can set the desired size
// for the other reflows that happen
mSize.width = maxXMost;
mSize.height = y;
NS_FRAME_TRACE_REFLOW_OUT("nsSimplePageSequeceFrame::Reflow", aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
//----------------------------------------------------------------------
#ifdef DEBUG_FRAME_DUMP
nsresult
nsSimplePageSequenceFrame::GetFrameName(nsAString& aResult) const
{
--- a/layout/generic/nsSimplePageSequenceFrame.h
+++ b/layout/generic/nsSimplePageSequenceFrame.h
@@ -59,20 +59,20 @@ class nsSimplePageSequenceFrame : public
public nsIPageSequenceFrame {
public:
friend nsIFrame* NS_NewSimplePageSequenceFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aMaxSize,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aMaxSize,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
// nsIPageSequenceFrame
NS_IMETHOD SetPageNo(int32_t aPageNo) { return NS_OK;}
NS_IMETHOD SetSelectionHeight(nscoord aYOffset, nscoord aHeight) MOZ_OVERRIDE { mYSelOffset = aYOffset; mSelectionHeight = aHeight; return NS_OK; }
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -683,17 +683,17 @@ nsSubDocumentFrame::ComputeSize(nsRender
subDocRoot->GetIntrinsicSize(),
subDocRoot->GetIntrinsicRatio(),
aCBSize, aMargin, aBorder, aPadding);
}
return nsLeafFrame::ComputeSize(aRenderingContext, aCBSize, aAvailableWidth,
aMargin, aBorder, aPadding, aFlags);
}
-nsresult
+void
nsSubDocumentFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsSubDocumentFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
// printf("OuterFrame::Reflow %X (%d,%d) \n", this, aReflowState.AvailableWidth(), aReflowState.AvailableHeight());
@@ -704,17 +704,19 @@ nsSubDocumentFrame::Reflow(nsPresContext
aStatus = NS_FRAME_COMPLETE;
NS_ASSERTION(mContent->GetPrimaryFrame() == this,
"Shouldn't happen");
// XUL <iframe> or <browser>, or HTML <iframe>, <object> or <embed>
nsresult rv = nsLeafFrame::DoReflow(aPresContext, aDesiredSize, aReflowState,
aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ if (NS_FAILED(rv)) {
+ return;
+ }
// "offset" is the offset of our content area from our frame's
// top-left corner.
nsPoint offset = nsPoint(aReflowState.ComputedPhysicalBorderPadding().left,
aReflowState.ComputedPhysicalBorderPadding().top);
nsSize innerSize(aDesiredSize.Width(), aDesiredSize.Height());
innerSize.width -= aReflowState.ComputedPhysicalBorderPadding().LeftRight();
@@ -744,17 +746,16 @@ nsSubDocumentFrame::Reflow(nsPresContext
// printf("OuterFrame::Reflow DONE %X (%d,%d)\n", this,
// aDesiredSize.Width(), aDesiredSize.Height());
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsSubDocumentFrame::Reflow: size=%d,%d status=%x",
aDesiredSize.Width(), aDesiredSize.Height(), aStatus));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
bool
nsSubDocumentFrame::ReflowFinished()
{
if (mFrameLoader) {
nsWeakFrame weakFrame(this);
--- a/layout/generic/nsSubDocumentFrame.h
+++ b/layout/generic/nsSubDocumentFrame.h
@@ -56,20 +56,20 @@ public:
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap) MOZ_OVERRIDE;
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -7556,39 +7556,38 @@ nsTextFrame::IsFloatingFirstLetterChild(
}
struct NewlineProperty {
int32_t mStartOffset;
// The offset of the first \n after mStartOffset, or -1 if there is none
int32_t mNewlineOffset;
};
-nsresult
+void
nsTextFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTextFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
// XXX If there's no line layout, we shouldn't even have created this
// frame. This may happen if, for example, this is text inside a table
// but not inside a cell. For now, just don't reflow.
if (!aReflowState.mLineLayout) {
ClearMetrics(aMetrics);
aStatus = NS_FRAME_COMPLETE;
- return NS_OK;
+ return;
}
ReflowText(*aReflowState.mLineLayout, aReflowState.AvailableWidth(),
aReflowState.rendContext, aMetrics, aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
- return NS_OK;
}
#ifdef ACCESSIBILITY
/**
* Notifies accessibility about text reflow. Used by nsTextFrame::ReflowText.
*/
class MOZ_STACK_CLASS ReflowTextA11yNotifier
{
--- a/layout/generic/nsTextFrame.h
+++ b/layout/generic/nsTextFrame.h
@@ -210,20 +210,20 @@ public:
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
virtual nsRect ComputeTightBounds(gfxContext* aContext) const MOZ_OVERRIDE;
virtual nsresult GetPrefWidthTightBounds(nsRenderingContext* aContext,
nscoord* aX,
nscoord* aXMost) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aMetrics,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aMetrics,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool CanContinueTextRun() const MOZ_OVERRIDE;
// Method that is called for a text frame that is logically
// adjacent to the end of the line (i.e. followed only by empty text frames,
// placeholders or inlines containing such).
struct TrimOutput {
// true if we trimmed some space or changed metrics in some other way.
// In this case, we should call RecomputeOverflow on this frame.
bool mChanged;
--- a/layout/generic/nsVideoFrame.cpp
+++ b/layout/generic/nsVideoFrame.cpp
@@ -234,17 +234,17 @@ public:
nsContentUtils::DispatchTrustedEvent(mContent->OwnerDoc(), mContent,
NS_LITERAL_STRING("resizevideocontrols"),
false, false);
return NS_OK;
}
nsCOMPtr<nsIContent> mContent;
};
-nsresult
+void
nsVideoFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsVideoFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
@@ -283,17 +283,19 @@ nsVideoFrame::Reflow(nsPresContext*
aMetrics.Height());
uint32_t posterHeight, posterWidth;
nsSize scaledPosterSize(0, 0);
nsSize computedArea(aReflowState.ComputedWidth(), aReflowState.ComputedHeight());
nsPoint posterTopLeft(0, 0);
nsCOMPtr<nsIDOMHTMLImageElement> posterImage = do_QueryInterface(mPosterImage);
- NS_ENSURE_TRUE(posterImage, NS_ERROR_FAILURE);
+ if (!posterImage) {
+ return;
+ }
posterImage->GetNaturalHeight(&posterHeight);
posterImage->GetNaturalWidth(&posterWidth);
if (ShouldDisplayPoster() && posterHeight && posterWidth) {
gfxFloat scale =
std::min(static_cast<float>(computedArea.width)/nsPresContext::CSSPixelsToAppUnits(static_cast<float>(posterWidth)),
static_cast<float>(computedArea.height)/nsPresContext::CSSPixelsToAppUnits(static_cast<float>(posterHeight)));
gfxSize scaledRatio = gfxSize(scale*posterWidth, scale*posterHeight);
@@ -351,18 +353,16 @@ nsVideoFrame::Reflow(nsPresContext*
aMetrics.SetOverflowAreasToDesiredBounds();
FinishAndStoreOverflow(&aMetrics);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsVideoFrame::Reflow: size=%d,%d",
aMetrics.Width(), aMetrics.Height()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
-
- return NS_OK;
}
class nsDisplayVideo : public nsDisplayItem {
public:
nsDisplayVideo(nsDisplayListBuilder* aBuilder, nsVideoFrame* aFrame)
: nsDisplayItem(aBuilder, aFrame)
{
MOZ_COUNT_CTOR(nsDisplayVideo);
--- a/layout/generic/nsVideoFrame.h
+++ b/layout/generic/nsVideoFrame.h
@@ -56,20 +56,20 @@ public:
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual bool IsLeaf() const MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
--- a/layout/generic/nsViewportFrame.cpp
+++ b/layout/generic/nsViewportFrame.cpp
@@ -168,17 +168,17 @@ ViewportFrame::AdjustReflowStateAsContai
rect.SizeTo(ps->GetScrollPositionClampingScrollPortSize());
}
// Make sure content document fixed-position margins are respected.
rect.Deflate(ps->GetContentDocumentFixedPositionMargins());
return rect;
}
-nsresult
+void
ViewportFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("ViewportFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_FRAME_TRACE_REFLOW_IN("ViewportFrame::Reflow");
@@ -195,36 +195,34 @@ ViewportFrame::Reflow(nsPresContext*
// unconstrained; that's ok. Consumers should watch out for that.
SetSize(nsSize(aReflowState.ComputedWidth(), aReflowState.ComputedHeight()));
// Reflow the main content first so that the placeholders of the
// fixed-position frames will be in the right places on an initial
// reflow.
nscoord kidHeight = 0;
- nsresult rv = NS_OK;
-
if (mFrames.NotEmpty()) {
// Deal with a non-incremental reflow or an incremental reflow
// targeted at our one-and-only principal child frame.
if (aReflowState.ShouldReflowAllKids() ||
aReflowState.mFlags.mVResize ||
NS_SUBTREE_DIRTY(mFrames.FirstChild())) {
// Reflow our one-and-only principal child frame
nsIFrame* kidFrame = mFrames.FirstChild();
nsHTMLReflowMetrics kidDesiredSize(aReflowState);
nsSize availableSpace(aReflowState.AvailableWidth(),
aReflowState.AvailableHeight());
nsHTMLReflowState kidReflowState(aPresContext, aReflowState,
kidFrame, availableSpace);
// Reflow the frame
kidReflowState.SetComputedHeight(aReflowState.ComputedHeight());
- rv = ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState,
- 0, 0, 0, aStatus);
+ ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowState,
+ 0, 0, 0, aStatus);
kidHeight = kidDesiredSize.Height();
FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, nullptr, 0, 0, 0);
} else {
kidHeight = mFrames.FirstChild()->GetSize().height;
}
}
@@ -257,20 +255,20 @@ ViewportFrame::Reflow(nsPresContext*
NS_ASSERTION(reflowState.ComputedPhysicalBorderPadding() == nsMargin(0,0,0,0),
"Viewports can't have border/padding");
reflowState.SetComputedHeight(aDesiredSize.Height());
}
nsRect rect = AdjustReflowStateAsContainingBlock(&reflowState);
// Just reflow all the fixed-pos frames.
- rv = GetAbsoluteContainingBlock()->Reflow(this, aPresContext, reflowState, aStatus,
- rect,
- false, true, true, // XXX could be optimized
- &aDesiredSize.mOverflowAreas);
+ GetAbsoluteContainingBlock()->Reflow(this, aPresContext, reflowState, aStatus,
+ rect,
+ false, true, true, // XXX could be optimized
+ &aDesiredSize.mOverflowAreas);
}
// If we were dirty then do a repaint
if (GetStateBits() & NS_FRAME_IS_DIRTY) {
InvalidateFrame();
}
// Clipping is handled by the document container (e.g., nsSubDocumentFrame),
@@ -284,17 +282,16 @@ ViewportFrame::Reflow(nsPresContext*
if (container && !container->ShouldClipSubdocument()) {
container->PresContext()->PresShell()->
FrameNeedsReflow(container, nsIPresShell::eResize, NS_FRAME_IS_DIRTY);
}
}
NS_FRAME_TRACE_REFLOW_OUT("ViewportFrame::Reflow", aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return rv;
}
nsIAtom*
ViewportFrame::GetType() const
{
return nsGkAtoms::viewportFrame;
}
--- a/layout/generic/nsViewportFrame.h
+++ b/layout/generic/nsViewportFrame.h
@@ -52,20 +52,20 @@ public:
nsIFrame* aOldFrame) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::viewportFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
--- a/layout/mathml/nsMathMLContainerFrame.cpp
+++ b/layout/mathml/nsMathMLContainerFrame.cpp
@@ -873,17 +873,17 @@ nsMathMLContainerFrame::ReflowChild(nsIF
aDesiredSize.mBoundingMetrics.rightBearing = r.XMost();
aDesiredSize.mBoundingMetrics.ascent = aDesiredSize.TopAscent() - r.y;
aDesiredSize.mBoundingMetrics.descent = r.YMost() - aDesiredSize.TopAscent();
aDesiredSize.mBoundingMetrics.width = aDesiredSize.Width();
}
return NS_OK;
}
-nsresult
+void
nsMathMLContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
aDesiredSize.Width() = aDesiredSize.Height() = 0;
aDesiredSize.SetTopAscent(0);
aDesiredSize.mBoundingMetrics = nsBoundingMetrics();
@@ -954,17 +954,16 @@ nsMathMLContainerFrame::Reflow(nsPresCon
}
/////////////
// Place children now by re-adjusting the origins to align the baselines
FinalizeReflow(*aReflowState.rendContext, aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
static nscoord AddInterFrameSpacingToSize(nsHTMLReflowMetrics& aDesiredSize,
nsMathMLContainerFrame* aFrame);
/* virtual */ nscoord
nsMathMLContainerFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
{
--- a/layout/mathml/nsMathMLContainerFrame.h
+++ b/layout/mathml/nsMathMLContainerFrame.h
@@ -101,17 +101,17 @@ public:
/**
* Return the intrinsic horizontal metrics of the frame's content area.
*/
virtual void
GetIntrinsicWidthMetrics(nsRenderingContext* aRenderingContext,
nsHTMLReflowMetrics& aDesiredSize);
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult
WillReflow(nsPresContext* aPresContext) MOZ_OVERRIDE
{
--- a/layout/mathml/nsMathMLSelectedFrame.cpp
+++ b/layout/mathml/nsMathMLSelectedFrame.cpp
@@ -94,17 +94,17 @@ nsMathMLSelectedFrame::BuildDisplayList(
#if defined(DEBUG) && defined(SHOW_BOUNDING_BOX)
// visual debug
DisplayBoundingMetrics(aBuilder, this, mReference, mBoundingMetrics, aLists);
#endif
}
// Only reflow the selected child ...
-nsresult
+void
nsMathMLSelectedFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
aStatus = NS_FRAME_COMPLETE;
aDesiredSize.Width() = aDesiredSize.Height() = 0;
aDesiredSize.SetTopAscent(0);
@@ -117,17 +117,16 @@ nsMathMLSelectedFrame::Reflow(nsPresCont
ReflowChild(childFrame, aPresContext, aDesiredSize,
childReflowState, aStatus);
SaveReflowAndBoundingMetricsFor(childFrame, aDesiredSize,
aDesiredSize.mBoundingMetrics);
mBoundingMetrics = aDesiredSize.mBoundingMetrics;
}
FinalizeReflow(*aReflowState.rendContext, aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
// Only place the selected child ...
/* virtual */ nsresult
nsMathMLSelectedFrame::Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
nsHTMLReflowMetrics& aDesiredSize)
{
--- a/layout/mathml/nsMathMLSelectedFrame.h
+++ b/layout/mathml/nsMathMLSelectedFrame.h
@@ -29,17 +29,17 @@ public:
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nsresult
Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
nsHTMLReflowMetrics& aDesiredSize) MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsQueryFrame::FrameIID GetFrameId() = 0;
protected:
--- a/layout/mathml/nsMathMLTokenFrame.cpp
+++ b/layout/mathml/nsMathMLTokenFrame.cpp
@@ -129,17 +129,17 @@ nsMathMLTokenFrame::InsertFrames(ChildLi
if (NS_FAILED(rv))
return rv;
MarkTextFramesAsTokenMathML();
return rv;
}
-nsresult
+void
nsMathMLTokenFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// initializations needed for empty markup like <mtag></mtag>
aDesiredSize.Width() = aDesiredSize.Height() = 0;
aDesiredSize.SetTopAscent(0);
@@ -163,17 +163,16 @@ nsMathMLTokenFrame::Reflow(nsPresContext
childFrame = childFrame->GetNextSibling();
}
// place and size children
FinalizeReflow(*aReflowState.rendContext, aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
// For token elements, mBoundingMetrics is computed at the ReflowToken
// pass, it is not computed here because our children may be text frames
// that do not implement the GetBoundingMetrics() interface.
/* virtual */ nsresult
nsMathMLTokenFrame::Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
--- a/layout/mathml/nsMathMLTokenFrame.h
+++ b/layout/mathml/nsMathMLTokenFrame.h
@@ -42,17 +42,17 @@ public:
AppendFrames(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
virtual nsresult
InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aChildList) MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult
Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
--- a/layout/mathml/nsMathMLmfencedFrame.cpp
+++ b/layout/mathml/nsMathMLmfencedFrame.cpp
@@ -179,17 +179,17 @@ nsMathMLmfencedFrame::BuildDisplayList(n
mCloseChar->Display(aBuilder, this, aLists, count++);
}
for (int32_t i = 0; i < mSeparatorsCount; i++) {
mSeparatorsChar[i].Display(aBuilder, this, aLists, count++);
}
}
-nsresult
+void
nsMathMLmfencedFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
aDesiredSize.Width() = aDesiredSize.Height() = 0;
aDesiredSize.SetTopAscent(0);
aDesiredSize.mBoundingMetrics = nsBoundingMetrics();
@@ -395,17 +395,16 @@ nsMathMLmfencedFrame::Reflow(nsPresConte
// Finished with these:
ClearSavedChildMetrics();
// Set our overflow area
GatherAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
static void
GetCharSpacing(nsMathMLChar* aMathMLChar,
nsOperatorFlags aForm,
int32_t aScriptLevel,
nscoord em,
nscoord& aLeftSpace,
--- a/layout/mathml/nsMathMLmfencedFrame.h
+++ b/layout/mathml/nsMathMLmfencedFrame.h
@@ -27,17 +27,17 @@ public:
NS_IMETHOD
InheritAutomaticData(nsIFrame* aParent) MOZ_OVERRIDE;
virtual nsresult
SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
--- a/layout/mathml/nsMathMLmoFrame.cpp
+++ b/layout/mathml/nsMathMLmoFrame.cpp
@@ -930,29 +930,28 @@ nsMathMLmoFrame::SetInitialChildList(Chi
nsresult rv = nsMathMLTokenFrame::SetInitialChildList(aListID, aChildList);
if (NS_FAILED(rv))
return rv;
ProcessTextData();
return rv;
}
-nsresult
+void
nsMathMLmoFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// certain values use units that depend on our style context, so
// it is safer to just process the whole lot here
ProcessOperatorData();
nsMathMLTokenFrame::Reflow(aPresContext, aDesiredSize,
aReflowState, aStatus);
- return NS_OK;
}
/* virtual */ void
nsMathMLmoFrame::MarkIntrinsicWidthsDirty()
{
// if we get this, it may mean that something changed in the text
// content. So blow away everything an re-build the automatic data
// from the parent of our outermost embellished container (we ensure
--- a/layout/mathml/nsMathMLmoFrame.h
+++ b/layout/mathml/nsMathMLmoFrame.h
@@ -37,17 +37,17 @@ public:
NS_IMETHOD
TransmitAutomaticData() MOZ_OVERRIDE;
virtual nsresult
SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void MarkIntrinsicWidthsDirty() MOZ_OVERRIDE;
virtual void
--- a/layout/mathml/nsMathMLmpaddedFrame.cpp
+++ b/layout/mathml/nsMathMLmpaddedFrame.cpp
@@ -295,30 +295,29 @@ nsMathMLmpaddedFrame::UpdateValue(int32_
aValueToUpdate += amount;
else if (NS_MATHML_SIGN_MINUS == aSign)
aValueToUpdate -= amount;
else
aValueToUpdate = amount;
}
}
-nsresult
+void
nsMathMLmpaddedFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
ProcessAttributes();
///////////////
// Let the base class format our content like an inferred mrow
nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize,
aReflowState, aStatus);
//NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status");
- return NS_OK;
}
/* virtual */ nsresult
nsMathMLmpaddedFrame::Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
nsHTMLReflowMetrics& aDesiredSize)
{
nsresult rv =
--- a/layout/mathml/nsMathMLmpaddedFrame.h
+++ b/layout/mathml/nsMathMLmpaddedFrame.h
@@ -22,17 +22,17 @@ public:
NS_IMETHOD
InheritAutomaticData(nsIFrame* aParent) MOZ_OVERRIDE;
NS_IMETHOD
TransmitAutomaticData() MOZ_OVERRIDE {
return TransmitAutomaticDataForMrowLikeElement();
}
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult
Place(nsRenderingContext& aRenderingContext,
bool aPlaceOrigin,
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -140,17 +140,17 @@ GetRadicalXOffsets(nscoord aIndexWidth,
}
if (aIndexOffset)
*aIndexOffset = dxIndex;
if (aSqrOffset)
*aSqrOffset = dxSqr;
}
-nsresult
+void
nsMathMLmrootFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
nsSize availSize(aReflowState.ComputedWidth(), NS_UNCONSTRAINEDSIZE);
nsReflowStatus childStatus;
@@ -197,17 +197,17 @@ nsMathMLmrootFrame::Reflow(nsPresContext
if (2 != count) {
// report an error, encourage people to get their markups in order
ReportChildCountError();
ReflowError(renderingContext, aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
// Call DidReflow() for the child frames we successfully did reflow.
DidReflowChildren(mFrames.FirstChild(), childFrame);
- return NS_OK;
+ return;
}
////////////
// Prepare the radical symbol and the overline bar
nsRefPtr<nsFontMetrics> fm;
nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm));
renderingContext.SetFont(fm);
@@ -340,17 +340,16 @@ nsMathMLmrootFrame::Reflow(nsPresContext
MirrorIfRTL(aDesiredSize.Width(), baseSize.Width(), dx),
dy, 0);
mReference.x = 0;
mReference.y = aDesiredSize.TopAscent();
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
/* virtual */ void
nsMathMLmrootFrame::GetIntrinsicWidthMetrics(nsRenderingContext* aRenderingContext, nsHTMLReflowMetrics& aDesiredSize)
{
nsIFrame* baseFrame = mFrames.FirstChild();
nsIFrame* indexFrame = nullptr;
if (baseFrame)
--- a/layout/mathml/nsMathMLmrootFrame.h
+++ b/layout/mathml/nsMathMLmrootFrame.h
@@ -29,17 +29,17 @@ public:
virtual void
Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD
TransmitAutomaticData() MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void
GetIntrinsicWidthMetrics(nsRenderingContext* aRenderingContext,
nsHTMLReflowMetrics& aDesiredSize) MOZ_OVERRIDE;
--- a/layout/mathml/nsMathMLmspaceFrame.cpp
+++ b/layout/mathml/nsMathMLmspaceFrame.cpp
@@ -86,17 +86,17 @@ nsMathMLmspaceFrame::ProcessAttributes(n
mDepth = 0;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::depth_, value);
if (!value.IsEmpty()) {
ParseNumericValue(value, &mDepth, 0,
aPresContext, mStyleContext);
}
}
-nsresult
+void
nsMathMLmspaceFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
ProcessAttributes(aPresContext);
mBoundingMetrics = nsBoundingMetrics();
@@ -109,17 +109,16 @@ nsMathMLmspaceFrame::Reflow(nsPresContex
aDesiredSize.SetTopAscent(mHeight);
aDesiredSize.Width() = std::max(0, mBoundingMetrics.width);
aDesiredSize.Height() = aDesiredSize.TopAscent() + mDepth;
// Also return our bounding metrics
aDesiredSize.mBoundingMetrics = mBoundingMetrics;
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
/* virtual */ nsresult
nsMathMLmspaceFrame::MeasureForWidth(nsRenderingContext& aRenderingContext,
nsHTMLReflowMetrics& aDesiredSize)
{
ProcessAttributes(PresContext());
mBoundingMetrics = nsBoundingMetrics();
--- a/layout/mathml/nsMathMLmspaceFrame.h
+++ b/layout/mathml/nsMathMLmspaceFrame.h
@@ -24,17 +24,17 @@ public:
// The REC defines the following elements to be space-like:
// * an mtext, mspace, maligngroup, or malignmark element;
mPresentationData.flags |= NS_MATHML_SPACE_LIKE;
return NS_OK;
}
virtual bool IsLeaf() const MOZ_OVERRIDE;
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
protected:
nsMathMLmspaceFrame(nsStyleContext* aContext) : nsMathMLContainerFrame(aContext) {}
virtual ~nsMathMLmspaceFrame();
--- a/layout/mathml/nsMathMLmtableFrame.cpp
+++ b/layout/mathml/nsMathMLmtableFrame.cpp
@@ -540,17 +540,17 @@ nsMathMLmtableOuterFrame::GetRowFrameAt(
return rowFrame;
}
--aRowIndex;
}
}
return nullptr;
}
-nsresult
+void
nsMathMLmtableOuterFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
nsAutoString value;
// we want to return a table that is anchored according to the align attribute
@@ -640,18 +640,16 @@ nsMathMLmtableOuterFrame::Reflow(nsPresC
mBoundingMetrics.ascent = aDesiredSize.TopAscent();
mBoundingMetrics.descent = aDesiredSize.Height() - aDesiredSize.TopAscent();
mBoundingMetrics.width = aDesiredSize.Width();
mBoundingMetrics.leftBearing = 0;
mBoundingMetrics.rightBearing = aDesiredSize.Width();
aDesiredSize.mBoundingMetrics = mBoundingMetrics;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
-
- return NS_OK;
}
nsIFrame*
NS_NewMathMLmtableFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsMathMLmtableFrame(aContext);
}
@@ -881,28 +879,27 @@ nsMathMLmtdInnerFrame::nsMathMLmtdInnerF
mUniqueStyleText = new (PresContext()) nsStyleText(*StyleText());
}
nsMathMLmtdInnerFrame::~nsMathMLmtdInnerFrame()
{
mUniqueStyleText->Destroy(PresContext());
}
-nsresult
+void
nsMathMLmtdInnerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// Let the base class do the reflow
nsBlockFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
// more about <maligngroup/> and <malignmark/> later
// ...
- return NS_OK;
}
const
nsStyleText* nsMathMLmtdInnerFrame::StyleTextForLineLayout()
{
// Set the default alignment in case nothing was specified
uint8_t alignment = StyleText()->mTextAlign;
--- a/layout/mathml/nsMathMLmtableFrame.h
+++ b/layout/mathml/nsMathMLmtableFrame.h
@@ -23,17 +23,17 @@ class nsMathMLmtableOuterFrame : public
public:
friend nsIFrame* NS_NewMathMLmtableOuterFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// overloaded nsTableOuterFrame methods
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult
AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
@@ -231,17 +231,17 @@ public:
uint32_t aFlagsValues,
uint32_t aFlagsToUpdate) MOZ_OVERRIDE
{
nsMathMLContainerFrame::PropagatePresentationDataFromChildAt(this,
aFirstIndex, aLastIndex, aFlagsValues, aFlagsToUpdate);
return NS_OK;
}
- virtual nsresult
+ virtual void
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const MOZ_OVERRIDE
{
return nsBlockFrame::IsFrameOfType(aFlags &
--- a/layout/svg/nsSVGForeignObjectFrame.cpp
+++ b/layout/svg/nsSVGForeignObjectFrame.cpp
@@ -111,17 +111,17 @@ nsSVGForeignObjectFrame::AttributeChange
aAttribute == nsGkAtoms::preserveAspectRatio) {
nsSVGEffects::InvalidateRenderingObservers(this);
}
}
return NS_OK;
}
-nsresult
+void
nsSVGForeignObjectFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
NS_ABORT_IF_FALSE(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY),
"Should not have been called");
@@ -143,18 +143,16 @@ nsSVGForeignObjectFrame::Reflow(nsPresCo
"svg.css should ensure we have no padding/border/margin");
DoReflow();
aDesiredSize.Width() = aReflowState.ComputedWidth();
aDesiredSize.Height() = aReflowState.ComputedHeight();
aDesiredSize.SetOverflowAreasToDesiredBounds();
aStatus = NS_FRAME_COMPLETE;
-
- return NS_OK;
}
void
nsSVGForeignObjectFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
if (!static_cast<const nsSVGElement*>(mContent)->HasValidDimensions()) {
--- a/layout/svg/nsSVGForeignObjectFrame.h
+++ b/layout/svg/nsSVGForeignObjectFrame.h
@@ -38,20 +38,20 @@ public:
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
virtual nsIFrame* GetContentInsertionFrame() MOZ_OVERRIDE {
return GetFirstPrincipalChild()->GetContentInsertionFrame();
}
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
--- a/layout/svg/nsSVGOuterSVGFrame.cpp
+++ b/layout/svg/nsSVGOuterSVGFrame.cpp
@@ -300,17 +300,17 @@ nsSVGOuterSVGFrame::ComputeSize(nsRender
}
return nsLayoutUtils::ComputeSizeWithIntrinsicDimensions(
aRenderingContext, this,
intrinsicSize, GetIntrinsicRatio(), cbSize,
aMargin, aBorder, aPadding);
}
-nsresult
+void
nsSVGOuterSVGFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsSVGOuterSVGFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
@@ -444,17 +444,16 @@ nsSVGOuterSVGFrame::Reflow(nsPresContext
anonKid->GetVisualOverflowRect() + anonKid->GetPosition());
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
("exit nsSVGOuterSVGFrame::Reflow: size=%d,%d",
aDesiredSize.Width(), aDesiredSize.Height()));
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsresult
nsSVGOuterSVGFrame::DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus)
{
nsresult rv = nsSVGOuterSVGFrameBase::DidReflow(aPresContext,aReflowState,aStatus);
--- a/layout/svg/nsSVGOuterSVGFrame.h
+++ b/layout/svg/nsSVGOuterSVGFrame.h
@@ -44,20 +44,20 @@ public:
virtual mozilla::IntrinsicSize GetIntrinsicSize() MOZ_OVERRIDE;
virtual nsSize GetIntrinsicRatio() MOZ_OVERRIDE;
virtual nsSize ComputeSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder, nsSize aPadding,
uint32_t aFlags) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus) MOZ_OVERRIDE;
virtual bool UpdateOverflow() MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -840,17 +840,18 @@ CalcUnpaginagedHeight(nsPresContext*
}
else if (rowX >= rowIndex) {
computedHeight += row->GetUnpaginatedHeight(aPresContext);
}
}
return computedHeight;
}
-nsresult nsTableCellFrame::Reflow(nsPresContext* aPresContext,
+void
+nsTableCellFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableCellFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (aReflowState.mFlags.mSpecialHeightReflow) {
@@ -1009,17 +1010,16 @@ nsresult nsTableCellFrame::Reflow(nsPres
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
InvalidateFrame();
}
// remember the desired size for this reflow
SetDesiredSize(aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
/* ----- global methods ----- */
NS_QUERYFRAME_HEAD(nsTableCellFrame)
NS_QUERYFRAME_ENTRY(nsTableCellFrame)
NS_QUERYFRAME_ENTRY(nsITableCellLayout)
NS_QUERYFRAME_ENTRY(nsIPercentHeightObserver)
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -101,20 +101,20 @@ public:
nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists);
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual IntrinsicWidthOffsetData
IntrinsicWidthOffsets(nsRenderingContext* aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsLayoutAtoms::tableCellFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
--- a/layout/tables/nsTableColFrame.cpp
+++ b/layout/tables/nsTableColFrame.cpp
@@ -80,34 +80,34 @@ void nsTableColFrame::SetContinuousBCBor
case NS_SIDE_BOTTOM:
mBottomContBorderWidth = aPixelValue;
return;
default:
NS_ERROR("invalid side arg");
}
}
-nsresult nsTableColFrame::Reflow(nsPresContext* aPresContext,
+void
+nsTableColFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableColFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aDesiredSize.Width() = 0;
aDesiredSize.Height() = 0;
const nsStyleVisibility* colVis = StyleVisibility();
bool collapseCol = (NS_STYLE_VISIBILITY_COLLAPSE == colVis->mVisible);
if (collapseCol) {
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
tableFrame->SetNeedToCollapse(true);
}
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
int32_t nsTableColFrame::GetSpan()
{
return StyleTable()->mSpan;
}
#ifdef DEBUG
--- a/layout/tables/nsTableColFrame.h
+++ b/layout/tables/nsTableColFrame.h
@@ -43,20 +43,20 @@ public:
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) MOZ_OVERRIDE;
int32_t GetColIndex() const;
void SetColIndex (int32_t aColIndex);
nsTableColFrame* GetNextCol() const;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* Table columns never paint anything, nor receive events.
*/
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {}
--- a/layout/tables/nsTableColGroupFrame.cpp
+++ b/layout/tables/nsTableColGroupFrame.cpp
@@ -353,25 +353,25 @@ nsTableColGroupFrame::GetLogicalSkipSide
skip |= 1 << LOGICAL_SIDE_B_START;
}
if (nullptr != GetNextInFlow()) {
skip |= 1 << LOGICAL_SIDE_B_END;
}
return skip;
}
-nsresult nsTableColGroupFrame::Reflow(nsPresContext* aPresContext,
+void
+nsTableColGroupFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableColGroupFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
NS_ASSERTION(nullptr!=mContent, "bad state -- null content for frame");
- nsresult rv=NS_OK;
const nsStyleVisibility* groupVis = StyleVisibility();
bool collapseGroup = (NS_STYLE_VISIBILITY_COLLAPSE == groupVis->mVisible);
if (collapseGroup) {
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
tableFrame->SetNeedToCollapse(true);
}
// for every content child that (is a column thingy and does not already have a frame)
@@ -388,17 +388,16 @@ nsresult nsTableColGroupFrame::Reflow(ns
ReflowChild(kidFrame, aPresContext, kidSize, kidReflowState, 0, 0, 0, status);
FinishReflowChild(kidFrame, aPresContext, kidSize, nullptr, 0, 0, 0);
}
aDesiredSize.Width() = 0;
aDesiredSize.Height() = 0;
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return rv;
}
nsTableColFrame * nsTableColGroupFrame::GetFirstColumn()
{
return GetNextColumn(nullptr);
}
nsTableColFrame * nsTableColGroupFrame::GetNextColumn(nsIFrame *aChildFrame)
--- a/layout/tables/nsTableColGroupFrame.h
+++ b/layout/tables/nsTableColGroupFrame.h
@@ -101,20 +101,20 @@ public:
bool aResetSubsequentColIndices);
/** reflow of a column group is a trivial matter of reflowing
* the col group's children (columns), and setting this frame
* to 0-size. Since tables are row-centric, column group frames
* don't play directly in the rendering game. They do however
* maintain important state that effects table and cell layout.
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableColGroupFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -1759,31 +1759,31 @@ nsTableFrame::RequestSpecialHeightReflow
*
* XXXldb Special height reflow should really be its own method, not
* part of nsIFrame::Reflow. It should then call nsIFrame::Reflow on
* the contents of the cells to do the necessary vertical resizing.
*
******************************************************************************************/
/* Layout the entire inner table. */
-nsresult nsTableFrame::Reflow(nsPresContext* aPresContext,
+void
+nsTableFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
bool isPaginated = aPresContext->IsPaginated();
aStatus = NS_FRAME_COMPLETE;
if (!GetPrevInFlow() && !mTableLayoutStrategy) {
NS_ASSERTION(false, "strategy should have been created in Init");
- return NS_ERROR_NULL_POINTER;
- }
- nsresult rv = NS_OK;
+ return;
+ }
// see if collapsing borders need to be calculated
if (!GetPrevInFlow() && IsBorderCollapse() && NeedToCalcBCBorders()) {
CalcBCBorders();
}
aDesiredSize.Width() = aReflowState.AvailableWidth();
@@ -1913,17 +1913,16 @@ nsresult nsTableFrame::Reflow(nsPresCont
if ((GetStateBits() & NS_FRAME_FIRST_REFLOW) ||
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
nsIFrame::InvalidateFrame();
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return rv;
}
void
nsTableFrame::FixupPositionedTableParts(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState)
{
auto positionedParts =
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -333,20 +333,20 @@ public:
* do column balancing
* set mFirstPassValid to true
* do pass 2
* use column widths to Reflow cells
* </pre>
*
* @see nsIFrame::Reflow
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
nsresult ReflowTable(nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nscoord aAvailHeight,
nsIFrame*& aLastChildReflowed,
nsReflowStatus& aStatus);
nsFrameList& GetColGroups();
--- a/layout/tables/nsTableOuterFrame.cpp
+++ b/layout/tables/nsTableOuterFrame.cpp
@@ -833,17 +833,17 @@ nsTableOuterFrame::OuterBeginReflowChild
uint8_t captionSide = GetCaptionSide();
if (captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM ||
captionSide == NS_STYLE_CAPTION_SIDE_BOTTOM_OUTSIDE) {
childRS.mFlags.mIsTopOfPage = false;
}
}
}
-nsresult
+void
nsTableOuterFrame::OuterDoReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
const nsHTMLReflowState& aChildRS,
nsHTMLReflowMetrics& aMetrics,
nsReflowStatus& aStatus)
{
// use the current position as a best guess for placement
@@ -854,18 +854,18 @@ nsTableOuterFrame::OuterDoReflowChild(ns
// frame, because outer table frames always assume that their inner table
// frames don't go away. If an outer table frame is removed because it is
// a next-in-flow of an already complete outer table frame, then it will
// take care of removing it's inner table frame.
if (aChildFrame == InnerTableFrame()) {
flags |= NS_FRAME_NO_DELETE_NEXT_IN_FLOW_CHILD;
}
- return ReflowChild(aChildFrame, aPresContext, aMetrics, aChildRS,
- childPt.x, childPt.y, flags, aStatus);
+ ReflowChild(aChildFrame, aPresContext, aMetrics, aChildRS,
+ childPt.x, childPt.y, flags, aStatus);
}
void
nsTableOuterFrame::UpdateReflowMetrics(uint8_t aCaptionSide,
nsHTMLReflowMetrics& aMet,
const nsMargin& aInnerMargin,
const nsMargin& aCaptionMargin)
{
@@ -874,25 +874,25 @@ nsTableOuterFrame::UpdateReflowMetrics(u
aMet.SetOverflowAreasToDesiredBounds();
ConsiderChildOverflow(aMet.mOverflowAreas, InnerTableFrame());
if (mCaptionFrames.NotEmpty()) {
ConsiderChildOverflow(aMet.mOverflowAreas, mCaptionFrames.FirstChild());
}
}
-nsresult nsTableOuterFrame::Reflow(nsPresContext* aPresContext,
+void
+nsTableOuterFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aOuterRS,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableOuterFrame");
DISPLAY_REFLOW(aPresContext, this, aOuterRS, aDesiredSize, aStatus);
- nsresult rv = NS_OK;
uint8_t captionSide = GetCaptionSide();
// Initialize out parameters
aDesiredSize.Width() = aDesiredSize.Height() = 0;
aStatus = NS_FRAME_COMPLETE;
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
// Set up our kids. They're already present, on an overflow list,
@@ -976,19 +976,18 @@ nsresult nsTableOuterFrame::Reflow(nsPre
}
// First reflow the caption.
nsHTMLReflowMetrics captionMet(captionRS->GetWritingMode());
nsSize captionSize;
nsMargin captionMargin;
if (mCaptionFrames.NotEmpty()) {
nsReflowStatus capStatus; // don't let the caption cause incomplete
- rv = OuterDoReflowChild(aPresContext, mCaptionFrames.FirstChild(),
- *captionRS, captionMet, capStatus);
- if (NS_FAILED(rv)) return rv;
+ OuterDoReflowChild(aPresContext, mCaptionFrames.FirstChild(),
+ *captionRS, captionMet, capStatus);
captionSize.width = captionMet.Width();
captionSize.height = captionMet.Height();
captionMargin = captionRS->ComputedPhysicalMargin();
// Now that we know the height of the caption, reduce the available height
// for the table frame if we are height constrained and the caption is above
// or below the inner table.
if (NS_UNCONSTRAINEDSIZE != aOuterRS.AvailableHeight()) {
nscoord captionHeight = 0;
@@ -1007,19 +1006,18 @@ nsresult nsTableOuterFrame::Reflow(nsPre
} else {
captionSize.SizeTo(0,0);
captionMargin.SizeTo(0,0,0,0);
}
// Then, now that we know how much to reduce the width of the inner
// table to account for side captions, reflow the inner table.
nsHTMLReflowMetrics innerMet(innerRS->GetWritingMode());
- rv = OuterDoReflowChild(aPresContext, InnerTableFrame(), *innerRS,
- innerMet, aStatus);
- if (NS_FAILED(rv)) return rv;
+ OuterDoReflowChild(aPresContext, InnerTableFrame(), *innerRS,
+ innerMet, aStatus);
nsSize innerSize;
innerSize.width = innerMet.Width();
innerSize.height = innerMet.Height();
nsMargin innerMargin = innerRS->ComputedPhysicalMargin();
nsSize containSize = GetContainingBlockSize(aOuterRS);
// Now that we've reflowed both we can place them.
@@ -1062,17 +1060,16 @@ nsresult nsTableOuterFrame::Reflow(nsPre
aStatus);
}
FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aOuterRS, aStatus);
// Return our desired rect
NS_FRAME_SET_TRUNCATION(aStatus, aOuterRS, aDesiredSize);
- return rv;
}
nsIAtom*
nsTableOuterFrame::GetType() const
{
return nsGkAtoms::tableOuterFrame;
}
--- a/layout/tables/nsTableOuterFrame.h
+++ b/layout/tables/nsTableOuterFrame.h
@@ -109,20 +109,20 @@ public:
virtual nsSize ComputeAutoSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap) MOZ_OVERRIDE;
/** process a reflow command for the table.
* This involves reflowing the caption and the inner table.
* @see nsIFrame::Reflow */
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableOuterFrame
*/
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
@@ -252,21 +252,21 @@ protected:
// reflow the child (caption or innertable frame)
void OuterBeginReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
const nsHTMLReflowState& aOuterRS,
void* aChildRSSpace,
nscoord aAvailWidth);
- nsresult OuterDoReflowChild(nsPresContext* aPresContext,
- nsIFrame* aChildFrame,
- const nsHTMLReflowState& aChildRS,
- nsHTMLReflowMetrics& aMetrics,
- nsReflowStatus& aStatus);
+ void OuterDoReflowChild(nsPresContext* aPresContext,
+ nsIFrame* aChildFrame,
+ const nsHTMLReflowState& aChildRS,
+ nsHTMLReflowMetrics& aMetrics,
+ nsReflowStatus& aStatus);
// Set the reflow metrics
void UpdateReflowMetrics(uint8_t aCaptionSide,
nsHTMLReflowMetrics& aMet,
const nsMargin& aInnerMargin,
const nsMargin& aCaptionMargin);
// Get the margin. aMarginNoAuto is aMargin, but with auto
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -1030,41 +1030,39 @@ nsTableRowFrame::ReflowChildren(nsPresCo
aDesiredSize.UnionOverflowAreasWithDesiredBounds();
FinishAndStoreOverflow(&aDesiredSize);
return rv;
}
/** Layout the entire row.
* This method stacks cells horizontally according to HTML 4.0 rules.
*/
-nsresult
+void
nsTableRowFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableRowFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
- nsresult rv = NS_OK;
nsTableFrame* tableFrame = nsTableFrame::GetTableFrame(this);
const nsStyleVisibility* rowVis = StyleVisibility();
bool collapseRow = (NS_STYLE_VISIBILITY_COLLAPSE == rowVis->mVisible);
if (collapseRow) {
tableFrame->SetNeedToCollapse(true);
}
// see if a special height reflow needs to occur due to having a pct height
nsTableFrame::CheckRequestSpecialHeightReflow(aReflowState);
// See if we have a cell with specified/pct height
InitHasCellWithStyleHeight(tableFrame);
- rv = ReflowChildren(aPresContext, aDesiredSize, aReflowState, *tableFrame,
- aStatus);
+ ReflowChildren(aPresContext, aDesiredSize, aReflowState, *tableFrame, aStatus);
if (aPresContext->IsPaginated() && !NS_FRAME_IS_FULLY_COMPLETE(aStatus) &&
ShouldAvoidBreakInside(aReflowState)) {
aStatus = NS_INLINE_LINE_BREAK_BEFORE();
}
// just set our width to what was available. The table will calculate the width and not use our value.
aDesiredSize.Width() = aReflowState.AvailableWidth();
@@ -1072,17 +1070,16 @@ nsTableRowFrame::Reflow(nsPresContext*
// If our parent is in initial reflow, it'll handle invalidating our
// entire overflow rect.
if (!(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW) &&
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
InvalidateFrame();
}
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return rv;
}
/**
* This function is called by the row group frame's SplitRowGroup() code when
* pushing a row frame that has cell frames that span into it. The cell frame
* should be reflowed with the specified height
*/
nscoord
--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -75,20 +75,20 @@ public:
*
* @param aDesiredSize width set to width of the sum of the cells, height set to
* height of cells with rowspan=1.
*
* @see nsIFrame::Reflow
* @see nsTableFrame::BalanceColumnWidths
* @see nsTableFrame::ShrinkWrapChildren
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
void DidResize();
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowFrame
*/
--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1280,26 +1280,25 @@ nsTableRowGroupFrame::SplitRowGroup(nsPr
}
return NS_OK;
}
/** Layout the entire row group.
* This method stacks rows vertically according to HTML 4.0 rules.
* Rows are responsible for layout of their children.
*/
-nsresult
+void
nsTableRowGroupFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsTableRowGroupFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
- nsresult rv = NS_OK;
aStatus = NS_FRAME_COMPLETE;
// Row geometry may be going to change so we need to invalidate any row cursor.
ClearRowCursor();
// see if a special height reflow needs to occur due to having a pct height
nsTableFrame::CheckRequestSpecialHeightReflow(aReflowState);
@@ -1311,18 +1310,18 @@ nsTableRowGroupFrame::Reflow(nsPresConte
tableFrame->SetNeedToCollapse(true);
}
// Check for an overflow list
MoveOverflowToChildList();
// Reflow the existing frames.
bool splitDueToPageBreak = false;
- rv = ReflowChildren(aPresContext, aDesiredSize, state, aStatus,
- &splitDueToPageBreak);
+ ReflowChildren(aPresContext, aDesiredSize, state, aStatus,
+ &splitDueToPageBreak);
// See if all the frames fit. Do not try to split anything if we're
// not paginated ... we can't split across columns yet.
if (aReflowState.mFlags.mTableIsSplittable &&
NS_UNCONSTRAINEDSIZE != aReflowState.AvailableHeight() &&
(NS_FRAME_NOT_COMPLETE == aStatus || splitDueToPageBreak ||
aDesiredSize.Height() > aReflowState.AvailableHeight())) {
// Nope, find a place to split the row group
@@ -1354,17 +1353,16 @@ nsTableRowGroupFrame::Reflow(nsPresConte
// entire overflow rect.
if (!(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW) &&
nsSize(aDesiredSize.Width(), aDesiredSize.Height()) != mRect.Size()) {
InvalidateFrame();
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return rv;
}
bool
nsTableRowGroupFrame::UpdateOverflow()
{
// Row cursor invariants depend on the visual overflow area of the rows,
// which may have changed, so we need to clear the cursor now.
ClearRowCursor();
--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -95,20 +95,20 @@ public:
* Rows are all set to the same width and stacked vertically.
* <P> rows are not split unless absolutely necessary.
*
* @param aDesiredSize width set to width of rows, height set to
* sum of height of rows that fit in aMaxSize.height.
*
* @see nsIFrame::Reflow
*/
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual bool UpdateOverflow() MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableRowGroupFrame
*/
--- a/layout/xul/nsBoxFrame.cpp
+++ b/layout/xul/nsBoxFrame.cpp
@@ -621,17 +621,17 @@ nsBoxFrame::GetPrefWidth(nsRenderingCont
GetBorderAndPadding(bp);
result = prefSize.width - bp.LeftRight();
result = std::max(result, 0);
return result;
}
-nsresult
+void
nsBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// If you make changes to this method, please keep nsLeafBoxFrame::Reflow
// in sync, if the changes are applicable there.
@@ -731,17 +731,16 @@ nsBoxFrame::Reflow(nsPresContext*
}
}
#endif
ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
- return NS_OK;
}
nsSize
nsBoxFrame::GetPrefSize(nsBoxLayoutState& aBoxLayoutState)
{
NS_ASSERTION(aBoxLayoutState.GetRenderingContext(),
"must have rendering context");
--- a/layout/xul/nsBoxFrame.h
+++ b/layout/xul/nsBoxFrame.h
@@ -79,20 +79,20 @@ public:
virtual nsresult AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
virtual void MarkIntrinsicWidthsDirty() MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -175,17 +175,17 @@ nsLeafBoxFrame::ComputeAutoSize(nsRender
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap)
{
// Important: NOT calling our direct superclass here!
return nsFrame::ComputeAutoSize(aRenderingContext, aCBSize, aAvailableWidth,
aMargin, aBorder, aPadding, aShrinkWrap);
}
-nsresult
+void
nsLeafBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// This is mostly a copy of nsBoxFrame::Reflow().
// We aren't able to share an implementation because of the frame
// class hierarchy. If you make changes here, please keep
@@ -307,18 +307,16 @@ nsLeafBoxFrame::Reflow(nsPresContext*
if (maxElementWidth) {
printf("MW:%d\n", *maxElementWidth);
} else {
printf("MW:?\n");
}
}
#endif
-
- return NS_OK;
}
#ifdef DEBUG_FRAME_DUMP
nsresult
nsLeafBoxFrame::GetFrameName(nsAString& aResult) const
{
return MakeFrameName(NS_LITERAL_STRING("LeafBox"), aResult);
}
--- a/layout/xul/nsLeafBoxFrame.h
+++ b/layout/xul/nsLeafBoxFrame.h
@@ -44,20 +44,20 @@ public:
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
// Our auto size is that provided by nsFrame, not nsLeafFrame
virtual nsSize ComputeAutoSize(nsRenderingContext *aRenderingContext,
nsSize aCBSize, nscoord aAvailableWidth,
nsSize aMargin, nsSize aBorder,
nsSize aPadding, bool aShrinkWrap) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult CharacterDataChanged(CharacterDataChangeInfo* aInfo) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
--- a/layout/xul/nsRootBoxFrame.cpp
+++ b/layout/xul/nsRootBoxFrame.cpp
@@ -61,17 +61,17 @@ public:
virtual nsresult AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
virtual nsresult RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
+ virtual void Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsresult HandleEvent(nsPresContext* aPresContext,
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
@@ -181,17 +181,17 @@ nsRootBoxFrame::RemoveFrame(ChildListID
return rv;
}
#ifdef DEBUG_REFLOW
int32_t gReflows = 0;
#endif
-nsresult
+void
nsRootBoxFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRootBoxFrame");
#ifdef DEBUG_REFLOW
--- a/layout/xul/nsScrollbarFrame.cpp
+++ b/layout/xul/nsScrollbarFrame.cpp
@@ -48,35 +48,32 @@ nsScrollbarFrame::Init(nsIContent* aCont
// We want to be a reflow root since we use reflows to move the
// slider. Any reflow inside the scrollbar frame will be a reflow to
// move the slider and will thus not change anything outside of the
// scrollbar or change the size of the scrollbar frame.
mState |= NS_FRAME_REFLOW_ROOT;
}
-nsresult
+void
nsScrollbarFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
- nsresult rv = nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBoxFrame::Reflow(aPresContext, aDesiredSize, aReflowState, aStatus);
// nsGfxScrollFrame may have told us to shrink to nothing. If so, make sure our
// desired size agrees.
if (aReflowState.AvailableWidth() == 0) {
aDesiredSize.Width() = 0;
}
if (aReflowState.AvailableHeight() == 0) {
aDesiredSize.Height() = 0;
}
-
- return NS_OK;
}
nsIAtom*
nsScrollbarFrame::GetType() const
{
return nsGkAtoms::scrollbarFrame;
}
--- a/layout/xul/nsScrollbarFrame.h
+++ b/layout/xul/nsScrollbarFrame.h
@@ -55,20 +55,20 @@ public:
NS_IMETHOD HandleRelease(nsPresContext* aPresContext,
mozilla::WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
virtual void Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
- virtual nsresult Reflow(nsPresContext* aPresContext,
- nsHTMLReflowMetrics& aDesiredSize,
- const nsHTMLReflowState& aReflowState,
- nsReflowStatus& aStatus) MOZ_OVERRIDE;
+ virtual void Reflow(nsPresContext* aPresContext,
+ nsHTMLReflowMetrics& aDesiredSize,
+ const nsHTMLReflowState& aReflowState,
+ nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
void SetScrollbarMediatorContent(nsIContent* aMediator);
nsIScrollbarMediator* GetScrollbarMediator();
// nsBox methods
