Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-01-19 09:30:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move reflow command construction into nsPresShell::AppendReflowCommand, remove

Browse Source 
some members, switch some callers to the non-COM-ish apis.  Bug 267085, r+sr=rbs
This commit is contained in:
bzbarsky%mit.edu 2005-02-08 00:59:52 +00:00
parent e855f5bf2f
commit e042c2f571
23 changed files with 126 additions and 374 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
layout/base/nsCSSFrameConstructor.cpp
View File

@ -10193,14 +10193,9 @@ nsCSSFrameConstructor::StyleChangeReflow(nsPresContext* aPresContext,
aFrame = GetIBContainingBlockFor(aFrame); aFrame = GetIBContainingBlockFor(aFrame);
// Target a style-change reflow at the frame. // Target a style-change reflow at the frame.
nsHTMLReflowCommand *reflowCmd; aPresContext->PresShell()->AppendReflowCommand(aFrame,
nsresult rv = NS_NewHTMLReflowCommand(&reflowCmd, aFrame, eReflowType_StyleChanged,
eReflowType_StyleChanged, nsnull);
nsnull,
aAttribute);
if (NS_SUCCEEDED(rv))
aPresContext->PresShell()->AppendReflowCommand(reflowCmd);
} }
return NS_OK; return NS_OK;

6
layout/base/nsIPresShell.h
View File

@ -84,7 +84,6 @@ class nsILayoutHistoryState;
class nsIReflowCallback; class nsIReflowCallback;
class nsISupportsArray; class nsISupportsArray;
class nsIDOMNode; class nsIDOMNode;
class nsHTMLReflowCommand;
class nsIStyleFrameConstruction; class nsIStyleFrameConstruction;
class nsIStyleSheet; class nsIStyleSheet;
class nsCSSFrameConstructor; class nsCSSFrameConstructor;
@ -323,7 +322,10 @@ public:
/** /**
* Reflow commands * Reflow commands
*/ */
NS_IMETHOD AppendReflowCommand(nsHTMLReflowCommand* aReflowCommand) = 0; NS_IMETHOD AppendReflowCommand(nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIAtom* aChildListName) = 0;
// XXXbz don't we need a child list name on this too?
NS_IMETHOD CancelReflowCommand(nsIFrame* aTargetFrame, nsReflowType* aCmdType) = 0; NS_IMETHOD CancelReflowCommand(nsIFrame* aTargetFrame, nsReflowType* aCmdType) = 0;
NS_IMETHOD CancelAllReflowCommands() = 0; NS_IMETHOD CancelAllReflowCommands() = 0;

51
layout/base/nsPresShell.cpp
View File

