fix build warnings and fix free space calculation in maximize step

Author: intergalacticspacehighway

yoga/algorithm/grid/GridLayout.cpp

@@ -362,29 +362,29 @@ void calculateGridLayoutInternal(Node* node,
       // alignment of grid items happen in the grid area
       // measured dimension includes padding and border
       float actualItemWidth = item.node->getLayout().measuredDimension(Dimension::Width);
-      auto freeSpaceInlineAxis = containingBlockWidth - actualItemWidth - marginInlineStart - marginInlineEnd;
+      auto freeSpaceInlineAxisItem = containingBlockWidth - actualItemWidth - marginInlineStart - marginInlineEnd;
       float leftAutoMarginOffset = 0.0f;
       float rightAutoMarginOffset = 0.0f;
       // https://www.w3.org/TR/css-grid-1/#auto-margins
       // auto margins in either axis absorb positive free space prior to alignment via the box alignment properties, thereby disabling the effects of any self-alignment properties in that axis.
       if (item.node->style().flexStartMarginIsAuto(FlexDirection::Row, direction) 
           && item.node->style().flexEndMarginIsAuto(FlexDirection::Row, direction)) {
-        leftAutoMarginOffset = freeSpaceInlineAxis / 2;
-        rightAutoMarginOffset = freeSpaceInlineAxis / 2;
-        freeSpaceInlineAxis = 0.0f;
+        leftAutoMarginOffset = freeSpaceInlineAxisItem / 2;
+        rightAutoMarginOffset = freeSpaceInlineAxisItem / 2;
+        freeSpaceInlineAxisItem = 0.0f;
       } else if (item.node->style().flexStartMarginIsAuto(FlexDirection::Row, direction)) {
-        leftAutoMarginOffset = freeSpaceInlineAxis;
-        freeSpaceInlineAxis = 0.0f;
+        leftAutoMarginOffset = freeSpaceInlineAxisItem;
+        freeSpaceInlineAxisItem = 0.0f;
       } else if (item.node->style().flexEndMarginIsAuto(FlexDirection::Row, direction)) {
-        rightAutoMarginOffset = freeSpaceInlineAxis;
-        freeSpaceInlineAxis = 0.0f;
+        rightAutoMarginOffset = freeSpaceInlineAxisItem;
+        freeSpaceInlineAxisItem = 0.0f;
       }
 
       float justifySelfOffset = 0.0f;
       if (justifySelf == Justify::End) {
-        justifySelfOffset = freeSpaceInlineAxis;
+        justifySelfOffset = freeSpaceInlineAxisItem;
       } else if (justifySelf == Justify::Center) {
-        justifySelfOffset = freeSpaceInlineAxis / 2;
+        justifySelfOffset = freeSpaceInlineAxisItem / 2;
       }
 
       float finalLeft;
@@ -397,24 +397,24 @@ void calculateGridLayoutInternal(Node* node,
       item.node->setLayoutPosition(finalLeft, PhysicalEdge::Left);
 
       float actualItemHeight = item.node->getLayout().measuredDimension(Dimension::Height);
-      auto freeSpaceBlockAxis = containingBlockHeight - actualItemHeight - marginBlockStart - marginBlockEnd;
+      auto freeSpaceBlockAxisItem = containingBlockHeight - actualItemHeight - marginBlockStart - marginBlockEnd;
       float topAutoMarginOffset = 0.0f;
       if (item.node->style().flexStartMarginIsAuto(FlexDirection::Column, direction) 
             && item.node->style().flexEndMarginIsAuto(FlexDirection::Column, direction)) {
-        topAutoMarginOffset = freeSpaceBlockAxis / 2;
-        freeSpaceBlockAxis = 0.0f;
+        topAutoMarginOffset = freeSpaceBlockAxisItem / 2;
+        freeSpaceBlockAxisItem = 0.0f;
       } else if (item.node->style().flexStartMarginIsAuto(FlexDirection::Column, direction)) {
-        topAutoMarginOffset = freeSpaceBlockAxis;
-        freeSpaceBlockAxis = 0.0f;
+        topAutoMarginOffset = freeSpaceBlockAxisItem;
+        freeSpaceBlockAxisItem = 0.0f;
       } else if (item.node->style().flexEndMarginIsAuto(FlexDirection::Column, direction)) {
-        freeSpaceBlockAxis = 0.0f;
+        freeSpaceBlockAxisItem = 0.0f;
       }
 
       float alignSelfOffset = 0.0f;
       if (alignSelf == Align::End) {
-        alignSelfOffset = freeSpaceBlockAxis;
+        alignSelfOffset = freeSpaceBlockAxisItem;
       } else if (alignSelf == Align::Center) {
-        alignSelfOffset = freeSpaceBlockAxis / 2;
+        alignSelfOffset = freeSpaceBlockAxisItem / 2;
       }
 
       float finalTop = gridAreaTop + marginBlockStart + topAutoMarginOffset + alignSelfOffset + gridBlockOffset + leadingPaddingAndBorderBlock;

yoga/algorithm/grid/TrackSizing.h

@@ -514,7 +514,11 @@ struct TrackSizing {
   void distributeFreeSpaceToTracks(Dimension dimension, float targetAvailableSize) {
     auto& tracks = dimension == Dimension::Width ? columnTracks : rowTracks;
     auto sizingMode = dimension == Dimension::Width ? widthSizingMode : heightSizingMode;
-    auto freeSpace = calculateFreeSpace(dimension);
+    float freeSpace = 0.0f;
+    if (yoga::isDefined(targetAvailableSize)) {
+      auto totalBaseSize = getTotalBaseSize(dimension);
+      freeSpace = std::max(0.0f, targetAvailableSize - totalBaseSize);
+    }
 
     // For the purpose of this step: if sizing the grid container under a max-content constraint, the free space is infinite; 
     // if sizing under a min-content constraint, the free space is zero.
@@ -864,18 +868,18 @@ struct TrackSizing {
   };
 
   float getMaxContentContribution(const GridItemArea& item, Dimension dimension, const ItemConstraint& itemConstraints) {
-    auto widthSizingMode = dimension == Dimension::Width ? SizingMode::MaxContent : itemConstraints.widthSizingMode;
-    auto heightSizingMode = dimension == Dimension::Height ? SizingMode::MaxContent : itemConstraints.heightSizingMode;
-    auto availableWidth = dimension == Dimension::Width ? YGUndefined : itemConstraints.width;
-    auto availableHeight = dimension == Dimension::Height ? YGUndefined : itemConstraints.height;
+    auto itemWidthSizingMode = dimension == Dimension::Width ? SizingMode::MaxContent : itemConstraints.widthSizingMode;
+    auto itemHeightSizingMode = dimension == Dimension::Height ? SizingMode::MaxContent : itemConstraints.heightSizingMode;
+    auto itemAvailableWidth = dimension == Dimension::Width ? YGUndefined : itemConstraints.width;
+    auto itemAvailableHeight = dimension == Dimension::Height ? YGUndefined : itemConstraints.height;
 
     calculateLayoutInternal(
         item.node,
-        availableWidth,
-        availableHeight,
+        itemAvailableWidth,
+        itemAvailableHeight,
         node->getLayout().direction(),
-        widthSizingMode,
-        heightSizingMode,
+        itemWidthSizingMode,
+        itemHeightSizingMode,
         itemConstraints.containingBlockWidth,
         itemConstraints.containingBlockHeight,
         false,