Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-01-23 13:04:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 321294: Remove unused ReplaceFrame codepaths.

Browse Source 
r/sr=roc
This commit is contained in:
cvshook%sicking.cc 2006-01-10 22:58:37 +00:00
parent 161cca7a9b
commit 7db01c8d27
30 changed files with 0 additions and 391 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
layout/base/nsFrameManager.h
View File

@ -151,14 +151,6 @@ public:
nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_HIDDEN_(nsresult) ReplaceFrame(nsIFrame* aParentFrame,
nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
return aParentFrame->ReplaceFrame(aListName, aOldFrame, aNewFrame);
}
/*
* Notification that a frame is about to be destroyed. This allows any
* outstanding references to the frame to be cleaned up.

15
layout/forms/nsFieldSetFrame.cpp
View File

@ -94,9 +94,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
virtual nsIFrame* GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer);
@ -647,18 +644,6 @@ nsFieldSetFrame::RemoveFrame(nsIAtom* aListName,
return mContentFrame->RemoveFrame(aListName, aOldFrame);
}
NS_IMETHODIMP
nsFieldSetFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
if (aOldFrame == mLegendFrame) {
mLegendFrame = aNewFrame;
return nsContainerFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
}
return mContentFrame->ReplaceFrame(aListName, aOldFrame, aNewFrame);
}
nsIFrame*
nsFieldSetFrame::GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer)

9
layout/forms/nsHTMLButtonControlFrame.cpp
View File

@ -572,12 +572,3 @@ nsHTMLButtonControlFrame::RemoveFrame(nsIAtom* aListName,
{
return mFrames.FirstChild()->RemoveFrame(aListName, aOldFrame);
}
NS_IMETHODIMP
nsHTMLButtonControlFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
ReParentFrameList(GetPresContext()->FrameManager(), aNewFrame);
return mFrames.FirstChild()->ReplaceFrame(aListName, aOldFrame, aNewFrame);
}

4
layout/forms/nsHTMLButtonControlFrame.h
View File

@ -112,10 +112,6 @@ public:
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
#ifdef ACCESSIBILITY
NS_IMETHOD GetAccessible(nsIAccessible** aAccessible);
#endif

12
layout/generic/nsAbsoluteContainingBlock.cpp
View File

@ -122,18 +122,6 @@ nsAbsoluteContainingBlock::RemoveFrame(nsIFrame* aDelegatingFrame,
return result ? NS_OK : NS_ERROR_FAILURE;
}
nsresult
nsAbsoluteContainingBlock::ReplaceFrame(nsIFrame* aDelegatingFrame,
nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
PRBool result = mAbsoluteFrames.ReplaceFrame(aDelegatingFrame,
aOldFrame, aNewFrame, PR_TRUE);
NS_ASSERTION(result, "Problems replacing a frame");
return result ? NS_OK : NS_ERROR_FAILURE;
}
static void
AddFrameToChildBounds(nsIFrame* aKidFrame, nsRect* aChildBounds)
{

4
layout/generic/nsAbsoluteContainingBlock.h
View File

@ -83,10 +83,6 @@ public:
nsresult RemoveFrame(nsIFrame* aDelegatingFrame,
nsIAtom* aListName,
nsIFrame* aOldFrame);
nsresult ReplaceFrame(nsIFrame* aDelegatingFrame,
nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
// Called by the delegating frame after it has done its reflow first. This
// function will reflow any absolutely positioned child frames that need to

22
layout/generic/nsContainerFrame.cpp
View File

@ -349,28 +349,6 @@ nsContainerFrame::GetFrameForPointUsing(const nsPoint& aPoint,
return nsnull;
}
NS_IMETHODIMP
nsContainerFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
nsIFrame* prevFrame;
nsresult rv;
// Get the old frame's previous sibling frame
nsFrameList frames(GetFirstChild(aListName));
NS_ASSERTION(frames.ContainsFrame(aOldFrame), "frame is not a valid child frame");
prevFrame = frames.GetPrevSiblingFor(aOldFrame);
// Default implementation treats it like two separate operations
rv = RemoveFrame(aListName, aOldFrame);
if (NS_SUCCEEDED(rv)) {
rv = InsertFrames(aListName, prevFrame, aNewFrame);
}
return rv;
}
NS_IMETHODIMP
nsContainerFrame::ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild)
{

3
layout/generic/nsContainerFrame.h
View File

@ -72,9 +72,6 @@ public:
PRUint32 aFlags = 0);
virtual nsIFrame* GetFrameForPoint(const nsPoint& aPoint,
nsFramePaintLayer aWhichLayer);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild);
virtual PRBool IsLeaf() const;

9
layout/generic/nsFrame.cpp
View File

@ -617,15 +617,6 @@ nsFrame::RemoveFrame(nsIAtom* aListName,
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_PRECONDITION(PR_FALSE, "not a container");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsFrame::Destroy(nsPresContext* aPresContext)
{

3
layout/generic/nsFrame.h
View File

@ -176,9 +176,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Destroy(nsPresContext* aPresContext);
NS_IMETHOD CalcBorderPadding(nsMargin& aBorderPadding) const;
virtual nsStyleContext* GetAdditionalStyleContext(PRInt32 aIndex) const;

52
layout/generic/nsFrameList.cpp
View File

@ -299,58 +299,6 @@ nsFrameList::InsertFrames(nsIFrame* aParent,
#endif
}
PRBool
nsFrameList::DoReplaceFrame(nsIFrame* aParent,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_PRECONDITION(aOldFrame, "null ptr");
NS_PRECONDITION(aNewFrame, "null ptr");
if (!aOldFrame || !aNewFrame) {
return PR_FALSE;
}
nsIFrame* nextFrame = aOldFrame->GetNextSibling();
if (aOldFrame == mFirstChild) {
mFirstChild = aNewFrame;
}
else {
nsIFrame* prevSibling = GetPrevSiblingFor(aOldFrame);
if (!prevSibling) {
NS_WARNING("nsFrameList::ReplaceFrame: aOldFrame not found in list");
return PR_FALSE;
}
prevSibling->SetNextSibling(aNewFrame);
}
aNewFrame->SetNextSibling(nextFrame);
if (aParent) {
aNewFrame->SetParent(aParent);
}
#ifdef DEBUG
CheckForLoops();
#endif
return PR_TRUE;
}
PRBool
nsFrameList::ReplaceFrame(nsIFrame* aParent,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame,
PRBool aDestroy)
{
NS_PRECONDITION(aOldFrame, "null ptr");
NS_PRECONDITION(aNewFrame, "null ptr");
if (DoReplaceFrame(aParent, aOldFrame, aNewFrame)) {
if (aDestroy) {
aOldFrame->Destroy(aOldFrame->GetPresContext());
}
return PR_TRUE;
}
return PR_FALSE;
}
PRBool
nsFrameList::Split(nsIFrame* aAfterFrame, nsIFrame** aNextFrameResult)
{

9
layout/generic/nsFrameList.h
View File

@ -108,11 +108,6 @@ public:
aFrameList.mFirstChild = nsnull;
}
PRBool ReplaceFrame(nsIFrame* aParent,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame,
PRBool aDestroy);
PRBool Split(nsIFrame* aAfterFrame, nsIFrame** aNextFrameResult);
/**
@ -168,10 +163,6 @@ public:
#endif
private:
PRBool DoReplaceFrame(nsIFrame* aParent,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
#ifdef DEBUG
void CheckForLoops();
#endif

21
layout/generic/nsGfxScrollFrame.cpp
View File

@ -215,17 +215,6 @@ nsHTMLScrollFrame::RemoveFrame(nsIAtom* aListName,
}
NS_IMETHODIMP
nsHTMLScrollFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_ASSERTION(!aListName, "Only main list supported");
nsresult rv = nsHTMLContainerFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
mInner.ReloadChildFrames();
return rv;
}
PRIntn
nsHTMLScrollFrame::GetSkipSides() const
{
@ -1095,16 +1084,6 @@ nsXULScrollFrame::RemoveFrame(nsIAtom* aListName,
}
NS_IMETHODIMP
nsXULScrollFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
nsresult rv = nsBoxFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
mInner.ReloadChildFrames();
return rv;
}
NS_IMETHODIMP
nsXULScrollFrame::GetPadding(nsMargin& aMargin)
{

8
layout/generic/nsGfxScrollFrame.h
View File

@ -219,10 +219,6 @@ public:
nsIFrame* aPrevFrame,
nsIFrame* aFrameList);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Destroy(nsPresContext* aPresContext);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
@ -353,10 +349,6 @@ public:
nsIFrame* aPrevFrame,
nsIFrame* aFrameList);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Destroy(nsPresContext* aPresContext);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,

21
layout/generic/nsIFrame.h
View File

@ -519,27 +519,6 @@ public:
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame) = 0;
/**
* This method is responsible for replacing the old frame with the
* new frame. The old frame should be destroyed and the new frame inserted
* in its place in the specified child list.
*
* @param aListName the name of the child list. A NULL pointer for the atom
* name means the unnamed principal child list
* @param aOldFrame the frame to remove
* @param aNewFrame the frame to replace it with. The new frame has its
* NS_FRAME_IS_DIRTY bit set
* @return NS_ERROR_INVALID_ARG if there is no child list with the specified
* name,
* NS_ERROR_FAILURE if the old child frame is not in the specified
* child list,
* NS_ERROR_UNEXPECTED if the frame is an atomic frame,
* NS_OK otherwise
*/
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame) = 0;
/**
* Get the content object associated with this frame. Does not add a reference.
*/

37
layout/generic/nsInlineFrame.cpp
View File

@ -263,30 +263,6 @@ nsInlineFrame::RemoveFrame(nsIAtom* aListName,
return NS_OK;
}
NS_IMETHODIMP
nsInlineFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
if (aListName) {
NS_ERROR("Don't have any special lists on inline frames!");
return NS_ERROR_INVALID_ARG;
}
if (!aOldFrame || !aNewFrame) {
NS_ERROR("Missing aOldFrame or aNewFrame");
return NS_ERROR_INVALID_ARG;
}
PRBool retval =
mFrames.ReplaceFrame(this, aOldFrame, aNewFrame, PR_TRUE);
// Ask the parent frame to reflow me.
ReflowDirtyChild(GetPresContext()->PresShell(), nsnull);
return retval ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsInlineFrame::Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
@ -1115,19 +1091,6 @@ nsPositionedInlineFrame::RemoveFrame(nsIAtom* aListName,
return rv;
}
NS_IMETHODIMP
nsPositionedInlineFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
if (mAbsoluteContainer.GetChildListName() == aListName) {
return mAbsoluteContainer.ReplaceFrame(this, aListName, aOldFrame,
aNewFrame);
} else {
return nsInlineFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
}
}
nsIAtom*
nsPositionedInlineFrame::GetAdditionalChildListName(PRInt32 aIndex) const
{

6
layout/generic/nsInlineFrame.h
View File

@ -81,9 +81,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Paint(nsPresContext* aPresContext,
nsIRenderingContext& aRenderingContext,
const nsRect& aDirtyRect,
@ -214,9 +211,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
virtual nsIAtom* GetAdditionalChildListName(PRInt32 aIndex) const;

14
layout/mathml/base/src/nsMathMLContainerFrame.cpp
View File

@ -936,20 +936,6 @@ nsMathMLContainerFrame::RemoveFrame(nsIAtom* aListName,
return ChildListChanged(nsIDOMMutationEvent::REMOVAL);
}
NS_IMETHODIMP
nsMathMLContainerFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
if (aListName || !aOldFrame || !aNewFrame) {
return NS_ERROR_INVALID_ARG;
}
// Replace the old frame with the new frame in the list
mFrames.ReplaceFrame(this, aOldFrame, aNewFrame, PR_TRUE);
return ChildListChanged(nsIDOMMutationEvent::MODIFICATION);
}
NS_IMETHODIMP
nsMathMLContainerFrame::AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,

27
layout/mathml/base/src/nsMathMLContainerFrame.h
View File

@ -142,11 +142,6 @@ public:
RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD
ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHODIMP
ReflowDirtyChild(nsIPresShell* aPresShell,
nsIFrame* aChild);
@ -377,17 +372,6 @@ public:
return rv;
}
NS_IMETHOD
ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_ASSERTION(!aListName, "internal error");
nsresult rv = nsBlockFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
nsMathMLContainerFrame::ReLayoutChildren(this);
return rv;
}
NS_IMETHOD
RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame)
@ -464,17 +448,6 @@ public:
return rv;
}
NS_IMETHOD
ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_ASSERTION(!aListName, "internal error");
nsresult rv = nsInlineFrame::ReplaceFrame(aListName, aOldFrame, aNewFrame);
nsMathMLContainerFrame::ReLayoutChildren(this);
return rv;
}
NS_IMETHOD
RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame)

