s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

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

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 349 matching lines @@
         (m_direction == ForColumns) ? varyingTrackSpan : fixedTrackSpan;
     size_t columnSpan =
         (m_direction == ForColumns) ? fixedTrackSpan : varyingTrackSpan;
 
     size_t& varyingTrackIndex =
         (m_direction == ForColumns) ? m_rowIndex : m_columnIndex;
     const size_t endOfVaryingTrackIndex =
         (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
     for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
       if (checkEmptyCells(rowSpan, columnSpan)) {
-        std::unique_ptr<GridArea> result = wrapUnique(
+        std::unique_ptr<GridArea> result = WTF::wrapUnique(
             new GridArea(GridSpan::translatedDefiniteGridSpan(
                              m_rowIndex, m_rowIndex + rowSpan),
                          GridSpan::translatedDefiniteGridSpan(
                              m_columnIndex, m_columnIndex + columnSpan)));
         // Advance the iterator to avoid an infinite loop where we would return
         // the same grid area over and over.
         ++varyingTrackIndex;
         return result;
       }
     }
@@ skipping 735 matching lines @@
         additionalTracksToTreatAsInflexible->contains(index))
       continue;
     LayoutUnit baseSize = tracks[index].baseSize();
     double flexFactor =
         gridTrackSize(direction, index).maxTrackBreadth().flex();
     // treating all such tracks as inflexible.
     if (baseSize > hypotheticalFactorUnitSize * flexFactor) {
       leftOverSpace -= baseSize;
       flexFactorSum -= flexFactor;
       if (!additionalTracksToTreatAsInflexible)
-        additionalTracksToTreatAsInflexible = makeUnique<TrackIndexSet>();
+        additionalTracksToTreatAsInflexible = WTF::makeUnique<TrackIndexSet>();
       additionalTracksToTreatAsInflexible->add(index);
       validFlexFactorUnit = false;
     }
   }
   if (!validFlexFactorUnit)
     return computeFlexFactorUnitSize(
         tracks, direction, flexFactorSum, leftOverSpace, flexibleTracksIndexes,
         std::move(additionalTracksToTreatAsInflexible));
   return hypotheticalFactorUnitSize;
 }
@@ skipping 901 matching lines @@
   std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
   size_t insertionPoint = isRowAxis
                               ? styleRef().gridAutoRepeatColumnsInsertionPoint()
                               : styleRef().gridAutoRepeatRowsInsertionPoint();
   size_t firstAutoRepeatTrack =
       insertionPoint + std::abs(grid.smallestTrackStart(direction));
   size_t lastAutoRepeatTrack =
       firstAutoRepeatTrack + grid.autoRepeatTracks(direction);
 
   if (!m_grid.hasGridItems()) {
-    emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
+    emptyTrackIndexes = WTF::wrapUnique(new OrderedTrackIndexSet);
     for (size_t trackIndex = firstAutoRepeatTrack;
          trackIndex < lastAutoRepeatTrack; ++trackIndex)
       emptyTrackIndexes->add(trackIndex);
   } else {
     for (size_t trackIndex = firstAutoRepeatTrack;
          trackIndex < lastAutoRepeatTrack; ++trackIndex) {
       GridIterator iterator(grid, direction, trackIndex);
       if (!iterator.nextGridItem()) {
         if (!emptyTrackIndexes)
-          emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
+          emptyTrackIndexes = WTF::wrapUnique(new OrderedTrackIndexSet);
         emptyTrackIndexes->add(trackIndex);
       }
     }
   }
   return emptyTrackIndexes;
 }
 
 void LayoutGrid::placeItemsOnGrid(LayoutGrid::Grid& grid,
                                   SizingOperation sizingOperation) {
   if (!grid.needsItemsPlacement())
@@ skipping 152 matching lines @@
     GridTrackSizingDirection specifiedDirection,
     const GridSpan& specifiedPositions) const {
   GridTrackSizingDirection crossDirection =
       specifiedDirection == ForColumns ? ForRows : ForColumns;
   const size_t endOfCrossDirection = grid.numTracks(crossDirection);
   size_t crossDirectionSpanSize =
       GridPositionsResolver::spanSizeForAutoPlacedItem(*style(), gridItem,
                                                        crossDirection);
   GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(
       endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
-  return wrapUnique(
+  return WTF::wrapUnique(
       new GridArea(specifiedDirection == ForColumns ? crossDirectionPositions
                                                     : specifiedPositions,
                    specifiedDirection == ForColumns ? specifiedPositions
                                                     : crossDirectionPositions));
 }
 
 void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(
     Grid& grid,
     const Vector<LayoutBox*>& autoGridItems) const {
   bool isForColumns = autoPlacementMajorAxisDirection() == ForColumns;
@@ skipping 1356 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink