[css-flexbox] Rename some variables for more clarity

third_party/WebKit/Source/core/layout/LayoutFlexibleBox.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 45 matching lines @@
     {
     }
 
     LayoutUnit crossAxisOffset;
     LayoutUnit crossAxisExtent;
     size_t numberOfChildren;
     LayoutUnit maxAscent;
 };
 
 struct LayoutFlexibleBox::FlexItem {
-    FlexItem(LayoutBox* box, LayoutUnit innerFlexBaseSize, LayoutUnit hypotheticalMainSize)
+    FlexItem(LayoutBox* box, LayoutUnit flexBaseContentSize, LayoutUnit hypotheticalMainContentSize)
         : box(box)
-        , innerFlexBaseSize(innerFlexBaseSize)
-        , hypotheticalMainSize(hypotheticalMainSize)
+        , flexBaseContentSize(flexBaseContentSize)
+        , hypotheticalMainContentSize(hypotheticalMainContentSize)
         , frozen(false)
     {
     }
 
     // This constructor is used for out-of-flow children
     explicit FlexItem(LayoutBox* box)
         : box(box)
-        , innerFlexBaseSize()
-        , hypotheticalMainSize()
+        , flexBaseContentSize()
+        , hypotheticalMainContentSize()
         , frozen(true)
     {
     }
     LayoutBox* box;
-    const LayoutUnit innerFlexBaseSize;
-    const LayoutUnit hypotheticalMainSize;
+    const LayoutUnit flexBaseContentSize;
+    const LayoutUnit hypotheticalMainContentSize;
     LayoutUnit flexedContentSize;
     bool frozen;
 };
 
 LayoutFlexibleBox::LayoutFlexibleBox(Element* element)
     : LayoutBlock(element)
     , m_orderIterator(this)
     , m_numberOfInFlowChildrenOnFirstLine(-1)
     , m_hasDefiniteHeight(SizeDefiniteness::Unknown)
 {
@@ skipping 1157 matching lines @@
     }
     return true;
 }
 
 void LayoutFlexibleBox::freezeViolations(Vector<FlexItem*>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
 {
     for (size_t i = 0; i < violations.size(); ++i) {
         DCHECK(!violations[i]->frozen) << i;
         LayoutBox* child = violations[i]->box;
         LayoutUnit childSize = violations[i]->flexedContentSize;
-        availableFreeSpace -= childSize - violations[i]->innerFlexBaseSize;
+        availableFreeSpace -= childSize - violations[i]->flexBaseContentSize;
         totalFlexGrow -= child->style()->flexGrow();
         totalFlexShrink -= child->style()->flexShrink();
-        totalWeightedFlexShrink -= child->style()->flexShrink() * violations[i]->innerFlexBaseSize;
+        totalWeightedFlexShrink -= child->style()->flexShrink() * violations[i]->flexBaseContentSize;
         // totalWeightedFlexShrink can be negative when we exceed the precision of a double when we initially
         // calcuate totalWeightedFlexShrink. We then subtract each child's weighted flex shrink with full precision,
         // now leading to a negative result. See css3/flexbox/large-flex-shrink-assert.html
         totalWeightedFlexShrink = std::max(totalWeightedFlexShrink, 0.0);
         violations[i]->frozen = true;
     }
 }
 
 void LayoutFlexibleBox::freezeInflexibleItems(FlexSign flexSign, OrderedFlexItemList& children, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
 {
     // Per https://drafts.csswg.org/css-flexbox/#resolve-flexible-lengths step 2,
     // we freeze all items with a flex factor of 0 as well as this with a min/max size violation.
     Vector<FlexItem*> newInflexibleItems;
     for (size_t i = 0; i < children.size(); ++i) {
         FlexItem& flexItem = children[i];
         LayoutBox* child = flexItem.box;
         if (child->isOutOfFlowPositioned())
             continue;
         DCHECK(!flexItem.frozen) << i;
         float flexFactor = (flexSign == PositiveFlexibility) ? child->style()->flexGrow() : child->style()->flexShrink();
         if (flexFactor == 0
-            || (flexSign == PositiveFlexibility && flexItem.innerFlexBaseSize > flexItem.hypotheticalMainSize)
-            || (flexSign == NegativeFlexibility && flexItem.innerFlexBaseSize < flexItem.hypotheticalMainSize)) {
-            flexItem.flexedContentSize = flexItem.hypotheticalMainSize;
+            || (flexSign == PositiveFlexibility && flexItem.flexBaseContentSize > flexItem.hypotheticalMainContentSize)
+            || (flexSign == NegativeFlexibility && flexItem.flexBaseContentSize < flexItem.hypotheticalMainContentSize)) {
+            flexItem.flexedContentSize = flexItem.hypotheticalMainContentSize;
             newInflexibleItems.append(&flexItem);
         }
     }
     freezeViolations(newInflexibleItems, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink);
 }
 
 // Returns true if we successfully ran the algorithm and sized the flex items.
 bool LayoutFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, OrderedFlexItemList& children, LayoutUnit initialFreeSpace, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
 {
     LayoutUnit totalViolation;
@@ skipping 10 matching lines @@
 
     for (size_t i = 0; i < children.size(); ++i) {
         FlexItem& flexItem = children[i];
         LayoutBox* child = flexItem.box;
         if (child->isOutOfFlowPositioned())
             continue;
 
         if (flexItem.frozen)
             continue;
 
-        LayoutUnit childSize = flexItem.innerFlexBaseSize;
+        LayoutUnit childSize = flexItem.flexBaseContentSize;
         double extraSpace = 0;
         if (remainingFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow)) {
             extraSpace = remainingFreeSpace * child->style()->flexGrow() / totalFlexGrow;
         } else if (remainingFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink) && child->style()->flexShrink()) {
-            extraSpace = remainingFreeSpace * child->style()->flexShrink() * flexItem.innerFlexBaseSize / totalWeightedFlexShrink;
+            extraSpace = remainingFreeSpace * child->style()->flexShrink() * flexItem.flexBaseContentSize / totalWeightedFlexShrink;
         }
         if (std::isfinite(extraSpace))
             childSize += LayoutUnit::fromFloatRound(extraSpace);
 
         LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize);
         DCHECK_GE(adjustedChildSize, 0);
         flexItem.flexedContentSize = adjustedChildSize;
-        usedFreeSpace += adjustedChildSize - flexItem.innerFlexBaseSize;
+        usedFreeSpace += adjustedChildSize - flexItem.flexBaseContentSize;
 
         LayoutUnit violation = adjustedChildSize - childSize;
         if (violation > 0)
             minViolations.append(&flexItem);
         else if (violation < 0)
             maxViolations.append(&flexItem);
         totalViolation += violation;
     }
 
     if (totalViolation)
@@ skipping 562 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink