DOMMatrix should use TransformationMatrix internally.

BUG=388780

Review URL: https://codereview.chromium.org/460713002

git-svn-id: svn://svn.chromium.org/blink/trunk@180399 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/dom/DOMMatrix.cpp

@@ -9,40 +9,17 @@ namespace blink {
 
 DOMMatrix* DOMMatrix::create()
 {
-    return new DOMMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+    return new DOMMatrix(TransformationMatrix());
 }
 
 DOMMatrix* DOMMatrix::create(DOMMatrixReadOnly* other)
 {
-    return new DOMMatrix(other->m11(), other->m12(), other->m13(), other->m14(),
-        other->m21(), other->m22(), other->m23(), other->m24(),
-        other->m31(), other->m32(), other->m33(), other->m34(),
-        other->m41(), other->m42(), other->m43(), other->m44(),
-        other->is2D());
+    return new DOMMatrix(other->matrix(), other->is2D());
 }
 
-DOMMatrix::DOMMatrix(double m11, double m12, double m13, double m14,
-    double m21, double m22, double m23, double m24,
-    double m31, double m32, double m33, double m34,
-    double m41, double m42, double m43, double m44,
-    bool is2D)
+DOMMatrix::DOMMatrix(const TransformationMatrix& matrix, bool is2D)
 {
-    m_matrix[0][0] = m11;
-    m_matrix[0][1] = m12;
-    m_matrix[0][2] = m13;
-    m_matrix[0][3] = m14;
-    m_matrix[1][0] = m21;
-    m_matrix[1][1] = m22;
-    m_matrix[1][2] = m23;
-    m_matrix[1][3] = m24;
-    m_matrix[2][0] = m31;
-    m_matrix[2][1] = m32;
-    m_matrix[2][2] = m33;
-    m_matrix[2][3] = m34;
-    m_matrix[3][0] = m41;
-    m_matrix[3][1] = m42;
-    m_matrix[3][2] = m43;
-    m_matrix[3][3] = m44;
+    m_matrix = matrix;
     m_is2D = is2D;
 }
 

third_party/WebKit/Source/core/dom/DOMMatrix.h

@@ -14,36 +14,32 @@ public:
     static DOMMatrix* create();
     static DOMMatrix* create(DOMMatrixReadOnly*);
 
-    void setA(double value) { setM11(value); }
-    void setB(double value) { setM12(value); }
-    void setC(double value) { setM21(value); }
-    void setD(double value) { setM22(value); }
-    void setE(double value) { setM41(value); }
-    void setF(double value) { setM42(value); }
-
-    void setM11(double value) { m_matrix[0][0] = value; }
-    void setM12(double value) { m_matrix[0][1] = value; }
-    void setM13(double value) { m_matrix[0][2] = value; setIs2D(!value); }
-    void setM14(double value) { m_matrix[0][3] = value; setIs2D(!value); }
-    void setM21(double value) { m_matrix[1][0] = value; }
-    void setM22(double value) { m_matrix[1][1] = value; }
-    void setM23(double value) { m_matrix[1][2] = value; setIs2D(!value); }
-    void setM24(double value) { m_matrix[1][3] = value; setIs2D(!value); }
-    void setM31(double value) { m_matrix[2][0] = value; setIs2D(!value); }
-    void setM32(double value) { m_matrix[2][1] = value; setIs2D(!value); }
-    void setM33(double value) { m_matrix[2][2] = value; setIs2D(value != 1); }
-    void setM34(double value) { m_matrix[2][3] = value; setIs2D(!value); }
-    void setM41(double value) { m_matrix[3][0] = value; }
-    void setM42(double value) { m_matrix[3][1] = value; }
-    void setM43(double value) { m_matrix[3][2] = value; setIs2D(!value); }
-    void setM44(double value) { m_matrix[3][3] = value; setIs2D(value != 1); }
+    void setA(double value) { m_matrix.setM11(value); }
+    void setB(double value) { m_matrix.setM12(value); }
+    void setC(double value) { m_matrix.setM21(value); }
+    void setD(double value) { m_matrix.setM22(value); }
+    void setE(double value) { m_matrix.setM41(value); }
+    void setF(double value) { m_matrix.setM42(value); }
+
+    void setM11(double value) { m_matrix.setM11(value); }
+    void setM12(double value) { m_matrix.setM12(value); }
+    void setM13(double value) { m_matrix.setM13(value); setIs2D(!value); }
+    void setM14(double value) { m_matrix.setM14(value); setIs2D(!value); }
+    void setM21(double value) { m_matrix.setM21(value); }
+    void setM22(double value) { m_matrix.setM22(value); }
+    void setM23(double value) { m_matrix.setM23(value); setIs2D(!value); }
+    void setM24(double value) { m_matrix.setM24(value); setIs2D(!value); }
+    void setM31(double value) { m_matrix.setM31(value); setIs2D(!value); }
+    void setM32(double value) { m_matrix.setM32(value); setIs2D(!value); }
+    void setM33(double value) { m_matrix.setM33(value); setIs2D(value != 1); }
+    void setM34(double value) { m_matrix.setM34(value); setIs2D(!value); }
+    void setM41(double value) { m_matrix.setM41(value); }
+    void setM42(double value) { m_matrix.setM42(value); }
+    void setM43(double value) { m_matrix.setM43(value); setIs2D(!value); }
+    void setM44(double value) { m_matrix.setM44(value); setIs2D(value != 1); }
 
 private:
-    DOMMatrix(double m11, double m12, double m13, double m14,
-        double m21, double m22, double m23, double m24,
-        double m31, double m32, double m33, double m34,
-        double m41, double m42, double m43, double m44,
-        bool is2D = true);
+    DOMMatrix(const TransformationMatrix&, bool is2D = true);
 
     void setIs2D(bool value);
 };

third_party/WebKit/Source/core/dom/DOMMatrixReadOnly.cpp

@@ -14,10 +14,7 @@ bool DOMMatrixReadOnly::is2D() const
 
 bool DOMMatrixReadOnly::isIdentity() const
 {
-    return m11() == 1 && m21() == 0 && m31() == 0 && m41() == 0
-        && m12() == 0 && m22() == 1 && m32() == 0 && m42() == 0
-        && m13() == 0 && m23() == 0 && m33() == 1 && m43() == 0
-        && m14() == 0 && m24() == 0 && m34() == 0 && m44() == 1;
+    return m_matrix.isIdentity();
 }
 
 } // namespace blink

third_party/WebKit/Source/core/dom/DOMMatrixReadOnly.h

@@ -7,42 +7,45 @@
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "platform/heap/Handle.h"
+#include "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
 class DOMMatrixReadOnly : public GarbageCollected<DOMMatrixReadOnly>, public ScriptWrappableBase {
 public:
-    double a() const { return m11(); }
-    double b() const { return m12(); }
-    double c() const { return m21(); }
-    double d() const { return m22(); }
-    double e() const { return m41(); }
-    double f() const { return m42(); }
-
-    double m11() const { return m_matrix[0][0]; }
-    double m12() const { return m_matrix[0][1]; }
-    double m13() const { return m_matrix[0][2]; }
-    double m14() const { return m_matrix[0][3]; }
-    double m21() const { return m_matrix[1][0]; }
-    double m22() const { return m_matrix[1][1]; }
-    double m23() const { return m_matrix[1][2]; }
-    double m24() const { return m_matrix[1][3]; }
-    double m31() const { return m_matrix[2][0]; }
-    double m32() const { return m_matrix[2][1]; }
-    double m33() const { return m_matrix[2][2]; }
-    double m34() const { return m_matrix[2][3]; }
-    double m41() const { return m_matrix[3][0]; }
-    double m42() const { return m_matrix[3][1]; }
-    double m43() const { return m_matrix[3][2]; }
-    double m44() const { return m_matrix[3][3]; }
+    double a() const { return m_matrix.m11(); }
+    double b() const { return m_matrix.m12(); }
+    double c() const { return m_matrix.m21(); }
+    double d() const { return m_matrix.m22(); }
+    double e() const { return m_matrix.m41(); }
+    double f() const { return m_matrix.m42(); }
+
+    double m11() const { return m_matrix.m11(); }
+    double m12() const { return m_matrix.m12(); }
+    double m13() const { return m_matrix.m13(); }
+    double m14() const { return m_matrix.m14(); }
+    double m21() const { return m_matrix.m21(); }
+    double m22() const { return m_matrix.m22(); }
+    double m23() const { return m_matrix.m23(); }
+    double m24() const { return m_matrix.m24(); }
+    double m31() const { return m_matrix.m31(); }
+    double m32() const { return m_matrix.m32(); }
+    double m33() const { return m_matrix.m33(); }
+    double m34() const { return m_matrix.m34(); }
+    double m41() const { return m_matrix.m41(); }
+    double m42() const { return m_matrix.m42(); }
+    double m43() const { return m_matrix.m43(); }
+    double m44() const { return m_matrix.m44(); }
 
     bool is2D() const;
     bool isIdentity() const;
 
+    const TransformationMatrix& matrix() const { return m_matrix; }
+
     void trace(Visitor*) { }
 
 protected:
-    double m_matrix[4][4];
+    TransformationMatrix m_matrix;
     bool m_is2D;
 };