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

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 72 matching lines @@
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
-using namespace std;
-
 namespace WebCore {
 
 namespace {
 
 static bool gModifyRenderTreeStructureAnyState = false;
 
 } // namespace
 
 using namespace HTMLNames;
 
@@ skipping 968 matching lines @@
         graphicsContext->setShouldAntialias(wasAntialiased);
         graphicsContext->setStrokeStyle(oldStrokeStyle);
         return;
     }
 
     int adjacent1BigThird = ((adjacentWidth1 > 0) ? adjacentWidth1 + 1 : adjacentWidth1 - 1) / 3;
     int adjacent2BigThird = ((adjacentWidth2 > 0) ? adjacentWidth2 + 1 : adjacentWidth2 - 1) / 3;
 
     switch (side) {
     case BSTop:
-        drawLineForBoxSide(graphicsContext, x1 + max((-adjacentWidth1 * 2 + 1) / 3, 0),
-            y1, x2 - max((-adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
+        drawLineForBoxSide(graphicsContext, x1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
+            y1, x2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
-        drawLineForBoxSide(graphicsContext, x1 + max((adjacentWidth1 * 2 + 1) / 3, 0),
-            y2 - thirdOfThickness, x2 - max((adjacentWidth2 * 2 + 1) / 3, 0), y2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
+            y2 - thirdOfThickness, x2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0), y2,
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         break;
     case BSLeft:
-        drawLineForBoxSide(graphicsContext, x1, y1 + max((-adjacentWidth1 * 2 + 1) / 3, 0),
-            x1 + thirdOfThickness, y2 - max((-adjacentWidth2 * 2 + 1) / 3, 0),
+        drawLineForBoxSide(graphicsContext, x1, y1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
+            x1 + thirdOfThickness, y2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0),
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
-        drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + max((adjacentWidth1 * 2 + 1) / 3, 0),
-            x2, y2 - max((adjacentWidth2 * 2 + 1) / 3, 0),
+        drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
+            x2, y2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0),
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         break;
     case BSBottom:
-        drawLineForBoxSide(graphicsContext, x1 + max((adjacentWidth1 * 2 + 1) / 3, 0),
-            y1, x2 - max((adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
+        drawLineForBoxSide(graphicsContext, x1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
+            y1, x2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0), y1 + thirdOfThickness,
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
-        drawLineForBoxSide(graphicsContext, x1 + max((-adjacentWidth1 * 2 + 1) / 3, 0),
-            y2 - thirdOfThickness, x2 - max((-adjacentWidth2 * 2 + 1) / 3, 0), y2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
+            y2 - thirdOfThickness, x2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0), y2,
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         break;
     case BSRight:
-        drawLineForBoxSide(graphicsContext, x1, y1 + max((adjacentWidth1 * 2 + 1) / 3, 0),
-            x1 + thirdOfThickness, y2 - max((adjacentWidth2 * 2 + 1) / 3, 0),
+        drawLineForBoxSide(graphicsContext, x1, y1 + std::max((adjacentWidth1 * 2 + 1) / 3, 0),
+            x1 + thirdOfThickness, y2 - std::max((adjacentWidth2 * 2 + 1) / 3, 0),
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
-        drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + max((-adjacentWidth1 * 2 + 1) / 3, 0),
-            x2, y2 - max((-adjacentWidth2 * 2 + 1) / 3, 0),
+        drawLineForBoxSide(graphicsContext, x2 - thirdOfThickness, y1 + std::max((-adjacentWidth1 * 2 + 1) / 3, 0),
+            x2, y2 - std::max((-adjacentWidth2 * 2 + 1) / 3, 0),
             side, color, SOLID, adjacent1BigThird, adjacent2BigThird, antialias);
         break;
     default:
         break;
     }
 }
 
 void RenderObject::drawRidgeOrGrooveBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, EBorderStyle style, int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     EBorderStyle s1;
     EBorderStyle s2;
     if (style == GROOVE) {
         s1 = INSET;
         s2 = OUTSET;
     } else {
         s1 = OUTSET;
         s2 = INSET;
     }
 
     int adjacent1BigHalf = ((adjacentWidth1 > 0) ? adjacentWidth1 + 1 : adjacentWidth1 - 1) / 2;
     int adjacent2BigHalf = ((adjacentWidth2 > 0) ? adjacentWidth2 + 1 : adjacentWidth2 - 1) / 2;
 
     switch (side) {
     case BSTop:
-        drawLineForBoxSide(graphicsContext, x1 + max(-adjacentWidth1, 0) / 2, y1, x2 - max(-adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max(-adjacentWidth1, 0) / 2, y1, x2 - std::max(-adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
             side, color, s1, adjacent1BigHalf, adjacent2BigHalf, antialias);
-        drawLineForBoxSide(graphicsContext, x1 + max(adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - max(adjacentWidth2 + 1, 0) / 2, y2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max(adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - std::max(adjacentWidth2 + 1, 0) / 2, y2,
             side, color, s2, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
         break;
     case BSLeft:
-        drawLineForBoxSide(graphicsContext, x1, y1 + max(-adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - max(-adjacentWidth2, 0) / 2,
+        drawLineForBoxSide(graphicsContext, x1, y1 + std::max(-adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - std::max(-adjacentWidth2, 0) / 2,
             side, color, s1, adjacent1BigHalf, adjacent2BigHalf, antialias);
-        drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + max(adjacentWidth1 + 1, 0) / 2, x2, y2 - max(adjacentWidth2 + 1, 0) / 2,
+        drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + std::max(adjacentWidth1 + 1, 0) / 2, x2, y2 - std::max(adjacentWidth2 + 1, 0) / 2,
             side, color, s2, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
         break;
     case BSBottom:
-        drawLineForBoxSide(graphicsContext, x1 + max(adjacentWidth1, 0) / 2, y1, x2 - max(adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max(adjacentWidth1, 0) / 2, y1, x2 - std::max(adjacentWidth2, 0) / 2, (y1 + y2 + 1) / 2,
             side, color, s2, adjacent1BigHalf, adjacent2BigHalf, antialias);
-        drawLineForBoxSide(graphicsContext, x1 + max(-adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - max(-adjacentWidth2 + 1, 0) / 2, y2,
+        drawLineForBoxSide(graphicsContext, x1 + std::max(-adjacentWidth1 + 1, 0) / 2, (y1 + y2 + 1) / 2, x2 - std::max(-adjacentWidth2 + 1, 0) / 2, y2,
             side, color, s1, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
         break;
     case BSRight:
-        drawLineForBoxSide(graphicsContext, x1, y1 + max(adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - max(adjacentWidth2, 0) / 2,
+        drawLineForBoxSide(graphicsContext, x1, y1 + std::max(adjacentWidth1, 0) / 2, (x1 + x2 + 1) / 2, y2 - std::max(adjacentWidth2, 0) / 2,
             side, color, s2, adjacent1BigHalf, adjacent2BigHalf, antialias);
-        drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + max(-adjacentWidth1 + 1, 0) / 2, x2, y2 - max(-adjacentWidth2 + 1, 0) / 2,
+        drawLineForBoxSide(graphicsContext, (x1 + x2 + 1) / 2, y1 + std::max(-adjacentWidth1 + 1, 0) / 2, x2, y2 - std::max(-adjacentWidth2 + 1, 0) / 2,
             side, color, s1, adjacentWidth1 / 2, adjacentWidth2 / 2, antialias);
         break;
     }
 }
 
 void RenderObject::drawSolidBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
     BoxSide side, Color color, int adjacentWidth1, int adjacentWidth2, bool antialias)
 {
     StrokeStyle oldStrokeStyle = graphicsContext->strokeStyle();
     graphicsContext->setStrokeStyle(NoStroke);
     graphicsContext->setFillColor(color);
     ASSERT(x2 >= x1);
     ASSERT(y2 >= y1);
     if (!adjacentWidth1 && !adjacentWidth2) {
         // Turn off antialiasing to match the behavior of drawConvexPolygon();
         // this matters for rects in transformed contexts.
         bool wasAntialiased = graphicsContext->shouldAntialias();
         graphicsContext->setShouldAntialias(antialias);
         graphicsContext->drawRect(IntRect(x1, y1, x2 - x1, y2 - y1));
         graphicsContext->setShouldAntialias(wasAntialiased);
         graphicsContext->setStrokeStyle(oldStrokeStyle);
         return;
     }
     FloatPoint quad[4];
     switch (side) {
     case BSTop:
-        quad[0] = FloatPoint(x1 + max(-adjacentWidth1, 0), y1);
-        quad[1] = FloatPoint(x1 + max(adjacentWidth1, 0), y2);
-        quad[2] = FloatPoint(x2 - max(adjacentWidth2, 0), y2);
-        quad[3] = FloatPoint(x2 - max(-adjacentWidth2, 0), y1);
+        quad[0] = FloatPoint(x1 + std::max(-adjacentWidth1, 0), y1);
+        quad[1] = FloatPoint(x1 + std::max(adjacentWidth1, 0), y2);
+        quad[2] = FloatPoint(x2 - std::max(adjacentWidth2, 0), y2);
+        quad[3] = FloatPoint(x2 - std::max(-adjacentWidth2, 0), y1);
         break;
     case BSBottom:
-        quad[0] = FloatPoint(x1 + max(adjacentWidth1, 0), y1);
-        quad[1] = FloatPoint(x1 + max(-adjacentWidth1, 0), y2);
-        quad[2] = FloatPoint(x2 - max(-adjacentWidth2, 0), y2);
-        quad[3] = FloatPoint(x2 - max(adjacentWidth2, 0), y1);
+        quad[0] = FloatPoint(x1 + std::max(adjacentWidth1, 0), y1);
+        quad[1] = FloatPoint(x1 + std::max(-adjacentWidth1, 0), y2);
+        quad[2] = FloatPoint(x2 - std::max(-adjacentWidth2, 0), y2);
+        quad[3] = FloatPoint(x2 - std::max(adjacentWidth2, 0), y1);
         break;
     case BSLeft:
-        quad[0] = FloatPoint(x1, y1 + max(-adjacentWidth1, 0));
-        quad[1] = FloatPoint(x1, y2 - max(-adjacentWidth2, 0));
-        quad[2] = FloatPoint(x2, y2 - max(adjacentWidth2, 0));
-        quad[3] = FloatPoint(x2, y1 + max(adjacentWidth1, 0));
+        quad[0] = FloatPoint(x1, y1 + std::max(-adjacentWidth1, 0));
+        quad[1] = FloatPoint(x1, y2 - std::max(-adjacentWidth2, 0));
+        quad[2] = FloatPoint(x2, y2 - std::max(adjacentWidth2, 0));
+        quad[3] = FloatPoint(x2, y1 + std::max(adjacentWidth1, 0));
         break;
     case BSRight:
-        quad[0] = FloatPoint(x1, y1 + max(adjacentWidth1, 0));
-        quad[1] = FloatPoint(x1, y2 - max(adjacentWidth2, 0));
-        quad[2] = FloatPoint(x2, y2 - max(-adjacentWidth2, 0));
-        quad[3] = FloatPoint(x2, y1 + max(-adjacentWidth1, 0));
+        quad[0] = FloatPoint(x1, y1 + std::max(adjacentWidth1, 0));
+        quad[1] = FloatPoint(x1, y2 - std::max(adjacentWidth2, 0));
+        quad[2] = FloatPoint(x2, y2 - std::max(-adjacentWidth2, 0));
+        quad[3] = FloatPoint(x2, y1 + std::max(-adjacentWidth1, 0));
         break;
     }
 
     graphicsContext->drawConvexPolygon(4, quad, antialias);
     graphicsContext->setStrokeStyle(oldStrokeStyle);
 }
 
 void RenderObject::paintFocusRing(PaintInfo& paintInfo, const LayoutPoint& paintOffset, RenderStyle* style)
 {
     Vector<IntRect> focusRingRects;
@@ skipping 527 matching lines @@
     RenderStyle* outlineStyle = outlineStyleForPaintInvalidation();
     LayoutUnit outlineWidth = outlineStyle->outlineSize();
     LayoutBoxExtent insetShadowExtent = style()->getBoxShadowInsetExtent();
     LayoutUnit width = absoluteValue(newBounds.width() - oldBounds.width());
     if (width) {
         LayoutUnit shadowLeft;
         LayoutUnit shadowRight;
         style()->getBoxShadowHorizontalExtent(shadowLeft, shadowRight);
         int borderRight = isBox() ? toRenderBox(this)->borderRight() : 0;
         LayoutUnit boxWidth = isBox() ? toRenderBox(this)->width() : LayoutUnit();
-        LayoutUnit minInsetRightShadowExtent = min<LayoutUnit>(-insetShadowExtent.right(), min<LayoutUnit>(newBounds.width(), oldBounds.width()));
-        LayoutUnit borderWidth = max<LayoutUnit>(borderRight, max<LayoutUnit>(valueForLength(style()->borderTopRightRadius().width(), boxWidth), valueForLength(style()->borderBottomRightRadius().width(), boxWidth)));
-        LayoutUnit decorationsLeftWidth = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderWidth + minInsetRightShadowExtent) + max<LayoutUnit>(outlineWidth, -shadowLeft);
-        LayoutUnit decorationsRightWidth = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderWidth + minInsetRightShadowExtent) + max<LayoutUnit>(outlineWidth, shadowRight);
-        LayoutRect rightRect(newBounds.x() + min(newBounds.width(), oldBounds.width()) - decorationsLeftWidth,
+        LayoutUnit minInsetRightShadowExtent = std::min<LayoutUnit>(-insetShadowExtent.right(), std::min<LayoutUnit>(newBounds.width(), oldBounds.width()));
+        LayoutUnit borderWidth = std::max<LayoutUnit>(borderRight, std::max<LayoutUnit>(valueForLength(style()->borderTopRightRadius().width(), boxWidth), valueForLength(style()->borderBottomRightRadius().width(), boxWidth)));
+        LayoutUnit decorationsLeftWidth = std::max<LayoutUnit>(-outlineStyle->outlineOffset(), borderWidth + minInsetRightShadowExtent) + std::max<LayoutUnit>(outlineWidth, -shadowLeft);
+        LayoutUnit decorationsRightWidth = std::max<LayoutUnit>(-outlineStyle->outlineOffset(), borderWidth + minInsetRightShadowExtent) + std::max<LayoutUnit>(outlineWidth, shadowRight);
+        LayoutRect rightRect(newBounds.x() + std::min(newBounds.width(), oldBounds.width()) - decorationsLeftWidth,
             newBounds.y(),
             width + decorationsLeftWidth + decorationsRightWidth,
-            max(newBounds.height(), oldBounds.height()));
-        LayoutUnit right = min<LayoutUnit>(newBounds.maxX(), oldBounds.maxX());
+            std::max(newBounds.height(), oldBounds.height()));
+        LayoutUnit right = std::min<LayoutUnit>(newBounds.maxX(), oldBounds.maxX());
         if (rightRect.x() < right) {
-            rightRect.setWidth(min(rightRect.width(), right - rightRect.x()));
+            rightRect.setWidth(std::min(rightRect.width(), right - rightRect.x()));
             invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(rightRect), invalidationReason);
         }
     }
     LayoutUnit height = absoluteValue(newBounds.height() - oldBounds.height());
     if (height) {
         LayoutUnit shadowTop;
         LayoutUnit shadowBottom;
         style()->getBoxShadowVerticalExtent(shadowTop, shadowBottom);
         int borderBottom = isBox() ? toRenderBox(this)->borderBottom() : 0;
         LayoutUnit boxHeight = isBox() ? toRenderBox(this)->height() : LayoutUnit();
-        LayoutUnit minInsetBottomShadowExtent = min<LayoutUnit>(-insetShadowExtent.bottom(), min<LayoutUnit>(newBounds.height(), oldBounds.height()));
-        LayoutUnit borderHeight = max<LayoutUnit>(borderBottom, max<LayoutUnit>(valueForLength(style()->borderBottomLeftRadius().height(), boxHeight), valueForLength(style()->borderBottomRightRadius().height(), boxHeight)));
-        LayoutUnit decorationsTopHeight = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderHeight + minInsetBottomShadowExtent) + max<LayoutUnit>(outlineWidth, -shadowTop);
-        LayoutUnit decorationsBottomHeight = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderHeight + minInsetBottomShadowExtent) + max<LayoutUnit>(outlineWidth, shadowBottom);
+        LayoutUnit minInsetBottomShadowExtent = std::min<LayoutUnit>(-insetShadowExtent.bottom(), std::min<LayoutUnit>(newBounds.height(), oldBounds.height()));
+        LayoutUnit borderHeight = std::max<LayoutUnit>(borderBottom, std::max<LayoutUnit>(valueForLength(style()->borderBottomLeftRadius().height(), boxHeight), valueForLength(style()->borderBottomRightRadius().height(), boxHeight)));
+        LayoutUnit decorationsTopHeight = std::max<LayoutUnit>(-outlineStyle->outlineOffset(), borderHeight + minInsetBottomShadowExtent) + std::max<LayoutUnit>(outlineWidth, -shadowTop);
+        LayoutUnit decorationsBottomHeight = std::max<LayoutUnit>(-outlineStyle->outlineOffset(), borderHeight + minInsetBottomShadowExtent) + std::max<LayoutUnit>(outlineWidth, shadowBottom);
         LayoutRect bottomRect(newBounds.x(),
-            min(newBounds.maxY(), oldBounds.maxY()) - decorationsTopHeight,
-            max(newBounds.width(), oldBounds.width()),
+            std::min(newBounds.maxY(), oldBounds.maxY()) - decorationsTopHeight,
+            std::max(newBounds.width(), oldBounds.width()),
             height + decorationsTopHeight + decorationsBottomHeight);
-        LayoutUnit bottom = min(newBounds.maxY(), oldBounds.maxY());
+        LayoutUnit bottom = std::min(newBounds.maxY(), oldBounds.maxY());
         if (bottomRect.y() < bottom) {
-            bottomRect.setHeight(min(bottomRect.height(), bottom - bottomRect.y()));
+            bottomRect.setHeight(std::min(bottomRect.height(), bottom - bottomRect.y()));
             invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(bottomRect), invalidationReason);
         }
     }
     return false;
 }
 
 void RenderObject::invalidatePaintForOverflow()
 {
 }
 
@@ skipping 1463 matching lines @@
 }
 
 int RenderObject::caretMinOffset() const
 {
     return 0;
 }
 
 int RenderObject::caretMaxOffset() const
 {
     if (isReplaced())
-        return node() ? max(1U, node()->countChildren()) : 1;
+        return node() ? std::max(1U, node()->countChildren()) : 1;
     if (isHR())
         return 1;
     return 0;
 }
 
 int RenderObject::previousOffset(int current) const
 {
     return current - 1;
 }
 
@@ skipping 259 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif