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

Source/core/dom/ViewportDescription.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
  *
@@ skipping 18 matching lines @@
 #include "core/dom/ViewportDescription.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 
-using namespace std;
-
 namespace WebCore {
 
 static const float& compareIgnoringAuto(const float& value1, const float& value2, const float& (*compare) (const float&, const float&))
 {
     if (value1 == ViewportDescription::ValueAuto)
         return value2;
 
     if (value2 == ViewportDescription::ValueAuto)
         return value1;
 
@@ skipping 54 matching lines @@
     float resultMaxHeight = resolveViewportLength(maxHeight, initialViewportSize, Vertical);
     float resultMinHeight = resolveViewportLength(minHeight, initialViewportSize, Vertical);
 
     float resultZoom = zoom;
     float resultMinZoom = minZoom;
     float resultMaxZoom = maxZoom;
     bool resultUserZoom = userZoom;
 
     // 1. Resolve min-zoom and max-zoom values.
     if (resultMinZoom != ViewportDescription::ValueAuto && resultMaxZoom != ViewportDescription::ValueAuto)
-        resultMaxZoom = max(resultMinZoom, resultMaxZoom);
+        resultMaxZoom = std::max(resultMinZoom, resultMaxZoom);
 
     // 2. Constrain zoom value to the [min-zoom, max-zoom] range.
     if (resultZoom != ViewportDescription::ValueAuto)
-        resultZoom = compareIgnoringAuto(resultMinZoom, compareIgnoringAuto(resultMaxZoom, resultZoom, min), max);
+        resultZoom = compareIgnoringAuto(resultMinZoom, compareIgnoringAuto(resultMaxZoom, resultZoom, std::min), std::max);
 
-    float extendZoom = compareIgnoringAuto(resultZoom, resultMaxZoom, min);
+    float extendZoom = compareIgnoringAuto(resultZoom, resultMaxZoom, std::min);
 
     // 3. Resolve non-"auto" lengths to pixel lengths.
     if (extendZoom == ViewportDescription::ValueAuto) {
         if (resultMaxWidth == ViewportDescription::ValueExtendToZoom)
             resultMaxWidth = ViewportDescription::ValueAuto;
 
         if (resultMaxHeight == ViewportDescription::ValueExtendToZoom)
             resultMaxHeight = ViewportDescription::ValueAuto;
 
         if (resultMinWidth == ViewportDescription::ValueExtendToZoom)
             resultMinWidth = resultMaxWidth;
 
         if (resultMinHeight == ViewportDescription::ValueExtendToZoom)
             resultMinHeight = resultMaxHeight;
     } else {
         float extendWidth = initialViewportSize.width() / extendZoom;
         float extendHeight = initialViewportSize.height() / extendZoom;
 
         if (resultMaxWidth == ViewportDescription::ValueExtendToZoom)
             resultMaxWidth = extendWidth;
 
         if (resultMaxHeight == ViewportDescription::ValueExtendToZoom)
             resultMaxHeight = extendHeight;
 
         if (resultMinWidth == ViewportDescription::ValueExtendToZoom)
-            resultMinWidth = compareIgnoringAuto(extendWidth, resultMaxWidth, max);
+            resultMinWidth = compareIgnoringAuto(extendWidth, resultMaxWidth, std::max);
 
         if (resultMinHeight == ViewportDescription::ValueExtendToZoom)
-            resultMinHeight = compareIgnoringAuto(extendHeight, resultMaxHeight, max);
+            resultMinHeight = compareIgnoringAuto(extendHeight, resultMaxHeight, std::max);
     }
 
     // 4. Resolve initial width from min/max descriptors.
     if (resultMinWidth != ViewportDescription::ValueAuto || resultMaxWidth != ViewportDescription::ValueAuto)
-        resultWidth = compareIgnoringAuto(resultMinWidth, compareIgnoringAuto(resultMaxWidth, initialViewportSize.width(), min), max);
+        resultWidth = compareIgnoringAuto(resultMinWidth, compareIgnoringAuto(resultMaxWidth, initialViewportSize.width(), std::min), std::max);
 
     // 5. Resolve initial height from min/max descriptors.
     if (resultMinHeight != ViewportDescription::ValueAuto || resultMaxHeight != ViewportDescription::ValueAuto)
-        resultHeight = compareIgnoringAuto(resultMinHeight, compareIgnoringAuto(resultMaxHeight, initialViewportSize.height(), min), max);
+        resultHeight = compareIgnoringAuto(resultMinHeight, compareIgnoringAuto(resultMaxHeight, initialViewportSize.height(), std::min), std::max);
 
     // 6-7. Resolve width value.
     if (resultWidth == ViewportDescription::ValueAuto) {
         if (resultHeight == ViewportDescription::ValueAuto || !initialViewportSize.height())
             resultWidth = initialViewportSize.width();
         else
             resultWidth = resultHeight * (initialViewportSize.width() / initialViewportSize.height());
     }
 
     // 8. Resolve height value.
     if (resultHeight == ViewportDescription::ValueAuto) {
         if (!initialViewportSize.width())
             resultHeight = initialViewportSize.height();
         else
             resultHeight = resultWidth * initialViewportSize.height() / initialViewportSize.width();
     }
 
     // Resolve initial-scale value.
     if (resultZoom == ViewportDescription::ValueAuto) {
         if (resultWidth != ViewportDescription::ValueAuto && resultWidth > 0)
             resultZoom = initialViewportSize.width() / resultWidth;
         if (resultHeight != ViewportDescription::ValueAuto && resultHeight > 0) {
             // if 'auto', the initial-scale will be negative here and thus ignored.
-            resultZoom = max<float>(resultZoom, initialViewportSize.height() / resultHeight);
+            resultZoom = std::max<float>(resultZoom, initialViewportSize.height() / resultHeight);
         }
     }
 
     // If user-scalable = no, lock the min/max scale to the computed initial
     // scale.
     if (!resultUserZoom)
         resultMinZoom = resultMaxZoom = resultZoom;
 
     // Only set initialScale to a value if it was explicitly set.
     if (zoom == ViewportDescription::ValueAuto)
@@ skipping 61 matching lines @@
         }
     } else if (type == ViewportDescription::HandheldFriendlyMeta) {
         blink::Platform::current()->histogramEnumeration("Viewport.MetaTagType", MetaHandheldFriendly, TypeCount);
     } else if (type == ViewportDescription::MobileOptimizedMeta) {
         blink::Platform::current()->histogramEnumeration("Viewport.MetaTagType", MobileOptimizedMeta, TypeCount);
     }
 #endif
 }
 
 } // namespace WebCore