Avoiding name collisions between flexbox and grid

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/GridTrackSizingAlgorithm.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/Grid.h"
 #include "core/layout/LayoutGrid.h"
 #include "platform/LengthFunctions.h"
@@ skipping 107 matching lines @@
   bool recomputeUsedFlexFractionIfNeeded(
       Vector<size_t>& flexibleSizedTracksIndex,
       double& flexFraction,
       Vector<LayoutUnit>& increments,
       LayoutUnit& totalGrowth) const override {
     return false;
   }
 };
 
 // TODO(svillar): Repeated in LayoutGrid.
-static LayoutUnit computeMarginLogicalSizeForChild(MarginDirection forDirection,
-                                                   const LayoutGrid* grid,
-                                                   const LayoutBox& child) {
+LayoutUnit GridTrackSizingAlgorithmStrategy::computeMarginLogicalSizeForChild(
+    MarginDirection forDirection,
+    const LayoutGrid* grid,
+    const LayoutBox& child) {
   if (!child.styleRef().hasMargin())
     return LayoutUnit();
 
   bool isRowAxis = forDirection == InlineDirection;
   LayoutUnit marginStart;
   LayoutUnit marginEnd;
   LayoutUnit logicalSize =
       isRowAxis ? child.logicalWidth() : child.logicalHeight();
   Length marginStartLength = isRowAxis ? child.styleRef().marginStart()
                                        : child.styleRef().marginBefore();
   Length marginEndLength =
       isRowAxis ? child.styleRef().marginEnd() : child.styleRef().marginAfter();
   child.computeMarginsForDirection(
       forDirection, grid, child.containingBlockLogicalWidthForContent(),
       logicalSize, marginStart, marginEnd, marginStartLength, marginEndLength);
 
   return marginStart + marginEnd;
 }
 
-static bool hasOverrideContainingBlockContentSizeForChild(
-    const LayoutBox& child,
-    GridTrackSizingDirection direction) {
+bool GridTrackSizingAlgorithmStrategy::
+    hasOverrideContainingBlockContentSizeForChild(
+        const LayoutBox& child,
+        GridTrackSizingDirection direction) {
   return direction == ForColumns
              ? child.hasOverrideContainingBlockLogicalWidth()
              : child.hasOverrideContainingBlockLogicalHeight();
 }
 
-static LayoutUnit overrideContainingBlockContentSizeForChild(
+LayoutUnit
+GridTrackSizingAlgorithmStrategy::overrideContainingBlockContentSizeForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) {
   return direction == ForColumns
              ? child.overrideContainingBlockContentLogicalWidth()
              : child.overrideContainingBlockContentLogicalHeight();
 }
 
-static bool shouldClearOverrideContainingBlockContentSizeForChild(
-    const LayoutBox& child,
-    GridTrackSizingDirection direction) {
+bool GridTrackSizingAlgorithmStrategy::
+    shouldClearOverrideContainingBlockContentSizeForChild(
+        const LayoutBox& child,
+        GridTrackSizingDirection direction) {
   if (direction == ForColumns) {
     return child.hasRelativeLogicalWidth() ||
            child.styleRef().logicalWidth().isIntrinsicOrAuto();
   }
   return child.hasRelativeLogicalHeight() ||
          child.styleRef().logicalHeight().isIntrinsicOrAuto();
 }
 
-static void setOverrideContainingBlockContentSizeForChild(
-    LayoutBox& child,
-    GridTrackSizingDirection direction,
-    LayoutUnit size) {
+void GridTrackSizingAlgorithmStrategy::
+    setOverrideContainingBlockContentSizeForChild(
+        LayoutBox& child,
+        GridTrackSizingDirection direction,
+        LayoutUnit size) {
   if (direction == ForColumns)
     child.setOverrideContainingBlockContentLogicalWidth(size);
   else
     child.setOverrideContainingBlockContentLogicalHeight(size);
 }
 
-static GridTrackSizingDirection flowAwareDirectionForChild(
+GridTrackSizingDirection
+GridTrackSizingAlgorithmStrategy::flowAwareDirectionForChild(
     const LayoutGrid* layoutGrid,
     const LayoutBox& child,
     GridTrackSizingDirection direction) {
   return child.isHorizontalWritingMode() ==
                  layoutGrid->isHorizontalWritingMode()
              ? direction
              : (direction == ForColumns ? ForRows : ForColumns);
 }
 
 LayoutUnit GridTrackSizingAlgorithm::assumedRowsSizeForOrthogonalChild(
@@ skipping 1242 matching lines @@
   DCHECK(m_algorithm.isValidTransition());
   DCHECK(!m_algorithm.m_needsSetup);
 }
 
 GridTrackSizingAlgorithm::StateMachine::~StateMachine() {
   m_algorithm.advanceNextState();
   m_algorithm.m_needsSetup = true;
 }
 
 }  // namespace blink