@ -1032,7 +1032,7 @@ ReflowCommandHashHashKey(PLDHashTable *table, const void *key)
// same high-order bits as all the other child list names. // same high-order bits as all the other child list names.
return return
(NS_PTR_TO_INT32(command->GetTarget()) >> 2) ^ (NS_PTR_TO_INT32(command->GetTarget()) >> 2) ^
(command->GetType() << 17) ^ (command->Type() << 17) ^
(NS_PTR_TO_INT32(command->GetChildListName()) << 20); (NS_PTR_TO_INT32(command->GetChildListName()) << 20);
} }
@ -1048,7 +1048,7 @@ ReflowCommandHashMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *entry,
return return
command->GetTarget() == command2->GetTarget() && command->GetTarget() == command2->GetTarget() &&
command->GetType() == command2->GetType() && command->Type() == command2->Type() &&
command->GetChildListName() == command2->GetChildListName(); command->GetChildListName() == command2->GetChildListName();
} }
@ -1109,8 +1109,10 @@ public:
nsISupports** aResult) const; nsISupports** aResult) const;
NS_IMETHOD GetPlaceholderFrameFor(nsIFrame* aFrame, NS_IMETHOD GetPlaceholderFrameFor(nsIFrame* aFrame,
nsIFrame** aPlaceholderFrame) const; nsIFrame** aPlaceholderFrame) const;
NS_IMETHOD AppendReflowCommand(nsHTMLReflowCommand* aReflowCommand); NS_IMETHOD AppendReflowCommand(nsIFrame* aTargetFrame,
NS_IMETHOD CancelReflowCommand(nsIFrame* aTargetFrame, nsReflowType aReflowType,
nsIAtom* aChildListName);
NS_IMETHOD CancelReflowCommand(nsIFrame* aTargetFrame,
nsReflowType* aCmdType); nsReflowType* aCmdType);
NS_IMETHOD CancelReflowCommandInternal(nsIFrame* aTargetFrame, NS_IMETHOD CancelReflowCommandInternal(nsIFrame* aTargetFrame,
nsReflowType* aCmdType, nsReflowType* aCmdType,
@ -3558,7 +3560,9 @@ PresShell::AlreadyInQueue(nsHTMLReflowCommand* aReflowCommand)
} }
NS_IMETHODIMP NS_IMETHODIMP
PresShell::AppendReflowCommand(nsHTMLReflowCommand* aReflowCommand) PresShell::AppendReflowCommand(nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIAtom* aChildListName)
{ {
// If we've not yet done the initial reflow, then don't bother // If we've not yet done the initial reflow, then don't bother
// enqueuing a reflow command yet. // enqueuing a reflow command yet.
@ -3569,10 +3573,20 @@ PresShell::AppendReflowCommand(nsHTMLReflowCommand* aReflowCommand)
//printf("gShellCounter: %d\n", gShellCounter++); //printf("gShellCounter: %d\n", gShellCounter++);
if (mInVerifyReflow) { if (mInVerifyReflow) {
return NS_OK; return NS_OK;
} }
#endif
nsHTMLReflowCommand* command = new nsHTMLReflowCommand(aTargetFrame,
aReflowType,
aChildListName);
if (!command) {
return NS_ERROR_OUT_OF_MEMORY;
}
#ifdef DEBUG
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) { if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
printf("\nPresShell@%p: adding reflow command\n", (void*)this); printf("\nPresShell@%p: adding reflow command\n", (void*)this);
aReflowCommand->List(stdout); command->List(stdout);
if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) { if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) {
printf("Current content model:\n"); printf("Current content model:\n");
nsIContent *rootContent = mDocument->GetRootContent(); nsIContent *rootContent = mDocument->GetRootContent();
@ -3585,20 +3599,20 @@ PresShell::AppendReflowCommand(nsHTMLReflowCommand* aReflowCommand)
// Add the reflow command to the queue // Add the reflow command to the queue
nsresult rv = NS_OK; nsresult rv = NS_OK;
if (!AlreadyInQueue(aReflowCommand)) { if (!AlreadyInQueue(command)) {
if (mReflowCommands.AppendElement(aReflowCommand)) { if (mReflowCommands.AppendElement(command)) {
ReflowCommandAdded(aReflowCommand); ReflowCommandAdded(command);
} else { } else {
// Drop this command.... we're out of memory // Drop this command.... we're out of memory
PL_DHashTableOperate(&mReflowCommandTable, aReflowCommand, PL_DHashTableOperate(&mReflowCommandTable, command,
PL_DHASH_REMOVE); PL_DHASH_REMOVE);
delete aReflowCommand; delete command;
rv = NS_ERROR_OUT_OF_MEMORY; rv = NS_ERROR_OUT_OF_MEMORY;
} }
} }
else { else {
// We're not going to process this reflow command. // We're not going to process this reflow command.
delete aReflowCommand; delete command;
} }
// For async reflow during doc load, post a reflow event if we are not batching reflow commands. // For async reflow during doc load, post a reflow event if we are not batching reflow commands.
@ -3687,7 +3701,7 @@ PresShell::CancelReflowCommandInternal(nsIFrame* aTargetFrame,
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
nsHTMLReflowCommand* rc = (nsHTMLReflowCommand*) mReflowCommands.ElementAt(i); nsHTMLReflowCommand* rc = (nsHTMLReflowCommand*) mReflowCommands.ElementAt(i);
if (rc && rc->GetTarget() == aTargetFrame && if (rc && rc->GetTarget() == aTargetFrame &&
(!aCmdType || rc->GetType() == *aCmdType)) { (!aCmdType || rc->Type() == *aCmdType)) {
#ifdef DEBUG #ifdef DEBUG
if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) { if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {
printf("PresShell: removing rc=%p for frame ", (void*)rc); printf("PresShell: removing rc=%p for frame ", (void*)rc);
@ -6372,10 +6386,7 @@ PresShell::ReflowCommandAdded(nsHTMLReflowCommand* aRC)
if (gAsyncReflowDuringDocLoad) { if (gAsyncReflowDuringDocLoad) {
NS_PRECONDITION(mRCCreatedDuringLoad >= 0, "PresShell's reflow command queue is in a bad state."); NS_PRECONDITION(mRCCreatedDuringLoad >= 0, "PresShell's reflow command queue is in a bad state.");
if (mDocumentLoading) { if (mDocumentLoading) {
PRInt32 flags; aRC->AddFlagBits(NS_RC_CREATED_DURING_DOCUMENT_LOAD);
aRC->GetFlags(&flags);
flags |= NS_RC_CREATED_DURING_DOCUMENT_LOAD;
aRC->SetFlags(flags);
mRCCreatedDuringLoad++; mRCCreatedDuringLoad++;
#ifdef PR_LOGGING #ifdef PR_LOGGING
@ -6413,9 +6424,7 @@ PresShell::ReflowCommandRemoved(nsHTMLReflowCommand* aRC)
if (gAsyncReflowDuringDocLoad) { if (gAsyncReflowDuringDocLoad) {
NS_PRECONDITION(mRCCreatedDuringLoad >= 0, "PresShell's reflow command queue is in a bad state."); NS_PRECONDITION(mRCCreatedDuringLoad >= 0, "PresShell's reflow command queue is in a bad state.");
PRInt32 flags; if (aRC->GetFlagBits() & NS_RC_CREATED_DURING_DOCUMENT_LOAD) {
aRC->GetFlags(&flags);
if (flags & NS_RC_CREATED_DURING_DOCUMENT_LOAD) {
mRCCreatedDuringLoad--; mRCCreatedDuringLoad--;
PR_LOG(gLog, PR_LOG_DEBUG, PR_LOG(gLog, PR_LOG_DEBUG,

9
layout/forms/nsFormControlHelper.cpp
View File

@ -381,12 +381,9 @@ void
nsFormControlHelper::StyleChangeReflow(nsPresContext* aPresContext, nsFormControlHelper::StyleChangeReflow(nsPresContext* aPresContext,
nsIFrame* aFrame) nsIFrame* aFrame)
{ {
nsHTMLReflowCommand* reflowCmd; aPresContext->PresShell()->AppendReflowCommand(aFrame,
nsresult rv = NS_NewHTMLReflowCommand(&reflowCmd, aFrame, eReflowType_StyleChanged,
eReflowType_StyleChanged); nsnull);
if (NS_SUCCEEDED(rv)) {
aPresContext->PresShell()->AppendReflowCommand(reflowCmd);
}
} }

50
layout/generic/nsAbsoluteContainingBlock.cpp
View File

@ -78,8 +78,6 @@ nsAbsoluteContainingBlock::AppendFrames(nsIFrame* aDelegatingFrame,
nsIAtom* aListName, nsIAtom* aListName,
nsIFrame* aFrameList) nsIFrame* aFrameList)
{ {
nsresult rv = NS_OK;
// Append the frames to our list of absolutely positioned frames // Append the frames to our list of absolutely positioned frames
#ifdef NS_DEBUG #ifdef NS_DEBUG
nsFrame::VerifyDirtyBitSet(aFrameList); nsFrame::VerifyDirtyBitSet(aFrameList);
@ -87,15 +85,9 @@ nsAbsoluteContainingBlock::AppendFrames(nsIFrame* aDelegatingFrame,
mAbsoluteFrames.AppendFrames(nsnull, aFrameList); mAbsoluteFrames.AppendFrames(nsnull, aFrameList);
// Generate a reflow command to reflow the dirty frames // Generate a reflow command to reflow the dirty frames
nsHTMLReflowCommand* reflowCmd; return aDelegatingFrame->GetPresContext()->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, aDelegatingFrame, eReflowType_ReflowDirty); AppendReflowCommand(aDelegatingFrame, eReflowType_ReflowDirty,
if (NS_SUCCEEDED(rv)) { GetChildListName());
reflowCmd->SetChildListName(GetChildListName());
aDelegatingFrame->GetPresContext()->PresShell()->
AppendReflowCommand(reflowCmd);
}
return rv;
} }
nsresult nsresult
@ -104,8 +96,6 @@ nsAbsoluteContainingBlock::InsertFrames(nsIFrame* aDelegatingFrame,
nsIFrame* aPrevFrame, nsIFrame* aPrevFrame,
nsIFrame* aFrameList) nsIFrame* aFrameList)
{ {
nsresult rv = NS_OK;
// Insert the new frames // Insert the new frames
#ifdef NS_DEBUG #ifdef NS_DEBUG
nsFrame::VerifyDirtyBitSet(aFrameList); nsFrame::VerifyDirtyBitSet(aFrameList);
@ -113,15 +103,9 @@ nsAbsoluteContainingBlock::InsertFrames(nsIFrame* aDelegatingFrame,
mAbsoluteFrames.InsertFrames(nsnull, aPrevFrame, aFrameList); mAbsoluteFrames.InsertFrames(nsnull, aPrevFrame, aFrameList);
// Generate a reflow command to reflow the dirty frames // Generate a reflow command to reflow the dirty frames
nsHTMLReflowCommand* reflowCmd; return aDelegatingFrame->GetPresContext()->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, aDelegatingFrame, eReflowType_ReflowDirty); AppendReflowCommand(aDelegatingFrame, eReflowType_ReflowDirty,
if (NS_SUCCEEDED(rv)) { GetChildListName());
reflowCmd->SetChildListName(GetChildListName());
aDelegatingFrame->GetPresContext()->PresShell()->
AppendReflowCommand(reflowCmd);
}
return rv;
} }
nsresult nsresult
@ -248,10 +232,7 @@ nsAbsoluteContainingBlock::ReflowingAbsolutesOnly(nsIFrame* aDelegatingFrame,
if (command) { if (command) {
// It's targeted at us. See if it's for the positioned child frames // It's targeted at us. See if it's for the positioned child frames
nsCOMPtr<nsIAtom> listName; if (GetChildListName() != command->GetChildListName()) {
command->GetChildListName(*getter_AddRefs(listName));
if (GetChildListName() != listName) {
// A reflow command is targeted directly at this block. // A reflow command is targeted directly at this block.
// The block will have to do a proper reflow. // The block will have to do a proper reflow.
return PR_FALSE; return PR_FALSE;
@ -403,18 +384,11 @@ nsAbsoluteContainingBlock::IncrementalReflow(nsIFrame* aDelegatin
if (command) { if (command) {
// It's targeted at us. See if it's for the positioned child frames // It's targeted at us. See if it's for the positioned child frames
nsCOMPtr<nsIAtom> listName; if (GetChildListName() == command->GetChildListName()) {
command->GetChildListName(*getter_AddRefs(listName));
if (GetChildListName() == listName) {
nsReflowType type;
// Get the type of reflow command
command->GetType(type);
// The only type of reflow command we expect is that we have dirty // The only type of reflow command we expect is that we have dirty
// child frames to reflow // child frames to reflow
NS_ASSERTION(type == eReflowType_ReflowDirty, "unexpected reflow type"); NS_ASSERTION(command->Type() == eReflowType_ReflowDirty,
"unexpected reflow type");
// Walk the positioned frames and reflow the dirty frames // Walk the positioned frames and reflow the dirty frames
for (nsIFrame* f = mAbsoluteFrames.FirstChild(); f; f = f->GetNextSibling()) { for (nsIFrame* f = mAbsoluteFrames.FirstChild(); f; f = f->GetNextSibling()) {
@ -504,9 +478,7 @@ nsAbsoluteContainingBlock::ReflowAbsoluteFrame(nsIFrame* aDelegat
if (command) { if (command) {
// We're the target. // We're the target.
nsReflowType type; printf("(%d)", command->Type());
command->GetType(type);
printf("(%d)", type);
} }
} }
char width[16]; char width[16];

50
layout/generic/nsBlockFrame.cpp
View File

@ -593,9 +593,7 @@ nsBlockFrame::Reflow(nsPresContext* aPresContext,
// We're the target. // We're the target.
reflow += " ("; reflow += " (";
nsReflowType type; reflow += kReflowCommandType[command->Type()];
command->GetType(type);
reflow += kReflowCommandType[type];
reflow += ")"; reflow += ")";
} }
@ -760,12 +758,10 @@ nsBlockFrame::Reflow(nsPresContext* aPresContext,
nsReflowPath *path = aReflowState.path; nsReflowPath *path = aReflowState.path;
nsHTMLReflowCommand *command = path->mReflowCommand; nsHTMLReflowCommand *command = path->mReflowCommand;
if (command) { if (command) {
nsReflowType type;
command->GetType(type);
#ifdef NOISY_REFLOW_REASON #ifdef NOISY_REFLOW_REASON
printf("type=%s ", kReflowCommandType[type]); printf("type=%s ", kReflowCommandType[command->Type()]);
#endif #endif
switch (type) { switch (command->Type()) {
case eReflowType_StyleChanged: case eReflowType_StyleChanged:
rv = PrepareStyleChangedReflow(state); rv = PrepareStyleChangedReflow(state);
break; break;
@ -2080,9 +2076,8 @@ nsBlockFrame::ReflowDirtyLines(nsBlockReflowState& aState)
nsHTMLReflowCommand *command = aState.mReflowState.path->mReflowCommand; nsHTMLReflowCommand *command = aState.mReflowState.path->mReflowCommand;
if (command) { if (command) {
nsReflowType type; printf(": type=%s(%d)", kReflowCommandType[command->Type()],
command->GetType(type); command->Type());
printf(": type=%s(%d)", kReflowCommandType[type], type);
} }
} }
else { else {
@ -2991,13 +2986,8 @@ nsBlockFrame::AttributeChanged(nsIContent* aChild,
// XXX Not sure if this is necessary anymore // XXX Not sure if this is necessary anymore
RenumberLists(presContext); RenumberLists(presContext);
nsHTMLReflowCommand* reflowCmd; rv = presContext->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, AppendReflowCommand(this, eReflowType_ContentChanged, nsnull);
eReflowType_ContentChanged,
nsnull,
aAttribute);
if (NS_SUCCEEDED(rv))
presContext->PresShell()->AppendReflowCommand(reflowCmd);
} }
else if (nsHTMLAtoms::value == aAttribute) { else if (nsHTMLAtoms::value == aAttribute) {
const nsStyleDisplay* styleDisplay = GetStyleDisplay(); const nsStyleDisplay* styleDisplay = GetStyleDisplay();
@ -3024,13 +3014,8 @@ nsBlockFrame::AttributeChanged(nsIContent* aChild,
// XXX Not sure if this is necessary anymore // XXX Not sure if this is necessary anymore
blockParent->RenumberLists(presContext); blockParent->RenumberLists(presContext);
nsHTMLReflowCommand* reflowCmd; rv = presContext->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, blockParent, AppendReflowCommand(blockParent, eReflowType_ContentChanged, nsnull);
eReflowType_ContentChanged,
nsnull,
aAttribute);
if (NS_SUCCEEDED(rv))
presContext->PresShell()->AppendReflowCommand(reflowCmd);
} }
} }
} }
@ -6549,13 +6534,9 @@ nsBlockFrame::ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild)
// although we should. We can't use the NS_FRAME_HAS_DIRTY_CHILDREN // although we should. We can't use the NS_FRAME_HAS_DIRTY_CHILDREN
// flag, because that's used to indicate whether in-flow children are // flag, because that's used to indicate whether in-flow children are
// dirty... // dirty...
nsHTMLReflowCommand* reflowCmd; nsresult rv = aPresShell->
nsresult rv = NS_NewHTMLReflowCommand(&reflowCmd, this, AppendReflowCommand(this, eReflowType_ReflowDirty,
eReflowType_ReflowDirty); mAbsoluteContainer.GetChildListName());
if (NS_SUCCEEDED(rv)) {
reflowCmd->SetChildListName(mAbsoluteContainer.GetChildListName());
aPresShell->AppendReflowCommand(reflowCmd);
}
#ifdef DEBUG #ifdef DEBUG
if (gNoisyReflow) { if (gNoisyReflow) {
@ -6599,8 +6580,7 @@ nsBlockFrame::ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild)
// post a dirty children reflow command targeted at yourself // post a dirty children reflow command targeted at yourself
mState |= NS_FRAME_HAS_DIRTY_CHILDREN; mState |= NS_FRAME_HAS_DIRTY_CHILDREN;
nsFrame::CreateAndPostReflowCommand(aPresShell, this, aPresShell->AppendReflowCommand(this, eReflowType_ReflowDirty, nsnull);
eReflowType_ReflowDirty, nsnull, nsnull, nsnull);
#ifdef DEBUG #ifdef DEBUG
if (gNoisyReflow) { if (gNoisyReflow) {
@ -6970,9 +6950,7 @@ nsBlockFrame::ReflowBullet(nsBlockReflowState& aState,
// the block, in which case, we propagate that to its children. // the block, in which case, we propagate that to its children.
nsHTMLReflowCommand *command = rs.path->mReflowCommand; nsHTMLReflowCommand *command = rs.path->mReflowCommand;
if (command) { if (command) {
nsReflowType type; if (command->Type() == eReflowType_StyleChanged)
command->GetType(type);
if (type == eReflowType_StyleChanged)
reason = eReflowReason_StyleChange; reason = eReflowReason_StyleChange;
} }
} }

5
layout/generic/nsColumnSetFrame.cpp
View File

@ -685,10 +685,7 @@ nsColumnSetFrame::Reflow(nsPresContext* aPresContext,
// See if it's targeted at us // See if it's targeted at us
if (command) { if (command) {
nsReflowType reflowType; switch (command->Type()) {
command->GetType(reflowType);
switch (reflowType) {
case eReflowType_StyleChanged: case eReflowType_StyleChanged:
kidReason = eReflowReason_StyleChange; kidReason = eReflowReason_StyleChange;

4
layout/generic/nsContainerFrame.cpp
View File

@ -48,7 +48,6 @@
#include "nsIView.h" #include "nsIView.h"
#include "nsIScrollableView.h" #include "nsIScrollableView.h"
#include "nsVoidArray.h" #include "nsVoidArray.h"
#include "nsHTMLReflowCommand.h"
#include "nsHTMLContainerFrame.h" #include "nsHTMLContainerFrame.h"
#include "nsFrameManager.h" #include "nsFrameManager.h"
#include "nsIPresShell.h" #include "nsIPresShell.h"
@ -416,8 +415,7 @@ nsContainerFrame::ReflowDirtyChild(nsIPresShell* aPresShell, nsIFrame* aChild)
// child because the frame may have more than one child // child because the frame may have more than one child
mState |= NS_FRAME_HAS_DIRTY_CHILDREN; mState |= NS_FRAME_HAS_DIRTY_CHILDREN;
nsFrame::CreateAndPostReflowCommand(aPresShell, aChild, aPresShell->AppendReflowCommand(aChild, eReflowType_ReflowDirty, nsnull);
eReflowType_ReflowDirty, nsnull, nsnull, nsnull);
return NS_OK; return NS_OK;
} }

53
layout/generic/nsFrame.cpp
View File

@ -4504,34 +4504,6 @@ nsFrame::GetFirstLeaf(nsPresContext* aPresContext, nsIFrame **aFrame)
} }
} }
nsresult nsFrame::CreateAndPostReflowCommand(nsIPresShell* aPresShell,
nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIFrame* aChildFrame,
nsIAtom* aAttribute,
nsIAtom* aListName)
{
nsresult rv;
if (!aPresShell || !aTargetFrame) {
rv = NS_ERROR_NULL_POINTER;
}
else {
nsHTMLReflowCommand* reflowCmd;
rv = NS_NewHTMLReflowCommand(&reflowCmd, aTargetFrame,
aReflowType, aChildFrame,
aAttribute);
if (NS_SUCCEEDED(rv)) {
if (nsnull != aListName) {
reflowCmd->SetChildListName(aListName);
}
aPresShell->AppendReflowCommand(reflowCmd);
}
}
return rv;
}
NS_IMETHODIMP NS_IMETHODIMP
nsFrame::CaptureMouse(nsPresContext* aPresContext, PRBool aGrabMouseEvents) nsFrame::CaptureMouse(nsPresContext* aPresContext, PRBool aGrabMouseEvents)
{ {
@ -5298,14 +5270,12 @@ nsFrame::BoxReflow(nsBoxLayoutState& aState,
PRBool reflowChild = PR_TRUE; PRBool reflowChild = PR_TRUE;
if (path->mReflowCommand && if (path->mReflowCommand &&
path->FirstChild() == path->EndChildren()) { path->FirstChild() == path->EndChildren() &&
path->mReflowCommand->Type() == eReflowType_StyleChanged) {
// There's an incremental reflow targeted directly at our // There's an incremental reflow targeted directly at our
// frame, and our frame only (i.e., none of our descendants // frame, and our frame only (i.e., none of our descendants
// are targets). // are targets).
nsReflowType type; reflowChild = PR_FALSE;
path->mReflowCommand->GetType(type);
if (type == eReflowType_StyleChanged)
reflowChild = PR_FALSE;
} }
if (reflowChild) { if (reflowChild) {
@ -5607,14 +5577,11 @@ nsFrame::CanSetMaxElementWidth(nsBoxLayoutState& aState, nsReflowReason& aReason
// only incremental reflows can handle maxelementsize being set. // only incremental reflows can handle maxelementsize being set.
if (reflowState->reason == eReflowReason_Incremental) { if (reflowState->reason == eReflowReason_Incremental) {
nsReflowPath *path = *aReflowPath; nsReflowPath *path = *aReflowPath;
if (path && path->mReflowCommand) { if (path && path->mReflowCommand &&
path->mReflowCommand->Type() == eReflowType_StyleChanged) {
// MaxElement doesn't work on style change reflows.. :-( // MaxElement doesn't work on style change reflows.. :-(
// XXXwaterson why? // XXXwaterson why?
nsReflowType type; return PR_FALSE;
path->mReflowCommand->GetType(type);
if (type == eReflowType_StyleChanged)
return PR_FALSE;
} }
return PR_TRUE; return PR_TRUE;
@ -5719,9 +5686,7 @@ nsAdaptorPrintReason(nsHTMLReflowState& aReflowState)
break; break;
case eReflowReason_Incremental: case eReflowReason_Incremental:
{ {
nsReflowType type; switch (aReflowState.reflowCommand->Type()) {
aReflowState.reflowCommand->GetType(type);
switch (type) {
case eReflowType_StyleChanged: case eReflowType_StyleChanged:
reflowReasonString = "incremental (StyleChanged)"; reflowReasonString = "incremental (StyleChanged)";
break; break;
@ -6413,10 +6378,8 @@ static void DisplayReflowEnterPrint(nsPresContext* aPresContext,
DR_state->PrettyUC(aReflowState.availableWidth, width); DR_state->PrettyUC(aReflowState.availableWidth, width);
DR_state->PrettyUC(aReflowState.availableHeight, height); DR_state->PrettyUC(aReflowState.availableHeight, height);
if (aReflowState.path && aReflowState.path->mReflowCommand) { if (aReflowState.path && aReflowState.path->mReflowCommand) {
nsReflowType type;
aReflowState.path->mReflowCommand->GetType(type);
const char *incr_reason; const char *incr_reason;
switch(type) { switch(aReflowState.path->mReflowCommand->Type()) {
case eReflowType_ContentChanged: case eReflowType_ContentChanged:
incr_reason = "incr. (Content)"; incr_reason = "incr. (Content)";
break; break;

7
layout/generic/nsFrame.h
View File

@ -358,13 +358,6 @@ public:
PRBool IsFrameTreeTooDeep(const nsHTMLReflowState& aReflowState, PRBool IsFrameTreeTooDeep(const nsHTMLReflowState& aReflowState,
nsHTMLReflowMetrics& aMetrics); nsHTMLReflowMetrics& aMetrics);
static nsresult CreateAndPostReflowCommand(nsIPresShell* aPresShell,
nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIFrame* aChildFrame,
nsIAtom* aAttribute,
nsIAtom* aListName);
// Do the work for getting the parent style context frame so that // Do the work for getting the parent style context frame so that
// other frame's |GetParentStyleContextFrame| methods can call this // other frame's |GetParentStyleContextFrame| methods can call this
// method on *another* frame. (This function handles out-of-flow // method on *another* frame. (This function handles out-of-flow

8
layout/generic/nsGfxScrollFrame.cpp
View File

@ -38,7 +38,7 @@
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsHTMLParts.h" #include "nsHTMLParts.h"
#include "nsPresContext.h" #include "nsPresContext.h"
#include "nsHTMLReflowCommand.h" #include "nsReflowType.h"
#include "nsIDeviceContext.h" #include "nsIDeviceContext.h"
#include "nsPageFrame.h" #include "nsPageFrame.h"
#include "nsViewsCID.h" #include "nsViewsCID.h"
@ -2010,9 +2010,9 @@ nsGfxScrollFrameInner::Layout(nsBoxLayoutState& aState)
// at least one fixed child // at least one fixed child
if (parentFrame->GetFirstChild(nsLayoutAtoms::fixedList)) { if (parentFrame->GetFirstChild(nsLayoutAtoms::fixedList)) {
// force a reflow of the fixed children // force a reflow of the fixed children
nsFrame::CreateAndPostReflowCommand(mOuter->GetPresContext()->PresShell(), mOuter->GetPresContext()->PresShell()->
parentFrame, AppendReflowCommand(parentFrame, eReflowType_UserDefined,
eReflowType_UserDefined, nsnull, nsnull, nsLayoutAtoms::fixedList); nsLayoutAtoms::fixedList);
} }
} }
} }

20
layout/generic/nsHTMLFrame.cpp
View File

@ -288,11 +288,8 @@ CanvasFrame::AppendFrames(nsIAtom* aListName,
mFrames.AppendFrame(nsnull, aFrameList); mFrames.AppendFrame(nsnull, aFrameList);
// Generate a reflow command to reflow the newly inserted frame // Generate a reflow command to reflow the newly inserted frame
nsHTMLReflowCommand* reflowCmd; rv = GetPresContext()->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, eReflowType_ReflowDirty); AppendReflowCommand(this, eReflowType_ReflowDirty, nsnull);
if (NS_SUCCEEDED(rv)) {
GetPresContext()->PresShell()->AppendReflowCommand(reflowCmd);
}
} }
return rv; return rv;
@ -339,12 +336,8 @@ CanvasFrame::RemoveFrame(nsIAtom* aListName,
mFrames.DestroyFrame(GetPresContext(), aOldFrame); mFrames.DestroyFrame(GetPresContext(), aOldFrame);
// Generate a reflow command so we get reflowed // Generate a reflow command so we get reflowed
nsHTMLReflowCommand* reflowCmd; rv = GetPresContext()->PresShell()->
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, eReflowType_ReflowDirty); AppendReflowCommand(this, eReflowType_ReflowDirty, nsnull);
if (NS_SUCCEEDED(rv)) {
GetPresContext()->PresShell()->AppendReflowCommand(reflowCmd);
}
} else { } else {
rv = NS_ERROR_FAILURE; rv = NS_ERROR_FAILURE;
} }
@ -468,10 +461,7 @@ CanvasFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowCommand *command = aReflowState.path->mReflowCommand; nsHTMLReflowCommand *command = aReflowState.path->mReflowCommand;
if (command) { if (command) {
// Get the reflow type // Get the reflow type
nsReflowType reflowType; switch (command->Type()) {
command->GetType(reflowType);
switch (reflowType) {
case eReflowType_ReflowDirty: case eReflowType_ReflowDirty:
isDirtyChildReflow = PR_TRUE; isDirtyChildReflow = PR_TRUE;
break; break;

8
layout/generic/nsHTMLParts.h
View File

@ -259,12 +259,4 @@ NS_NewHTMLFragmentContentSink(nsIFragmentContentSink** aInstancePtrResult);
nsresult nsresult
NS_NewHTMLFragmentContentSink2(nsIFragmentContentSink** aInstancePtrResult); NS_NewHTMLFragmentContentSink2(nsIFragmentContentSink** aInstancePtrResult);
/** Create a new HTML reflow command */
nsresult
NS_NewHTMLReflowCommand(nsHTMLReflowCommand** aInstancePtrResult,
nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIFrame* aChildFrame = nsnull,
nsIAtom* aAttribute = nsnull);
#endif /* nsHTMLParts_h___ */ #endif /* nsHTMLParts_h___ */

41
layout/generic/nsHTMLReflowCommand.cpp
View File

@ -46,25 +46,6 @@
#include "nsContainerFrame.h" #include "nsContainerFrame.h"
#include "nsLayoutAtoms.h" #include "nsLayoutAtoms.h"
nsresult
NS_NewHTMLReflowCommand(nsHTMLReflowCommand** aInstancePtrResult,
nsIFrame* aTargetFrame,
nsReflowType aReflowType,
nsIFrame* aChildFrame,
nsIAtom* aAttribute)
{
NS_ASSERTION(aInstancePtrResult,
"null result passed to NS_NewHTMLReflowCommand");
*aInstancePtrResult = new nsHTMLReflowCommand(aTargetFrame, aReflowType,
aChildFrame, aAttribute);
if (!*aInstancePtrResult) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
#ifdef DEBUG_jesup #ifdef DEBUG_jesup
PRInt32 gReflows; PRInt32 gReflows;
PRInt32 gReflowsInUse; PRInt32 gReflowsInUse;
@ -105,17 +86,12 @@ mPathStats gmPathStats;
// and optional child frame // and optional child frame
nsHTMLReflowCommand::nsHTMLReflowCommand(nsIFrame* aTargetFrame, nsHTMLReflowCommand::nsHTMLReflowCommand(nsIFrame* aTargetFrame,
nsReflowType aReflowType, nsReflowType aReflowType,
nsIFrame* aChildFrame, nsIAtom* aChildListName)
nsIAtom* aAttribute) : mType(aReflowType), mTargetFrame(aTargetFrame), mListName(aChildListName),
: mType(aReflowType), mTargetFrame(aTargetFrame), mChildFrame(aChildFrame),
mAttribute(aAttribute),
mListName(nsnull),
mFlags(0) mFlags(0)
{ {
MOZ_COUNT_CTOR(nsHTMLReflowCommand); MOZ_COUNT_CTOR(nsHTMLReflowCommand);
NS_PRECONDITION(mTargetFrame != nsnull, "null target frame"); NS_PRECONDITION(mTargetFrame != nsnull, "null target frame");
if (nsnull!=mAttribute)
NS_ADDREF(mAttribute);
#ifdef DEBUG_jesup #ifdef DEBUG_jesup
gReflows++; gReflows++;
gReflowsInUse++; gReflowsInUse++;
@ -136,9 +112,6 @@ nsHTMLReflowCommand::~nsHTMLReflowCommand()
gReflowsMaxLarger++; gReflowsMaxLarger++;
gReflowsInUse--; gReflowsInUse--;
#endif #endif
NS_IF_RELEASE(mAttribute);
NS_IF_RELEASE(mListName);
} }
nsresult nsresult
@ -158,16 +131,6 @@ nsHTMLReflowCommand::List(FILE* out) const
fprintf(out, " target="); fprintf(out, " target=");
nsFrame::ListTag(out, mTargetFrame); nsFrame::ListTag(out, mTargetFrame);
} }
if (mChildFrame) {
fprintf(out, " child=");
nsFrame::ListTag(out, mChildFrame);
}
if (mAttribute) {
fprintf(out, " attr=");
nsAutoString attr;
mAttribute->ToString(attr);
fputs(NS_LossyConvertUCS2toASCII(attr).get(), out);
}
if (mListName) { if (mListName) {
fprintf(out, " list="); fprintf(out, " list=");
nsAutoString attr; nsAutoString attr;

64
layout/generic/nsHTMLReflowCommand.h
View File

@ -82,8 +82,7 @@ public:
*/ */
nsHTMLReflowCommand(nsIFrame* aTargetFrame, nsHTMLReflowCommand(nsIFrame* aTargetFrame,
nsReflowType aReflowType, nsReflowType aReflowType,
nsIFrame* aChildFrame = nsnull, nsIAtom* aChildListName);
nsIAtom* aAttribute = nsnull);
~nsHTMLReflowCommand(); ~nsHTMLReflowCommand();
@ -95,17 +94,7 @@ public:
/** /**
* Get the type of reflow command. * Get the type of reflow command.
*/ */
nsReflowType GetType() const { return mType; } nsReflowType Type() const { return mType; }
/**
* Can return nsnull.
*/
nsIAtom* GetAttribute() const { return mAttribute; }
/**
* Get the child frame associated with the reflow command.
*/
nsIFrame* GetChildFrame() const { return mChildFrame; }
/** /**
* Returns the name of the child list to which the child frame belongs. * Returns the name of the child list to which the child frame belongs.
@ -117,25 +106,14 @@ public:
*/ */
nsIAtom* GetChildListName() const { return mListName; } nsIAtom* GetChildListName() const { return mListName; }
/**
* Sets the name of the child list to which the child frame belongs.
* Only used for reflow command types FrameAppended, FrameInserted, and
* FrameRemoved
*/
void SetChildListName(nsIAtom* aListName) {
NS_ASSERTION(!mListName, "SetChildListName called twice");
mListName = aListName;
NS_IF_ADDREF(mListName);
}
/** /**
* Dump out the reflow-command to out * Dump out the reflow-command to out
*/ */
nsresult List(FILE* out) const; nsresult List(FILE* out) const;
/** /**
* Get/set reflow command flags * Get/set reflow command flags
*/ */
PRInt32 GetFlagBits() { return mFlags; } PRInt32 GetFlagBits() { return mFlags; }
void AddFlagBits(PRInt32 aBits) { mFlags |= aBits; } void AddFlagBits(PRInt32 aBits) { mFlags |= aBits; }
void RemoveFlagBits(PRInt32 aBits) { mFlags &= ~aBits; } void RemoveFlagBits(PRInt32 aBits) { mFlags &= ~aBits; }
@ -152,40 +130,18 @@ public:
aReflowType = mType; aReflowType = mType;
return NS_OK; return NS_OK;
} }
nsresult GetAttribute(nsIAtom *& aAttribute) const {
aAttribute = mAttribute;
NS_IF_ADDREF(aAttribute);
return NS_OK;
}
nsresult GetChildFrame(nsIFrame*& aChildFrame) const {
aChildFrame = mChildFrame;
return NS_OK;
}
nsresult GetChildListName(nsIAtom*& aListName) const { nsresult GetChildListName(nsIAtom*& aListName) const {
aListName = mListName; aListName = mListName;
NS_IF_ADDREF(aListName); NS_IF_ADDREF(aListName);
return NS_OK; return NS_OK;
} }
nsresult GetFlags(PRInt32* aFlags) {
*aFlags = mFlags;
return NS_OK;
}
nsresult SetFlags(PRInt32 aFlags) {
mFlags = aFlags;
return NS_OK;
}
private: private:
nsReflowType mType; nsReflowType mType;
nsIFrame* mTargetFrame; nsIFrame* mTargetFrame;
nsIFrame* mChildFrame; nsCOMPtr<nsIAtom> mListName;
nsIAtom* mAttribute; // XXXbz remove the flags? They're not being used for much...
nsIAtom* mListName;
PRInt32 mFlags; PRInt32 mFlags;
}; };

7
layout/generic/nsLineLayout.cpp
View File

@ -885,15 +885,12 @@ nsLineLayout::ReflowFrame(nsIFrame* aFrame,
// subtree. // subtree.
nsHTMLReflowCommand* rc = rs->path->mReflowCommand; nsHTMLReflowCommand* rc = rs->path->mReflowCommand;
if (rc) { if (rc) {
nsReflowType type; nsReflowType type = rc->Type();
rc->GetType(type);
if (type == eReflowType_StyleChanged) { if (type == eReflowType_StyleChanged) {
nsIFrame* parentFrame = psd->mFrame nsIFrame* parentFrame = psd->mFrame
? psd->mFrame->mFrame ? psd->mFrame->mFrame
: mBlockReflowState->frame; : mBlockReflowState->frame;
nsIFrame* target; if (rc->GetTarget() == parentFrame) {
rc->GetTarget(target);
if (target == parentFrame) {
reason = eReflowReason_StyleChange; reason = eReflowReason_StyleChange;
} }
} }

5
layout/mathml/base/src/nsMathMLmactionFrame.cpp
View File

@ -452,8 +452,9 @@ nsMathMLmactionFrame::MouseClick(nsIDOMEvent* aMouseEvent)
// targeted at our selected frame // targeted at our selected frame
nsIPresShell *presShell = mPresContext->PresShell(); nsIPresShell *presShell = mPresContext->PresShell();
presShell->CancelReflowCommand(this, nsnull); presShell->CancelReflowCommand(this, nsnull);
nsFrame::CreateAndPostReflowCommand(presShell, mSelectedFrame, presShell->AppendReflowCommand(mSelectedFrame,
eReflowType_StyleChanged, nsnull, nsnull, nsnull); eReflowType_StyleChanged,
nsnull);
} }
} }
} }

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

@ -254,7 +254,6 @@ protected:
const nsHTMLReflowState& aReflowState); const nsHTMLReflowState& aReflowState);
// nsIView* mView; // nsIView* mView;
nsIPresShell* mPresShell; // XXX is a non-owning ref ok?
PRUint32 mRedrawSuspendCount; PRUint32 mRedrawSuspendCount;
PRBool mNeedsReflow; PRBool mNeedsReflow;
PRBool mViewportInitialized; PRBool mViewportInitialized;
@ -289,9 +288,6 @@ NS_NewSVGOuterSVGFrame(nsIPresShell* aPresShell, nsIContent* aContent, nsIFrame*
*aNewFrame = it; *aNewFrame = it;
// XXX is this ok?
it->mPresShell = aPresShell;
return NS_OK; return NS_OK;
} }
@ -876,11 +872,9 @@ nsSVGOuterSVGFrame::InvalidateRegion(nsISVGRendererRegion* region, PRBool bRedra
if (!region && !bRedraw) return NS_OK; if (!region && !bRedraw) return NS_OK;
NS_ENSURE_TRUE(mPresShell, NS_ERROR_FAILURE);
// just ignore invalidates if painting is suppressed by the shell // just ignore invalidates if painting is suppressed by the shell
PRBool suppressed = PR_FALSE; PRBool suppressed = PR_FALSE;
mPresShell->IsPaintingSuppressed(&suppressed); GetPresContext()->PresShell()->IsPaintingSuppressed(&suppressed);
if (suppressed) return NS_OK; if (suppressed) return NS_OK;
nsIView* view = GetClosestView(); nsIView* view = GetClosestView();
@ -975,8 +969,6 @@ nsSVGOuterSVGFrame::UnsuspendRedraw()
} }
} }
NS_ENSURE_TRUE(mPresShell, NS_ERROR_FAILURE);
vm->EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC); vm->EndUpdateViewBatch(NS_VMREFRESH_NO_SYNC);
return NS_OK; return NS_OK;
} }
@ -1076,18 +1068,12 @@ void nsSVGOuterSVGFrame::InitiateReflow()
mNeedsReflow = PR_FALSE; mNeedsReflow = PR_FALSE;
// Generate a reflow command to reflow ourselves // Generate a reflow command to reflow ourselves
nsHTMLReflowCommand *reflowCmd; nsIPresShell* presShell = GetPresContext()->PresShell();
NS_NewHTMLReflowCommand(&reflowCmd, this, eReflowType_ReflowDirty); presShell->AppendReflowCommand(this, eReflowType_ReflowDirty, nsnull);
if (!reflowCmd) {
NS_ERROR("error creating reflow command object");
return;
}
mPresShell->AppendReflowCommand(reflowCmd);
// XXXbz why is this synchronously flushing reflows, exactly? If it // XXXbz why is this synchronously flushing reflows, exactly? If it
// needs to, why is it not using the presshell's reflow batching // needs to, why is it not using the presshell's reflow batching
// instead of hacking its own? // instead of hacking its own?
mPresShell->FlushPendingNotifications(Flush_OnlyReflow); presShell->FlushPendingNotifications(Flush_OnlyReflow);
} }

6
layout/tables/nsTableColGroupFrame.cpp
View File

@ -419,11 +419,7 @@ NS_METHOD nsTableColGroupFrame::IR_TargetIsMe(nsHTMLReflowMetrics& aDesiredS
{ {
nsresult rv = NS_OK; nsresult rv = NS_OK;
aStatus = NS_FRAME_COMPLETE; aStatus = NS_FRAME_COMPLETE;
nsReflowType type; switch (aReflowState.path->mReflowCommand->Type())
aReflowState.path->mReflowCommand->GetType(type);
nsIFrame *objectFrame;
aReflowState.path->mReflowCommand->GetChildFrame(objectFrame);
switch (type)
{ {
case eReflowType_StyleChanged : case eReflowType_StyleChanged :
rv = IR_StyleChanged(aDesiredSize, aReflowState, aStatus); rv = IR_StyleChanged(aDesiredSize, aReflowState, aStatus);

20
layout/tables/nsTableFrame.cpp
View File

@ -343,15 +343,8 @@ nsTableFrame::AppendDirtyReflowCommand(nsIFrame* aFrame)
{ {
aFrame->AddStateBits(NS_FRAME_IS_DIRTY); // mark the table frame as dirty aFrame->AddStateBits(NS_FRAME_IS_DIRTY); // mark the table frame as dirty
nsHTMLReflowCommand* reflowCmd; return aFrame->GetPresContext()->PresShell()->
nsresult rv = NS_NewHTMLReflowCommand(&reflowCmd, aFrame, AppendReflowCommand(aFrame, eReflowType_ReflowDirty, nsnull);
eReflowType_ReflowDirty);
if (NS_SUCCEEDED(rv)) {
// Add the reflow command
rv = aFrame->GetPresContext()->PresShell()->AppendReflowCommand(reflowCmd);
}
return rv;
} }
// Make sure any views are positioned properly // Make sure any views are positioned properly
@ -2667,10 +2660,7 @@ nsTableFrame::IR_TargetIsMe(nsTableReflowState& aReflowState,
nsresult rv = NS_OK; nsresult rv = NS_OK;
aStatus = NS_FRAME_COMPLETE; aStatus = NS_FRAME_COMPLETE;
nsReflowType type; switch (aReflowState.reflowState.path->mReflowCommand->Type()) {
aReflowState.reflowState.path->mReflowCommand->GetType(type);
switch (type) {
case eReflowType_StyleChanged : case eReflowType_StyleChanged :
rv = IR_StyleChanged(aReflowState, aStatus); rv = IR_StyleChanged(aReflowState, aStatus);
break; break;
@ -7419,9 +7409,7 @@ void nsTableFrame::DebugReflow(nsIFrame* aFrame,
timer->mCount = gRflCount++; timer->mCount = gRflCount++;
nsHTMLReflowCommand* reflowCommand = aState.reflowCommand; nsHTMLReflowCommand* reflowCommand = aState.reflowCommand;
if (reflowCommand) { if (reflowCommand) {
nsReflowType reflowType; timer->mReflowType = reflowType->Type();
reflowCommand->GetType(reflowType);
timer->mReflowType = reflowType;
} }
timer->Start(); timer->Start();
aState.mDebugHook = timer; aState.mDebugHook = timer;

37
layout/tables/nsTableOuterFrame.cpp
View File

@ -236,11 +236,9 @@ nsTableOuterFrame::AppendFrames(nsIAtom* aListName,
// Reflow the new caption frame. It's already marked dirty, so generate a reflow // Reflow the new caption frame. It's already marked dirty, so generate a reflow
// command that tells us to reflow our dirty child frames // command that tells us to reflow our dirty child frames
nsHTMLReflowCommand* reflowCmd; rv = GetPresContext()->
PresShell()->AppendReflowCommand(this, eReflowType_ReflowDirty,
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, eReflowType_ReflowDirty); nsnull);
if (NS_SUCCEEDED(rv))
GetPresContext()->PresShell()->AppendReflowCommand(reflowCmd);
} }
} }
else { else {
@ -264,8 +262,6 @@ NS_IMETHODIMP
nsTableOuterFrame::RemoveFrame(nsIAtom* aListName, nsTableOuterFrame::RemoveFrame(nsIAtom* aListName,
nsIFrame* aOldFrame) nsIFrame* aOldFrame)
{ {
nsresult rv;
// We only have two child frames: the inner table and one caption frame. // We only have two child frames: the inner table and one caption frame.
// The inner frame can't be removed so this should be the caption // The inner frame can't be removed so this should be the caption
NS_PRECONDITION(nsLayoutAtoms::captionList == aListName, "can't remove inner frame"); NS_PRECONDITION(nsLayoutAtoms::captionList == aListName, "can't remove inner frame");
@ -290,11 +286,9 @@ nsTableOuterFrame::RemoveFrame(nsIAtom* aListName,
} }
// Generate a reflow command so we get reflowed // Generate a reflow command so we get reflowed
nsHTMLReflowCommand* reflowCmd; GetPresContext()->PresShell()->AppendReflowCommand(this,
eReflowType_ReflowDirty,
rv = NS_NewHTMLReflowCommand(&reflowCmd, this, eReflowType_ReflowDirty); nsnull);
if (NS_SUCCEEDED(rv))
GetPresContext()->PresShell()->AppendReflowCommand(reflowCmd);
return NS_OK; return NS_OK;
} }
@ -1305,9 +1299,7 @@ nsTableOuterFrame::OuterReflowChild(nsPresContext* aPresContext,
mInnerTableFrame == aChildFrame && childRS.reason == eReflowReason_Incremental) { mInnerTableFrame == aChildFrame && childRS.reason == eReflowReason_Incremental) {
nsHTMLReflowCommand* command = childRS.path->mReflowCommand; nsHTMLReflowCommand* command = childRS.path->mReflowCommand;
if (command) { if (command) {
nsReflowType type; *aNeedToReflowCaption = eReflowType_StyleChanged == command->Type();
command->GetType(type);
*aNeedToReflowCaption = eReflowType_StyleChanged == type;
} }
} }
@ -1454,9 +1446,7 @@ nsTableOuterFrame::IR_TargetIsCaptionFrame(nsPresContext* aPresContext
nsReflowReason reflowReason = eReflowReason_Incremental; nsReflowReason reflowReason = eReflowReason_Incremental;
nsHTMLReflowCommand* command = aOuterRS.path->mReflowCommand; nsHTMLReflowCommand* command = aOuterRS.path->mReflowCommand;
if (command) { if (command) {
nsReflowType reflowCommandType; switch(command->Type()) {
command->GetType(reflowCommandType);
switch(reflowCommandType) {
case eReflowType_StyleChanged: case eReflowType_StyleChanged:
needInnerReflow = PR_TRUE; needInnerReflow = PR_TRUE;
break; break;
@ -1605,12 +1595,7 @@ nsresult nsTableOuterFrame::IR_TargetIsMe(nsPresContext* aPresContext,
nsReflowStatus& aStatus) nsReflowStatus& aStatus)
{ {
nsresult rv = NS_OK; nsresult rv = NS_OK;
nsHTMLReflowCommand* command = aReflowState.path->mReflowCommand; switch (aReflowState.path->mReflowCommand->Type()) {
nsReflowType type;
command->GetType(type);
nsIFrame* objectFrame;
command->GetChildFrame(objectFrame);
switch (type) {
case eReflowType_ReflowDirty: case eReflowType_ReflowDirty:
rv = IR_ReflowDirty(aPresContext, aDesiredSize, aReflowState, aStatus); rv = IR_ReflowDirty(aPresContext, aDesiredSize, aReflowState, aStatus);
break; break;
@ -1658,9 +1643,7 @@ nsTableOuterFrame::IR_InnerTableReflow(nsPresContext* aPresContext,
nsReflowReason reflowReason = eReflowReason_Incremental; nsReflowReason reflowReason = eReflowReason_Incremental;
nsHTMLReflowCommand* command = aOuterRS.path->mReflowCommand; nsHTMLReflowCommand* command = aOuterRS.path->mReflowCommand;
if (command) { if (command) {
nsReflowType type; if (eReflowType_StyleChanged == command->Type()) {
command->GetType(type);
if (eReflowType_StyleChanged == type) {
reflowReason = eReflowReason_StyleChange; reflowReason = eReflowReason_StyleChange;
reflowCaption = PR_TRUE; reflowCaption = PR_TRUE;
} }

9
layout/xul/base/src/nsBox.cpp
View File

@ -331,8 +331,8 @@ nsBox::MarkStyleChange(nsBoxLayoutState& aState)
return parent->RelayoutDirtyChild(aState, this); return parent->RelayoutDirtyChild(aState, this);
else { else {
/* /*
nsFrame::CreateAndPostReflowCommand(aState.PresShell(), this, aState.PresShell()->AppendReflowCommand(this, eReflowType_StyleChanged,
nsHTMLReflowCommand::StyleChange, nsnull, nsnull, nsnull); nsnull);
return NS_OK; return NS_OK;
*/ */
return GetParent()->ReflowDirtyChild(aState.PresShell(), this); return GetParent()->ReflowDirtyChild(aState.PresShell(), this);
@ -396,9 +396,8 @@ nsBox::RelayoutDirtyChild(nsBoxLayoutState& aState, nsIBox* aChild)
AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN); AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
if (GetStateBits() & NS_FRAME_REFLOW_ROOT) { if (GetStateBits() & NS_FRAME_REFLOW_ROOT) {
nsFrame::CreateAndPostReflowCommand(aState.PresShell(), this, aState.PresShell()->AppendReflowCommand(this, eReflowType_ReflowDirty,
eReflowType_ReflowDirty, nsnull);
nsnull, nsnull, nsnull);
return NS_OK; return NS_OK;
} }

7
layout/xul/base/src/nsSplitterFrame.cpp
View File

@ -623,11 +623,8 @@ nsSplitterFrameInner::MouseDrag(nsPresContext* aPresContext, nsGUIEvent* aEvent)
/* /*
nsIPresShell *shell = aPresContext->PresShell(); nsIPresShell *shell = aPresContext->PresShell();
nsCOMPtr<nsHTMLReflowCommand> reflowCmd; shell->AppendReflowCommand(mOuter->mParent, eReflowType_StyleChanged,
nsresult rv = NS_NewHTMLReflowCommand(getter_AddRefs(reflowCmd), mOuter->mParent, nsnull);
eReflowType_StyleChanged);
if (NS_SUCCEEDED(rv))
shell->AppendReflowCommand(reflowCmd);
mOuter->mState |= NS_FRAME_IS_DIRTY; mOuter->mState |= NS_FRAME_IS_DIRTY;
mOuter->mParent->ReflowDirtyChild(shell, mOuter); mOuter->mParent->ReflowDirtyChild(shell, mOuter);