Removing "using" declarations that import names in the C++ Standard library.(Source/platform/[m* - …

Source/platform/transforms/TransformationMatrix.cpp

 /*
  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright (C) 2013 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.
@@ skipping 24 matching lines @@
 #include "platform/geometry/LayoutRect.h"
 #include "platform/transforms/AffineTransform.h"
 
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
-using namespace std;
-
 namespace blink {
 
 //
 // Supporting Math Functions
 //
 // This is a set of function from various places (attributed inline) to do things like
 // inversion and decomposition of a 4x4 matrix. They are used throughout the code
 //
 
 //
@@ skipping 197 matching lines @@
     result[1] = (p[0] * m[0][1]) + (p[1] * m[1][1]) +
                 (p[2] * m[2][1]) + (p[3] * m[3][1]);
     result[2] = (p[0] * m[0][2]) + (p[1] * m[1][2]) +
                 (p[2] * m[2][2]) + (p[3] * m[3][2]);
     result[3] = (p[0] * m[0][3]) + (p[1] * m[1][3]) +
                 (p[2] * m[2][3]) + (p[3] * m[3][3]);
 }
 
 static double v3Length(Vector3 a)
 {
-    return sqrt((a[0] * a[0]) + (a[1] * a[1]) + (a[2] * a[2]));
+    return std::sqrt((a[0] * a[0]) + (a[1] * a[1]) + (a[2] * a[2]));
 }
 
 static void v3Scale(Vector3 v, double desiredLength)
 {
     double len = v3Length(v);
     if (len != 0) {
         double l = desiredLength / len;
         v[0] *= l;
         v[1] *= l;
         v[2] *= l;
@@ skipping 155 matching lines @@
     // } else {
     //     ret.rotateX = atan2(-row[2][0], row[1][1]);
     //     ret.rotateZ = 0;
     // }
 
     double s, t, x, y, z, w;
 
     t = row[0][0] + row[1][1] + row[2][2] + 1.0;
 
     if (t > 1e-4) {
-        s = 0.5 / sqrt(t);
+        s = 0.5 / std::sqrt(t);
         w = 0.25 / s;
         x = (row[2][1] - row[1][2]) * s;
         y = (row[0][2] - row[2][0]) * s;
         z = (row[1][0] - row[0][1]) * s;
     } else if (row[0][0] > row[1][1] && row[0][0] > row[2][2]) {
-        s = sqrt (1.0 + row[0][0] - row[1][1] - row[2][2]) * 2.0; // S=4*qx
+        s = std::sqrt(1.0 + row[0][0] - row[1][1] - row[2][2]) * 2.0; // S=4*qx
         x = 0.25 * s;
         y = (row[0][1] + row[1][0]) / s;
         z = (row[0][2] + row[2][0]) / s;
         w = (row[2][1] - row[1][2]) / s;
     } else if (row[1][1] > row[2][2]) {
-        s = sqrt (1.0 + row[1][1] - row[0][0] - row[2][2]) * 2.0; // S=4*qy
+        s = std::sqrt(1.0 + row[1][1] - row[0][0] - row[2][2]) * 2.0; // S=4*qy
         x = (row[0][1] + row[1][0]) / s;
         y = 0.25 * s;
         z = (row[1][2] + row[2][1]) / s;
         w = (row[0][2] - row[2][0]) / s;
     } else {
-        s = sqrt(1.0 + row[2][2] - row[0][0] - row[1][1]) * 2.0; // S=4*qz
+        s = std::sqrt(1.0 + row[2][2] - row[0][0] - row[1][1]) * 2.0; // S=4*qz
         x = (row[0][2] + row[2][0]) / s;
         y = (row[1][2] + row[2][1]) / s;
         z = 0.25 * s;
         w = (row[1][0] - row[0][1]) / s;
     }
 
     result.quaternionX = x;
     result.quaternionY = y;
     result.quaternionZ = z;
     result.quaternionW = w;
@@ skipping 17 matching lines @@
     angle = ax * bx + ay * by + az * bz + aw * bw;
 
     if (angle < 0.0) {
         ax = -ax; ay = -ay;
         az = -az; aw = -aw;
         angle = -angle;
     }
 
     if (angle + 1.0 > .05) {
         if (1.0 - angle >= .05) {
-            th = acos (angle);
-            invth = 1.0 / sin (th);
-            scale = sin (th * (1.0 - t)) * invth;
-            invscale = sin (th * t) * invth;
+            th = std::acos(angle);
+            invth = 1.0 / std::sin(th);
+            scale = std::sin(th * (1.0 - t)) * invth;
+            invscale = std::sin(th * t) * invth;
         } else {
             scale = 1.0 - t;
             invscale = t;
         }
     } else {
         bx = -ay;
         by = ax;
         bz = -aw;
         bw = az;
-        scale = sin(piDouble * (.5 - t));
-        invscale = sin (piDouble * t);
+        scale = std::sin(piDouble * (.5 - t));
+        invscale = std::sin(piDouble * t);
     }
 
     cx = ax * scale + bx * invscale;
     cy = ay * scale + by * invscale;
     cz = az * scale + bz * invscale;
     cw = aw * scale + bw * invscale;
 
     qa[0] = cx; qa[1] = cy; qa[2] = cz; qa[3] = cw;
 }
 
@@ skipping 94 matching lines @@
     bool everythingWasClipped = clamped1 && clamped2 && clamped3 && clamped4;
     if (everythingWasClipped)
         return FloatQuad();
 
     return projectedQuad;
 }
 
 static float clampEdgeValue(float f)
 {
     ASSERT(!std::isnan(f));
-    return min<float>(max<float>(f, (-LayoutUnit::max() / 2).toFloat()), (LayoutUnit::max() / 2).toFloat());
+    return std::min<float>(std::max<float>(f, (-LayoutUnit::max() / 2).toFloat()), (LayoutUnit::max() / 2).toFloat());
 }
 
 LayoutRect TransformationMatrix::clampedBoundsOfProjectedQuad(const FloatQuad& q) const
 {
     FloatRect mappedQuadBounds = projectQuad(q).boundingBox();
 
     float left = clampEdgeValue(floorf(mappedQuadBounds.x()));
     float top = clampEdgeValue(floorf(mappedQuadBounds.y()));
 
     float right;
@@ skipping 118 matching lines @@
     m_matrix[2][0] *= sz;
     m_matrix[2][1] *= sz;
     m_matrix[2][2] *= sz;
     m_matrix[2][3] *= sz;
     return *this;
 }
 
 TransformationMatrix& TransformationMatrix::rotate3d(double x, double y, double z, double angle)
 {
     // Normalize the axis of rotation
-    double length = sqrt(x * x + y * y + z * z);
+    double length = std::sqrt(x * x + y * y + z * z);
     if (length == 0) {
         // A direction vector that cannot be normalized, such as [0, 0, 0], will cause the rotation to not be applied.
         return *this;
     } else if (length != 1) {
         x /= length;
         y /= length;
         z /= length;
     }
 
     // Angles are in degrees. Switch to radians.
     angle = deg2rad(angle);
 
-    double sinTheta = sin(angle);
-    double cosTheta = cos(angle);
+    double sinTheta = std::sin(angle);
+    double cosTheta = std::cos(angle);
 
     TransformationMatrix mat;
 
     // Optimize cases where the axis is along a major axis
     if (x == 1.0 && y == 0.0 && z == 0.0) {
         mat.m_matrix[0][0] = 1.0;
         mat.m_matrix[0][1] = 0.0;
         mat.m_matrix[0][2] = 0.0;
         mat.m_matrix[1][0] = 0.0;
         mat.m_matrix[1][1] = cosTheta;
@@ skipping 58 matching lines @@
 
 TransformationMatrix& TransformationMatrix::rotate3d(double rx, double ry, double rz)
 {
     // Angles are in degrees. Switch to radians.
     rx = deg2rad(rx);
     ry = deg2rad(ry);
     rz = deg2rad(rz);
 
     TransformationMatrix mat;
 
-    double sinTheta = sin(rz);
-    double cosTheta = cos(rz);
+    double sinTheta = std::sin(rz);
+    double cosTheta = std::cos(rz);
 
     mat.m_matrix[0][0] = cosTheta;
     mat.m_matrix[0][1] = sinTheta;
     mat.m_matrix[0][2] = 0.0;
     mat.m_matrix[1][0] = -sinTheta;
     mat.m_matrix[1][1] = cosTheta;
     mat.m_matrix[1][2] = 0.0;
     mat.m_matrix[2][0] = 0.0;
     mat.m_matrix[2][1] = 0.0;
     mat.m_matrix[2][2] = 1.0;
     mat.m_matrix[0][3] = mat.m_matrix[1][3] = mat.m_matrix[2][3] = 0.0;
     mat.m_matrix[3][0] = mat.m_matrix[3][1] = mat.m_matrix[3][2] = 0.0;
     mat.m_matrix[3][3] = 1.0;
 
     TransformationMatrix rmat(mat);
 
-    sinTheta = sin(ry);
-    cosTheta = cos(ry);
+    sinTheta = std::sin(ry);
+    cosTheta = std::cos(ry);
 
     mat.m_matrix[0][0] = cosTheta;
     mat.m_matrix[0][1] = 0.0;
     mat.m_matrix[0][2] = -sinTheta;
     mat.m_matrix[1][0] = 0.0;
     mat.m_matrix[1][1] = 1.0;
     mat.m_matrix[1][2] = 0.0;
     mat.m_matrix[2][0] = sinTheta;
     mat.m_matrix[2][1] = 0.0;
     mat.m_matrix[2][2] = cosTheta;
     mat.m_matrix[0][3] = mat.m_matrix[1][3] = mat.m_matrix[2][3] = 0.0;
     mat.m_matrix[3][0] = mat.m_matrix[3][1] = mat.m_matrix[3][2] = 0.0;
     mat.m_matrix[3][3] = 1.0;
 
     rmat.multiply(mat);
 
-    sinTheta = sin(rx);
-    cosTheta = cos(rx);
+    sinTheta = std::sin(rx);
+    cosTheta = std::cos(rx);
 
     mat.m_matrix[0][0] = 1.0;
     mat.m_matrix[0][1] = 0.0;
     mat.m_matrix[0][2] = 0.0;
     mat.m_matrix[1][0] = 0.0;
     mat.m_matrix[1][1] = cosTheta;
     mat.m_matrix[1][2] = sinTheta;
     mat.m_matrix[2][0] = 0.0;
     mat.m_matrix[2][1] = -sinTheta;
     mat.m_matrix[2][2] = cosTheta;
@@ skipping 57 matching lines @@
     return *this;
 }
 
 TransformationMatrix& TransformationMatrix::skew(double sx, double sy)
 {
     // angles are in degrees. Switch to radians
     sx = deg2rad(sx);
     sy = deg2rad(sy);
 
     TransformationMatrix mat;
-    mat.m_matrix[0][1] = tan(sy); // note that the y shear goes in the first row
-    mat.m_matrix[1][0] = tan(sx); // and the x shear in the second row
+    mat.m_matrix[0][1] = std::tan(sy); // note that the y shear goes in the first row
+    mat.m_matrix[1][0] = std::tan(sx); // and the x shear in the second row
 
     multiply(mat);
     return *this;
 }
 
 TransformationMatrix& TransformationMatrix::applyPerspective(double p)
 {
     TransformationMatrix mat;
     if (p != 0)
         mat.m_matrix[2][3] = -1/p;
@@ skipping 537 matching lines @@
     ret.setDouble(2, 2, matrix.m33());
     ret.setDouble(2, 3, matrix.m43());
     ret.setDouble(3, 0, matrix.m14());
     ret.setDouble(3, 1, matrix.m24());
     ret.setDouble(3, 2, matrix.m34());
     ret.setDouble(3, 3, matrix.m44());
     return ret;
 }
 
 }