if (desiredSize.width < kidMaxSize.width) { desiredSize.width = kidMaxSize.width;
if (desiredSize.width < kidReflowState.minWidth) { desiredSize.width = kidReflowState.minWidth;
RootFrame::Reflow(nsIPresContext&          aPresContext,                  nsHTMLReflowMetrics&     aDesiredSize,                  const nsHTMLReflowState& aReflowState,                  nsReflowStatus&          aStatus){  NS_FRAME_TRACE_REFLOW_IN("RootFrame::Reflow");  aStatus = NS_FRAME_COMPLETE;  // XXX Copy the reflow state so that we can change the   // reason in cases where we're inserting and deleting  // frames from the root. Troy may want to reconstruct  // this routine.  nsHTMLReflowState reflowState(aReflowState);  if (eReflowReason_Incremental == reflowState.reason) {    // See if we're the target frame    nsIFrame* targetFrame;    reflowState.reflowCommand->GetTarget(targetFrame);    if (this == targetFrame) {      nsIReflowCommand::ReflowType  reflowType;      nsIFrame*                     childFrame;      // Get the reflow type      reflowState.reflowCommand->GetType(reflowType);      if ((nsIReflowCommand::FrameAppended == reflowType) ||          (nsIReflowCommand::FrameInserted == reflowType)) {        // Insert the frame into the child list        reflowState.reflowCommand->GetChildFrame(childFrame);        if (nsnull == mFirstChild) {          mFirstChild = childFrame;        } else {          nsIFrame* lastChild = LastFrame(mFirstChild);          lastChild->SetNextSibling(childFrame);        }        // XXX This is wrong. Only the new child should be reflowed         // with this reason. The rest should just be resized.        reflowState.reason = eReflowReason_Initial;      } else if (nsIReflowCommand::FrameRemoved == reflowType) {        nsIFrame* deletedFrame;        // Get the child frame we should delete        reflowState.reflowCommand->GetChildFrame(deletedFrame);        // Remove it from the child list        if (deletedFrame == mFirstChild) {          deletedFrame->GetNextSibling(mFirstChild);        } else {          nsIFrame* prevSibling = nsnull;          nsIFrame* f;          for (f = mFirstChild; nsnull != f; f->GetNextSibling(f)) {            if (f == deletedFrame) {              break;            }            prevSibling = f;          }          if (nsnull != f) {            nsIFrame* nextSibling;            f->GetNextSibling(nextSibling);            NS_ASSERTION(nsnull != prevSibling, "null pointer");            prevSibling->SetNextSibling(nextSibling);          }        }        deletedFrame->SetNextSibling(nsnull);                  // Delete the frame        deletedFrame->DeleteFrame(aPresContext);        reflowState.reason = eReflowReason_Resize;      }    } else {      nsIFrame* nextFrame;      // Get the next frame in the reflow chain      reflowState.reflowCommand->GetNext(nextFrame);      NS_ASSERTION(nextFrame == mFirstChild, "unexpected next reflow command frame");    }  }  // Reflow our child frame  if (nsnull != mFirstChild) {    // Compute how much space to reserve for our border and padding    nsMargin borderPadding;    nsHTMLReflowState::ComputeBorderPaddingFor(this, nsnull,                                               borderPadding);    // Compute the margins around the child frame    nsMargin childMargins;    nsHTMLReflowState::ComputeMarginFor(mFirstChild, &aReflowState,                                        childMargins);    nscoord top = borderPadding.top + childMargins.top;    nscoord bottom = borderPadding.bottom + childMargins.bottom;    nscoord left = borderPadding.left + childMargins.left;    nscoord right = borderPadding.right + childMargins.right;    nsSize  kidMaxSize(reflowState.maxSize);    kidMaxSize.width -= left + right;    kidMaxSize.height -= top + bottom;    nsHTMLReflowMetrics desiredSize(nsnull);    // We must pass in that the available height is unconstrained, because    // constrained is only for when we're paginated...    nsHTMLReflowState kidReflowState(aPresContext, mFirstChild, reflowState,                                     nsSize(kidMaxSize.width, NS_UNCONSTRAINEDSIZE));    // XXX HACK    kidReflowState.widthConstraint = eHTMLFrameConstraint_Fixed;    kidReflowState.minWidth = kidMaxSize.width;    kidReflowState.heightConstraint = eHTMLFrameConstraint_Fixed;    kidReflowState.minHeight = kidMaxSize.height;    nsIHTMLReflow* htmlReflow;    if (NS_OK == mFirstChild->QueryInterface(kIHTMLReflowIID, (void**)&htmlReflow)) {      ReflowChild(mFirstChild, aPresContext, desiredSize, kidReflowState, aStatus);          // Place and size the child. Because we told the child it was      // fixed make sure it's at least as big as we told it. This      // handles the case where the child ignores the reflow state      // constraints      if (desiredSize.width < kidMaxSize.width) {        desiredSize.width = kidMaxSize.width;      }      if (desiredSize.height < kidMaxSize.height) {        desiredSize.height = kidMaxSize.height;      }      nsRect  rect(left, top, desiredSize.width, desiredSize.height);      mFirstChild->SetRect(rect);      // XXX We should resolve the details of who/when DidReflow()      // notifications are sent...      htmlReflow->DidReflow(aPresContext, NS_FRAME_REFLOW_FINISHED);    }    // If this is a resize reflow then do a repaint    if (eReflowReason_Resize == reflowState.reason) {      nsRect  damageRect(0, 0, reflowState.maxSize.width, reflowState.maxSize.height);      Invalidate(damageRect, PR_FALSE);    }  }  // Return the max size as our desired size  aDesiredSize.width = reflowState.maxSize.width;  aDesiredSize.height = reflowState.maxSize.height;  aDesiredSize.ascent = aDesiredSize.height;  aDesiredSize.descent = 0;  NS_FRAME_TRACE_REFLOW_OUT("RootFrame::Reflow", aStatus);  return NS_OK;}