Revert of Removing "using" declarations that import names in the C++ Standard library.

Source/web/tests/ScrollAnimatorNoneTest.cpp

 /*
  * Copyright (C) 2010 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 19 matching lines @@
 #include "platform/scroll/ScrollAnimatorNone.h"
 
 #include "platform/Logging.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/scroll/ScrollAnimator.h"
 #include "platform/scroll/ScrollableArea.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+using namespace std;
 using namespace WebCore;
 
 using testing::AtLeast;
 using testing::Return;
 using testing::_;
 
 class MockScrollableArea : public ScrollableArea {
 public:
     MockScrollableArea(bool scrollAnimatorEnabled)
         : m_scrollAnimatorEnabled(scrollAnimatorEnabled) { }
@@ skipping 219 matching lines @@
     double oldDesiredVelocity = m_data->m_desiredVelocity;
     double oldTimeLeft = m_data->m_animationTime - (m_data->m_lastAnimationTime - m_data->m_startTime);
     bool result = m_data->updateDataFromParameters(step, multiplier, scrollableSize, currentTime, parameters);
     if (m_scrollingDown)
         EXPECT_LE(oldVelocity, m_data->m_currentVelocity);
     else
         EXPECT_GE(oldVelocity, m_data->m_currentVelocity);
 
     double deltaTime = m_data->m_lastAnimationTime - m_data->m_startTime;
     double timeLeft = m_data->m_animationTime - deltaTime;
-    double releaseTimeLeft = std::min(timeLeft, m_data->m_releaseTime);
-    double attackTimeLeft = std::max(0., m_data->m_attackTime - deltaTime);
-    double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
+    double releaseTimeLeft = min(timeLeft, m_data->m_releaseTime);
+    double attackTimeLeft = max(0., m_data->m_attackTime - deltaTime);
+    double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
 
     // If we're getting near the finish, the desired velocity can decrease since the time left gets increased.
     if (step * multiplier) {
         double allowedVelocityDecreaseFactor = 0.99 * oldTimeLeft / timeLeft;
         allowedVelocityDecreaseFactor *= allowedVelocityDecreaseFactor;
         if (m_scrollingDown)
             EXPECT_LE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
         else
             EXPECT_GE(oldDesiredVelocity * allowedVelocityDecreaseFactor, m_data->m_desiredVelocity);
 
         double startPosition = attackTimeLeft ? m_data->m_attackPosition : m_currentPosition;
         double expectedReleasePosition = startPosition + sustainTimeLeft * m_data->m_desiredVelocity;
         EXPECT_NEAR(expectedReleasePosition, m_data->m_releasePosition, result ? .0001 : 1);
     }
 
     return result;
 }
 
 bool ScrollAnimatorNoneTest::animateScroll(double currentTime)
 {
     double oldPosition = *m_data->m_currentPosition;
     bool testEstimatedMaxVelocity = m_data->m_startTime + m_data->m_animationTime - m_data->m_lastAnimationTime > m_data->m_releaseTime;
 
     bool result = m_data->animateScroll(currentTime);
 
     double deltaTime = m_data->m_lastAnimationTime - m_data->m_startTime;
     double timeLeft = m_data->m_animationTime - deltaTime;
-    double releaseTimeLeft = std::min(timeLeft, m_data->m_releaseTime);
-    double attackTimeLeft = std::max(0., m_data->m_attackTime - deltaTime);
-    double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
+    double releaseTimeLeft = min(timeLeft, m_data->m_releaseTime);
+    double attackTimeLeft = max(0., m_data->m_attackTime - deltaTime);
+    double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
     double distanceLeft = m_data->m_desiredPosition - *m_data->m_currentPosition;
 
     if (m_scrollingDown) {
         EXPECT_LE(0, m_data->m_currentVelocity);
         EXPECT_LE(oldPosition, *m_data->m_currentPosition);
     } else {
         EXPECT_GE(0, m_data->m_currentVelocity);
         EXPECT_GE(oldPosition, *m_data->m_currentPosition);
     }
     EXPECT_GE(fabs(m_data->m_desiredVelocity) * 2, fabs(m_data->m_currentVelocity));
@@ skipping 721 matching lines @@
     EXPECT_TRUE(result);
     result = result && animateScroll(t);
     double after = m_currentPosition;
     EXPECT_GE(before, after);
 
     t += kAnimationTime;
     for (; result && t < kEndTime; t += kAnimationTime)
         result = result && animateScroll(t);
     EXPECT_GE(before, m_currentPosition);
 }