Rename WebCore namespace to blink in Platform

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 26 matching lines @@
 
 #include "wtf/Assertions.h"
 #include "wtf/MathExtras.h"
 
 #if CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
 using namespace std;
 
-namespace WebCore {
+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
 //
 
 //
 // Adapted from Matrix Inversion by Richard Carling, Graphics Gems <http://tog.acm.org/GraphicsGems/index.html>.
@@ skipping 1232 matching lines @@
         resultY /= w;
         resultZ /= w;
     }
 }
 
 bool TransformationMatrix::isInvertible() const
 {
     if (isIdentityOrTranslation())
         return true;
 
-    double det = WebCore::determinant4x4(m_matrix);
+    double det = blink::determinant4x4(m_matrix);
 
     if (fabs(det) < SMALL_NUMBER)
         return false;
 
     return true;
 }
 
 TransformationMatrix TransformationMatrix::inverse() const
 {
     if (isIdentityOrTranslation()) {
         // identity matrix
         if (m_matrix[3][0] == 0 && m_matrix[3][1] == 0 && m_matrix[3][2] == 0)
             return TransformationMatrix();
 
         // translation
         return TransformationMatrix(1, 0, 0, 0,
                                     0, 1, 0, 0,
                                     0, 0, 1, 0,
                                     -m_matrix[3][0], -m_matrix[3][1], -m_matrix[3][2], 1);
     }
 
     TransformationMatrix invMat;
-    bool inverted = WebCore::inverse(m_matrix, invMat.m_matrix);
+    bool inverted = blink::inverse(m_matrix, invMat.m_matrix);
     if (!inverted)
         return TransformationMatrix();
 
     return invMat;
 }
 
 void TransformationMatrix::makeAffine()
 {
     m_matrix[0][2] = 0;
     m_matrix[0][3] = 0;
@@ skipping 60 matching lines @@
 bool TransformationMatrix::decompose(DecomposedType& decomp) const
 {
     if (isIdentity()) {
         memset(&decomp, 0, sizeof(decomp));
         decomp.perspectiveW = 1;
         decomp.scaleX = 1;
         decomp.scaleY = 1;
         decomp.scaleZ = 1;
     }
 
-    if (!WebCore::decompose(m_matrix, decomp))
+    if (!blink::decompose(m_matrix, decomp))
         return false;
     return true;
 }
 
 void TransformationMatrix::recompose(const DecomposedType& decomp)
 {
     makeIdentity();
 
     // first apply perspective
     m_matrix[0][3] = decomp.perspectiveX;
@@ skipping 99 matching lines @@
     //
     // Since we know we will be using (0, 0, 1), and we only care about the z-component of
     // the transformed normal, then we only need the m33() element of the
     // inverse-transpose. Therefore we do not need the transpose.
     //
     // Additionally, if we only need the m33() element, we do not need to compute a full
     // inverse. Instead, knowing the inverse of a matrix is adjoint(matrix) / determinant,
     // we can simply compute the m33() of the adjoint (adjugate) matrix, without computing
     // the full adjoint.
 
-    double determinant = WebCore::determinant4x4(m_matrix);
+    double determinant = blink::determinant4x4(m_matrix);
 
     // If the matrix is not invertible, then we assume its backface is not visible.
     if (fabs(determinant) < SMALL_NUMBER)
         return false;
 
     double cofactor33 = determinant3x3(m11(), m12(), m14(), m21(), m22(), m24(), m41(), m42(), m44());
     double zComponentOfTransformedNormal = cofactor33 / determinant;
 
     return zComponentOfTransformedNormal < 0;
 }
@@ skipping 14 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;
 }
 
 }