Removing "using" declarations that import names in the C++ Standard library.(Source/platform/[m* - …

Source/platform/scroll/ScrollAnimatorNone.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 21 matching lines @@
 
 #include "platform/scroll/ScrollAnimatorNone.h"
 
 #include <algorithm>
 #include "platform/scroll/ScrollableArea.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PassOwnPtr.h"
 
 #include "platform/TraceEvent.h"
 
-using namespace std;
-
 namespace blink {
 
 const double kFrameRate = 60;
 const double kTickTime = 1 / kFrameRate;
 const double kMinimumTimerInterval = .001;
 
 PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea)
 {
     if (scrollableArea && scrollableArea->scrollAnimatorEnabled())
         return adoptPtr(new ScrollAnimatorNone(scrollableArea));
@@ skipping 85 matching lines @@
         return t * t * t / 3;
     case Cubic:
         return t * t * t * t / 4;
     case Quartic:
         return t * t * t * t * t / 5;
     case Bounce:
         const double kTimeBase = 2.75;
         const double kTimeBaseSquared = kTimeBase * kTimeBase;
         const double kTimeBaseSquaredOverThree = kTimeBaseSquared / 3;
         double area;
-        double t1 = min(t, 1 / kTimeBase);
+        double t1 = std::min(t, 1 / kTimeBase);
         area = kTimeBaseSquaredOverThree * t1 * t1 * t1;
         if (t < 1 / kTimeBase)
             return area;
 
-        t1 = min(t - 1 / kTimeBase, 1 / kTimeBase);
+        t1 = std::min(t - 1 / kTimeBase, 1 / kTimeBase);
         // The integral of kTimeBaseSquared * (t1 - .5 / kTimeBase) * (t1 - .5 / kTimeBase) + kParabolaAtEdge
         const double kSecondInnerOffset = kTimeBaseSquared * .5 / kTimeBase;
         double bounceArea = t1 * (t1 * (kTimeBaseSquaredOverThree * t1 - kSecondInnerOffset) + 1);
         area += bounceArea;
         if (t < 2 / kTimeBase)
             return area;
 
-        t1 = min(t - 2 / kTimeBase, 0.5 / kTimeBase);
+        t1 = std::min(t - 2 / kTimeBase, 0.5 / kTimeBase);
         // The integral of kTimeBaseSquared * (t1 - .25 / kTimeBase) * (t1 - .25 / kTimeBase) + kParabolaAtEdge
         const double kThirdInnerOffset = kTimeBaseSquared * .25 / kTimeBase;
         bounceArea =  t1 * (t1 * (kTimeBaseSquaredOverThree * t1 - kThirdInnerOffset) + 1);
         area += bounceArea;
         if (t < 2.5 / kTimeBase)
             return area;
 
         t1 = t - 2.5 / kTimeBase;
         // The integral of kTimeBaseSquared * (t1 - .125 / kTimeBase) * (t1 - .125 / kTimeBase) + kParabolaAtEdge
         const double kFourthInnerOffset = kTimeBaseSquared * .125 / kTimeBase;
@@ skipping 53 matching lines @@
 bool ScrollAnimatorNone::PerAxisData::updateDataFromParameters(float step, float delta, float scrollableSize, double currentTime, Parameters* parameters)
 {
     float pixelDelta = step * delta;
     if (!m_startTime || !pixelDelta || (pixelDelta < 0) != (m_desiredPosition - *m_currentPosition < 0)) {
         m_desiredPosition = *m_currentPosition;
         m_startTime = 0;
     }
     float newPosition = m_desiredPosition + pixelDelta;
 
     if (newPosition < 0 || newPosition > scrollableSize)
-        newPosition = max(min(newPosition, scrollableSize), 0.0f);
+        newPosition = std::max(std::min(newPosition, scrollableSize), 0.0f);
 
     if (newPosition == m_desiredPosition)
         return false;
 
     m_desiredPosition = newPosition;
 
     if (!m_startTime) {
         m_attackTime = parameters->m_attackTime;
         m_attackCurve = parameters->m_attackCurve;
     }
@@ skipping 14 matching lines @@
         m_startPosition = *m_currentPosition;
         m_lastAnimationTime = m_startTime;
     }
     m_startVelocity = m_currentVelocity;
 
     double remainingDelta = m_desiredPosition - *m_currentPosition;
 
     double attackAreaLeft = 0;
 
     double deltaTime = m_lastAnimationTime - m_startTime;
-    double attackTimeLeft = max(0., m_attackTime - deltaTime);
+    double attackTimeLeft = std::max(0., m_attackTime - deltaTime);
     double timeLeft = m_animationTime - deltaTime;
-    double minTimeLeft = m_releaseTime + min(parameters->m_repeatMinimumSustainTime, m_animationTime - m_releaseTime - attackTimeLeft);
+    double minTimeLeft = m_releaseTime + std::min(parameters->m_repeatMinimumSustainTime, m_animationTime - m_releaseTime - attackTimeLeft);
     if (timeLeft < minTimeLeft) {
         m_animationTime = deltaTime + minTimeLeft;
         timeLeft = minTimeLeft;
     }
 
     if (parameters->m_maximumCoastTime > (parameters->m_repeatMinimumSustainTime + parameters->m_releaseTime)) {
         double targetMaxCoastVelocity = m_visibleLength * .25 * kFrameRate;
         // This needs to be as minimal as possible while not being intrusive to page up/down.
         double minCoastDelta = m_visibleLength;
 
         if (fabs(remainingDelta) > minCoastDelta) {
             double maxCoastDelta = parameters->m_maximumCoastTime * targetMaxCoastVelocity;
-            double coastFactor = min(1., (fabs(remainingDelta) - minCoastDelta) / (maxCoastDelta - minCoastDelta));
+            double coastFactor = std::min(1., (fabs(remainingDelta) - minCoastDelta) / (maxCoastDelta - minCoastDelta));
 
             // We could play with the curve here - linear seems a little soft. Initial testing makes me want to feed into the sustain time more aggressively.
-            double coastMinTimeLeft = min(parameters->m_maximumCoastTime, minTimeLeft + coastCurve(parameters->m_coastTimeCurve, coastFactor) * (parameters->m_maximumCoastTime - minTimeLeft));
+            double coastMinTimeLeft = std::min(parameters->m_maximumCoastTime, minTimeLeft + coastCurve(parameters->m_coastTimeCurve, coastFactor) * (parameters->m_maximumCoastTime - minTimeLeft));
 
-            double additionalTime = max(0., coastMinTimeLeft - minTimeLeft);
+            double additionalTime = std::max(0., coastMinTimeLeft - minTimeLeft);
             if (additionalTime) {
-                double additionalReleaseTime = min(additionalTime, parameters->m_releaseTime / (parameters->m_releaseTime + parameters->m_repeatMinimumSustainTime) * additionalTime);
+                double additionalReleaseTime = std::min(additionalTime, parameters->m_releaseTime / (parameters->m_releaseTime + parameters->m_repeatMinimumSustainTime) * additionalTime);
                 m_releaseTime = parameters->m_releaseTime + additionalReleaseTime;
                 m_animationTime = deltaTime + coastMinTimeLeft;
                 timeLeft = coastMinTimeLeft;
             }
         }
     }
 
-    double releaseTimeLeft = min(timeLeft, m_releaseTime);
-    double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
+    double releaseTimeLeft = std::min(timeLeft, m_releaseTime);
+    double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
 
     if (attackTimeLeft) {
         double attackSpot = deltaTime / m_attackTime;
         attackAreaLeft = attackArea(m_attackCurve, attackSpot, 1) * m_attackTime;
     }
 
     double releaseSpot = (m_releaseTime - releaseTimeLeft) / m_releaseTime;
     double releaseAreaLeft  = releaseArea(m_releaseCurve, releaseSpot, 1) * m_releaseTime;
 
     m_desiredVelocity = remainingDelta / (attackAreaLeft + sustainTimeLeft + releaseAreaLeft);
@@ skipping 205 matching lines @@
     return m_animationActive;
 }
 
 void ScrollAnimatorNone::stopAnimationTimerIfNeeded()
 {
     if (animationTimerActive())
         m_animationActive = false;
 }
 
 } // namespace blink