WTF/std normalization: replace WTF::Vector::first() with ::front()

third_party/WebKit/Source/core/css/CSSGradientValue.cpp

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2015 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:
  * 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
@@ skipping 239 matching lines @@
   // We need at least two stops to normalize
   if (stops.size() < 2)
     return false;
 
   // Repeating gradients are implemented using a normalized stop offset range
   // with the point/radius pairs aligned on the interval endpoints.
   if (gradient->spreadMethod() == SpreadMethodRepeat)
     return true;
 
   // Degenerate stops
-  if (stops.first().offset < 0 || stops.back().offset > 1)
+  if (stops.front().offset < 0 || stops.back().offset > 1)
     return true;
 
   return false;
 }
 
 // Redistribute the stops such that they fully cover [0 , 1] and add them to the
 // gradient.
 static bool normalizeAndAddStops(const Vector<GradientStop>& stops,
                                  Gradient* gradient) {
   ASSERT(stops.size() > 1);
 
-  const float firstOffset = stops.first().offset;
+  const float firstOffset = stops.front().offset;
   const float lastOffset = stops.back().offset;
   const float span = lastOffset - firstOffset;
 
   if (fabs(span) < std::numeric_limits<float>::epsilon()) {
     // All stops are coincident -> use a single clamped offset value.
     const float clampedOffset = std::min(std::max(firstOffset, 0.f), 1.f);
 
     // For repeating gradients, a coincident stop set defines a solid-color
     // image with the color of the last color-stop in the rule.
     // For non-repeating gradients, both the first color and the last color can
     // be significant (padding on both sides of the offset).
     if (gradient->spreadMethod() != SpreadMethodRepeat)
-      gradient->addColorStop(clampedOffset, stops.first().color);
+      gradient->addColorStop(clampedOffset, stops.front().color);
     gradient->addColorStop(clampedOffset, stops.back().color);
 
     return false;
   }
 
   ASSERT(span > 0);
 
   for (size_t i = 0; i < stops.size(); ++i) {
     const float normalizedOffset = (stops[i].offset - firstOffset) / span;
 
@@ skipping 158 matching lines @@
            --prevSpecifiedIndex) {
         if (stops[prevSpecifiedIndex].specified)
           break;
       }
 
       if (stops[i].offset < stops[prevSpecifiedIndex].offset)
         stops[i].offset = stops[prevSpecifiedIndex].offset;
     }
   }
 
-  ASSERT(stops.first().specified && stops.back().specified);
+  ASSERT(stops.front().specified && stops.back().specified);
 
   // If any color-stop still does not have a position, then, for each run of
   // adjacent color-stops without positions, set their positions so that they
   // are evenly spaced between the preceding and following color-stops with
   // positions.
   if (numStops > 2) {
     size_t unspecifiedRunStart = 0;
     bool inUnspecifiedRun = false;
 
     for (size_t i = 0; i < numStops; ++i) {
@@ skipping 28 matching lines @@
   // adjustments for repeat gradients and degenerate values if needed.
   if (requiresStopsNormalization(stops, gradient)) {
     // Negative offsets are only an issue for non-repeating radial gradients:
     // linear gradient points can be repositioned arbitrarily, and for repeating
     // radial gradients we shift the radii into equivalent positive values.
     if (isRadialGradientValue() && !m_repeating)
       clampNegativeOffsets(stops);
 
     if (normalizeAndAddStops(stops, gradient)) {
       if (isLinearGradientValue()) {
-        adjustGradientPointsForOffsetRange(gradient, stops.first().offset,
+        adjustGradientPointsForOffsetRange(gradient, stops.front().offset,
                                            stops.back().offset);
       } else {
-        adjustGradientRadiiForOffsetRange(gradient, stops.first().offset,
+        adjustGradientRadiiForOffsetRange(gradient, stops.front().offset,
                                           stops.back().offset);
       }
     } else {
       // Normalization failed because the stop set is coincident.
     }
   } else {
     // No normalization required, just add the current stops.
     for (const auto& stop : stops)
       gradient->addColorStop(stop.offset, stop.color);
   }
@@ skipping 790 matching lines @@
   visitor->trace(m_firstRadius);
   visitor->trace(m_secondRadius);
   visitor->trace(m_shape);
   visitor->trace(m_sizingBehavior);
   visitor->trace(m_endHorizontalSize);
   visitor->trace(m_endVerticalSize);
   CSSGradientValue::traceAfterDispatch(visitor);
 }
 
 }  // namespace blink