16
layout/mathml/base/src/nsMathMLForeignFrameWrapper.h
View File

@ -122,22 +122,6 @@ public:
return NS_ERROR_NOT_IMPLEMENTED;
}
// need special care here because the base class implementation treats this
// as two operations: remove & insert; In our case, removing the child will
// remove us too... so we have to operate from our parent's perspective
NS_IMETHOD
ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
nsresult rv = mParent->ReplaceFrame(aListName, this, aNewFrame);
// XXX the usage of ReplaceFrame() vs. ReplaceFrameAndDestroy() is
// XXX ambiguous - see bug 122748. The style system doesn't call ReplaceFrame()
// XXX and that's why nobody seems to have been biten by the ambiguity yet
aOldFrame->Destroy(GetPresContext());
return rv;
}
// Our life is bound to the life of our unique child.
// When our child goes away, we ask our parent to delete us
NS_IMETHOD

9
layout/svg/base/src/nsSVGDefsFrame.cpp
View File

@ -182,15 +182,6 @@ nsSVGDefsFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGDefsFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGDefsFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
nsIAtom *
nsSVGDefsFrame::GetType() const
{

3
layout/svg/base/src/nsSVGDefsFrame.h
View File

@ -76,9 +76,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Init(nsPresContext* aPresContext,
nsIContent* aContent,
nsIFrame* aParent,

19
layout/svg/base/src/nsSVGForeignObjectFrame.cpp
View File

@ -107,10 +107,6 @@ public:
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
/**
* Get the "type" of the frame
*
@ -414,21 +410,6 @@ nsSVGForeignObjectFrame::RemoveFrame(nsIAtom* aListName,
return rv;
}
NS_IMETHODIMP
nsSVGForeignObjectFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
#ifdef DEBUG
printf("**nsSVGForeignObjectFrame::ReplaceFrame()\n");
#endif
nsresult rv;
rv = nsSVGForeignObjectFrameBase::ReplaceFrame(aListName, aOldFrame,
aNewFrame);
Update();
return rv;
}
// XXX Need to make sure that any of the code examining
// frametypes, particularly code looking at block and area
// also handles foreignObject before we return our own frametype

9
layout/svg/base/src/nsSVGGenericContainerFrame.cpp
View File

@ -155,15 +155,6 @@ nsSVGGenericContainerFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGGenericContainerFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGGenericContainerFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsSVGGenericContainerFrame::AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,

3
layout/svg/base/src/nsSVGGenericContainerFrame.h
View File

@ -76,9 +76,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Init(nsPresContext* aPresContext,
nsIContent* aContent,
nsIFrame* aParent,

12
layout/svg/base/src/nsSVGInnerSVGFrame.cpp
View File

@ -89,9 +89,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Init(nsPresContext* aPresContext,
nsIContent* aContent,
nsIFrame* aParent,
@ -329,15 +326,6 @@ nsSVGInnerSVGFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGInnerSVGFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGInnerSVGFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsSVGInnerSVGFrame::AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,

12
layout/svg/base/src/nsSVGOuterSVGFrame.cpp
View File

@ -195,9 +195,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,
@ -665,15 +662,6 @@ nsSVGOuterSVGFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGOuterSVGFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGOuterSVGFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsSVGOuterSVGFrame::AttributeChanged(PRInt32 aNameSpaceID,
nsIAtom* aAttribute,

9
layout/svg/base/src/nsSVGTSpanFrame.cpp
View File

@ -266,15 +266,6 @@ nsSVGTSpanFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGTSpanFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGTSpanFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
//----------------------------------------------------------------------
// nsISVGValueObserver methods:

3
layout/svg/base/src/nsSVGTSpanFrame.h
View File

@ -100,9 +100,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Init(nsPresContext* aPresContext,
nsIContent* aContent,
nsIFrame* aParent,

12
layout/svg/base/src/nsSVGTextFrame.cpp
View File

@ -102,9 +102,6 @@ public:
nsIFrame* aFrameList);
NS_IMETHOD RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame);
NS_IMETHOD ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame);
NS_IMETHOD Init(nsPresContext* aPresContext,
nsIContent* aContent,
@ -443,15 +440,6 @@ nsSVGTextFrame::RemoveFrame(nsIAtom* aListName,
return result ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsSVGTextFrame::ReplaceFrame(nsIAtom* aListName,
nsIFrame* aOldFrame,
nsIFrame* aNewFrame)
{
NS_NOTYETIMPLEMENTED("nsSVGTextFrame::ReplaceFrame");
return NS_ERROR_NOT_IMPLEMENTED;
}
//----------------------------------------------------------------------
// nsISVGValueObserver methods: