The Tor Browser: layout/xul/nsSprocketLayout.cpp@7e26c7da4463 (annotated)

layout/xul/nsSprocketLayout.cpp@7e26c7da4463 (annotated)

layout/xul/nsSprocketLayout.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 //
 // Eric Vaughan
 // Netscape Communications
 //
 // See documentation in associated header file
 //
 #include "nsBoxLayoutState.h"
 #include "nsSprocketLayout.h"
 #include "nsPresContext.h"
 #include "nsCOMPtr.h"
 #include "nsIContent.h"
 #include "nsIPresShell.h"
 #include "nsContainerFrame.h"
 #include "nsBoxFrame.h"
 #include "StackArena.h"
 #include "mozilla/Likely.h"
 #include <algorithm>
 nsBoxLayout* nsSprocketLayout::gInstance = nullptr;
 //#define DEBUG_GROW
 #define DEBUG_SPRING_SIZE 8
 #define DEBUG_BORDER_SIZE 2
 #define COIL_SIZE 8
 nsresult
 NS_NewSprocketLayout( nsIPresShell* aPresShell, nsCOMPtr<nsBoxLayout>& aNewLayout)
 {
   if (!nsSprocketLayout::gInstance) {
     nsSprocketLayout::gInstance = new nsSprocketLayout();
     NS_IF_ADDREF(nsSprocketLayout::gInstance);
   }
   // we have not instance variables so just return our static one.
   aNewLayout = nsSprocketLayout::gInstance;
   return NS_OK;
 }
 /*static*/ void
 nsSprocketLayout::Shutdown()
 {
   NS_IF_RELEASE(gInstance);
 }
 nsSprocketLayout::nsSprocketLayout()
 {
 }
 bool
 nsSprocketLayout::IsHorizontal(nsIFrame* aBox)
 {
    return (aBox->GetStateBits() & NS_STATE_IS_HORIZONTAL) != 0;
 }
 void
 nsSprocketLayout::GetFrameState(nsIFrame* aBox, nsFrameState& aState)
 {
    aState = aBox->GetStateBits();
 }
 static uint8_t
 GetFrameDirection(nsIFrame* aBox)
 {
    return aBox->StyleVisibility()->mDirection;
 }
 static void
 HandleBoxPack(nsIFrame* aBox, const nsFrameState& aFrameState, nscoord& aX, nscoord& aY,
               const nsRect& aOriginalRect, const nsRect& aClientRect)
 {
   // In the normal direction we lay out our kids in the positive direction (e.g., |x| will get
   // bigger for a horizontal box, and |y| will get bigger for a vertical box).  In the reverse
   // direction, the opposite is true.  We'll be laying out each child at a smaller |x| or
   // |y|.
   uint8_t frameDirection = GetFrameDirection(aBox);
   if (aFrameState & NS_STATE_IS_HORIZONTAL) {
     if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
       // The normal direction. |x| increases as we move through our children.
       aX = aClientRect.x;
     }
     else {
       // The reverse direction. |x| decreases as we move through our children.
       aX = aClientRect.x + aOriginalRect.width;
     }
     // |y| is always in the normal direction in horizontal boxes
     aY = aClientRect.y;
   }
   else {
     // take direction property into account for |x| in vertical boxes
     if (frameDirection == NS_STYLE_DIRECTION_LTR) {
       // The normal direction. |x| increases as we move through our children.
       aX = aClientRect.x;
     }
     else {
       // The reverse direction. |x| decreases as we move through our children.
       aX = aClientRect.x + aOriginalRect.width;
     }
     if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL) {
       // The normal direction. |y| increases as we move through our children.
       aY = aClientRect.y;
     }
     else {
       // The reverse direction. |y| decreases as we move through our children.
       aY = aClientRect.y + aOriginalRect.height;
     }
   }
   // Get our pack/alignment information.
   nsIFrame::Halignment halign = aBox->GetHAlign();
   nsIFrame::Valignment valign = aBox->GetVAlign();
   // The following code handles box PACKING.  Packing comes into play in the case where the computed size for
   // all of our children (now stored in our client rect) is smaller than the size available for
   // the box (stored in |aOriginalRect|).
   //
   // Here we adjust our |x| and |y| variables accordingly so that we start at the beginning,
   // middle, or end of the box.
   //
   // XXXdwh JUSTIFY needs to be implemented!
   if (aFrameState & NS_STATE_IS_HORIZONTAL) {
     switch(halign) {
       case nsBoxFrame::hAlign_Left:
         break; // Nothing to do.  The default initialized us properly.
       case nsBoxFrame::hAlign_Center:
         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
           aX += (aOriginalRect.width - aClientRect.width)/2;
         else
           aX -= (aOriginalRect.width - aClientRect.width)/2;
         break;
       case nsBoxFrame::hAlign_Right:
         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
           aX += (aOriginalRect.width - aClientRect.width);
         else
           aX -= (aOriginalRect.width - aClientRect.width);
         break; // Nothing to do for the reverse dir.  The default initialized us properly.
     }
   } else {
     switch(valign) {
       case nsBoxFrame::vAlign_Top:
       case nsBoxFrame::vAlign_BaseLine: // This value is technically impossible to specify for pack.
         break;  // Don't do anything.  We were initialized correctly.
       case nsBoxFrame::vAlign_Middle:
         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
           aY += (aOriginalRect.height - aClientRect.height)/2;
         else
           aY -= (aOriginalRect.height - aClientRect.height)/2;
         break;
       case nsBoxFrame::vAlign_Bottom:
         if (aFrameState & NS_STATE_IS_DIRECTION_NORMAL)
           aY += (aOriginalRect.height - aClientRect.height);
         else
           aY -= (aOriginalRect.height - aClientRect.height);
         break;
     }
   }
 }
 NS_IMETHODIMP
 nsSprocketLayout::Layout(nsIFrame* aBox, nsBoxLayoutState& aState)
 {
   // See if we are collapsed. If we are, then simply iterate over all our
   // children and give them a rect of 0 width and height.
   if (aBox->IsCollapsed()) {
     nsIFrame* child = aBox->GetChildBox();
     while(child)
     {
       nsBoxFrame::LayoutChildAt(aState, child, nsRect(0,0,0,0));
       child = child->GetNextBox();
     }
     return NS_OK;
   }
   nsBoxLayoutState::AutoReflowDepth depth(aState);
   mozilla::AutoStackArena arena;
   // ----- figure out our size ----------
   const nsSize originalSize = aBox->GetSize();
   // -- make sure we remove our border and padding  ----
   nsRect clientRect;
   aBox->GetClientRect(clientRect);
   // |originalClientRect| represents the rect of the entire box (excluding borders
   // and padding).  We store it here because we're going to use |clientRect| to hold
   // the required size for all our kids.  As an example, consider an hbox with a
   // specified width of 300.  If the kids total only 150 pixels of width, then
   // we have 150 pixels left over.  |clientRect| is going to hold a width of 150 and
   // is going to be adjusted based off the value of the PACK property.  If flexible
   // objects are in the box, then the two rects will match.
   nsRect originalClientRect(clientRect);
   // The frame state contains cached knowledge about our box, such as our orientation
   // and direction.
   nsFrameState frameState = nsFrameState(0);
   GetFrameState(aBox, frameState);
   // Build a list of our children's desired sizes and computed sizes
   nsBoxSize*         boxSizes = nullptr;
   nsComputedBoxSize* computedBoxSizes = nullptr;
   nscoord min = 0;
   nscoord max = 0;
   int32_t flexes = 0;
   PopulateBoxSizes(aBox, aState, boxSizes, min, max, flexes);
   // The |size| variable will hold the total size of children along the axis of
   // the box.  Continuing with the example begun in the comment above, size would
   // be 150 pixels.
   nscoord size = clientRect.width;
   if (!IsHorizontal(aBox))
     size = clientRect.height;
   ComputeChildSizes(aBox, aState, size, boxSizes, computedBoxSizes);
   // After the call to ComputeChildSizes, the |size| variable contains the
   // total required size of all the children.  We adjust our clientRect in the
   // appropriate dimension to match this size.  In our example, we now assign
   // 150 pixels into the clientRect.width.
   //
   // The variables |min| and |max| hold the minimum required size box must be
   // in the OPPOSITE orientation, e.g., for a horizontal box, |min| is the minimum
   // height we require to enclose our children, and |max| is the maximum height
   // required to enclose our children.
   if (IsHorizontal(aBox)) {
     clientRect.width = size;
     if (clientRect.height < min)
       clientRect.height = min;
     if (frameState & NS_STATE_AUTO_STRETCH) {
       if (clientRect.height > max)
         clientRect.height = max;
     }
   } else {
     clientRect.height = size;
     if (clientRect.width < min)
       clientRect.width = min;
     if (frameState & NS_STATE_AUTO_STRETCH) {
       if (clientRect.width > max)
         clientRect.width = max;
     }
   }
   // With the sizes computed, now it's time to lay out our children.
   bool finished;
   nscoord passes = 0;
   // We flow children at their preferred locations (along with the appropriate computed flex).
   // After we flow a child, it is possible that the child will change its size.  If/when this happens,
   // we have to do another pass.  Typically only 2 passes are required, but the code is prepared to
   // do as many passes as are necessary to achieve equilibrium.
   nscoord x = 0;
   nscoord y = 0;
   nscoord origX = 0;
   nscoord origY = 0;
   // |childResized| lets us know if a child changed its size after we attempted to lay it out at
   // the specified size.  If this happens, we usually have to do another pass.
   bool childResized = false;
   // |passes| stores our number of passes.  If for any reason we end up doing more than, say, 10
   // passes, we assert to indicate that something is seriously screwed up.
   passes = 0;
   do
   {
 #ifdef DEBUG_REFLOW
     if (passes > 0) {
       AddIndents();
       printf("ChildResized doing pass: %d\n", passes);
     }
 #endif
     // Always assume that we're done.  This will change if, for example, children don't stay
     // the same size after being flowed.
     finished = true;
     // Handle box packing.
     HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
     // Now that packing is taken care of we set up a few additional
     // tracking variables.
     origX = x;
     origY = y;
     nscoord nextX = x;
     nscoord nextY = y;
     // Now we iterate over our box children and our box size lists in
     // parallel.  For each child, we look at its sizes and figure out
     // where to place it.
     nsComputedBoxSize* childComputedBoxSize = computedBoxSizes;
     nsBoxSize* childBoxSize                 = boxSizes;
     nsIFrame* child = aBox->GetChildBox();
     int32_t count = 0;
     while (child || (childBoxSize && childBoxSize->bogus))
     {
       // If for some reason, our lists are not the same length, we guard
       // by bailing out of the loop.
       if (childBoxSize == nullptr) {
         NS_NOTREACHED("Lists not the same length.");
         break;
       }
       nscoord width = clientRect.width;
       nscoord height = clientRect.height;
       if (!childBoxSize->bogus) {
         // We have a valid box size entry.  This entry already contains information about our
         // sizes along the axis of the box (e.g., widths in a horizontal box).  If our default
         // ALIGN is not stretch, however, then we also need to know the child's size along the
         // opposite axis.
         if (!(frameState & NS_STATE_AUTO_STRETCH)) {
            nsSize prefSize = child->GetPrefSize(aState);
            nsSize minSize = child->GetMinSize(aState);
            nsSize maxSize = child->GetMaxSize(aState);
            prefSize = nsBox::BoundsCheck(minSize, prefSize, maxSize);
            AddMargin(child, prefSize);
            width = std::min(prefSize.width, originalClientRect.width);
            height = std::min(prefSize.height, originalClientRect.height);
         }
       }
       // Obtain the computed size along the axis of the box for this child from the computedBoxSize entry.
       // We store the result in |width| for horizontal boxes and |height| for vertical boxes.
       if (frameState & NS_STATE_IS_HORIZONTAL)
         width = childComputedBoxSize->size;
       else
         height = childComputedBoxSize->size;
       // Adjust our x/y for the left/right spacing.
       if (frameState & NS_STATE_IS_HORIZONTAL) {
         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
           x += (childBoxSize->left);
         else
           x -= (childBoxSize->right);
       } else {
         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
           y += (childBoxSize->left);
         else
           y -= (childBoxSize->right);
       }
       nextX = x;
       nextY = y;
       // Now we build a child rect.
       nscoord rectX = x;
       nscoord rectY = y;
       if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
         if (frameState & NS_STATE_IS_HORIZONTAL)
           rectX -= width;
         else
           rectY -= height;
       }
       // We now create an accurate child rect based off our computed size information.
       nsRect childRect(rectX, rectY, width, height);
       // Sanity check against our clientRect.  It is possible that a child specified
       // a size that is too large to fit.  If that happens, then we have to grow
       // our client rect.  Remember, clientRect is not the total rect of the enclosing
       // box.  It currently holds our perception of how big the children needed to
       // be.
       if (childRect.width > clientRect.width)
         clientRect.width = childRect.width;
       if (childRect.height > clientRect.height)
         clientRect.height = childRect.height;
       // Either |nextX| or |nextY| is updated by this function call, according
       // to our axis.
       ComputeChildsNextPosition(aBox, x, y, nextX, nextY, childRect);
       // Now we further update our nextX/Y along our axis.
       // We also set childRect.y/x along the opposite axis appropriately for a
       // stretch alignment.  (Non-stretch alignment is handled below.)
       if (frameState & NS_STATE_IS_HORIZONTAL) {
         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
           nextX += (childBoxSize->right);
         else
           nextX -= (childBoxSize->left);
         childRect.y = originalClientRect.y;
       }
       else {
         if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
           nextY += (childBoxSize->right);
         else
           nextY -= (childBoxSize->left);
         childRect.x = originalClientRect.x;
       }
       // If we encounter a completely bogus box size, we just leave this child completely
       // alone and continue through the loop to the next child.
       if (childBoxSize->bogus)
       {
         childComputedBoxSize = childComputedBoxSize->next;
         childBoxSize = childBoxSize->next;
         count++;
         x = nextX;
         y = nextY;
         continue;
       }
       nsMargin margin(0,0,0,0);
       bool layout = true;
       // Deflate the rect of our child by its margin.
       child->GetMargin(margin);
       childRect.Deflate(margin);
       if (childRect.width < 0)
         childRect.width = 0;
       if (childRect.height < 0)
         childRect.height = 0;
       // Now we're trying to figure out if we have to lay out this child, i.e., to call
       // the child's Layout method.
       if (passes > 0) {
         layout = false;
       } else {
         // Always perform layout if we are dirty or have dirty children
         if (!NS_SUBTREE_DIRTY(child))
           layout = false;
       }
       nsRect oldRect(child->GetRect());
       // Non-stretch alignment will be handled in AlignChildren(), so don't
       // change child out-of-axis positions yet.
       if (!(frameState & NS_STATE_AUTO_STRETCH)) {
         if (frameState & NS_STATE_IS_HORIZONTAL) {
           childRect.y = oldRect.y;
         } else {
           childRect.x = oldRect.x;
         }
       }
       // We computed a childRect.  Now we want to set the bounds of the child to be that rect.
       // If our old rect is different, then we know our size changed and we cache that fact
       // in the |sizeChanged| variable.
       child->SetBounds(aState, childRect);
       bool sizeChanged = (childRect.width != oldRect.width ||
                             childRect.height != oldRect.height);
       if (sizeChanged) {
         // Our size is different.  Sanity check against our maximum allowed size to ensure
         // we didn't exceed it.
         nsSize minSize = child->GetMinSize(aState);
         nsSize maxSize = child->GetMaxSize(aState);
         maxSize = nsBox::BoundsCheckMinMax(minSize, maxSize);
         // make sure the size is in our max size.
         if (childRect.width > maxSize.width)
           childRect.width = maxSize.width;
         if (childRect.height > maxSize.height)
           childRect.height = maxSize.height;
         // set it again
         child->SetBounds(aState, childRect);
       }
       // If we already determined that layout was required or if our size has changed, then
       // we make sure to call layout on the child, since its children may need to be shifted
       // around as a result of the size change.
       if (layout || sizeChanged)
         child->Layout(aState);
       // If the child was a block or inline (e.g., HTML) it may have changed its rect *during* layout.
       // We have to check for this.
       nsRect newChildRect(child->GetRect());
       if (!newChildRect.IsEqualInterior(childRect)) {
 #ifdef DEBUG_GROW
         child->DumpBox(stdout);
         printf(" GREW from (%d,%d) -> (%d,%d)\n", childRect.width, childRect.height, newChildRect.width, newChildRect.height);
 #endif
         newChildRect.Inflate(margin);
         childRect.Inflate(margin);
         // The child changed size during layout.  The ChildResized method handles this
         // scenario.
         ChildResized(aBox,
                      aState,
                      child,
                      childBoxSize,
                      childComputedBoxSize,
                      boxSizes,
                      computedBoxSizes,
                      childRect,
                      newChildRect,
                      clientRect,
                      flexes,
                      finished);
         // We note that a child changed size, which means that another pass will be required.
         childResized = true;
         // Now that a child resized, it's entirely possible that OUR rect is too small.  Now we
         // ensure that |originalClientRect| is grown to accommodate the size of |clientRect|.
         if (clientRect.width > originalClientRect.width)
           originalClientRect.width = clientRect.width;
         if (clientRect.height > originalClientRect.height)
           originalClientRect.height = clientRect.height;
         if (!(frameState & NS_STATE_IS_DIRECTION_NORMAL)) {
           // Our childRect had its XMost() or YMost() (depending on our layout
           // direction), positioned at a certain point.  Ensure that the
           // newChildRect satisfies the same constraint.  Note that this is
           // just equivalent to adjusting the x/y by the difference in
           // width/height between childRect and newChildRect.  So we don't need
           // to reaccount for the left and right of the box layout state again.
           if (frameState & NS_STATE_IS_HORIZONTAL)
             newChildRect.x = childRect.XMost() - newChildRect.width;
           else
             newChildRect.y = childRect.YMost() - newChildRect.height;
         }
         // If the child resized then recompute its position.
         ComputeChildsNextPosition(aBox, x, y, nextX, nextY, newChildRect);
         if (newChildRect.width >= margin.left + margin.right && newChildRect.height >= margin.top + margin.bottom)
           newChildRect.Deflate(margin);
         if (childRect.width >= margin.left + margin.right && childRect.height >= margin.top + margin.bottom)
           childRect.Deflate(margin);
         child->SetBounds(aState, newChildRect);
         // If we are the first box that changed size, then we don't need to do a second pass
         if (count == 0)
           finished = true;
       }
       // Now update our x/y finally.
       x = nextX;
       y = nextY;
       // Move to the next child.
       childComputedBoxSize = childComputedBoxSize->next;
       childBoxSize = childBoxSize->next;
       child = child->GetNextBox();
       count++;
     }
     // Sanity-checking code to ensure we don't do an infinite # of passes.
     passes++;
     NS_ASSERTION(passes < 10, "A Box's child is constantly growing!!!!!");
     if (passes > 10)
       break;
   } while (false == finished);
   // Get rid of our size lists.
   while(boxSizes)
   {
     nsBoxSize* toDelete = boxSizes;
     boxSizes = boxSizes->next;
     delete toDelete;
   }
   while(computedBoxSizes)
   {
     nsComputedBoxSize* toDelete = computedBoxSizes;
     computedBoxSizes = computedBoxSizes->next;
     delete toDelete;
   }
   if (childResized) {
     // See if one of our children forced us to get bigger
     nsRect tmpClientRect(originalClientRect);
     nsMargin bp(0,0,0,0);
     aBox->GetBorderAndPadding(bp);
     tmpClientRect.Inflate(bp);
     if (tmpClientRect.width > originalSize.width || tmpClientRect.height > originalSize.height)
     {
       // if it did reset our bounds.
       nsRect bounds(aBox->GetRect());
       if (tmpClientRect.width > originalSize.width)
         bounds.width = tmpClientRect.width;
       if (tmpClientRect.height > originalSize.height)
         bounds.height = tmpClientRect.height;
       aBox->SetBounds(aState, bounds);
     }
   }
   // Because our size grew, we now have to readjust because of box packing.  Repack
   // in order to update our x and y to the correct values.
   HandleBoxPack(aBox, frameState, x, y, originalClientRect, clientRect);
   // Compare against our original x and y and only worry about adjusting the children if
   // we really did have to change the positions because of packing (typically for 'center'
   // or 'end' pack values).
   if (x != origX || y != origY) {
     nsIFrame* child = aBox->GetChildBox();
     // reposition all our children
     while (child)
     {
       nsRect childRect(child->GetRect());
       childRect.x += (x - origX);
       childRect.y += (y - origY);
       child->SetBounds(aState, childRect);
       child = child->GetNextBox();
     }
   }
   // Perform out-of-axis alignment for non-stretch alignments
   if (!(frameState & NS_STATE_AUTO_STRETCH)) {
     AlignChildren(aBox, aState);
   }
   // That's it!  If you made it this far without having a nervous breakdown,
   // congratulations!  Go get yourself a beer.
   return NS_OK;
 }
 void
 nsSprocketLayout::PopulateBoxSizes(nsIFrame* aBox, nsBoxLayoutState& aState, nsBoxSize*& aBoxSizes, nscoord& aMinSize, nscoord& aMaxSize, int32_t& aFlexes)
 {
   // used for the equal size flag
   nscoord biggestPrefWidth = 0;
   nscoord biggestMinWidth = 0;
   nscoord smallestMaxWidth = NS_INTRINSICSIZE;
   nsFrameState frameState = nsFrameState(0);
   GetFrameState(aBox, frameState);
   //if (frameState & NS_STATE_CURRENTLY_IN_DEBUG)
   //   printf("In debug\n");
   aMinSize = 0;
   aMaxSize = NS_INTRINSICSIZE;
   bool isHorizontal;
   if (IsHorizontal(aBox))
      isHorizontal = true;
   else
      isHorizontal = false;
   // this is a nice little optimization
   // it turns out that if we only have 1 flexable child
   // then it does not matter what its preferred size is
   // there is nothing to flex it relative. This is great
   // because we can avoid asking for a preferred size in this
   // case. Why is this good? Well you might have html inside it
   // and asking html for its preferred size is rather expensive.
   // so we can just optimize it out this way.
   // set flexes
   nsIFrame* child = aBox->GetChildBox();
   aFlexes = 0;
   nsBoxSize* currentBox = nullptr;
 #if 0
   nsBoxSize* start = aBoxSizes;
   while(child)
   {
     // ok if we started with a list move down the list
     // until we reach the end. Then start looking at childen.
     // This feature is used extensively for Grid.
     nscoord flex = 0;
     if (!start) {
       if (!currentBox) {
         aBoxSizes      = new (aState) nsBoxSize();
         currentBox      = aBoxSizes;
       } else {
         currentBox->next      = new (aState) nsBoxSize();
         currentBox      = currentBox->next;
       }
       flex = child->GetFlex(aState);
       currentBox->flex = flex;
       currentBox->collapsed = child->IsCollapsed();
     } else {
       flex = start->flex;
       start = start->next;
     }
     if (flex > 0)
        aFlexes++;
     child = child->GetNextBox();
   }
 #endif
   // get pref, min, max
   child = aBox->GetChildBox();
   currentBox = aBoxSizes;
   nsBoxSize* last = nullptr;
   nscoord maxFlex = 0;
   int32_t childCount = 0;
   while(child)
   {
     while (currentBox && currentBox->bogus) {
       last = currentBox;
       currentBox = currentBox->next;
     }
     ++childCount;
     nsSize pref(0,0);
     nsSize minSize(0,0);
     nsSize maxSize(NS_INTRINSICSIZE,NS_INTRINSICSIZE);
     nscoord ascent = 0;
     bool collapsed = child->IsCollapsed();
     if (!collapsed) {
     // only one flexible child? Cool we will just make its preferred size
     // 0 then and not even have to ask for it.
     //if (flexes != 1)  {
       pref = child->GetPrefSize(aState);
       minSize = child->GetMinSize(aState);
       maxSize = nsBox::BoundsCheckMinMax(minSize, child->GetMaxSize(aState));
       ascent = child->GetBoxAscent(aState);
       nsMargin margin;
       child->GetMargin(margin);
       ascent += margin.top;
     //}
       pref = nsBox::BoundsCheck(minSize, pref, maxSize);
       AddMargin(child, pref);
       AddMargin(child, minSize);
       AddMargin(child, maxSize);
     }
     if (!currentBox) {
       // create one.
       currentBox = new (aState) nsBoxSize();
       if (!aBoxSizes) {
         aBoxSizes = currentBox;
         last = aBoxSizes;
       } else {
         last->next = currentBox;
         last = currentBox;
       }
       nscoord minWidth;
       nscoord maxWidth;
       nscoord prefWidth;
       // get sizes from child
       if (isHorizontal) {
           minWidth  = minSize.width;
           maxWidth  = maxSize.width;
           prefWidth = pref.width;
       } else {
           minWidth = minSize.height;
           maxWidth = maxSize.height;
           prefWidth = pref.height;
       }
       nscoord flex = child->GetFlex(aState);
       // set them if you collapsed you are not flexible.
       if (collapsed) {
         currentBox->flex = 0;
       }
       else {
         if (flex > maxFlex) {
           maxFlex = flex;
         }
         currentBox->flex = flex;
       }
       // we specified all our children are equal size;
       if (frameState & NS_STATE_EQUAL_SIZE) {
         if (prefWidth > biggestPrefWidth)
           biggestPrefWidth = prefWidth;
         if (minWidth > biggestMinWidth)
           biggestMinWidth = minWidth;
         if (maxWidth < smallestMaxWidth)
           smallestMaxWidth = maxWidth;
       } else { // not we can set our children right now.
         currentBox->pref    = prefWidth;
         currentBox->min     = minWidth;
         currentBox->max     = maxWidth;
       }
       NS_ASSERTION(minWidth <= prefWidth && prefWidth <= maxWidth,"Bad min, pref, max widths!");
     }
     if (!isHorizontal) {
       if (minSize.width > aMinSize)
         aMinSize = minSize.width;
       if (maxSize.width < aMaxSize)
         aMaxSize = maxSize.width;
     } else {
       if (minSize.height > aMinSize)
         aMinSize = minSize.height;
       if (maxSize.height < aMaxSize)
         aMaxSize = maxSize.height;
     }
     currentBox->collapsed = collapsed;
     aFlexes += currentBox->flex;
     child = child->GetNextBox();
     last = currentBox;
     currentBox = currentBox->next;
   }
   if (childCount > 0) {
     nscoord maxAllowedFlex = nscoord_MAX / childCount;
     if (MOZ_UNLIKELY(maxFlex > maxAllowedFlex)) {
       // clamp all the flexes
       currentBox = aBoxSizes;
       while (currentBox) {
         currentBox->flex = std::min(currentBox->flex, maxAllowedFlex);
         currentBox = currentBox->next;
       }
     }
   }
 #ifdef DEBUG
   else {
     NS_ASSERTION(maxFlex == 0, "How did that happen?");
   }
 #endif
   // we specified all our children are equal size;
   if (frameState & NS_STATE_EQUAL_SIZE) {
     smallestMaxWidth = std::max(smallestMaxWidth, biggestMinWidth);
     biggestPrefWidth = nsBox::BoundsCheck(biggestMinWidth, biggestPrefWidth, smallestMaxWidth);
     currentBox = aBoxSizes;
     while(currentBox)
     {
       if (!currentBox->collapsed) {
         currentBox->pref = biggestPrefWidth;
         currentBox->min = biggestMinWidth;
         currentBox->max = smallestMaxWidth;
       } else {
         currentBox->pref = 0;
         currentBox->min = 0;
         currentBox->max = 0;
       }
       currentBox = currentBox->next;
     }
   }
 }
 void
 nsSprocketLayout::ComputeChildsNextPosition(nsIFrame* aBox,
                                       const nscoord& aCurX,
                                       const nscoord& aCurY,
                                       nscoord& aNextX,
                                       nscoord& aNextY,
                                       const nsRect& aCurrentChildSize)
 {
   // Get the position along the box axis for the child.
   // The out-of-axis position is not set.
   nsFrameState frameState = nsFrameState(0);
   GetFrameState(aBox, frameState);
   if (IsHorizontal(aBox)) {
     // horizontal box's children.
     if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
       aNextX = aCurX + aCurrentChildSize.width;
     else
       aNextX = aCurX - aCurrentChildSize.width;
   } else {
     // vertical box's children.
     if (frameState & NS_STATE_IS_DIRECTION_NORMAL)
       aNextY = aCurY + aCurrentChildSize.height;
     else
       aNextY = aCurY - aCurrentChildSize.height;
   }
 }
 void
 nsSprocketLayout::AlignChildren(nsIFrame* aBox,
                                 nsBoxLayoutState& aState)
 {
   nsFrameState frameState = nsFrameState(0);
   GetFrameState(aBox, frameState);
   bool isHorizontal = (frameState & NS_STATE_IS_HORIZONTAL) != 0;
   nsRect clientRect;
   aBox->GetClientRect(clientRect);
   NS_PRECONDITION(!(frameState & NS_STATE_AUTO_STRETCH),
                   "Only AlignChildren() with non-stretch alignment");
   // These are only calculated if needed
   nsIFrame::Halignment halign;
   nsIFrame::Valignment valign;
   nscoord maxAscent;
   bool isLTR;
   if (isHorizontal) {
     valign = aBox->GetVAlign();
     if (valign == nsBoxFrame::vAlign_BaseLine) {
       maxAscent = aBox->GetBoxAscent(aState);
     }
   } else {
     isLTR = GetFrameDirection(aBox) == NS_STYLE_DIRECTION_LTR;
     halign = aBox->GetHAlign();
   }
   nsIFrame* child = aBox->GetChildBox();
   while (child) {
     nsMargin margin;
     child->GetMargin(margin);
     nsRect childRect = child->GetRect();
     if (isHorizontal) {
       const nscoord startAlign = clientRect.y + margin.top;
       const nscoord endAlign =
         clientRect.YMost() - margin.bottom - childRect.height;
       nscoord y;
       switch (valign) {
         case nsBoxFrame::vAlign_Top:
           y = startAlign;
           break;
         case nsBoxFrame::vAlign_Middle:
           // Should this center the border box?
           // This centers the margin box, the historical behavior.
           y = (startAlign + endAlign) / 2;
           break;
         case nsBoxFrame::vAlign_Bottom:
           y = endAlign;
           break;
         case nsBoxFrame::vAlign_BaseLine:
           // Alignments don't force the box to grow (only sizes do),
           // so keep the children within the box.
           y = maxAscent - child->GetBoxAscent(aState);
           y = std::max(startAlign, y);
           y = std::min(y, endAlign);
           break;
       }
       childRect.y = y;
     } else { // vertical box
       const nscoord leftAlign = clientRect.x + margin.left;
       const nscoord rightAlign =
         clientRect.XMost() - margin.right - childRect.width;
       nscoord x;
       switch (halign) {
         case nsBoxFrame::hAlign_Left: // start
           x = isLTR ? leftAlign : rightAlign;
           break;
         case nsBoxFrame::hAlign_Center:
           x = (leftAlign + rightAlign) / 2;
           break;
         case nsBoxFrame::hAlign_Right: // end
           x = isLTR ? rightAlign : leftAlign;
           break;
       }
       childRect.x = x;
     }
     if (childRect.TopLeft() != child->GetPosition()) {
       child->SetBounds(aState, childRect);
     }
     child = child->GetNextBox();
   }
 }
 void
 nsSprocketLayout::ChildResized(nsIFrame* aBox,
                          nsBoxLayoutState& aState,
                          nsIFrame* aChild,
                          nsBoxSize* aChildBoxSize,
                          nsComputedBoxSize* aChildComputedSize,
                          nsBoxSize* aBoxSizes,
                          nsComputedBoxSize* aComputedBoxSizes,
                          const nsRect& aChildLayoutRect,
                          nsRect& aChildActualRect,
                          nsRect& aContainingRect,
                          int32_t aFlexes,
                          bool& aFinished)
 {
       nsRect childCurrentRect(aChildLayoutRect);
       bool isHorizontal = IsHorizontal(aBox);
       nscoord childLayoutWidth  = GET_WIDTH(aChildLayoutRect,isHorizontal);
       nscoord& childActualWidth  = GET_WIDTH(aChildActualRect,isHorizontal);
       nscoord& containingWidth   = GET_WIDTH(aContainingRect,isHorizontal);
       //nscoord childLayoutHeight = GET_HEIGHT(aChildLayoutRect,isHorizontal);
       nscoord& childActualHeight = GET_HEIGHT(aChildActualRect,isHorizontal);
       nscoord& containingHeight  = GET_HEIGHT(aContainingRect,isHorizontal);
       bool recompute = false;
       // if we are a horizontal box see if the child will fit inside us.
       if ( childActualHeight > containingHeight) {
             // if we are a horizontal box and the child is bigger than our height
             // ok if the height changed then we need to reflow everyone but us at the new height
             // so we will set the changed index to be us. And signal that we need a new pass.
             nsSize min = aChild->GetMinSize(aState);
             nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
             AddMargin(aChild, max);
             if (isHorizontal)
               childActualHeight = max.height < childActualHeight ? max.height : childActualHeight;
             else
               childActualHeight = max.width < childActualHeight ? max.width : childActualHeight;
             // only set if it changes
             if (childActualHeight > containingHeight) {
                  containingHeight = childActualHeight;
               // remember we do not need to clear the resized list because changing the height of a horizontal box
               // will not affect the width of any of its children because block flow left to right, top to bottom. Just trust me
               // on this one.
               aFinished = false;
               // only recompute if there are flexes.
               if (aFlexes > 0) {
                 // relayout everything
                 recompute = true;
                 InvalidateComputedSizes(aComputedBoxSizes);
                 nsComputedBoxSize* node = aComputedBoxSizes;
                 while(node) {
                   node->resized = false;
                   node = node->next;
                 }
               }
             }
       }
       if (childActualWidth > childLayoutWidth) {
             nsSize min = aChild->GetMinSize(aState);
             nsSize max = nsBox::BoundsCheckMinMax(min, aChild->GetMaxSize(aState));
             AddMargin(aChild, max);
             // our width now becomes the new size
             if (isHorizontal)
               childActualWidth = max.width < childActualWidth ? max.width : childActualWidth;
             else
               childActualWidth = max.height < childActualWidth ? max.height : childActualWidth;
             if (childActualWidth > childLayoutWidth) {
                aChildComputedSize->size = childActualWidth;
                aChildBoxSize->min = childActualWidth;
                if (aChildBoxSize->pref < childActualWidth)
                   aChildBoxSize->pref = childActualWidth;
                if (aChildBoxSize->max < childActualWidth)
                   aChildBoxSize->max = childActualWidth;
               // if we have flexible elements with us then reflex things. Otherwise we can skip doing it.
               if (aFlexes > 0) {
                 InvalidateComputedSizes(aComputedBoxSizes);
                 nsComputedBoxSize* node = aComputedBoxSizes;
                 aChildComputedSize->resized = true;
                 while(node) {
                   if (node->resized)
                       node->valid = true;
                   node = node->next;
                 }
                 recompute = true;
                 aFinished = false;
               } else {
                 containingWidth += aChildComputedSize->size - childLayoutWidth;
               }
             }
       }
       if (recompute)
             ComputeChildSizes(aBox, aState, containingWidth, aBoxSizes, aComputedBoxSizes);
       if (!childCurrentRect.IsEqualInterior(aChildActualRect)) {
         // the childRect includes the margin
         // make sure we remove it before setting
         // the bounds.
         nsMargin margin(0,0,0,0);
         aChild->GetMargin(margin);
         nsRect rect(aChildActualRect);
         if (rect.width >= margin.left + margin.right && rect.height >= margin.top + margin.bottom)
           rect.Deflate(margin);
         aChild->SetBounds(aState, rect);
         aChild->Layout(aState);
       }
 }
 void
 nsSprocketLayout::InvalidateComputedSizes(nsComputedBoxSize* aComputedBoxSizes)
 {
   while(aComputedBoxSizes) {
       aComputedBoxSizes->valid = false;
       aComputedBoxSizes = aComputedBoxSizes->next;
   }
 }
 void
 nsSprocketLayout::ComputeChildSizes(nsIFrame* aBox,
                            nsBoxLayoutState& aState,
                            nscoord& aGivenSize,
                            nsBoxSize* aBoxSizes,
                            nsComputedBoxSize*& aComputedBoxSizes)
 {
   //nscoord onePixel = aState.PresContext()->IntScaledPixelsToTwips(1);
   int32_t sizeRemaining            = aGivenSize;
   int32_t spacerConstantsRemaining = 0;
    // ----- calculate the spacers constants and the size remaining -----
   if (!aComputedBoxSizes)
       aComputedBoxSizes = new (aState) nsComputedBoxSize();
   nsBoxSize*         boxSizes = aBoxSizes;
   nsComputedBoxSize* computedBoxSizes = aComputedBoxSizes;
   int32_t count = 0;
   int32_t validCount = 0;
   while (boxSizes)
   {
     NS_ASSERTION((boxSizes->min <= boxSizes->pref && boxSizes->pref <= boxSizes->max),"bad pref, min, max size");
      // ignore collapsed children
   //  if (boxSizes->collapsed)
   //  {
     //  computedBoxSizes->valid = true;
     //  computedBoxSizes->size = boxSizes->pref;
      // validCount++;
   //      boxSizes->flex = 0;
    // }// else {
       if (computedBoxSizes->valid) {
         sizeRemaining -= computedBoxSizes->size;
         validCount++;
       } else {
           if (boxSizes->flex == 0)
           {
             computedBoxSizes->valid = true;
             computedBoxSizes->size = boxSizes->pref;
             validCount++;
           }
           spacerConstantsRemaining += boxSizes->flex;
           sizeRemaining -= boxSizes->pref;
       }
       sizeRemaining -= (boxSizes->left + boxSizes->right);
     //}
     boxSizes = boxSizes->next;
     if (boxSizes && !computedBoxSizes->next)
       computedBoxSizes->next = new (aState) nsComputedBoxSize();
     computedBoxSizes = computedBoxSizes->next;
     count++;
   }
   // everything accounted for?
   if (validCount < count)
   {
     // ----- Ok we are give a size to fit into so stretch or squeeze to fit
     // ----- Make sure we look at our min and max size
     bool limit = true;
     for (int pass=1; true == limit; pass++)
     {
       limit = false;
       boxSizes = aBoxSizes;
       computedBoxSizes = aComputedBoxSizes;
       while (boxSizes) {
         // ignore collapsed spacers
    //    if (!boxSizes->collapsed) {
           nscoord pref = 0;
           nscoord max  = NS_INTRINSICSIZE;
           nscoord min  = 0;
           nscoord flex = 0;
           pref = boxSizes->pref;
           min  = boxSizes->min;
           max  = boxSizes->max;
           flex = boxSizes->flex;
           // ----- look at our min and max limits make sure we aren't too small or too big -----
           if (!computedBoxSizes->valid) {
             int32_t newSize = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
             if (newSize<=min) {
               computedBoxSizes->size = min;
               computedBoxSizes->valid = true;
               spacerConstantsRemaining -= flex;
               sizeRemaining += pref;
               sizeRemaining -= min;
               limit = true;
             } else if (newSize>=max) {
               computedBoxSizes->size = max;
               computedBoxSizes->valid = true;
               spacerConstantsRemaining -= flex;
               sizeRemaining += pref;
               sizeRemaining -= max;
               limit = true;
             }
           }
        // }
         boxSizes         = boxSizes->next;
         computedBoxSizes = computedBoxSizes->next;
       }
     }
   }
   // ---- once we have removed and min and max issues just stretch us out in the remaining space
   // ---- or shrink us. Depends on the size remaining and the spacer constants
   aGivenSize = 0;
   boxSizes = aBoxSizes;
   computedBoxSizes = aComputedBoxSizes;
   while (boxSizes) {
     // ignore collapsed spacers
   //  if (!(boxSizes && boxSizes->collapsed)) {
       nscoord pref = 0;
       nscoord flex = 0;
       pref = boxSizes->pref;
       flex = boxSizes->flex;
       if (!computedBoxSizes->valid) {
         computedBoxSizes->size = pref + int32_t(int64_t(sizeRemaining) * flex / spacerConstantsRemaining);
         computedBoxSizes->valid = true;
       }
       aGivenSize += (boxSizes->left + boxSizes->right);
       aGivenSize += computedBoxSizes->size;
    // }
     boxSizes         = boxSizes->next;
     computedBoxSizes = computedBoxSizes->next;
   }
 }
 nsSize
 nsSprocketLayout::GetPrefSize(nsIFrame* aBox, nsBoxLayoutState& aState)
 {
    nsSize vpref (0, 0);
    bool isHorizontal = IsHorizontal(aBox);
    nscoord biggestPref = 0;
    // run through all the children and get their min, max, and preferred sizes
    // return us the size of the box
    nsIFrame* child = aBox->GetChildBox();
    nsFrameState frameState = nsFrameState(0);
    GetFrameState(aBox, frameState);
    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
    int32_t count = 0;
    while (child)
    {
       // ignore collapsed children
       if (!child->IsCollapsed())
       {
         nsSize pref = child->GetPrefSize(aState);
         AddMargin(child, pref);
         if (isEqual) {
           if (isHorizontal)
           {
             if (pref.width > biggestPref)
               biggestPref = pref.width;
           } else {
             if (pref.height > biggestPref)
               biggestPref = pref.height;
           }
         }
         AddLargestSize(vpref, pref, isHorizontal);
         count++;
       }
       child = child->GetNextBox();
    }
    if (isEqual) {
       if (isHorizontal)
          vpref.width = biggestPref*count;
       else
          vpref.height = biggestPref*count;
    }
    // now add our border and padding
    AddBorderAndPadding(aBox, vpref);
   return vpref;
 }
 nsSize
 nsSprocketLayout::GetMinSize(nsIFrame* aBox, nsBoxLayoutState& aState)
 {
    nsSize minSize (0, 0);
    bool isHorizontal = IsHorizontal(aBox);
    nscoord biggestMin = 0;
    // run through all the children and get their min, max, and preferred sizes
    // return us the size of the box
    nsIFrame* child = aBox->GetChildBox();
    nsFrameState frameState = nsFrameState(0);
    GetFrameState(aBox, frameState);
    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
    int32_t count = 0;
    while (child)
    {
        // ignore collapsed children
       if (!child->IsCollapsed())
       {
         nsSize min = child->GetMinSize(aState);
         nsSize pref(0,0);
         // if the child is not flexible then
         // its min size is its pref size.
         if (child->GetFlex(aState) == 0) {
             pref = child->GetPrefSize(aState);
             if (isHorizontal)
                min.width = pref.width;
             else
                min.height = pref.height;
         }
         if (isEqual) {
           if (isHorizontal)
           {
             if (min.width > biggestMin)
               biggestMin = min.width;
           } else {
             if (min.height > biggestMin)
               biggestMin = min.height;
           }
         }
         AddMargin(child, min);
         AddLargestSize(minSize, min, isHorizontal);
         count++;
       }
       child = child->GetNextBox();
    }
    if (isEqual) {
       if (isHorizontal)
          minSize.width = biggestMin*count;
       else
          minSize.height = biggestMin*count;
    }
   // now add our border and padding
   AddBorderAndPadding(aBox, minSize);
   return minSize;
 }
 nsSize
 nsSprocketLayout::GetMaxSize(nsIFrame* aBox, nsBoxLayoutState& aState)
 {
   bool isHorizontal = IsHorizontal(aBox);
    nscoord smallestMax = NS_INTRINSICSIZE;
    nsSize maxSize (NS_INTRINSICSIZE, NS_INTRINSICSIZE);
    // run through all the children and get their min, max, and preferred sizes
    // return us the size of the box
    nsIFrame* child = aBox->GetChildBox();
    nsFrameState frameState = nsFrameState(0);
    GetFrameState(aBox, frameState);
    bool isEqual = !!(frameState & NS_STATE_EQUAL_SIZE);
    int32_t count = 0;
    while (child)
    {
       // ignore collapsed children
       if (!child->IsCollapsed())
       {
         // if completely redefined don't even ask our child for its size.
         nsSize min = child->GetMinSize(aState);
         nsSize max = nsBox::BoundsCheckMinMax(min, child->GetMaxSize(aState));
         AddMargin(child, max);
         AddSmallestSize(maxSize, max, isHorizontal);
         if (isEqual) {
           if (isHorizontal)
           {
             if (max.width < smallestMax)
               smallestMax = max.width;
           } else {
             if (max.height < smallestMax)
               smallestMax = max.height;
           }
         }
         count++;
       }
       child = child->GetNextBox();
    }
    if (isEqual) {
      if (isHorizontal) {
          if (smallestMax != NS_INTRINSICSIZE)
             maxSize.width = smallestMax*count;
          else
             maxSize.width = NS_INTRINSICSIZE;
      } else {
          if (smallestMax != NS_INTRINSICSIZE)
             maxSize.height = smallestMax*count;
          else
             maxSize.height = NS_INTRINSICSIZE;
      }
    }
   // now add our border and padding
   AddBorderAndPadding(aBox, maxSize);
   return maxSize;
 }
 nscoord
 nsSprocketLayout::GetAscent(nsIFrame* aBox, nsBoxLayoutState& aState)
 {
    nscoord vAscent = 0;
    bool isHorizontal = IsHorizontal(aBox);
    // run through all the children and get their min, max, and preferred sizes
    // return us the size of the box
    nsIFrame* child = aBox->GetChildBox();
    while (child)
    {
       // ignore collapsed children
       //if (!child->IsCollapsed())
       //{
         // if completely redefined don't even ask our child for its size.
         nscoord ascent = child->GetBoxAscent(aState);
         nsMargin margin;
         child->GetMargin(margin);
         ascent += margin.top;
         if (isHorizontal)
         {
           if (ascent > vAscent)
             vAscent = ascent;
         } else {
           if (vAscent == 0)
             vAscent = ascent;
         }
       //}
       child = child->GetNextBox();
    }
    nsMargin borderPadding;
    aBox->GetBorderAndPadding(borderPadding);
    return vAscent + borderPadding.top;
 }
 void
 nsSprocketLayout::SetLargestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
 {
   if (aIsHorizontal)
   {
     if (aSize1.height < aSize2.height)
        aSize1.height = aSize2.height;
   } else {
     if (aSize1.width < aSize2.width)
        aSize1.width = aSize2.width;
   }
 }
 void
 nsSprocketLayout::SetSmallestSize(nsSize& aSize1, const nsSize& aSize2, bool aIsHorizontal)
 {
   if (aIsHorizontal)
   {
     if (aSize1.height > aSize2.height)
        aSize1.height = aSize2.height;
   } else {
     if (aSize1.width > aSize2.width)
        aSize1.width = aSize2.width;
   }
 }
 void
 nsSprocketLayout::AddLargestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
 {
   if (aIsHorizontal)
     AddCoord(aSize.width, aSizeToAdd.width);
   else
     AddCoord(aSize.height, aSizeToAdd.height);
   SetLargestSize(aSize, aSizeToAdd, aIsHorizontal);
 }
 void
 nsSprocketLayout::AddCoord(nscoord& aCoord, nscoord aCoordToAdd)
 {
   if (aCoord != NS_INTRINSICSIZE)
   {
     if (aCoordToAdd == NS_INTRINSICSIZE)
       aCoord = aCoordToAdd;
     else
       aCoord += aCoordToAdd;
   }
 }
 void
 nsSprocketLayout::AddSmallestSize(nsSize& aSize, const nsSize& aSizeToAdd, bool aIsHorizontal)
 {
   if (aIsHorizontal)
     AddCoord(aSize.width, aSizeToAdd.width);
   else
     AddCoord(aSize.height, aSizeToAdd.height);
   SetSmallestSize(aSize, aSizeToAdd, aIsHorizontal);
 }
 bool
 nsSprocketLayout::GetDefaultFlex(int32_t& aFlex)
 {
     aFlex = 0;
     return true;
 }
 nsComputedBoxSize::nsComputedBoxSize()
 {
   resized = false;
   valid = false;
   size = 0;
   next = nullptr;
 }
 nsBoxSize::nsBoxSize()
 {
   pref = 0;
   min = 0;
   max = NS_INTRINSICSIZE;
   collapsed = false;
   left = 0;
   right = 0;
   flex = 0;
   next = nullptr;
   bogus = false;
 }
 void*
 nsBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
 {
   return mozilla::AutoStackArena::Allocate(sz);
 }
 void
 nsBoxSize::operator delete(void* aPtr, size_t sz)
 {
 }
 void*
 nsComputedBoxSize::operator new(size_t sz, nsBoxLayoutState& aState) CPP_THROW_NEW
 {
    return mozilla::AutoStackArena::Allocate(sz);
 }
 void
 nsComputedBoxSize::operator delete(void* aPtr, size_t sz)
 {
 }

The Tor Browser / annotate

layout/xul/nsSprocketLayout.cpp@7e26c7da4463 (annotated)

layout/xul/nsSprocketLayout.cpp