--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -4544,37 +4544,35 @@ nsCSSFrameConstructor::InitAndRestoreFra
nsIFrame* aParentFrame,
nsIFrame* aPrevInFlow,
nsIFrame* aNewFrame,
bool aAllowCounters)
{
NS_PRECONDITION(mUpdateCount != 0,
"Should be in an update while creating frames");
- nsresult rv = NS_OK;
-
NS_ASSERTION(aNewFrame, "Null frame cannot be initialized");
if (!aNewFrame)
return NS_ERROR_NULL_POINTER;
// Initialize the frame
- rv = aNewFrame->Init(aContent, aParentFrame, aPrevInFlow);
+ aNewFrame->Init(aContent, aParentFrame, aPrevInFlow);
aNewFrame->AddStateBits(aState.mAdditionalStateBits);
if (aState.mFrameState) {
// Restore frame state for just the newly created frame.
RestoreFrameStateFor(aNewFrame, aState.mFrameState);
}
if (aAllowCounters && !aPrevInFlow &&
mCounterManager.AddCounterResetsAndIncrements(aNewFrame)) {
CountersDirty();
}
- return rv;
+ return NS_OK;
}
already_AddRefed<nsStyleContext>
nsCSSFrameConstructor::ResolveStyleContext(nsIFrame* aParentFrame,
nsIContent* aContent,
nsFrameConstructorState* aState)
{
nsStyleContext* parentStyleContext = nullptr;
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -1366,38 +1366,26 @@ nsComboboxControlFrame::CreateFrameFor(n
}
// Start by by creating our anonymous block frame
mDisplayFrame = new (shell) nsComboboxDisplayFrame(styleContext, this);
if (MOZ_UNLIKELY(!mDisplayFrame)) {
return nullptr;
}
- nsresult rv = mDisplayFrame->Init(mContent, this, nullptr);
- if (NS_FAILED(rv)) {
- mDisplayFrame->Destroy();
- mDisplayFrame = nullptr;
- return nullptr;
- }
+ mDisplayFrame->Init(mContent, this, nullptr);
// Create a text frame and put it inside the block frame
nsIFrame* textFrame = NS_NewTextFrame(shell, textStyleContext);
if (MOZ_UNLIKELY(!textFrame)) {
return nullptr;
}
// initialize the text frame
- rv = textFrame->Init(aContent, mDisplayFrame, nullptr);
- if (NS_FAILED(rv)) {
- mDisplayFrame->Destroy();
- mDisplayFrame = nullptr;
- textFrame->Destroy();
- textFrame = nullptr;
- return nullptr;
- }
+ textFrame->Init(aContent, mDisplayFrame, nullptr);
mDisplayContent->SetPrimaryFrame(textFrame);
nsFrameList textList(textFrame, textFrame);
mDisplayFrame->SetInitialChildList(kPrincipalList, textList);
return mDisplayFrame;
}
void
--- a/layout/forms/nsFileControlFrame.cpp
+++ b/layout/forms/nsFileControlFrame.cpp
@@ -66,30 +66,25 @@ NS_IMPL_FRAMEARENA_HELPERS(nsFileControl
nsFileControlFrame::nsFileControlFrame(nsStyleContext* aContext):
nsBlockFrame(aContext)
{
AddStateBits(NS_BLOCK_FLOAT_MGR);
}
-NS_IMETHODIMP
+void
nsFileControlFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
mMouseListener = new BrowseMouseListener(this);
- NS_ENSURE_TRUE(mMouseListener, NS_ERROR_OUT_OF_MEMORY);
mCaptureMouseListener = new CaptureMouseListener(this);
- NS_ENSURE_TRUE(mCaptureMouseListener, NS_ERROR_OUT_OF_MEMORY);
-
- return rv;
}
void
nsFileControlFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
ENSURE_TRUE(mContent);
// Remove the drag events
--- a/layout/forms/nsFileControlFrame.h
+++ b/layout/forms/nsFileControlFrame.h
@@ -19,19 +19,19 @@ class nsIDOMDragEvent;
class nsFileControlFrame : public nsBlockFrame,
public nsIFormControlFrame,
public nsIAnonymousContentCreator
{
public:
nsFileControlFrame(nsStyleContext* aContext);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
--- a/layout/forms/nsHTMLButtonControlFrame.cpp
+++ b/layout/forms/nsHTMLButtonControlFrame.cpp
@@ -53,27 +53,24 @@ nsHTMLButtonControlFrame::~nsHTMLButtonC
void
nsHTMLButtonControlFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
nsContainerFrame::DestroyFrom(aDestructRoot);
}
-NS_IMETHODIMP
+void
nsHTMLButtonControlFrame::Init(
nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
- if (NS_SUCCEEDED(rv)) {
- mRenderer.SetFrame(this, PresContext());
- }
- return rv;
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ mRenderer.SetFrame(this, PresContext());
}
NS_QUERYFRAME_HEAD(nsHTMLButtonControlFrame)
NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
#ifdef ACCESSIBILITY
a11y::AccType
--- a/layout/forms/nsHTMLButtonControlFrame.h
+++ b/layout/forms/nsHTMLButtonControlFrame.h
@@ -47,19 +47,19 @@ public:
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
virtual nsStyleContext* GetAdditionalStyleContext(int32_t aIndex) const;
virtual void SetAdditionalStyleContext(int32_t aIndex,
nsStyleContext* aStyleContext) MOZ_OVERRIDE;
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
--- a/layout/forms/nsImageControlFrame.cpp
+++ b/layout/forms/nsImageControlFrame.cpp
@@ -36,19 +36,19 @@ IntPointDtorFunc(void *aObject, nsIAtom
class nsImageControlFrame : public nsImageControlFrameSuper,
public nsIFormControlFrame
{
public:
nsImageControlFrame(nsStyleContext* aContext);
~nsImageControlFrame();
virtual void DestroyFrom(nsIFrame* aDestructRoot);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
@@ -99,33 +99,30 @@ nsImageControlFrame::DestroyFrom(nsIFram
nsIFrame*
NS_NewImageControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsImageControlFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsImageControlFrame)
-NS_IMETHODIMP
+void
nsImageControlFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsImageControlFrameSuper::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsImageControlFrameSuper::Init(aContent, aParent, aPrevInFlow);
- // nsIntPoint allocation can fail, in which case we just set the property
- // to null, which is safe
if (aPrevInFlow) {
- return NS_OK;
+ return;
}
- return mContent->SetProperty(nsGkAtoms::imageClickedPoint,
- new nsIntPoint(0, 0),
- IntPointDtorFunc);
+ mContent->SetProperty(nsGkAtoms::imageClickedPoint,
+ new nsIntPoint(0, 0),
+ IntPointDtorFunc);
}
NS_QUERYFRAME_HEAD(nsImageControlFrame)
NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsImageControlFrameSuper)
#ifdef ACCESSIBILITY
a11y::AccType
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -979,33 +979,28 @@ nsListControlFrame::GetSizeAttribute(uin
rv = selectElement->GetSize(aSize);
NS_RELEASE(selectElement);
}
return rv;
}
//---------------------------------------------------------
-NS_IMETHODIMP
+void
nsListControlFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult result = nsHTMLScrollFrame::Init(aContent, aParent, aPrevInFlow);
-
- // get the receiver interface from the browser button's content node
- NS_ENSURE_STATE(mContent);
+ nsHTMLScrollFrame::Init(aContent, aParent, aPrevInFlow);
// we shouldn't have to unregister this listener because when
// our frame goes away all these content node go away as well
// because our frame is the only one who references them.
// we need to hook up our listeners before the editor is initialized
mEventListener = new nsListEventListener(this);
- if (!mEventListener)
- return NS_ERROR_OUT_OF_MEMORY;
mContent->AddEventListener(NS_LITERAL_STRING("keypress"), mEventListener,
false, false);
mContent->AddEventListener(NS_LITERAL_STRING("mousedown"), mEventListener,
false, false);
mContent->AddEventListener(NS_LITERAL_STRING("mouseup"), mEventListener,
false, false);
mContent->AddEventListener(NS_LITERAL_STRING("mousemove"), mEventListener,
@@ -1014,18 +1009,16 @@ nsListControlFrame::Init(nsIContent*
mStartSelectionIndex = kNothingSelected;
mEndSelectionIndex = kNothingSelected;
mLastDropdownBackstopColor = PresContext()->DefaultBackgroundColor();
if (IsInDropDownMode()) {
AddStateBits(NS_FRAME_IN_POPUP);
}
-
- return result;
}
already_AddRefed<nsIContent>
nsListControlFrame::GetOptionAsContent(nsIDOMHTMLOptionsCollection* aCollection, int32_t aIndex)
{
nsIContent * content = nullptr;
nsCOMPtr<nsIDOMHTMLOptionElement> optionElement = GetOption(aCollection,
aIndex);
--- a/layout/forms/nsListControlFrame.h
+++ b/layout/forms/nsListControlFrame.h
@@ -59,19 +59,19 @@ public:
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
NS_IMETHOD Reflow(nsPresContext* aCX,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus);
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -6450,40 +6450,38 @@ nsBlockFrame::ChildIsDirty(nsIFrame* aCh
if (isValid) {
iter.GetContainer()->MarkLineDirty(iter.GetLine(), iter.GetLineList());
}
}
nsBlockFrameSuper::ChildIsDirty(aChild);
}
-NS_IMETHODIMP
+void
nsBlockFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
if (aPrevInFlow) {
// Copy over the inherited block frame bits from the prev-in-flow.
SetFlags(aPrevInFlow->GetStateBits() &
(NS_BLOCK_FLAGS_MASK & ~NS_BLOCK_FLAGS_NON_INHERITED_MASK));
}
- nsresult rv = nsBlockFrameSuper::Init(aContent, aParent, aPrevInFlow);
+ nsBlockFrameSuper::Init(aContent, aParent, aPrevInFlow);
if (!aPrevInFlow ||
aPrevInFlow->GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)
AddStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
if ((GetStateBits() &
(NS_FRAME_FONT_INFLATION_CONTAINER | NS_BLOCK_FLOAT_MGR)) ==
(NS_FRAME_FONT_INFLATION_CONTAINER | NS_BLOCK_FLOAT_MGR)) {
AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
}
-
- return rv;
}
NS_IMETHODIMP
nsBlockFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
NS_ASSERTION(aListID != kPrincipalList ||
(GetStateBits() & (NS_BLOCK_FRAME_HAS_INSIDE_BULLET |
--- a/layout/generic/nsBlockFrame.h
+++ b/layout/generic/nsBlockFrame.h
@@ -130,19 +130,19 @@ public:
reverse_line_iterator rline(nsLineBox* aList) { return mLines.rbegin(aList); }
friend nsIFrame* NS_NewBlockFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, uint32_t aFlags);
// nsQueryFrame
NS_DECL_QUERYFRAME
// nsIFrame
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList);
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList);
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList);
NS_IMETHOD RemoveFrame(ChildListID aListID,
--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -54,30 +54,29 @@ NS_IMPL_FRAMEARENA_HELPERS(nsContainerFr
nsContainerFrame::~nsContainerFrame()
{
}
NS_QUERYFRAME_HEAD(nsContainerFrame)
NS_QUERYFRAME_ENTRY(nsContainerFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSplittableFrame)
-NS_IMETHODIMP
+void
nsContainerFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
+ nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
if (aPrevInFlow) {
// Make sure we copy bits from our prev-in-flow that will affect
// us. A continuation for a container frame needs to know if it
// has a child with a view so that we'll properly reposition it.
if (aPrevInFlow->GetStateBits() & NS_FRAME_HAS_CHILD_WITH_VIEW)
AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW);
}
- return rv;
}
NS_IMETHODIMP
nsContainerFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
nsresult result;
if (mFrames.NotEmpty()) {
--- a/layout/generic/nsContainerFrame.h
+++ b/layout/generic/nsContainerFrame.h
@@ -48,19 +48,19 @@ class FramePropertyTable;
class nsContainerFrame : public nsSplittableFrame
{
public:
NS_DECL_FRAMEARENA_HELPERS
NS_DECL_QUERYFRAME_TARGET(nsContainerFrame)
NS_DECL_QUERYFRAME
// nsIFrame overrides
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList);
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList);
NS_IMETHOD RemoveFrame(ChildListID aListID,
--- a/layout/generic/nsFirstLetterFrame.cpp
+++ b/layout/generic/nsFirstLetterFrame.cpp
@@ -49,17 +49,17 @@ nsFirstLetterFrame::GetType() const
void
nsFirstLetterFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
BuildDisplayListForInline(aBuilder, aDirtyRect, aLists);
}
-NS_IMETHODIMP
+void
nsFirstLetterFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsRefPtr<nsStyleContext> newSC;
if (aPrevInFlow) {
// Get proper style context for ourselves. We're creating the frame
// that represents everything *except* the first letter, so just create
@@ -68,17 +68,17 @@ nsFirstLetterFrame::Init(nsIContent*
if (parentStyleContext) {
newSC = PresContext()->StyleSet()->
ResolveStyleForNonElement(parentStyleContext);
if (newSC)
SetStyleContextWithoutNotification(newSC);
}
}
- return nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
}
NS_IMETHODIMP
nsFirstLetterFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
nsFrameManager *frameManager = PresContext()->FrameManager();
--- a/layout/generic/nsFirstLetterFrame.h
+++ b/layout/generic/nsFirstLetterFrame.h
@@ -18,19 +18,19 @@ public:
NS_DECL_FRAMEARENA_HELPERS
nsFirstLetterFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) {}
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
#ifdef DEBUG
NS_IMETHOD GetFrameName(nsAString& aResult) const MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
bool IsFloating() const { return GetStateBits() & NS_FRAME_OUT_OF_FLOW; }
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -487,17 +487,17 @@ IsFontSizeInflationContainer(nsIFrame* a
aFrame->GetType() == nsGkAtoms::brFrame ||
aFrame->IsFrameOfType(nsIFrame::eMathML),
"line participants must not be containers");
NS_ASSERTION(aFrame->GetType() != nsGkAtoms::bulletFrame || isInline,
"bullets should not be containers");
return !isInline;
}
-NS_IMETHODIMP
+void
nsFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_PRECONDITION(!mContent, "Double-initing a frame?");
NS_ASSERTION(IsFrameOfType(eDEBUGAllFrames) &&
!IsFrameOfType(eDEBUGNoFrames),
"IsFrameOfType implementation that doesn't call base class");
@@ -555,18 +555,16 @@ nsFrame::Init(nsIContent* aContent,
(GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER),
"root frame should always be a container");
}
DidSetStyleContext(nullptr);
if (IsBoxWrapped())
InitBoxMetrics(false);
-
- return NS_OK;
}
NS_IMETHODIMP nsFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
// XXX This shouldn't be getting called at all, but currently is for backwards
// compatility reasons...
#if 0
--- a/layout/generic/nsFrame.h
+++ b/layout/generic/nsFrame.h
@@ -137,19 +137,19 @@ protected:
public:
// nsQueryFrame
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList);
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList);
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList);
NS_IMETHOD RemoveFrame(ChildListID aListID,
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -244,24 +244,23 @@ nsHTMLFramesetFrame::FrameResizePrefCall
kNameSpaceID_None,
nsGkAtoms::frameborder,
nsIDOMMutationEvent::MODIFICATION);
}
return 0;
}
-NS_IMETHODIMP
+void
nsHTMLFramesetFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
// find the highest ancestor that is a frameset
- nsresult rv = NS_OK;
nsIFrame* parentFrame = GetParent();
mTopLevelFrameset = this;
while (parentFrame) {
nsHTMLFramesetFrame* frameset = do_QueryFrame(parentFrame);
if (frameset) {
mTopLevelFrameset = frameset;
parentFrame = parentFrame->GetParent();
} else {
@@ -276,57 +275,49 @@ nsHTMLFramesetFrame::Init(nsIContent*
int32_t borderWidth = GetBorderWidth(presContext, false);
nscolor borderColor = GetBorderColor();
// Get the rows= cols= data
HTMLFrameSetElement* ourContent = HTMLFrameSetElement::FromContent(mContent);
NS_ASSERTION(ourContent, "Someone gave us a broken frameset element!");
const nsFramesetSpec* rowSpecs = nullptr;
const nsFramesetSpec* colSpecs = nullptr;
- nsresult result = ourContent->GetRowSpec(&mNumRows, &rowSpecs);
- NS_ENSURE_SUCCESS(result, result);
- result = ourContent->GetColSpec(&mNumCols, &colSpecs);
- NS_ENSURE_SUCCESS(result, result);
+ // GetRowSpec and GetColSpec can fail, but when they do they set
+ // mNumRows and mNumCols respectively to 0, so we deal with it fine.
+ ourContent->GetRowSpec(&mNumRows, &rowSpecs);
+ ourContent->GetColSpec(&mNumCols, &colSpecs);
// Maximum value of mNumRows and mNumCols is NS_MAX_FRAMESET_SPEC_COUNT
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nscoord));
mRowSizes = new nscoord[mNumRows];
mColSizes = new nscoord[mNumCols];
- if (!mRowSizes || !mColSizes)
- return NS_ERROR_OUT_OF_MEMORY;
// Ensure we can't overflow numCells
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT < INT32_MAX / NS_MAX_FRAMESET_SPEC_COUNT);
int32_t numCells = mNumRows*mNumCols;
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT < UINT_MAX / sizeof(nsHTMLFramesetBorderFrame*));
mVerBorders = new nsHTMLFramesetBorderFrame*[mNumCols]; // 1 more than number of ver borders
- if (!mVerBorders)
- return NS_ERROR_OUT_OF_MEMORY;
for (int verX = 0; verX < mNumCols; verX++)
mVerBorders[verX] = nullptr;
mHorBorders = new nsHTMLFramesetBorderFrame*[mNumRows]; // 1 more than number of hor borders
- if (!mHorBorders)
- return NS_ERROR_OUT_OF_MEMORY;
for (int horX = 0; horX < mNumRows; horX++)
mHorBorders[horX] = nullptr;
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT
< UINT_MAX / sizeof(int32_t) / NS_MAX_FRAMESET_SPEC_COUNT);
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT
< UINT_MAX / sizeof(nsFrameborder) / NS_MAX_FRAMESET_SPEC_COUNT);
PR_STATIC_ASSERT(NS_MAX_FRAMESET_SPEC_COUNT
< UINT_MAX / sizeof(nsBorderColor) / NS_MAX_FRAMESET_SPEC_COUNT);
mChildFrameborder = new nsFrameborder[numCells];
mChildBorderColors = new nsBorderColor[numCells];
- if (!mChildFrameborder || !mChildBorderColors)
- return NS_ERROR_OUT_OF_MEMORY;
// create the children frames; skip content which isn't <frameset> or <frame>
mChildCount = 0; // number of <frame> or <frameset> children
nsIFrame* frame;
// number of any type of children
uint32_t numChildren = mContent->GetChildCount();
@@ -354,89 +345,65 @@ nsHTMLFramesetFrame::Init(nsIContent*
// IMPORTANT: This must match the conditions in
// nsCSSFrameConstructor::ContentAppended/Inserted/Removed
if (!child->IsHTML())
continue;
nsIAtom *tag = child->Tag();
if (tag == nsGkAtoms::frameset || tag == nsGkAtoms::frame) {
nsRefPtr<nsStyleContext> kidSC;
- nsresult result;
kidSC = shell->StyleSet()->ResolveStyleFor(child->AsElement(),
mStyleContext);
if (tag == nsGkAtoms::frameset) {
frame = NS_NewHTMLFramesetFrame(shell, kidSC);
- if (MOZ_UNLIKELY(!frame))
- return NS_ERROR_OUT_OF_MEMORY;
nsHTMLFramesetFrame* childFrame = (nsHTMLFramesetFrame*)frame;
childFrame->SetParentFrameborder(frameborder);
childFrame->SetParentBorderWidth(borderWidth);
childFrame->SetParentBorderColor(borderColor);
- result = frame->Init(child, this, nullptr);
- if (NS_FAILED(result)) {
- frame->Destroy();
- return result;
- }
+ frame->Init(child, this, nullptr);
mChildBorderColors[mChildCount].Set(childFrame->GetBorderColor());
} else { // frame
frame = NS_NewSubDocumentFrame(shell, kidSC);
- if (MOZ_UNLIKELY(!frame))
- return NS_ERROR_OUT_OF_MEMORY;
- result = frame->Init(child, this, nullptr);
- if (NS_FAILED(result)) {
- frame->Destroy();
- return result;
- }
+ frame->Init(child, this, nullptr);
mChildFrameborder[mChildCount] = GetFrameBorder(child);
mChildBorderColors[mChildCount].Set(GetBorderColor(child));
}
child->SetPrimaryFrame(frame);
- if (NS_FAILED(result))
- return result;
-
mFrames.AppendFrame(nullptr, frame);
mChildCount++;
}
}
mNonBlankChildCount = mChildCount;
// add blank frames for frameset cells that had no content provided
for (int blankX = mChildCount; blankX < numCells; blankX++) {
nsRefPtr<nsStyleContext> pseudoStyleContext;
pseudoStyleContext = shell->StyleSet()->
ResolveAnonymousBoxStyle(nsCSSAnonBoxes::framesetBlank, mStyleContext);
- if (!pseudoStyleContext) {
- return NS_ERROR_OUT_OF_MEMORY;
- }
// XXX the blank frame is using the content of its parent - at some point it
// should just have null content, if we support that
nsHTMLFramesetBlankFrame* blankFrame = new (shell) nsHTMLFramesetBlankFrame(pseudoStyleContext);
- result = blankFrame->Init(mContent, this, nullptr);
- if (NS_FAILED(result)) {
- blankFrame->Destroy();
- return result;
- }
+ blankFrame->Init(mContent, this, nullptr);
mFrames.AppendFrame(nullptr, blankFrame);
mChildBorderColors[mChildCount].Set(NO_COLOR);
mChildCount++;
}
mNonBorderChildCount = mChildCount;
- return rv;
}
NS_IMETHODIMP
nsHTMLFramesetFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
// We do this weirdness where we create our child frames in Init(). On the
// other hand, we're going to get a SetInitialChildList() with an empty list
--- a/layout/generic/nsFrameSetFrame.h
+++ b/layout/generic/nsFrameSetFrame.h
@@ -73,19 +73,19 @@ public:
NS_DECL_QUERYFRAME_TARGET(nsHTMLFramesetFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
nsHTMLFramesetFrame(nsStyleContext* aContext);
virtual ~nsHTMLFramesetFrame();
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList);
static bool gDragInProgress;
void GetSizeOfChild(nsIFrame* aChild, nsSize& aSize);
--- a/layout/generic/nsHTMLCanvasFrame.cpp
+++ b/layout/generic/nsHTMLCanvasFrame.cpp
@@ -85,29 +85,27 @@ public:
nsIFrame*
NS_NewHTMLCanvasFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsHTMLCanvasFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsHTMLCanvasFrame)
-NS_IMETHODIMP
+void
nsHTMLCanvasFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
+ nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
// We can fill in the canvas before the canvas frame is created, in
// which case we never get around to marking the layer active. Therefore,
// we mark it active here when we create the frame.
MarkLayersActive(nsChangeHint(0));
-
- return rv;
}
nsHTMLCanvasFrame::~nsHTMLCanvasFrame()
{
}
nsIntSize
nsHTMLCanvasFrame::GetCanvasSize()
--- a/layout/generic/nsHTMLCanvasFrame.h
+++ b/layout/generic/nsHTMLCanvasFrame.h
@@ -33,19 +33,19 @@ public:
typedef mozilla::layers::Layer Layer;
typedef mozilla::layers::LayerManager LayerManager;
typedef mozilla::FrameLayerBuilder::ContainerParameters ContainerParameters;
NS_DECL_FRAMEARENA_HELPERS
nsHTMLCanvasFrame(nsStyleContext* aContext) : nsContainerFrame(aContext) {}
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
nsDisplayItem* aItem,
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -572,27 +572,25 @@ public:
/**
* Called to initialize the frame. This is called immediately after creating
* the frame.
*
* If the frame is a continuing frame, then aPrevInFlow indicates the previous
* frame (the frame that was split).
*
* If you want a view associated with your frame, you should create the view
- * now.
+ * after Init() has returned.
*
* @param aContent the content object associated with the frame
- * @param aGeometricParent the geometric parent frame
- * @param aContentParent the content parent frame
- * @param aContext the style context associated with the frame
+ * @param aParent the parent frame
* @param aPrevInFlow the prev-in-flow frame
*/
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) = 0;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) = 0;
/**
* Destroys this frame and each of its child frames (recursively calls
* Destroy() for each child). If this frame is a first-continuation, this
* also removes the frame from the primary frame map and clears undisplayed
* content for its content node.
* If the frame is a placeholder, it also ensures the out-of-flow frame's
* removal and destruction.
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -221,28 +221,29 @@ nsImageFrame::DestroyFrom(nsIFrame* aDes
if (mDisplayingIcon)
gIconLoad->RemoveIconObserver(this);
nsSplittableFrame::DestroyFrom(aDestructRoot);
}
-NS_IMETHODIMP
+void
nsImageFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsSplittableFrame::Init(aContent, aParent, aPrevInFlow);
mListener = new nsImageListener(this);
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(aContent);
- NS_ENSURE_TRUE(imageLoader, NS_ERROR_UNEXPECTED);
+ if (!imageLoader) {
+ NS_RUNTIMEABORT("Why do we have an nsImageFrame here at all?");
+ }
{
// Push a null JSContext on the stack so that code that runs
// within the below code doesn't think it's being called by
// JS. See bug 604262.
nsCxPusher pusher;
pusher.PushNull();
@@ -270,18 +271,16 @@ nsImageFrame::Init(nsIContent* aCon
// Set the animation mode here
if (currentRequest) {
nsCOMPtr<imgIContainer> image;
currentRequest->GetImage(getter_AddRefs(image));
if (image) {
image->SetAnimationMode(aPresContext->ImageAnimationMode());
}
}
-
- return rv;
}
bool
nsImageFrame::UpdateIntrinsicSize(imgIContainer* aImage)
{
NS_PRECONDITION(aImage, "null image");
if (!aImage)
return false;
--- a/layout/generic/nsImageFrame.h
+++ b/layout/generic/nsImageFrame.h
@@ -69,19 +69,19 @@ public:
NS_DECL_FRAMEARENA_HELPERS
nsImageFrame(nsStyleContext* aContext);
NS_DECL_QUERYFRAME_TARGET(nsImageFrame)
NS_DECL_QUERYFRAME
virtual void DestroyFrom(nsIFrame* aDestructRoot);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext);
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext);
virtual IntrinsicSize GetIntrinsicSize();
virtual nsSize GetIntrinsicRatio();
NS_IMETHOD Reflow(nsPresContext* aPresContext,
--- a/layout/generic/nsObjectFrame.cpp
+++ b/layout/generic/nsObjectFrame.cpp
@@ -283,27 +283,25 @@ nsObjectFrame::AccessibleType()
NS_IMETHODIMP nsObjectFrame::GetPluginPort(HWND *aPort)
{
*aPort = (HWND) mInstanceOwner->GetPluginPortFromWidget();
return NS_OK;
}
#endif
#endif
-NS_IMETHODIMP
+void
nsObjectFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
PR_LOG(GetObjectFrameLog(), PR_LOG_DEBUG,
("Initializing nsObjectFrame %p for content %p\n", this, aContent));
- nsresult rv = nsObjectFrameSuper::Init(aContent, aParent, aPrevInFlow);
-
- return rv;
+ nsObjectFrameSuper::Init(aContent, aParent, aPrevInFlow);
}
void
nsObjectFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
if (mReflowCallbackPosted) {
PresContext()->PresShell()->CancelReflowCallback(this);
}
--- a/layout/generic/nsObjectFrame.h
+++ b/layout/generic/nsObjectFrame.h
@@ -45,19 +45,19 @@ public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewObjectFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
NS_DECL_QUERYFRAME
NS_DECL_QUERYFRAME_TARGET(nsObjectFrame)
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext);
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext);
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus);
NS_IMETHOD DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
--- a/layout/generic/nsSplittableFrame.cpp
+++ b/layout/generic/nsSplittableFrame.cpp
@@ -10,30 +10,28 @@
#include "nsSplittableFrame.h"
#include "nsIContent.h"
#include "nsPresContext.h"
#include "nsStyleContext.h"
NS_IMPL_FRAMEARENA_HELPERS(nsSplittableFrame)
-NS_IMETHODIMP
+void
nsSplittableFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsFrame::Init(aContent, aParent, aPrevInFlow);
+ nsFrame::Init(aContent, aParent, aPrevInFlow);
if (aPrevInFlow) {
// Hook the frame into the flow
SetPrevInFlow(aPrevInFlow);
aPrevInFlow->SetNextInFlow(this);
}
-
- return rv;
}
void
nsSplittableFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// Disconnect from the flow list
if (mPrevContinuation || mNextContinuation) {
RemoveFromFlow(this);
--- a/layout/generic/nsSplittableFrame.h
+++ b/layout/generic/nsSplittableFrame.h
@@ -15,19 +15,19 @@
#include "nsFrame.h"
// Derived class that allows splitting
class nsSplittableFrame : public nsFrame
{
public:
NS_DECL_FRAMEARENA_HELPERS
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nsSplittableType GetSplittableType() const;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
/*
* Frame continuations can be either fluid or not:
* Fluid continuations ("in-flows") are the result of line breaking,
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -109,30 +109,28 @@ private:
};
static void
InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent);
static void
EndSwapDocShellsForViews(nsView* aView);
-NS_IMETHODIMP
+void
nsSubDocumentFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
// determine if we are a <frame> or <iframe>
if (aContent) {
nsCOMPtr<nsIDOMHTMLFrameElement> frameElem = do_QueryInterface(aContent);
mIsInline = frameElem ? false : true;
}
- nsresult rv = nsLeafFrame::Init(aContent, aParent, aPrevInFlow);
- if (NS_FAILED(rv))
- return rv;
+ nsLeafFrame::Init(aContent, aParent, aPrevInFlow);
// We are going to create an inner view. If we need a view for the
// OuterFrame but we wait for the normal view creation path in
// nsCSSFrameConstructor, then we will lose because the inner view's
// parent will already have been set to some outer view (e.g., the
// canvas) when it really needs to have this frame's view as its
// parent. So, create this frame's view right away, whether we
// really need it or not, and the inner view will get it as the
@@ -164,17 +162,16 @@ nsSubDocumentFrame::Init(nsIContent*
// Presentation is for a different document, don't restore it.
frameloader->Hide();
}
}
frameloader->SetDetachedSubdocView(nullptr, nullptr);
}
nsContentUtils::AddScriptRunner(new AsyncFrameInit(this));
- return NS_OK;
}
inline int32_t ConvertOverflow(uint8_t aOverflow)
{
switch (aOverflow) {
case NS_STYLE_OVERFLOW_VISIBLE:
case NS_STYLE_OVERFLOW_AUTO:
return nsIScrollable::Scrollbar_Auto;
--- a/layout/generic/nsSubDocumentFrame.h
+++ b/layout/generic/nsSubDocumentFrame.h
@@ -34,19 +34,19 @@ public:
virtual bool IsFrameOfType(uint32_t aFlags) const
{
// nsLeafFrame is already eReplacedContainsBlock, but that's somewhat bogus
return nsLeafFrame::IsFrameOfType(aFlags &
~(nsIFrame::eReplaced | nsIFrame::eReplacedContainsBlock));
}
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext);
virtual nscoord GetPrefWidth(nsRenderingContext *aRenderingContext);
virtual IntrinsicSize GetIntrinsicSize();
virtual nsSize GetIntrinsicRatio();
--- a/layout/generic/nsTextFrame.h
+++ b/layout/generic/nsTextFrame.h
@@ -50,19 +50,19 @@ public:
// nsQueryFrame
NS_DECL_QUERYFRAME
// nsIFrame
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
NS_IMETHOD GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor);
NS_IMETHOD CharacterDataChanged(CharacterDataChangeInfo* aInfo);
--- a/layout/generic/nsTextFrameThebes.cpp
+++ b/layout/generic/nsTextFrameThebes.cpp
@@ -3907,17 +3907,17 @@ nsTextFrame::AccessibleType()
}
return a11y::eTextLeafType;
}
#endif
//-----------------------------------------------------------------------------
-NS_IMETHODIMP
+void
nsTextFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(!aPrevInFlow, "Can't be a continuation!");
NS_PRECONDITION(aContent->IsNodeOfType(nsINode::eTEXT),
"Bogus content!");
@@ -3928,17 +3928,17 @@ nsTextFrame::Init(nsIContent* aCont
aContent->DeleteProperty(nsGkAtoms::flowlength);
}
// Since our content has a frame now, this flag is no longer needed.
aContent->UnsetFlags(NS_CREATE_FRAME_IF_NON_WHITESPACE);
// We're not a continuing frame.
// mContentOffset = 0; not necessary since we get zeroed out at init
- return nsFrame::Init(aContent, aParent, aPrevInFlow);
+ nsFrame::Init(aContent, aParent, aPrevInFlow);
}
void
nsTextFrame::ClearFrameOffsetCache()
{
// See if we need to remove ourselves from the offset cache
if (GetStateBits() & TEXT_IN_OFFSET_CACHE) {
nsIFrame* primaryFrame = mContent->GetPrimaryFrame();
@@ -3970,19 +3970,19 @@ nsTextFrame::DestroyFrom(nsIFrame* aDest
}
class nsContinuingTextFrame : public nsTextFrame {
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewContinuingTextFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
virtual nsIFrame* GetPrevContinuation() const {
return mPrevContinuation;
}
NS_IMETHOD SetPrevContinuation(nsIFrame* aPrevContinuation) {
NS_ASSERTION (!aPrevContinuation || GetType() == aPrevContinuation->GetType(),
@@ -4021,24 +4021,24 @@ public:
uint32_t aSkippedMaxLength = UINT32_MAX)
{ return NS_ERROR_NOT_IMPLEMENTED; } // Call on a primary text frame only
protected:
nsContinuingTextFrame(nsStyleContext* aContext) : nsTextFrame(aContext) {}
nsIFrame* mPrevContinuation;
};
-NS_IMETHODIMP
+void
nsContinuingTextFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aPrevInFlow, "Must be a continuation!");
// NOTE: bypassing nsTextFrame::Init!!!
- nsresult rv = nsFrame::Init(aContent, aParent, aPrevInFlow);
+ nsFrame::Init(aContent, aParent, aPrevInFlow);
#ifdef IBMBIDI
nsTextFrame* nextContinuation =
static_cast<nsTextFrame*>(aPrevInFlow->GetNextContinuation());
#endif // IBMBIDI
// Hook the frame into the flow
SetPrevInFlow(aPrevInFlow);
aPrevInFlow->SetNextInFlow(this);
@@ -4087,18 +4087,16 @@ nsContinuingTextFrame::Init(nsIContent*
"stealing text from different type of BIDI continuation");
nextContinuation->mContentOffset = mContentOffset;
nextContinuation = static_cast<nsTextFrame*>(nextContinuation->GetNextContinuation());
}
}
mState |= NS_FRAME_IS_BIDI;
} // prev frame is bidi
#endif // IBMBIDI
-
- return rv;
}
void
nsContinuingTextFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
ClearFrameOffsetCache();
// The text associated with this frame will become associated with our
--- a/layout/generic/nsViewportFrame.cpp
+++ b/layout/generic/nsViewportFrame.cpp
@@ -24,31 +24,29 @@ using namespace mozilla;
nsIFrame*
NS_NewViewportFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) ViewportFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(ViewportFrame)
-NS_IMETHODIMP
+void
ViewportFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = Super::Init(aContent, aParent, aPrevInFlow);
+ Super::Init(aContent, aParent, aPrevInFlow);
nsIFrame* parent = nsLayoutUtils::GetCrossDocParentFrame(this);
if (parent) {
nsFrameState state = parent->GetStateBits();
mState |= state & (NS_FRAME_IN_POPUP);
}
-
- return rv;
}
NS_IMETHODIMP
ViewportFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
// See which child list to add the frames to
#ifdef DEBUG
--- a/layout/generic/nsViewportFrame.h
+++ b/layout/generic/nsViewportFrame.h
@@ -28,19 +28,19 @@ public:
typedef nsContainerFrame Super;
ViewportFrame(nsStyleContext* aContext)
: nsContainerFrame(aContext)
{}
virtual ~ViewportFrame() { } // useful for debugging
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
NS_IMETHOD InsertFrames(ChildListID aListID,
--- a/layout/mathml/nsMathMLmactionFrame.cpp
+++ b/layout/mathml/nsMathMLmactionFrame.cpp
@@ -86,30 +86,30 @@ nsMathMLmactionFrame::~nsMathMLmactionFr
false);
mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mouseover"), mListener,
false);
mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mouseout"), mListener,
false);
}
}
-NS_IMETHODIMP
+void
nsMathMLmactionFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
// Init our local attributes
mChildCount = -1; // these will be updated in GetSelectedFrame()
mSelection = 0;
mSelectedFrame = nullptr;
mActionType = GetActionType(aContent);
// Let the base class do the rest
- return nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
}
NS_IMETHODIMP
nsMathMLmactionFrame::TransmitAutomaticData() {
// The REC defines the following element to be space-like:
// * an maction element whose selected sub-expression exists and is
// space-like;
nsIMathMLFrame* mathMLFrame = do_QueryFrame(mSelectedFrame);
--- a/layout/mathml/nsMathMLmactionFrame.h
+++ b/layout/mathml/nsMathMLmactionFrame.h
@@ -19,20 +19,20 @@ class nsMathMLmactionFrame : public nsMa
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewMathMLmactionFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
NS_IMETHOD
TransmitAutomaticData();
- NS_IMETHOD
+ virtual void
Init(nsIContent* aContent,
nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD
SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
virtual nsresult
ChildListChanged(int32_t aModType) MOZ_OVERRIDE;
--- a/layout/mathml/nsMathMLmrootFrame.cpp
+++ b/layout/mathml/nsMathMLmrootFrame.cpp
@@ -46,33 +46,31 @@ nsMathMLmrootFrame::nsMathMLmrootFrame(n
mBarRect()
{
}
nsMathMLmrootFrame::~nsMathMLmrootFrame()
{
}
-NS_IMETHODIMP
+void
nsMathMLmrootFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
nsPresContext *presContext = PresContext();
// No need to track the style context given to our MathML char.
// The Style System will use Get/SetAdditionalStyleContext() to keep it
// up-to-date if dynamic changes arise.
nsAutoString sqrChar; sqrChar.Assign(kSqrChar);
mSqrChar.SetData(presContext, sqrChar);
ResolveMathMLCharStyle(presContext, mContent, mStyleContext, &mSqrChar, true);
-
- return rv;
}
NS_IMETHODIMP
nsMathMLmrootFrame::TransmitAutomaticData()
{
// 1. The REC says:
// The <mroot> element increments scriptlevel by 2, and sets displaystyle to
// "false", within index, but leaves both attributes unchanged within base.
--- a/layout/mathml/nsMathMLmrootFrame.h
+++ b/layout/mathml/nsMathMLmrootFrame.h
@@ -21,20 +21,20 @@ public:
friend nsIFrame* NS_NewMathMLmrootFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
virtual void
SetAdditionalStyleContext(int32_t aIndex,
nsStyleContext* aStyleContext);
virtual nsStyleContext*
GetAdditionalStyleContext(int32_t aIndex) const;
- NS_IMETHOD
+ virtual void
Init(nsIContent* aContent,
nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD
TransmitAutomaticData() MOZ_OVERRIDE;
NS_IMETHOD
Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
--- a/layout/mathml/nsMathMLmsqrtFrame.cpp
+++ b/layout/mathml/nsMathMLmsqrtFrame.cpp
@@ -30,26 +30,24 @@ nsMathMLmsqrtFrame::nsMathMLmsqrtFrame(n
nsMathMLmencloseFrame(aContext)
{
}
nsMathMLmsqrtFrame::~nsMathMLmsqrtFrame()
{
}
-NS_IMETHODIMP
+void
nsMathMLmsqrtFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsMathMLContainerFrame::Init(aContent, aParent, aPrevInFlow);
AllocateMathMLChar(NOTATION_RADICAL);
mNotationsToDraw |= NOTATION_RADICAL;
-
- return rv;
}
NS_IMETHODIMP
nsMathMLmsqrtFrame::InheritAutomaticData(nsIFrame* aParent)
{
nsMathMLContainerFrame::InheritAutomaticData(aParent);
mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
--- a/layout/mathml/nsMathMLmsqrtFrame.h
+++ b/layout/mathml/nsMathMLmsqrtFrame.h
@@ -34,20 +34,20 @@ but can be set explicitly only on <mstyl
class nsMathMLmsqrtFrame : public nsMathMLmencloseFrame {
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewMathMLmsqrtFrame(nsIPresShell* aPresShell,
nsStyleContext* aContext);
- NS_IMETHOD
+ virtual void
Init(nsIContent* aContent,
nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD
InheritAutomaticData(nsIFrame* aParent) MOZ_OVERRIDE;
NS_IMETHOD
AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
--- a/layout/svg/SVGFEContainerFrame.cpp
+++ b/layout/svg/SVGFEContainerFrame.cpp
@@ -42,19 +42,19 @@ public:
{
return MakeFrameName(NS_LITERAL_STRING("SVGFEContainer"), aResult);
}
#endif
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgFEContainerFrame
*/
virtual nsIAtom* GetType() const;
@@ -79,26 +79,26 @@ NS_IMPL_FRAMEARENA_HELPERS(SVGFEContaine
/* virtual */ void
SVGFEContainerFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
SVGFEContainerFrameBase::DidSetStyleContext(aOldStyleContext);
nsSVGEffects::InvalidateRenderingObservers(this);
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
SVGFEContainerFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eFILTER),
"Trying to construct an SVGFEContainerFrame for a "
"content element that doesn't support the right interfaces");
- return SVGFEContainerFrameBase::Init(aContent, aParent, aPrevInFlow);
+ SVGFEContainerFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
SVGFEContainerFrame::GetType() const
{
return nsGkAtoms::svgFEContainerFrame;
}
--- a/layout/svg/SVGFEImageFrame.cpp
+++ b/layout/svg/SVGFEImageFrame.cpp
@@ -26,19 +26,19 @@ protected:
: SVGFEImageFrameBase(aContext)
{
AddStateBits(NS_FRAME_SVG_LAYOUT | NS_STATE_SVG_NONDISPLAY_CHILD);
}
public:
NS_DECL_FRAMEARENA_HELPERS
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
virtual bool IsFrameOfType(uint32_t aFlags) const
{
return SVGFEImageFrameBase::IsFrameOfType(aFlags & ~(nsIFrame::eSVG));
}
#ifdef DEBUG
@@ -91,17 +91,17 @@ SVGFEImageFrame::DestroyFrom(nsIFrame* a
if (imageLoader) {
imageLoader->FrameDestroyed(this);
imageLoader->DecrementVisibleCount();
}
SVGFEImageFrameBase::DestroyFrom(aDestructRoot);
}
-NS_IMETHODIMP
+void
SVGFEImageFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::feImage),
"Trying to construct an SVGFEImageFrame for a "
"content element that doesn't support the right interfaces");
@@ -109,18 +109,16 @@ SVGFEImageFrame::Init(nsIContent* aConte
nsCOMPtr<nsIImageLoadingContent> imageLoader =
do_QueryInterface(SVGFEImageFrameBase::mContent);
if (imageLoader) {
imageLoader->FrameCreated(this);
// We assume that feImage's are always visible.
imageLoader->IncrementVisibleCount();
}
-
- return NS_OK;
}
nsIAtom *
SVGFEImageFrame::GetType() const
{
return nsGkAtoms::svgFEImageFrame;
}
--- a/layout/svg/SVGFELeafFrame.cpp
+++ b/layout/svg/SVGFELeafFrame.cpp
@@ -25,19 +25,19 @@ protected:
{
AddStateBits(NS_FRAME_SVG_LAYOUT | NS_STATE_SVG_NONDISPLAY_CHILD);
}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
virtual bool IsFrameOfType(uint32_t aFlags) const
{
return SVGFELeafFrameBase::IsFrameOfType(aFlags & ~(nsIFrame::eSVG));
}
#ifdef DEBUG
@@ -77,26 +77,26 @@ NS_IMPL_FRAMEARENA_HELPERS(SVGFELeafFram
/* virtual */ void
SVGFELeafFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
SVGFELeafFrameBase::DidSetStyleContext(aOldStyleContext);
nsSVGEffects::InvalidateRenderingObservers(this);
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
SVGFELeafFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eFILTER),
"Trying to construct an SVGFELeafFrame for a "
"content element that doesn't support the right interfaces");
- return SVGFELeafFrameBase::Init(aContent, aParent, aPrevInFlow);
+ SVGFELeafFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
SVGFELeafFrame::GetType() const
{
return nsGkAtoms::svgFELeafFrame;
}
--- a/layout/svg/SVGViewFrame.cpp
+++ b/layout/svg/SVGViewFrame.cpp
@@ -30,19 +30,19 @@ protected:
{
AddStateBits(NS_STATE_SVG_NONDISPLAY_CHILD);
}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
virtual bool IsFrameOfType(uint32_t aFlags) const
{
return SVGViewFrameBase::IsFrameOfType(aFlags & ~(nsIFrame::eSVG));
}
#ifdef DEBUG
@@ -73,25 +73,25 @@ nsIFrame*
NS_NewSVGViewFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) SVGViewFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(SVGViewFrame)
#ifdef DEBUG
-NS_IMETHODIMP
+void
SVGViewFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::view),
"Content is not an SVG view");
- return SVGViewFrameBase::Init(aContent, aParent, aPrevInFlow);
+ SVGViewFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
SVGViewFrame::GetType() const
{
return nsGkAtoms::svgViewFrame;
}
--- a/layout/svg/nsSVGAFrame.cpp
+++ b/layout/svg/nsSVGAFrame.cpp
@@ -27,19 +27,19 @@ class nsSVGAFrame : public nsSVGAFrameBa
protected:
nsSVGAFrame(nsStyleContext* aContext) :
nsSVGAFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
// nsIFrame:
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
/**
@@ -81,26 +81,26 @@ NS_NewSVGAFrame(nsIPresShell* aPresShell
return new (aPresShell) nsSVGAFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGAFrame)
//----------------------------------------------------------------------
// nsIFrame methods
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGAFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::a),
"Trying to construct an SVGAFrame for a "
"content element that doesn't support the right interfaces");
- return nsSVGAFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGAFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
NS_IMETHODIMP
nsSVGAFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
--- a/layout/svg/nsSVGClipPathFrame.cpp
+++ b/layout/svg/nsSVGClipPathFrame.cpp
@@ -291,26 +291,26 @@ nsSVGClipPathFrame::AttributeChanged(int
nsSVGEffects::InvalidateRenderingObservers(this);
}
}
return nsSVGClipPathFrameBase::AttributeChanged(aNameSpaceID,
aAttribute, aModType);
}
-NS_IMETHODIMP
+void
nsSVGClipPathFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::clipPath),
"Content is not an SVG clipPath!");
AddStateBits(NS_STATE_SVG_CLIPPATH_CHILD);
- return nsSVGClipPathFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGClipPathFrameBase::Init(aContent, aParent, aPrevInFlow);
}
nsIAtom *
nsSVGClipPathFrame::GetType() const
{
return nsGkAtoms::svgClipPathFrame;
}
--- a/layout/svg/nsSVGClipPathFrame.h
+++ b/layout/svg/nsSVGClipPathFrame.h
@@ -51,19 +51,19 @@ public:
bool IsValid();
// nsIFrame interface:
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgClipPathFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGContainerFrame.cpp
+++ b/layout/svg/nsSVGContainerFrame.cpp
@@ -75,27 +75,26 @@ nsSVGContainerFrame::UpdateOverflow()
if (mState & NS_STATE_SVG_NONDISPLAY_CHILD) {
// We don't maintain overflow rects.
// XXX It would have be better if the restyle request hadn't even happened.
return false;
}
return nsSVGContainerFrameBase::UpdateOverflow();
}
-NS_IMETHODIMP
+void
nsSVGDisplayContainerFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
if (!(GetStateBits() & NS_STATE_IS_OUTER_SVG)) {
AddStateBits(aParent->GetStateBits() &
(NS_STATE_SVG_NONDISPLAY_CHILD | NS_STATE_SVG_CLIPPATH_CHILD));
}
- nsresult rv = nsSVGContainerFrame::Init(aContent, aParent, aPrevInFlow);
- return rv;
+ nsSVGContainerFrame::Init(aContent, aParent, aPrevInFlow);
}
void
nsSVGDisplayContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
if (mContent->IsSVG() &&
--- a/layout/svg/nsSVGContainerFrame.h
+++ b/layout/svg/nsSVGContainerFrame.h
@@ -120,19 +120,19 @@ public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
NS_IMETHOD RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual bool IsSVGTransformed(gfxMatrix *aOwnTransform = nullptr,
gfxMatrix *aFromParentTransform = nullptr) const MOZ_OVERRIDE;
--- a/layout/svg/nsSVGFilterFrame.cpp
+++ b/layout/svg/nsSVGFilterFrame.cpp
@@ -523,25 +523,25 @@ nsSVGFilterFrame::GetPostFilterBounds(ns
nsresult rv = instance.get()->ComputeOutputBBox(&bbox);
if (NS_SUCCEEDED(rv)) {
return TransformFilterSpaceToFrameSpace(instance.get(), &bbox);
}
return nsRect();
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGFilterFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::filter),
"Content is not an SVG filter");
- return nsSVGFilterFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGFilterFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGFilterFrame::GetType() const
{
return nsGkAtoms::svgFilterFrame;
}
--- a/layout/svg/nsSVGFilterFrame.h
+++ b/layout/svg/nsSVGFilterFrame.h
@@ -92,19 +92,19 @@ public:
* @param aPreFilterBounds The pre-filter visual overflow rect of
* aFilteredFrame, if non-null.
*/
nsRect GetPostFilterBounds(nsIFrame *aFilteredFrame,
const gfxRect *aOverrideBBox = nullptr,
const nsRect *aPreFilterBounds = nullptr);
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgFilterFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGForeignObjectFrame.cpp
+++ b/layout/svg/nsSVGForeignObjectFrame.cpp
@@ -47,34 +47,32 @@ nsSVGForeignObjectFrame::nsSVGForeignObj
//----------------------------------------------------------------------
// nsIFrame methods
NS_QUERYFRAME_HEAD(nsSVGForeignObjectFrame)
NS_QUERYFRAME_ENTRY(nsISVGChildFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGForeignObjectFrameBase)
-NS_IMETHODIMP
+void
nsSVGForeignObjectFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::foreignObject),
"Content is not an SVG foreignObject!");
- nsresult rv = nsSVGForeignObjectFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGForeignObjectFrameBase::Init(aContent, aParent, aPrevInFlow);
AddStateBits(aParent->GetStateBits() &
(NS_STATE_SVG_NONDISPLAY_CHILD | NS_STATE_SVG_CLIPPATH_CHILD));
AddStateBits(NS_FRAME_FONT_INFLATION_CONTAINER |
NS_FRAME_FONT_INFLATION_FLOW_ROOT);
- if (NS_SUCCEEDED(rv) &&
- !(mState & NS_STATE_SVG_NONDISPLAY_CHILD)) {
+ if (!(mState & NS_STATE_SVG_NONDISPLAY_CHILD)) {
nsSVGUtils::GetOuterSVGFrame(this)->RegisterForeignObject(this);
}
- return rv;
}
void nsSVGForeignObjectFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// Only unregister if we registered in the first place:
if (!(mState & NS_STATE_SVG_NONDISPLAY_CHILD)) {
nsSVGUtils::GetOuterSVGFrame(this)->UnregisterForeignObject(this);
}
--- a/layout/svg/nsSVGForeignObjectFrame.h
+++ b/layout/svg/nsSVGForeignObjectFrame.h
@@ -26,19 +26,19 @@ class nsSVGForeignObjectFrame : public n
protected:
nsSVGForeignObjectFrame(nsStyleContext* aContext);
public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) MOZ_OVERRIDE;
virtual nsIFrame* GetContentInsertionFrame() {
--- a/layout/svg/nsSVGGFrame.cpp
+++ b/layout/svg/nsSVGGFrame.cpp
@@ -23,26 +23,26 @@ nsIFrame*
NS_NewSVGGFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsSVGGFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGGFrame)
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGGFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsCOMPtr<SVGTransformableElement> transformable = do_QueryInterface(aContent);
NS_ASSERTION(transformable,
"The element doesn't support nsIDOMSVGTransformable\n");
- return nsSVGGFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGGFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGGFrame::GetType() const
{
return nsGkAtoms::svgGFrame;
}
--- a/layout/svg/nsSVGGFrame.h
+++ b/layout/svg/nsSVGGFrame.h
@@ -18,19 +18,19 @@ class nsSVGGFrame : public nsSVGGFrameBa
protected:
nsSVGGFrame(nsStyleContext* aContext) :
nsSVGGFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgGFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGGeometryFrame.cpp
+++ b/layout/svg/nsSVGGeometryFrame.cpp
@@ -14,25 +14,24 @@
#include "nsSVGPaintServerFrame.h"
#include "nsSVGUtils.h"
NS_IMPL_FRAMEARENA_HELPERS(nsSVGGeometryFrame)
//----------------------------------------------------------------------
// nsIFrame methods
-NS_IMETHODIMP
+void
nsSVGGeometryFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
AddStateBits(aParent->GetStateBits() &
(NS_STATE_SVG_NONDISPLAY_CHILD | NS_STATE_SVG_CLIPPATH_CHILD));
- nsresult rv = nsSVGGeometryFrameBase::Init(aContent, aParent, aPrevInFlow);
- return rv;
+ nsSVGGeometryFrameBase::Init(aContent, aParent, aPrevInFlow);
}
//----------------------------------------------------------------------
uint16_t
nsSVGGeometryFrame::GetClipRule()
{
return StyleSVG()->mClipRule;
--- a/layout/svg/nsSVGGeometryFrame.h
+++ b/layout/svg/nsSVGGeometryFrame.h
@@ -37,19 +37,19 @@ protected:
nsSVGGeometryFrame(nsStyleContext *aContext)
: nsSVGGeometryFrameBase(aContext)
{
AddStateBits(NS_FRAME_SVG_LAYOUT);
}
public:
// nsIFrame interface:
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual bool IsFrameOfType(uint32_t aFlags) const
{
return nsSVGGeometryFrameBase::IsFrameOfType(aFlags & ~(nsIFrame::eSVG | nsIFrame::eSVGGeometry));
}
// nsSVGGeometryFrame methods:
virtual gfxMatrix GetCanvasTM(uint32_t aFor) = 0;
--- a/layout/svg/nsSVGGlyphFrame.cpp
+++ b/layout/svg/nsSVGGlyphFrame.cpp
@@ -308,17 +308,17 @@ nsSVGGlyphFrame::DidSetStyleContext(nsSt
nsSVGGlyphFrameBase::DidSetStyleContext(aOldStyleContext);
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
ClearTextRun();
NotifyGlyphMetricsChange();
}
}
-NS_IMETHODIMP
+void
nsSVGGlyphFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
#ifdef DEBUG
NS_ASSERTION(aParent, "null parent");
nsIFrame* ancestorFrame = nsSVGUtils::GetFirstNonAAncestorFrame(aParent);
@@ -327,17 +327,17 @@ nsSVGGlyphFrame::Init(nsIContent* aConte
nsSVGTextContainerFrame *metrics = do_QueryFrame(ancestorFrame);
NS_ASSERTION(metrics,
"trying to construct an SVGGlyphFrame for an invalid container");
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
"trying to construct an SVGGlyphFrame for wrong content element");
#endif /* DEBUG */
- return nsSVGGlyphFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGGlyphFrameBase::Init(aContent, aParent, aPrevInFlow);
}
nsIAtom *
nsSVGGlyphFrame::GetType() const
{
return nsGkAtoms::svgGlyphFrame;
}
--- a/layout/svg/nsSVGGlyphFrame.h
+++ b/layout/svg/nsSVGGlyphFrame.h
@@ -188,19 +188,19 @@ public:
bool EndsWithWhitespace() const;
bool IsAllWhitespace() const;
// nsIFrame interface:
NS_IMETHOD CharacterDataChanged(CharacterDataChangeInfo* aInfo);
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgGlyphFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGGradientFrame.cpp
+++ b/layout/svg/nsSVGGradientFrame.cpp
@@ -415,25 +415,25 @@ nsSVGGradientFrame::GetStopFrame(int32_t
return next->GetStopFrame(aIndex, aStopFrame);
}
// -------------------------------------------------------------------------
// Linear Gradients
// -------------------------------------------------------------------------
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGLinearGradientFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::linearGradient),
"Content is not an SVG linearGradient");
- return nsSVGLinearGradientFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGLinearGradientFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom*
nsSVGLinearGradientFrame::GetType() const
{
return nsGkAtoms::svgLinearGradientFrame;
}
@@ -528,25 +528,25 @@ nsSVGLinearGradientFrame::CreateGradient
return pattern;
}
// -------------------------------------------------------------------------
// Radial Gradients
// -------------------------------------------------------------------------
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGRadialGradientFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::radialGradient),
"Content is not an SVG radialGradient");
- return nsSVGRadialGradientFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGRadialGradientFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom*
nsSVGRadialGradientFrame::GetType() const
{
return nsGkAtoms::svgRadialGradientFrame;
}
--- a/layout/svg/nsSVGGradientFrame.h
+++ b/layout/svg/nsSVGGradientFrame.h
@@ -138,19 +138,19 @@ protected:
nsSVGLinearGradientFrame(nsStyleContext* aContext) :
nsSVGLinearGradientFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame interface:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const; // frame type: nsGkAtoms::svgLinearGradientFrame
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
@@ -183,19 +183,19 @@ protected:
nsSVGRadialGradientFrame(nsStyleContext* aContext) :
nsSVGRadialGradientFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame interface:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
virtual nsIAtom* GetType() const; // frame type: nsGkAtoms::svgRadialGradientFrame
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
--- a/layout/svg/nsSVGImageFrame.cpp
+++ b/layout/svg/nsSVGImageFrame.cpp
@@ -61,19 +61,19 @@ public:
// nsSVGPathGeometryFrame methods:
virtual uint16_t GetHitTestFlags();
// nsIFrame interface:
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgImageFrame
*/
virtual nsIAtom* GetType() const;
@@ -124,45 +124,43 @@ nsSVGImageFrame::~nsSVGImageFrame()
imageLoader->RemoveObserver(mListener);
}
reinterpret_cast<nsSVGImageListener*>(mListener.get())->SetFrame(nullptr);
}
mListener = nullptr;
}
-NS_IMETHODIMP
+void
nsSVGImageFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::image),
"Content is not an SVG image!");
- nsresult rv = nsSVGImageFrameBase::Init(aContent, aParent, aPrevInFlow);
- if (NS_FAILED(rv)) return rv;
+ nsSVGImageFrameBase::Init(aContent, aParent, aPrevInFlow);
mListener = new nsSVGImageListener(this);
- if (!mListener) return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
- NS_ENSURE_TRUE(imageLoader, NS_ERROR_UNEXPECTED);
+ if (!imageLoader) {
+ NS_RUNTIMEABORT("Why is this not an image loading content?");
+ }
// We should have a PresContext now, so let's notify our image loader that
// we need to register any image animations with the refresh driver.
imageLoader->FrameCreated(this);
// Push a null JSContext on the stack so that code that runs within
// the below code doesn't think it's being called by JS. See bug
// 604262.
nsCxPusher pusher;
pusher.PushNull();
imageLoader->AddObserver(mListener);
-
- return NS_OK;
}
/* virtual */ void
nsSVGImageFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
nsCOMPtr<nsIImageLoadingContent> imageLoader =
do_QueryInterface(nsFrame::mContent);
--- a/layout/svg/nsSVGInnerSVGFrame.cpp
+++ b/layout/svg/nsSVGInnerSVGFrame.cpp
@@ -30,25 +30,25 @@ NS_IMPL_FRAMEARENA_HELPERS(nsSVGInnerSVG
// nsIFrame methods
NS_QUERYFRAME_HEAD(nsSVGInnerSVGFrame)
NS_QUERYFRAME_ENTRY(nsSVGInnerSVGFrame)
NS_QUERYFRAME_ENTRY(nsISVGSVGFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGInnerSVGFrameBase)
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGInnerSVGFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::svg),
"Content is not an SVG 'svg' element!");
- return nsSVGInnerSVGFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGInnerSVGFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGInnerSVGFrame::GetType() const
{
return nsGkAtoms::svgInnerSVGFrame;
}
--- a/layout/svg/nsSVGInnerSVGFrame.h
+++ b/layout/svg/nsSVGInnerSVGFrame.h
@@ -21,19 +21,19 @@ protected:
nsSVGInnerSVGFrameBase(aContext) {}
public:
NS_DECL_QUERYFRAME_TARGET(nsSVGInnerSVGFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgInnerSVGFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGMarkerFrame.cpp
+++ b/layout/svg/nsSVGMarkerFrame.cpp
@@ -44,24 +44,24 @@ nsSVGMarkerFrame::AttributeChanged(int32
nsSVGEffects::InvalidateDirectRenderingObservers(this);
}
return nsSVGMarkerFrameBase::AttributeChanged(aNameSpaceID,
aAttribute, aModType);
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGMarkerFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::marker), "Content is not an SVG marker");
- return nsSVGMarkerFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGMarkerFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGMarkerFrame::GetType() const
{
return nsGkAtoms::svgMarkerFrame;
}
--- a/layout/svg/nsSVGMarkerFrame.h
+++ b/layout/svg/nsSVGMarkerFrame.h
@@ -46,19 +46,19 @@ protected:
AddStateBits(NS_STATE_SVG_NONDISPLAY_CHILD);
}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame interface:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {}
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
--- a/layout/svg/nsSVGMaskFrame.cpp
+++ b/layout/svg/nsSVGMaskFrame.cpp
@@ -154,25 +154,25 @@ nsSVGMaskFrame::AttributeChanged(int32_t
nsSVGEffects::InvalidateDirectRenderingObservers(this);
}
return nsSVGMaskFrameBase::AttributeChanged(aNameSpaceID,
aAttribute, aModType);
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGMaskFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::mask),
"Content is not an SVG mask");
- return nsSVGMaskFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGMaskFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGMaskFrame::GetType() const
{
return nsGkAtoms::svgMaskFrame;
}
--- a/layout/svg/nsSVGMaskFrame.h
+++ b/layout/svg/nsSVGMaskFrame.h
@@ -39,19 +39,19 @@ public:
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
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
@@ -138,17 +138,17 @@ nsSVGOuterSVGFrame::nsSVGOuterSVGFrame(n
, mFullZoom(aContext->PresContext()->GetFullZoom())
, mViewportInitialized(false)
, mIsRootContent(false)
{
// Outer-<svg> has CSS layout, so remove this bit:
RemoveStateBits(NS_FRAME_SVG_LAYOUT);
}
-NS_IMETHODIMP
+void
nsSVGOuterSVGFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::svg),
"Content is not an SVG 'svg' element!");
AddStateBits(NS_STATE_IS_OUTER_SVG |
@@ -163,30 +163,28 @@ nsSVGOuterSVGFrame::Init(nsIContent* aCo
// prevent them from painting by [ab]use NS_STATE_SVG_NONDISPLAY_CHILD. The
// frame will be recreated via an nsChangeHint_ReconstructFrame restyle if
// the value returned by PassesConditionalProcessingTests changes.
SVGSVGElement *svg = static_cast<SVGSVGElement*>(aContent);
if (!svg->PassesConditionalProcessingTests()) {
AddStateBits(NS_STATE_SVG_NONDISPLAY_CHILD);
}
- nsresult rv = nsSVGOuterSVGFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGOuterSVGFrameBase::Init(aContent, aParent, aPrevInFlow);
nsIDocument* doc = mContent->GetCurrentDoc();
if (doc) {
// we only care about our content's zoom and pan values if it's the root element
if (doc->GetRootElement() == mContent) {
mIsRootContent = true;
}
// sSVGMutationObserver has the same lifetime as the document so does
// not need to be removed
doc->AddMutationObserverUnlessExists(&sSVGMutationObserver);
}
-
- return rv;
}
//----------------------------------------------------------------------
// nsQueryFrame methods
NS_QUERYFRAME_HEAD(nsSVGOuterSVGFrame)
NS_QUERYFRAME_ENTRY(nsISVGSVGFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGOuterSVGFrameBase)
@@ -916,24 +914,24 @@ NS_NewSVGOuterSVGAnonChildFrame(nsIPresS
nsStyleContext* aContext)
{
return new (aPresShell) nsSVGOuterSVGAnonChildFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGOuterSVGAnonChildFrame)
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGOuterSVGAnonChildFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ABORT_IF_FALSE(aParent->GetType() == nsGkAtoms::svgOuterSVGFrame,
"Unexpected parent");
- return nsSVGOuterSVGAnonChildFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGOuterSVGAnonChildFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif
nsIAtom *
nsSVGOuterSVGAnonChildFrame::GetType() const
{
return nsGkAtoms::svgOuterSVGAnonChildFrame;
}
--- a/layout/svg/nsSVGOuterSVGFrame.h
+++ b/layout/svg/nsSVGOuterSVGFrame.h
@@ -56,19 +56,19 @@ public:
NS_IMETHOD DidReflow(nsPresContext* aPresContext,
const nsHTMLReflowState* aReflowState,
nsDidReflowStatus aStatus);
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nsSplittableType GetSplittableType() const;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgOuterSVGFrame
*/
@@ -234,19 +234,19 @@ class nsSVGOuterSVGAnonChildFrame
nsSVGOuterSVGAnonChildFrame(nsStyleContext* aContext)
: nsSVGOuterSVGAnonChildFrameBase(aContext)
{}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD GetFrameName(nsAString& aResult) const {
return MakeFrameName(NS_LITERAL_STRING("SVGOuterSVGAnonChild"), aResult);
}
#endif
/**
* Get the "type" of the frame
--- a/layout/svg/nsSVGPatternFrame.cpp
+++ b/layout/svg/nsSVGPatternFrame.cpp
@@ -96,24 +96,24 @@ nsSVGPatternFrame::AttributeChanged(int3
nsSVGEffects::InvalidateDirectRenderingObservers(this);
}
return nsSVGPatternFrameBase::AttributeChanged(aNameSpaceID,
aAttribute, aModType);
}
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGPatternFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::pattern), "Content is not an SVG pattern");
- return nsSVGPatternFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGPatternFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom*
nsSVGPatternFrame::GetType() const
{
return nsGkAtoms::svgPatternFrame;
}
--- a/layout/svg/nsSVGPatternFrame.h
+++ b/layout/svg/nsSVGPatternFrame.h
@@ -54,19 +54,19 @@ public:
// nsIFrame interface:
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgPatternFrame
*/
virtual nsIAtom* GetType() const;
--- a/layout/svg/nsSVGStopFrame.cpp
+++ b/layout/svg/nsSVGStopFrame.cpp
@@ -26,19 +26,19 @@ protected:
AddStateBits(NS_STATE_SVG_NONDISPLAY_CHILD);
}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame interface:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE {}
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
@@ -70,24 +70,24 @@ public:
// Implementation
NS_IMPL_FRAMEARENA_HELPERS(nsSVGStopFrame)
//----------------------------------------------------------------------
// nsIFrame methods:
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGStopFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::stop), "Content is not a stop element");
- return nsSVGStopFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGStopFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
/* virtual */ void
nsSVGStopFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
nsSVGStopFrameBase::DidSetStyleContext(aOldStyleContext);
nsSVGEffects::InvalidateRenderingObservers(this);
--- a/layout/svg/nsSVGSwitchFrame.cpp
+++ b/layout/svg/nsSVGSwitchFrame.cpp
@@ -22,19 +22,19 @@ class nsSVGSwitchFrame : public nsSVGSwi
protected:
nsSVGSwitchFrame(nsStyleContext* aContext) :
nsSVGSwitchFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::svgSwitchFrame
*/
virtual nsIAtom* GetType() const;
@@ -69,25 +69,25 @@ nsIFrame*
NS_NewSVGSwitchFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsSVGSwitchFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGSwitchFrame)
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGSwitchFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::svgSwitch),
"Content is not an SVG switch\n");
- return nsSVGSwitchFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGSwitchFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGSwitchFrame::GetType() const
{
return nsGkAtoms::svgSwitchFrame;
}
--- a/layout/svg/nsSVGTSpanFrame.cpp
+++ b/layout/svg/nsSVGTSpanFrame.cpp
@@ -33,17 +33,17 @@ nsSVGTSpanFrame::GetType() const
NS_QUERYFRAME_HEAD(nsSVGTSpanFrame)
NS_QUERYFRAME_ENTRY(nsISVGGlyphFragmentNode)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGTSpanFrameBase)
//----------------------------------------------------------------------
// nsIFrame methods
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGTSpanFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aParent, "null parent");
// Some of our subclasses have an aContent that's not a <svg:tspan> or are
// allowed to be constructed even when there is no nsISVGTextContentMetrics
@@ -58,17 +58,17 @@ nsSVGTSpanFrame::Init(nsIContent* aConte
"trying to construct an SVGTSpanFrame for an invalid "
"container");
NS_ASSERTION(aContent->IsSVG() && (aContent->Tag() == nsGkAtoms::altGlyph ||
aContent->Tag() == nsGkAtoms::tspan),
"Content is not an SVG tspan or altGlyph");
}
- return nsSVGTSpanFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGTSpanFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
NS_IMETHODIMP
nsSVGTSpanFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
--- a/layout/svg/nsSVGTSpanFrame.h
+++ b/layout/svg/nsSVGTSpanFrame.h
@@ -37,19 +37,19 @@ protected:
nsSVGTSpanFrameBase(aContext) {}
public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
/**
* Get the "type" of the frame
--- a/layout/svg/nsSVGTextFrame.cpp
+++ b/layout/svg/nsSVGTextFrame.cpp
@@ -28,25 +28,25 @@ NS_NewSVGTextFrame(nsIPresShell* aPresSh
return new (aPresShell) nsSVGTextFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGTextFrame)
//----------------------------------------------------------------------
// nsIFrame methods
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGTextFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::text),
"Content is not an SVG text");
- return nsSVGTextFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGTextFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
NS_IMETHODIMP
nsSVGTextFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
--- a/layout/svg/nsSVGTextFrame.h
+++ b/layout/svg/nsSVGTextFrame.h
@@ -23,19 +23,19 @@ protected:
: nsSVGTextFrameBase(aContext),
mPositioningDirty(true) {}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
/**
* Get the "type" of the frame
--- a/layout/svg/nsSVGTextFrame2.cpp
+++ b/layout/svg/nsSVGTextFrame2.cpp
@@ -2908,30 +2908,29 @@ NS_NewSVGTextFrame2(nsIPresShell* aPresS
return new (aPresShell) nsSVGTextFrame2(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGTextFrame2)
// ---------------------------------------------------------------------
// nsIFrame methods
-NS_IMETHODIMP
+void
nsSVGTextFrame2::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::text), "Content is not an SVG text");
- nsresult rv = nsSVGTextFrame2Base::Init(aContent, aParent, aPrevInFlow);
+ nsSVGTextFrame2Base::Init(aContent, aParent, aPrevInFlow);
AddStateBits((aParent->GetStateBits() &
(NS_STATE_SVG_NONDISPLAY_CHILD | NS_STATE_SVG_CLIPPATH_CHILD)) |
NS_FRAME_SVG_LAYOUT | NS_FRAME_IS_SVG_TEXT);
mMutationObserver.StartObserving(this);
- return rv;
}
void
nsSVGTextFrame2::DestroyFrom(nsIFrame* aDestructRoot)
{
if (mGlyphMetricsUpdater) {
mGlyphMetricsUpdater->Revoke();
}
--- a/layout/svg/nsSVGTextFrame2.h
+++ b/layout/svg/nsSVGTextFrame2.h
@@ -188,19 +188,19 @@ protected:
}
public:
NS_DECL_QUERYFRAME_TARGET(nsSVGTextFrame2)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNamespaceID,
nsIAtom* aAttribute,
int32_t aModType);
virtual nsIFrame* GetContentInsertionFrame()
--- a/layout/svg/nsSVGTextPathFrame.cpp
+++ b/layout/svg/nsSVGTextPathFrame.cpp
@@ -24,34 +24,34 @@ nsIFrame*
NS_NewSVGTextPathFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsSVGTextPathFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsSVGTextPathFrame)
#ifdef DEBUG
-NS_IMETHODIMP
+void
nsSVGTextPathFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aParent, "null parent");
nsIFrame* ancestorFrame = nsSVGUtils::GetFirstNonAAncestorFrame(aParent);
NS_ASSERTION(ancestorFrame, "Must have ancestor");
NS_ASSERTION(ancestorFrame->GetType() == nsGkAtoms::svgTextFrame,
"trying to construct an SVGTextPathFrame for an invalid "
"container");
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::textPath),
"Content is not an SVG textPath");
- return nsSVGTextPathFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGTextPathFrameBase::Init(aContent, aParent, aPrevInFlow);
}
#endif /* DEBUG */
nsIAtom *
nsSVGTextPathFrame::GetType() const
{
return nsGkAtoms::svgTextPathFrame;
}
--- a/layout/svg/nsSVGTextPathFrame.h
+++ b/layout/svg/nsSVGTextPathFrame.h
@@ -36,19 +36,19 @@ class nsSVGTextPathFrame : public nsSVGT
protected:
nsSVGTextPathFrame(nsStyleContext* aContext) : nsSVGTextPathFrameBase(aContext) {}
public:
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame:
#ifdef DEBUG
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#endif
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
/**
* Get the "type" of the frame
*
--- a/layout/svg/nsSVGUseFrame.cpp
+++ b/layout/svg/nsSVGUseFrame.cpp
@@ -26,19 +26,19 @@ protected:
{}
public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// nsIFrame interface:
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
virtual void DestroyFrom(nsIFrame* aDestructRoot);
/**
@@ -92,28 +92,28 @@ nsSVGUseFrame::GetType() const
NS_QUERYFRAME_HEAD(nsSVGUseFrame)
NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
NS_QUERYFRAME_TAIL_INHERITING(nsSVGUseFrameBase)
//----------------------------------------------------------------------
// nsIFrame methods:
-NS_IMETHODIMP
+void
nsSVGUseFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_ASSERTION(aContent->IsSVG(nsGkAtoms::use),
"Content is not an SVG use!");
mHasValidDimensions =
static_cast<SVGUseElement*>(aContent)->HasValidDimensions();
- return nsSVGUseFrameBase::Init(aContent, aParent, aPrevInFlow);
+ nsSVGUseFrameBase::Init(aContent, aParent, aPrevInFlow);
}
NS_IMETHODIMP
nsSVGUseFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
SVGUseElement *useElement = static_cast<SVGUseElement*>(mContent);
--- a/layout/tables/nsTableCellFrame.cpp
+++ b/layout/tables/nsTableCellFrame.cpp
@@ -61,37 +61,35 @@ nsTableCellFrame::GetNextCell() const
if (cellFrame) {
return cellFrame;
}
childFrame = childFrame->GetNextSibling();
}
return nullptr;
}
-NS_IMETHODIMP
+void
nsTableCellFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
// Let the base class do its initialization
- nsresult rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
if (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) {
AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
}
if (aPrevInFlow) {
// Set the column index
nsTableCellFrame* cellFrame = (nsTableCellFrame*)aPrevInFlow;
int32_t colIndex;
cellFrame->GetColIndex(colIndex);
SetColIndex(colIndex);
}
-
- return rv;
}
// nsIPercentHeightObserver methods
void
nsTableCellFrame::NotifyPercentHeight(const nsHTMLReflowState& aReflowState)
{
// nsHTMLReflowState ensures the mCBReflowState of blocks inside a
--- a/layout/tables/nsTableCellFrame.h
+++ b/layout/tables/nsTableCellFrame.h
@@ -45,19 +45,19 @@ public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
// default constructor supplied by the compiler
nsTableCellFrame(nsStyleContext* aContext);
~nsTableCellFrame();
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() MOZ_OVERRIDE;
#endif
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -158,58 +158,52 @@ nsTableFrame::nsTableFrame(nsStyleContex
mTableLayoutStrategy(nullptr)
{
memset(&mBits, 0, sizeof(mBits));
}
NS_QUERYFRAME_HEAD(nsTableFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
-NS_IMETHODIMP
+void
nsTableFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
NS_PRECONDITION(!mCellMap, "Init called twice");
NS_PRECONDITION(!aPrevInFlow ||
aPrevInFlow->GetType() == nsGkAtoms::tableFrame,
"prev-in-flow must be of same type");
// Let the base class do its processing
- nsresult rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
// see if border collapse is on, if so set it
const nsStyleTableBorder* tableStyle = StyleTableBorder();
bool borderCollapse = (NS_STYLE_BORDER_COLLAPSE == tableStyle->mBorderCollapse);
SetBorderCollapse(borderCollapse);
// Create the cell map if this frame is the first-in-flow.
if (!aPrevInFlow) {
mCellMap = new nsTableCellMap(*this, borderCollapse);
- if (!mCellMap)
- return NS_ERROR_OUT_OF_MEMORY;
}
if (aPrevInFlow) {
// set my width, because all frames in a table flow are the same width and
// code in nsTableOuterFrame depends on this being set
mRect.width = aPrevInFlow->GetSize().width;
}
else {
NS_ASSERTION(!mTableLayoutStrategy, "strategy was created before Init was called");
// create the strategy
if (IsAutoLayout())
mTableLayoutStrategy = new BasicTableLayoutStrategy(this);
else
mTableLayoutStrategy = new FixedTableLayoutStrategy(this);
- if (!mTableLayoutStrategy)
- return NS_ERROR_OUT_OF_MEMORY;
- }
-
- return rv;
+ }
}
nsTableFrame::~nsTableFrame()
{
delete mCellMap;
delete mTableLayoutStrategy;
}
--- a/layout/tables/nsTableFrame.h
+++ b/layout/tables/nsTableFrame.h
@@ -119,19 +119,19 @@ public:
*
* @return the frame that was created
*/
friend nsIFrame* NS_NewTableFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
/** sets defaults for table-specific style.
* @see nsIFrame::Init
*/
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
static float GetTwipsToPixels(nsPresContext* aPresContext);
// Return true if aParentReflowState.frame or any of its ancestors within
// the containing table have non-auto height. (e.g. pct or fixed height)
static bool AncestorsHaveStyleHeight(const nsHTMLReflowState& aParentReflowState);
// See if a special height reflow will occur due to having a pct height when
--- a/layout/tables/nsTableRowFrame.cpp
+++ b/layout/tables/nsTableRowFrame.cpp
@@ -125,37 +125,33 @@ nsTableRowFrame::nsTableRowFrame(nsStyle
mBits.mRowIndex = mBits.mFirstInserted = 0;
ResetHeight(0);
}
nsTableRowFrame::~nsTableRowFrame()
{
}
-NS_IMETHODIMP
+void
nsTableRowFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv;
-
// Let the base class do its initialization
- rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
NS_ASSERTION(NS_STYLE_DISPLAY_TABLE_ROW == StyleDisplay()->mDisplay,
"wrong display on table row frame");
if (aPrevInFlow) {
// Set the row index
nsTableRowFrame* rowFrame = (nsTableRowFrame*)aPrevInFlow;
SetRowIndex(rowFrame->GetRowIndex());
}
-
- return rv;
}
/* virtual */ void
nsTableRowFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
{
nsContainerFrame::DidSetStyleContext(aOldStyleContext);
if (!aOldStyleContext) //avoid this on init
--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -37,19 +37,19 @@ class nsTableRowFrame : public nsContain
{
public:
NS_DECL_QUERYFRAME_TARGET(nsTableRowFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
virtual ~nsTableRowFrame();
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
/** @see nsIFrame::DidSetStyleContext */
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext);
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
--- a/layout/xul/base/src/nsBoxFrame.cpp
+++ b/layout/xul/base/src/nsBoxFrame.cpp
@@ -153,23 +153,22 @@ nsBoxFrame::DidSetStyleContext(nsStyleCo
// The values that CacheAttributes() computes depend on our style,
// so we need to recompute them here...
CacheAttributes();
}
/**
* Initialize us. This is a good time to get the alignment of the box
*/
-NS_IMETHODIMP
+void
nsBoxFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
if (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) {
AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
}
MarkIntrinsicWidthsDirty();
CacheAttributes();
@@ -178,19 +177,17 @@ nsBoxFrame::Init(nsIContent* aConte
// if we are root and this
if (mState & NS_STATE_IS_ROOT)
GetDebugPref(GetPresContext());
#endif
UpdateMouseThrough();
// register access key
- rv = RegUnregAccessKey(true);
-
- return rv;
+ RegUnregAccessKey(true);
}
void nsBoxFrame::UpdateMouseThrough()
{
if (mContent) {
static nsIContent::AttrValuesArray strings[] =
{&nsGkAtoms::never, &nsGkAtoms::always, nullptr};
switch (mContent->FindAttrValueIn(kNameSpaceID_None,
@@ -1839,53 +1836,49 @@ nsBoxFrame::GetFrameSizeWithMargin(nsIFr
aSize.width = rect.width;
aSize.height = rect.height;
return NS_OK;
}
#endif
// If you make changes to this function, check its counterparts
// in nsTextBoxFrame and nsXULLabelFrame
-nsresult
+void
nsBoxFrame::RegUnregAccessKey(bool aDoReg)
{
- // if we have no content, we can't do anything
- if (!mContent)
- return NS_ERROR_FAILURE;
+ MOZ_ASSERT(mContent);
// find out what type of element this is
nsIAtom *atom = mContent->Tag();
// only support accesskeys for the following elements
if (atom != nsGkAtoms::button &&
atom != nsGkAtoms::toolbarbutton &&
atom != nsGkAtoms::checkbox &&
atom != nsGkAtoms::textbox &&
atom != nsGkAtoms::tab &&
atom != nsGkAtoms::radio) {
- return NS_OK;
+ return;
}
nsAutoString accessKey;
mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey);
if (accessKey.IsEmpty())
- return NS_OK;
+ return;
// With a valid PresContext we can get the ESM
// and register the access key
nsEventStateManager *esm = PresContext()->EventStateManager();
uint32_t key = accessKey.First();
if (aDoReg)
esm->RegisterAccessKey(mContent, key);
else
esm->UnregisterAccessKey(mContent, key);
-
- return NS_OK;
}
bool
nsBoxFrame::SupportsOrdinalsInChildren()
{
return true;
}
--- a/layout/xul/base/src/nsBoxFrame.h
+++ b/layout/xul/base/src/nsBoxFrame.h
@@ -78,19 +78,19 @@ public:
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState);
virtual bool ComputesOwnOverflowArea() MOZ_OVERRIDE { return false; }
// ----- child and sibling operations ---
// ----- public methods -------
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
virtual void MarkIntrinsicWidthsDirty() MOZ_OVERRIDE;
virtual nscoord GetMinWidth(nsRenderingContext *aRenderingContext) MOZ_OVERRIDE;
@@ -213,17 +213,17 @@ protected:
// Get the point associated with this event. Returns true if a single valid
// point was found. Otherwise false.
bool GetEventPoint(nsGUIEvent *aEvent, nsPoint &aPoint);
// Gets the event coordinates relative to the widget offset associated with
// this frame. Return true if a single valid point was found.
bool GetEventPoint(nsGUIEvent *aEvent, nsIntPoint &aPoint);
protected:
- nsresult RegUnregAccessKey(bool aDoReg);
+ void RegUnregAccessKey(bool aDoReg);
NS_HIDDEN_(void) CheckBoxOrder();
private:
#ifdef DEBUG_LAYOUT
nsresult SetDebug(nsPresContext* aPresContext, bool aDebug);
bool GetInitialDebug(bool& aDebug);
--- a/layout/xul/base/src/nsDeckFrame.cpp
+++ b/layout/xul/base/src/nsDeckFrame.cpp
@@ -69,26 +69,24 @@ nsDeckFrame::AttributeChanged(int32_t
// if the index changed hide the old element and make the new element visible
if (aAttribute == nsGkAtoms::selectedIndex) {
IndexChanged();
}
return rv;
}
-NS_IMETHODIMP
+void
nsDeckFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
mIndex = GetSelectedIndex();
-
- return rv;
}
void
nsDeckFrame::HideBox(nsIFrame* aBox)
{
nsIPresShell::ClearMouseCapture(aBox);
}
--- a/layout/xul/base/src/nsDeckFrame.h
+++ b/layout/xul/base/src/nsDeckFrame.h
@@ -36,19 +36,19 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
virtual void BuildDisplayListForChildren(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
#ifdef DEBUG
NS_IMETHOD GetFrameName(nsAString& aResult) const MOZ_OVERRIDE
{
return MakeFrameName(NS_LITERAL_STRING("Deck"), aResult);
}
--- a/layout/xul/base/src/nsImageBoxFrame.cpp
+++ b/layout/xul/base/src/nsImageBoxFrame.cpp
@@ -174,37 +174,35 @@ nsImageBoxFrame::DestroyFrom(nsIFrame* a
if (mListener)
reinterpret_cast<nsImageBoxListener*>(mListener.get())->SetFrame(nullptr); // set the frame to null so we don't send messages to a dead object.
nsLeafBoxFrame::DestroyFrom(aDestructRoot);
}
-NS_IMETHODIMP
+void
nsImageBoxFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
if (!mListener) {
nsImageBoxListener *listener = new nsImageBoxListener();
NS_ADDREF(listener);
listener->SetFrame(this);
listener->QueryInterface(NS_GET_IID(imgINotificationObserver), getter_AddRefs(mListener));
NS_RELEASE(listener);
}
mSuppressStyleCheck = true;
- nsresult rv = nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
mSuppressStyleCheck = false;
UpdateLoadFlags();
UpdateImage();
-
- return rv;
}
void
nsImageBoxFrame::UpdateImage()
{
nsPresContext* presContext = PresContext();
if (mImageRequest) {
--- a/layout/xul/base/src/nsImageBoxFrame.h
+++ b/layout/xul/base/src/nsImageBoxFrame.h
@@ -45,19 +45,19 @@ public:
virtual nsSize GetMinSize(nsBoxLayoutState& aBoxLayoutState);
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual void MarkIntrinsicWidthsDirty() MOZ_OVERRIDE;
nsresult Notify(imgIRequest *aRequest, int32_t aType, const nsIntRect* aData);
friend nsIFrame* NS_NewImageBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
virtual void DidSetStyleContext(nsStyleContext* aOldStyleContext) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
--- a/layout/xul/base/src/nsLeafBoxFrame.cpp
+++ b/layout/xul/base/src/nsLeafBoxFrame.cpp
@@ -50,32 +50,29 @@ nsLeafBoxFrame::GetBoxName(nsAutoString&
GetFrameName(aName);
}
#endif
/**
* Initialize us. This is a good time to get the alignment of the box
*/
-NS_IMETHODIMP
+void
nsLeafBoxFrame::Init(
nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsLeafFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsLeafFrame::Init(aContent, aParent, aPrevInFlow);
if (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER) {
AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
}
UpdateMouseThrough();
-
- return rv;
}
NS_IMETHODIMP
nsLeafBoxFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
nsresult rv = nsLeafFrame::AttributeChanged(aNameSpaceID, aAttribute,
--- a/layout/xul/base/src/nsLeafBoxFrame.h
+++ b/layout/xul/base/src/nsLeafBoxFrame.h
@@ -51,20 +51,19 @@ public:
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
NS_IMETHOD CharacterDataChanged(CharacterDataChangeInfo* aInfo) MOZ_OVERRIDE;
- NS_IMETHOD Init(
- nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
--- a/layout/xul/base/src/nsListBoxBodyFrame.cpp
+++ b/layout/xul/base/src/nsListBoxBodyFrame.cpp
@@ -171,36 +171,33 @@ nsListBoxBodyFrame::~nsListBoxBodyFrame(
NS_QUERYFRAME_HEAD(nsListBoxBodyFrame)
NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
NS_QUERYFRAME_ENTRY(nsListBoxBodyFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
////////// nsIFrame /////////////////
-NS_IMETHODIMP
+void
nsListBoxBodyFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetScrollableFrameFor(this);
if (scrollFrame) {
nsIFrame* verticalScrollbar = scrollFrame->GetScrollbarBox(true);
nsScrollbarFrame* scrollbarFrame = do_QueryFrame(verticalScrollbar);
if (scrollbarFrame) {
scrollbarFrame->SetScrollbarMediatorContent(GetContent());
}
}
nsRefPtr<nsFontMetrics> fm;
nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm));
mRowHeight = fm->MaxHeight();
-
- return rv;
}
void
nsListBoxBodyFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// make sure we cancel any posted callbacks.
if (mReflowCallbackPosted)
PresContext()->PresShell()->CancelReflowCallback(this);
--- a/layout/xul/base/src/nsListBoxBodyFrame.h
+++ b/layout/xul/base/src/nsListBoxBodyFrame.h
@@ -43,19 +43,19 @@ public:
nsresult ScrollByLines(int32_t aNumLines);
nsresult GetItemAtIndex(int32_t aIndex, nsIDOMElement **aResult);
nsresult GetIndexOfItem(nsIDOMElement *aItem, int32_t *aResult);
friend nsIFrame* NS_NewListBoxBodyFrame(nsIPresShell* aPresShell,
nsStyleContext* aContext);
// nsIFrame
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType) MOZ_OVERRIDE;
// nsIScrollbarMediator
NS_IMETHOD PositionChanged(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t& aNewIndex);
NS_IMETHOD ScrollbarButtonPressed(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t aNewIndex) MOZ_OVERRIDE;
NS_IMETHOD VisibilityChanged(bool aVisible) MOZ_OVERRIDE;
--- a/layout/xul/base/src/nsMenuBarFrame.cpp
+++ b/layout/xul/base/src/nsMenuBarFrame.cpp
@@ -54,28 +54,26 @@ nsMenuBarFrame::nsMenuBarFrame(nsIPresSh
mMenuBarListener(nullptr),
mStayActive(false),
mIsActive(false),
mCurrentMenu(nullptr),
mTarget(nullptr)
{
} // cntr
-NS_IMETHODIMP
+void
nsMenuBarFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
// Create the menu bar listener.
mMenuBarListener = new nsMenuBarListener(this);
- NS_IF_ADDREF(mMenuBarListener);
- if (! mMenuBarListener)
- return NS_ERROR_OUT_OF_MEMORY;
+ NS_ADDREF(mMenuBarListener);
// Hook up the menu bar as a key listener on the whole document. It will see every
// key press that occurs, but after everyone else does.
nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(aContent->GetDocument());
mTarget = target;
// Also hook up the listener to the window listening for focus events. This is so we can keep proper
@@ -84,18 +82,16 @@ nsMenuBarFrame::Init(nsIContent* aC
target->AddEventListener(NS_LITERAL_STRING("keypress"), mMenuBarListener, false);
target->AddEventListener(NS_LITERAL_STRING("keydown"), mMenuBarListener, false);
target->AddEventListener(NS_LITERAL_STRING("keyup"), mMenuBarListener, false);
// mousedown event should be handled in all phase
target->AddEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, true);
target->AddEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, false);
target->AddEventListener(NS_LITERAL_STRING("blur"), mMenuBarListener, true);
-
- return rv;
}
NS_IMETHODIMP
nsMenuBarFrame::SetActive(bool aActiveFlag)
{
// If the activity is not changed, there is nothing to do.
if (mIsActive == aActiveFlag)
return NS_OK;
--- a/layout/xul/base/src/nsMenuBarFrame.h
+++ b/layout/xul/base/src/nsMenuBarFrame.h
@@ -45,19 +45,19 @@ public:
virtual bool IsMenu() { return false; }
virtual bool IsOpen() MOZ_OVERRIDE { return true; } // menubars are considered always open
bool IsMenuOpen() { return mCurrentMenu && mCurrentMenu->IsOpen(); }
void InstallKeyboardNavigator();
void RemoveKeyboardNavigator();
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual void LockMenuUntilClosed(bool aLock) MOZ_OVERRIDE {}
virtual bool IsMenuLocked() MOZ_OVERRIDE { return false; }
// Non-interface helpers
--- a/layout/xul/base/src/nsMenuFrame.cpp
+++ b/layout/xul/base/src/nsMenuFrame.cpp
@@ -233,35 +233,31 @@ public:
virtual void ReflowCallbackCanceled()
{
delete this;
}
nsWeakFrame mWeakFrame;
};
-NS_IMETHODIMP
+void
nsMenuFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
// Set up a mediator which can be used for callbacks on this frame.
mTimerMediator = new nsMenuTimerMediator(this);
- if (MOZ_UNLIKELY(!mTimerMediator))
- return NS_ERROR_OUT_OF_MEMORY;
InitMenuParent(aParent);
BuildAcceleratorText(false);
nsIReflowCallback* cb = new nsASyncMenuInitialization(this);
- NS_ENSURE_TRUE(cb, NS_ERROR_OUT_OF_MEMORY);
PresContext()->PresShell()->PostReflowCallback(cb);
- return rv;
}
const nsFrameList&
nsMenuFrame::GetChildList(ChildListID aListID) const
{
if (kPopupList == aListID) {
nsFrameList* list = GetPopupList();
return list ? *list : nsFrameList::EmptyList();
--- a/layout/xul/base/src/nsMenuFrame.h
+++ b/layout/xul/base/src/nsMenuFrame.h
@@ -80,19 +80,19 @@ public:
NS_DECL_QUERYFRAME_TARGET(nsMenuFrame)
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetMinSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
virtual nsSize GetPrefSize(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
#ifdef DEBUG_LAYOUT
NS_IMETHOD SetDebug(nsBoxLayoutState& aState, bool aDebug) MOZ_OVERRIDE;
#endif
// The following methods are all overridden so that the menupopup
// can be stored in a separate list, so that it doesn't impact reflow of the
// actual menu item at all.
--- a/layout/xul/base/src/nsMenuPopupFrame.cpp
+++ b/layout/xul/base/src/nsMenuPopupFrame.cpp
@@ -101,31 +101,29 @@ nsMenuPopupFrame::nsMenuPopupFrame(nsIPr
// the default, and false means that the 'parent' level is the default.
if (sDefaultLevelIsTop >= 0)
return;
sDefaultLevelIsTop =
Preferences::GetBool("ui.panel.default_level_parent", false);
} // ctor
-NS_IMETHODIMP
+void
nsMenuPopupFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
// lookup if we're allowed to overlap the OS bar (menubar/taskbar) from the
// look&feel object
mMenuCanOverlapOSBar =
LookAndFeel::GetInt(LookAndFeel::eIntID_MenusCanOverlapOSBar) != 0;
- rv = CreatePopupView();
- NS_ENSURE_SUCCESS(rv, rv);
+ CreatePopupView();
// XXX Hack. The popup's view should float above all other views,
// so we use the nsView::SetFloating() to tell the view manager
// about that constraint.
nsView* ourView = GetView();
nsViewManager* viewManager = ourView->GetViewManager();
viewManager->SetViewFloating(ourView, true);
@@ -166,18 +164,16 @@ nsMenuPopupFrame::Init(nsIContent*
nsIRootBox* rootBox =
nsIRootBox::GetRootBox(PresContext()->GetPresShell());
if (rootBox) {
rootBox->SetDefaultTooltip(aContent);
}
}
AddStateBits(NS_FRAME_IN_POPUP);
-
- return rv;
}
bool
nsMenuPopupFrame::IsNoAutoHide() const
{
// Panels with noautohide="true" don't hide when the mouse is clicked
// outside of them, or when another application is made active. Non-autohide
// panels cannot be used in content windows.
@@ -1910,45 +1906,38 @@ nsMenuPopupFrame::SetConsumeRollupEvent(
{
mConsumeRollupEvent = aConsumeMode;
}
/**
* KEEP THIS IN SYNC WITH nsContainerFrame::CreateViewForFrame
* as much as possible. Until we get rid of views finally...
*/
-nsresult
+void
nsMenuPopupFrame::CreatePopupView()
{
if (HasView()) {
- return NS_OK;
+ return;
}
nsViewManager* viewManager = PresContext()->GetPresShell()->GetViewManager();
NS_ASSERTION(nullptr != viewManager, "null view manager");
// Create a view
nsView* parentView = viewManager->GetRootView();
nsViewVisibility visibility = nsViewVisibility_kHide;
int32_t zIndex = INT32_MAX;
bool autoZIndex = false;
NS_ASSERTION(parentView, "no parent view");
// Create a view
nsView *view = viewManager->CreateView(GetRect(), parentView, visibility);
- if (view) {
- viewManager->SetViewZIndex(view, autoZIndex, zIndex);
- // XXX put view last in document order until we can do better
- viewManager->InsertChild(parentView, view, nullptr, true);
- }
+ viewManager->SetViewZIndex(view, autoZIndex, zIndex);
+ // XXX put view last in document order until we can do better
+ viewManager->InsertChild(parentView, view, nullptr, true);
// Remember our view
SetView(view);
NS_FRAME_LOG(NS_FRAME_TRACE_CALLS,
("nsMenuPopupFrame::CreatePopupView: frame=%p view=%p", this, view));
-
- if (!view)
- return NS_ERROR_OUT_OF_MEMORY;
-
- return NS_OK;
}
--- a/layout/xul/base/src/nsMenuPopupFrame.h
+++ b/layout/xul/base/src/nsMenuPopupFrame.h
@@ -144,19 +144,19 @@ public:
virtual bool IsMenuLocked() MOZ_OVERRIDE { return mIsMenuLocked; }
nsIWidget* GetWidget();
// The dismissal listener gets created and attached to the window.
void AttachedDismissalListener();
// Overridden methods
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
// returns true if the popup is a panel with the noautohide attribute set to
@@ -367,17 +367,17 @@ protected:
bool IsDirectionRTL() const {
return mAnchorContent && mAnchorContent->GetPrimaryFrame()
? mAnchorContent->GetPrimaryFrame()->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL
: StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL;
}
// Create a popup view for this frame. The view is added a child of the root
// view, and is initially hidden.
- nsresult CreatePopupView();
+ void CreatePopupView();
nsString mIncrementalString; // for incremental typing navigation
// the content that the popup is anchored to, if any, which may be in a
// different document than the popup.
nsCOMPtr<nsIContent> mAnchorContent;
// the content that triggered the popup, typically the node where the mouse
--- a/layout/xul/base/src/nsPopupSetFrame.cpp
+++ b/layout/xul/base/src/nsPopupSetFrame.cpp
@@ -17,31 +17,29 @@
nsIFrame*
NS_NewPopupSetFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsPopupSetFrame (aPresShell, aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsPopupSetFrame)
-NS_IMETHODIMP
+void
nsPopupSetFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
// Normally the root box is our grandparent, but in case of wrapping
// it can be our great-grandparent.
nsIRootBox *rootBox = nsIRootBox::GetRootBox(PresContext()->GetPresShell());
if (rootBox) {
rootBox->SetPopupSetFrame(this);
}
-
- return rv;
}
nsIAtom*
nsPopupSetFrame::GetType() const
{
return nsGkAtoms::popupSetFrame;
}
--- a/layout/xul/base/src/nsPopupSetFrame.h
+++ b/layout/xul/base/src/nsPopupSetFrame.h
@@ -18,19 +18,19 @@ class nsPopupSetFrame : public nsBoxFram
public:
NS_DECL_FRAMEARENA_HELPERS
nsPopupSetFrame(nsIPresShell* aShell, nsStyleContext* aContext):
nsBoxFrame(aShell, aContext) {}
~nsPopupSetFrame() {}
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) MOZ_OVERRIDE;
NS_IMETHOD RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) MOZ_OVERRIDE;
NS_IMETHOD InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
--- a/layout/xul/base/src/nsScrollbarFrame.cpp
+++ b/layout/xul/base/src/nsScrollbarFrame.cpp
@@ -28,30 +28,28 @@ NS_NewScrollbarFrame (nsIPresShell* aPre
}
NS_IMPL_FRAMEARENA_HELPERS(nsScrollbarFrame)
NS_QUERYFRAME_HEAD(nsScrollbarFrame)
NS_QUERYFRAME_ENTRY(nsScrollbarFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
-NS_IMETHODIMP
+void
nsScrollbarFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
// 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;
-
- return rv;
}
NS_IMETHODIMP
nsScrollbarFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
--- a/layout/xul/base/src/nsScrollbarFrame.h
+++ b/layout/xul/base/src/nsScrollbarFrame.h
@@ -51,19 +51,19 @@ public:
NS_IMETHOD HandleDrag(nsPresContext* aPresContext,
nsGUIEvent * aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
NS_IMETHOD HandleRelease(nsPresContext* aPresContext,
nsGUIEvent * aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus) MOZ_OVERRIDE;
virtual nsIAtom* GetType() const MOZ_OVERRIDE;
--- a/layout/xul/base/src/nsSliderFrame.cpp
+++ b/layout/xul/base/src/nsSliderFrame.cpp
@@ -72,34 +72,32 @@ nsSliderFrame::nsSliderFrame(nsIPresShel
{
}
// stop timer
nsSliderFrame::~nsSliderFrame()
{
}
-NS_IMETHODIMP
+void
nsSliderFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
static bool gotPrefs = false;
if (!gotPrefs) {
gotPrefs = true;
gMiddlePref = Preferences::GetBool("middlemouse.scrollbarPosition");
gSnapMultiplier = Preferences::GetInt("slider.snapMultiplier");
}
mCurPos = GetCurrentPosition(aContent);
-
- return rv;
}
NS_IMETHODIMP
nsSliderFrame::RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame)
{
nsresult rv = nsBoxFrame::RemoveFrame(aListID, aOldFrame);
if (mFrames.IsEmpty())
--- a/layout/xul/base/src/nsSliderFrame.h
+++ b/layout/xul/base/src/nsSliderFrame.h
@@ -77,19 +77,19 @@ public:
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus) MOZ_OVERRIDE;
NS_IMETHOD SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) MOZ_OVERRIDE;
--- a/layout/xul/base/src/nsSplitterFrame.cpp
+++ b/layout/xul/base/src/nsSplitterFrame.cpp
@@ -255,25 +255,23 @@ nsSplitterFrame::AttributeChanged(int32_
}
return rv;
}
/**
* Initialize us. If we are in a box get our alignment so we know what direction we are
*/
-NS_IMETHODIMP
+void
nsSplitterFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- NS_ENSURE_FALSE(mInner, NS_ERROR_ALREADY_INITIALIZED);
+ MOZ_ASSERT(!mInner);
mInner = new nsSplitterFrameInner(this);
- if (!mInner)
- return NS_ERROR_OUT_OF_MEMORY;
mInner->AddRef();
mInner->mChildInfosAfter = nullptr;
mInner->mChildInfosBefore = nullptr;
mInner->mState = nsSplitterFrameInner::Open;
mInner->mDragging = false;
// determine orientation of parent, and if vertical, set orient to vertical
@@ -289,23 +287,21 @@ nsSplitterFrame::Init(nsIContent* a
nsStyleContext* parentStyleContext = StyleContext()->GetParent();
nsRefPtr<nsStyleContext> newContext = PresContext()->StyleSet()->
ResolveStyleFor(aContent->AsElement(), parentStyleContext);
SetStyleContextWithoutNotification(newContext);
}
}
}
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
mInner->mState = nsSplitterFrameInner::Open;
mInner->AddListener(PresContext());
mInner->mParentBox = nullptr;
- return rv;
}
NS_IMETHODIMP
nsSplitterFrame::DoLayout(nsBoxLayoutState& aState)
{
if (GetStateBits() & NS_FRAME_FIRST_REFLOW)
{
mInner->mParentBox = GetParentBox();
--- a/layout/xul/base/src/nsSplitterFrame.h
+++ b/layout/xul/base/src/nsSplitterFrame.h
@@ -32,19 +32,19 @@ public:
}
#endif
// nsIFrame overrides
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
NS_IMETHOD GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor) MOZ_OVERRIDE;
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState) MOZ_OVERRIDE;
NS_IMETHOD HandlePress(nsPresContext* aPresContext,
nsGUIEvent * aEvent,
--- a/layout/xul/base/src/nsTextBoxFrame.cpp
+++ b/layout/xul/base/src/nsTextBoxFrame.cpp
@@ -102,31 +102,29 @@ nsTextBoxFrame::nsTextBoxFrame(nsIPresSh
}
nsTextBoxFrame::~nsTextBoxFrame()
{
delete mAccessKeyInfo;
}
-NS_IMETHODIMP
+void
nsTextBoxFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
nsTextBoxFrameSuper::Init(aContent, aParent, aPrevInFlow);
bool aResize;
bool aRedraw;
UpdateAttributes(nullptr, aResize, aRedraw); /* update all */
// register access key
RegUnregAccessKey(true);
-
- return NS_OK;
}
void
nsTextBoxFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// unregister access key
RegUnregAccessKey(false);
nsTextBoxFrameSuper::DestroyFrom(aDestructRoot);
--- a/layout/xul/base/src/nsTextBoxFrame.h
+++ b/layout/xul/base/src/nsTextBoxFrame.h
@@ -23,19 +23,19 @@ public:
virtual nscoord GetBoxAscent(nsBoxLayoutState& aBoxLayoutState);
NS_IMETHOD DoLayout(nsBoxLayoutState& aBoxLayoutState);
virtual void MarkIntrinsicWidthsDirty();
enum CroppingStyle { CropNone, CropLeft, CropRight, CropCenter };
friend nsIFrame* NS_NewTextBoxFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* asPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* asPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType);
#ifdef DEBUG
--- a/layout/xul/base/src/nsXULLabelFrame.cpp
+++ b/layout/xul/base/src/nsXULLabelFrame.cpp
@@ -57,27 +57,25 @@ nsXULLabelFrame::RegUnregAccessKey(bool
esm->UnregisterAccessKey(mContent, key);
return NS_OK;
}
/////////////////////////////////////////////////////////////////////////////
// nsIFrame
-NS_IMETHODIMP
+void
nsXULLabelFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
- if (NS_FAILED(rv))
- return rv;
+ nsBlockFrame::Init(aContent, aParent, aPrevInFlow);
// register access key
- return RegUnregAccessKey(true);
+ RegUnregAccessKey(true);
}
void
nsXULLabelFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
// unregister access key
RegUnregAccessKey(false);
nsBlockFrame::DestroyFrom(aDestructRoot);
--- a/layout/xul/base/src/nsXULLabelFrame.h
+++ b/layout/xul/base/src/nsXULLabelFrame.h
@@ -19,19 +19,19 @@ class nsXULLabelFrame : public nsBlockFr
{
public:
NS_DECL_FRAMEARENA_HELPERS
friend nsIFrame* NS_NewXULLabelFrame(nsIPresShell* aPresShell,
nsStyleContext *aContext);
// nsIFrame
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow);
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType) MOZ_OVERRIDE;
/**
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -150,33 +150,30 @@ GetBorderPadding(nsStyleContext* aContex
static void
AdjustForBorderPadding(nsStyleContext* aContext, nsRect& aRect)
{
nsMargin borderPadding(0, 0, 0, 0);
GetBorderPadding(aContext, borderPadding);
aRect.Deflate(borderPadding);
}
-NS_IMETHODIMP
+void
nsTreeBodyFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
- NS_ENSURE_SUCCESS(rv, rv);
+ nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
mIndentation = GetIndentation();
mRowHeight = GetRowHeight();
mCreatedListeners.Init();
mImageCache.Init(16);
EnsureBoxObject();
-
- return rv;
}
nsSize
nsTreeBodyFrame::GetMinSize(nsBoxLayoutState& aBoxLayoutState)
{
EnsureView();
nsIContent* baseElement = GetBaseElement();
--- a/layout/xul/tree/nsTreeBodyFrame.h
+++ b/layout/xul/tree/nsTreeBodyFrame.h
@@ -113,19 +113,19 @@ public:
virtual bool PseudoMatches(nsCSSSelector* aSelector) MOZ_OVERRIDE;
// nsIScrollbarMediator
NS_IMETHOD PositionChanged(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t& aNewIndex);
NS_IMETHOD ScrollbarButtonPressed(nsScrollbarFrame* aScrollbar, int32_t aOldIndex, int32_t aNewIndex) MOZ_OVERRIDE;
NS_IMETHOD VisibilityChanged(bool aVisible) MOZ_OVERRIDE { Invalidate(); return NS_OK; }
// Overridden from nsIFrame to cache our pres context.
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot);
NS_IMETHOD GetCursor(const nsPoint& aPoint,
nsIFrame::Cursor& aCursor);
NS_IMETHOD HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus);
--- a/layout/xul/tree/nsTreeColFrame.cpp
+++ b/layout/xul/tree/nsTreeColFrame.cpp
@@ -31,24 +31,23 @@ NS_NewTreeColFrame(nsIPresShell* aPresSh
NS_IMPL_FRAMEARENA_HELPERS(nsTreeColFrame)
// Destructor
nsTreeColFrame::~nsTreeColFrame()
{
}
-NS_IMETHODIMP
+void
nsTreeColFrame::Init(nsIContent* aContent,
nsIFrame* aParent,
nsIFrame* aPrevInFlow)
{
- nsresult rv = nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+ nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
InvalidateColumns();
- return rv;
}
void
nsTreeColFrame::DestroyFrom(nsIFrame* aDestructRoot)
{
InvalidateColumns(false);
nsBoxFrame::DestroyFrom(aDestructRoot);
}
--- a/layout/xul/tree/nsTreeColFrame.h
+++ b/layout/xul/tree/nsTreeColFrame.h
@@ -15,19 +15,19 @@ class nsTreeColFrame : public nsBoxFrame
{
public:
NS_DECL_FRAMEARENA_HELPERS
nsTreeColFrame(nsIPresShell* aPresShell,
nsStyleContext* aContext):
nsBoxFrame(aPresShell, aContext) {}
- NS_IMETHOD Init(nsIContent* aContent,
- nsIFrame* aParent,
- nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
+ virtual void Init(nsIContent* aContent,
+ nsIFrame* aParent,
+ nsIFrame* aPrevInFlow) MOZ_OVERRIDE;
virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
virtual void BuildDisplayListForChildren(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) MOZ_OVERRIDE;
NS_IMETHOD AttributeChanged(int32_t aNameSpaceID,