Add rotateRadians function to AffineTransform

Source/platform/transforms/AffineTransform.cpp

 /*
  * Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *               2010 Dirk Schulze <krit@webkit.org>
  * 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 116 matching lines @@
     trans.m_transform[4] = other.m_transform[4] * m_transform[0] + other.m_transform[5] * m_transform[2] + m_transform[4];
     trans.m_transform[5] = other.m_transform[4] * m_transform[1] + other.m_transform[5] * m_transform[3] + m_transform[5];
 
     setMatrix(trans.m_transform);
     return *this;
 }
 
 AffineTransform& AffineTransform::rotate(double a)
 {
     // angle is in degree. Switch to radian
-    a = deg2rad(a);
+    return rotateRadians(deg2rad(a));
+}
+
+AffineTransform& AffineTransform::rotateRadians(double a)
+{
     double cosAngle = cos(a);
     double sinAngle = sin(a);
     AffineTransform rot(cosAngle, sinAngle, -sinAngle, cosAngle, 0, 0);
 
     multiply(rot);
     return *this;
 }
 
 AffineTransform& AffineTransform::scale(double s)
 {
@@ skipping 23 matching lines @@
     return *this;
 }
 
 AffineTransform& AffineTransform::scaleNonUniform(double sx, double sy)
 {
     return scale(sx, sy);
 }
 
 AffineTransform& AffineTransform::rotateFromVector(double x, double y)
 {
-    return rotate(rad2deg(atan2(y, x)));
+    return rotateRadians(atan2(y, x));
 }
 
 AffineTransform& AffineTransform::flipX()
 {
     return scale(-1, 1);
 }
 
 AffineTransform& AffineTransform::flipY()
 {
     return scale(1, -1);
@@ skipping 173 matching lines @@
             sy = -sy;
     }
 
     // Remove scale from matrix
     m.scale(1 / sx, 1 / sy);
 
     // Compute rotation
     double angle = atan2(m.b(), m.a());
 
     // Remove rotation from matrix
-    m.rotate(rad2deg(-angle));
+    m.rotateRadians(-angle);
 
     // Return results
     decomp.scaleX = sx;
     decomp.scaleY = sy;
     decomp.angle = angle;
     decomp.remainderA = m.a();
     decomp.remainderB = m.b();
     decomp.remainderC = m.c();
     decomp.remainderD = m.d();
     decomp.translateX = m.e();
     decomp.translateY = m.f();
 
     return true;
 }
 
 void AffineTransform::recompose(const DecomposedType& decomp)
 {
     this->setA(decomp.remainderA);
     this->setB(decomp.remainderB);
     this->setC(decomp.remainderC);
     this->setD(decomp.remainderD);
     this->setE(decomp.translateX);
     this->setF(decomp.translateY);
-    this->rotate(rad2deg(decomp.angle));
+    this->rotateRadians(decomp.angle);
     this->scale(decomp.scaleX, decomp.scaleY);
 }
 
 }