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

Source/core/svg/animation/SVGSMILElement.cpp

 /*
  * Copyright (C) 2008 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 24 matching lines @@
 #include "core/events/EventSender.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGSVGElement.h"
 #include "core/svg/SVGURIReference.h"
 #include "core/svg/animation/SMILTimeContainer.h"
 #include "platform/FloatConversion.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
+using namespace std;
+
 namespace WebCore {
 
 class RepeatEvent FINAL : public Event {
 public:
     static PassRefPtrWillBeRawPtr<RepeatEvent> create(const AtomicString& type, int repeat)
     {
         return adoptRefWillBeNoop(new RepeatEvent(type, false, false, repeat));
     }
 
     virtual ~RepeatEvent() { }
@@ skipping 733 matching lines @@
 {
     if (m_cachedMin != invalidCachedTime)
         return m_cachedMin;
     const AtomicString& value = fastGetAttribute(SVGNames::minAttr);
     SMILTime result = parseClockValue(value);
     return m_cachedMin = (result.isUnresolved() || result < 0) ? 0 : result;
 }
 
 SMILTime SVGSMILElement::simpleDuration() const
 {
-    return std::min(dur(), SMILTime::indefinite());
+    return min(dur(), SMILTime::indefinite());
 }
 
 void SVGSMILElement::addBeginTime(SMILTime eventTime, SMILTime beginTime, SMILTimeWithOrigin::Origin origin)
 {
     ASSERT(!std::isnan(beginTime.value()));
     m_beginTimes.append(SMILTimeWithOrigin(beginTime, origin));
     sortTimeList(m_beginTimes);
     beginListChanged(eventTime);
 }
 
@@ skipping 51 matching lines @@
 SMILTime SVGSMILElement::repeatingDuration() const
 {
     // Computing the active duration
     // http://www.w3.org/TR/SMIL2/smil-timing.html#Timing-ComputingActiveDur
     SMILTime repeatCount = this->repeatCount();
     SMILTime repeatDur = this->repeatDur();
     SMILTime simpleDuration = this->simpleDuration();
     if (!simpleDuration || (repeatDur.isUnresolved() && repeatCount.isUnresolved()))
         return simpleDuration;
     SMILTime repeatCountDuration = simpleDuration * repeatCount;
-    return std::min(repeatCountDuration, std::min(repeatDur, SMILTime::indefinite()));
+    return min(repeatCountDuration, min(repeatDur, SMILTime::indefinite()));
 }
 
 SMILTime SVGSMILElement::resolveActiveEnd(SMILTime resolvedBegin, SMILTime resolvedEnd) const
 {
     // Computing the active duration
     // http://www.w3.org/TR/SMIL2/smil-timing.html#Timing-ComputingActiveDur
     SMILTime preliminaryActiveDuration;
     if (!resolvedEnd.isUnresolved() && dur().isUnresolved() && repeatDur().isUnresolved() && repeatCount().isUnresolved())
         preliminaryActiveDuration = resolvedEnd - resolvedBegin;
     else if (!resolvedEnd.isFinite())
         preliminaryActiveDuration = repeatingDuration();
     else
-        preliminaryActiveDuration = std::min(repeatingDuration(), resolvedEnd - resolvedBegin);
+        preliminaryActiveDuration = min(repeatingDuration(), resolvedEnd - resolvedBegin);
 
     SMILTime minValue = this->minValue();
     SMILTime maxValue = this->maxValue();
     if (minValue > maxValue) {
         // Ignore both.
         // http://www.w3.org/TR/2001/REC-smil-animation-20010904/#MinMax
         minValue = 0;
         maxValue = SMILTime::indefinite();
     }
-    return resolvedBegin + std::min(maxValue, std::max(minValue, preliminaryActiveDuration));
+    return resolvedBegin + min(maxValue, max(minValue, preliminaryActiveDuration));
 }
 
 SMILInterval SVGSMILElement::resolveInterval(ResolveInterval resolveIntervalType) const
 {
     bool first = resolveIntervalType == FirstInterval;
     // See the pseudocode in http://www.w3.org/TR/SMIL3/smil-timing.html#q90.
-    SMILTime beginAfter = first ? -std::numeric_limits<double>::infinity() : m_interval.end;
-    SMILTime lastIntervalTempEnd = std::numeric_limits<double>::infinity();
+    SMILTime beginAfter = first ? -numeric_limits<double>::infinity() : m_interval.end;
+    SMILTime lastIntervalTempEnd = numeric_limits<double>::infinity();
     while (true) {
         bool equalsMinimumOK = !first || m_interval.end > m_interval.begin;
         SMILTime tempBegin = findInstanceTime(Begin, beginAfter, equalsMinimumOK);
         if (tempBegin.isUnresolved())
             break;
         SMILTime tempEnd;
         if (m_endTimes.isEmpty())
             tempEnd = resolveActiveEnd(tempBegin, SMILTime::indefinite());
         else {
             tempEnd = findInstanceTime(End, tempBegin, true);
@@ skipping 15 matching lines @@
 }
 
 void SVGSMILElement::resolveFirstInterval()
 {
     SMILInterval firstInterval = resolveInterval(FirstInterval);
     ASSERT(!firstInterval.begin.isIndefinite());
 
     if (!firstInterval.begin.isUnresolved() && firstInterval != m_interval) {
         m_interval = firstInterval;
         notifyDependentsIntervalChanged();
-        m_nextProgressTime = std::min(m_nextProgressTime, m_interval.begin);
+        m_nextProgressTime = min(m_nextProgressTime, m_interval.begin);
 
         if (m_timeContainer)
             m_timeContainer->notifyIntervalsChanged();
     }
 }
 
 bool SVGSMILElement::resolveNextInterval()
 {
     SMILInterval nextInterval = resolveInterval(NextInterval);
     ASSERT(!nextInterval.begin.isIndefinite());
 
     if (!nextInterval.begin.isUnresolved() && nextInterval.begin != m_interval.begin) {
         m_interval = nextInterval;
         notifyDependentsIntervalChanged();
-        m_nextProgressTime = std::min(m_nextProgressTime, m_interval.begin);
+        m_nextProgressTime = min(m_nextProgressTime, m_interval.begin);
         return true;
     }
 
     return false;
 }
 
 SMILTime SVGSMILElement::nextProgressTime() const
 {
     return m_nextProgressTime;
 }
@@ skipping 124 matching lines @@
     ASSERT(simpleDuration.isFinite());
     SMILTime activeTime = elapsed - m_interval.begin;
     SMILTime repeatingDuration = this->repeatingDuration();
     if (elapsed >= m_interval.end || activeTime > repeatingDuration) {
         repeat = static_cast<unsigned>(repeatingDuration.value() / simpleDuration.value());
         if (!fmod(repeatingDuration.value(), simpleDuration.value()))
             repeat--;
 
         double percent = (m_interval.end.value() - m_interval.begin.value()) / simpleDuration.value();
         percent = percent - floor(percent);
-        if (percent < std::numeric_limits<float>::epsilon() || 1 - percent < std::numeric_limits<float>::epsilon())
+        if (percent < numeric_limits<float>::epsilon() || 1 - percent < numeric_limits<float>::epsilon())
             return 1.0f;
         return narrowPrecisionToFloat(percent);
     }
     repeat = static_cast<unsigned>(activeTime.value() / simpleDuration.value());
     SMILTime simpleTime = fmod(activeTime.value(), simpleDuration.value());
     return narrowPrecisionToFloat(simpleTime.value() / simpleDuration.value());
 }
 
 SMILTime SVGSMILElement::calculateNextProgressTime(SMILTime elapsed) const
 {
@@ skipping 236 matching lines @@
 void SVGSMILElement::trace(Visitor* visitor)
 {
     visitor->trace(m_targetElement);
     visitor->trace(m_timeContainer);
     visitor->trace(m_conditions);
     visitor->trace(m_syncBaseDependents);
     SVGElement::trace(visitor);
 }
 
 }