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

Source/core/html/forms/StepRange.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/html/forms/StepRange.h"
 
 #include "HTMLNames.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/WTFString.h"
 #include <float.h>
 
-using namespace std;
-
 namespace WebCore {
 
 using namespace HTMLNames;
 
 StepRange::StepRange()
     : m_maximum(100)
     , m_minimum(0)
     , m_step(1)
     , m_stepBase(0)
     , m_hasStep(false)
@@ skipping 35 matching lines @@
 {
     DEFINE_STATIC_LOCAL(const Decimal, tenPowerOf21, (Decimal::Positive, 21, 1));
     if (newValue >= tenPowerOf21)
         return newValue;
 
     return stepMismatch(currentValue) ? newValue : roundByStep(newValue, m_stepBase);
 }
 
 Decimal StepRange::clampValue(const Decimal& value) const
 {
-    const Decimal inRangeValue = max(m_minimum, min(value, m_maximum));
+    const Decimal inRangeValue = std::max(m_minimum, std::min(value, m_maximum));
     if (!m_hasStep)
         return inRangeValue;
     // Rounds inRangeValue to stepBase + N * step.
     const Decimal roundedValue = roundByStep(inRangeValue, m_stepBase);
     const Decimal clampedValue = roundedValue > m_maximum ? roundedValue - m_step : (roundedValue < m_minimum ? roundedValue + m_step : roundedValue);
     ASSERT(clampedValue >= m_minimum);
     ASSERT(clampedValue <= m_maximum);
     return clampedValue;
 }
 
@@ skipping 16 matching lines @@
     Decimal step = parseToDecimalForNumberType(stepString);
     if (!step.isFinite() || step <= 0)
         return stepDescription.defaultValue();
 
     switch (stepDescription.stepValueShouldBe) {
     case StepValueShouldBeReal:
         step *= stepDescription.stepScaleFactor;
         break;
     case ParsedStepValueShouldBeInteger:
         // For date, month, and week, the parsed value should be an integer for some types.
-        step = max(step.round(), Decimal(1));
+        step = std::max(step.round(), Decimal(1));
         step *= stepDescription.stepScaleFactor;
         break;
     case ScaledStepValueShouldBeInteger:
         // For datetime, datetime-local, time, the result should be an integer.
         step *= stepDescription.stepScaleFactor;
-        step = max(step.round(), Decimal(1));
+        step = std::max(step.round(), Decimal(1));
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     ASSERT(step > 0);
     return step;
 }
 
 Decimal StepRange::roundByStep(const Decimal& value, const Decimal& base) const
@@ skipping 20 matching lines @@
     // ... that number subtracted from the step base is not an integral multiple
     // of the allowed value step, the element is suffering from a step mismatch.
     const Decimal remainder = (value - m_step * (value / m_step).round()).abs();
     // Accepts errors in lower fractional part which IEEE 754 single-precision
     // can't represent.
     const Decimal computedAcceptableError = acceptableError();
     return computedAcceptableError < remainder && remainder < (m_step - computedAcceptableError);
 }
 
 } // namespace WebCore