Implement unit tests and temporary MathUtil wrappers for transform functionality

cc/math_util.h

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_MATH_UTIL_H_
 #define CC_MATH_UTIL_H_
 
 #include "base/logging.h"
 #include "cc/cc_export.h"
 #include "ui/gfx/point_f.h"
 #include "ui/gfx/point3_f.h"
+#include "ui/gfx/transform.h"
 
 namespace WebKit {
 class WebTransformationMatrix;
 }
 
 namespace gfx {
 class QuadF;
 class Rect;
 class RectF;
 class Vector2dF;
@@ skipping 86 matching lines @@
     static void flattenTransformTo2d(WebKit::WebTransformationMatrix&);
 
     static gfx::Vector2dF computeTransform2dScaleComponents(const WebKit::WebTransformationMatrix&);
 
     // Returns the smallest angle between the given two vectors in degrees. Neither vector is
     // assumed to be normalized.
     static float smallestAngleBetweenVectors(gfx::Vector2dF, gfx::Vector2dF);
 
     // Projects the |source| vector onto |destination|. Neither vector is assumed to be normalized.
     static gfx::Vector2dF projectVector(gfx::Vector2dF source, gfx::Vector2dF destination);
+
+    // Temporary API to ease migration from WebKit::WebTransformationMatrix
+    // to gfx::Transform.
+    //
+    // TODO(shawnsingh, vollick) we should phase out as much as possible of
+    // these temporary functions, putting functionality into gfx::Transform.
+    static bool isInvertible(const gfx::Transform&);
+    static bool isBackFaceVisible(const gfx::Transform&);
+    static bool isIdentity(const gfx::Transform&);
+    static bool isIdentityOrTranslation(const gfx::Transform&);
+    static bool hasPerspective(const gfx::Transform&);
+    static void makeIdentity(gfx::Transform*);

[Ian Vollick, 2012/11/16 13:44:46]

Would transform = gfx::Transform() suffice?

[danakj, 2012/11/16 16:25:15]

I've seen a pattern in the existing classes to provide both operator= and method
setters, such as SetRect(x,y,w,h). I think a MakeIdentity() follows the existing
pattern allowing one to avoid allocating and assigning.

+    static void rotateEulerAngles(gfx::Transform*, float eulerX, float eulerY, float eulerZ); // TODO: verify old webcore API was euler angles?

[Ian Vollick, 2012/11/16 13:44:46]

These should be doubles now that gfx::Transform is backed by doubles. This goes
for the functions below as well.

+    static void rotateAxisAngle(gfx::Transform*, float i, float j, float k, float degrees);
+    static gfx::Transform inverse(const gfx::Transform&);

[Ian Vollick, 2012/11/16 13:44:46]

I think this should be pulled from the API. gfx::Transform already has an
inverse and unlike this function, it's able to report when we can't invert due
to a singular matrix (which, now that I'm looking at it, should use
WARN_UNUSED_RESULT). Although we have an isInvertible function above, there's no
way to guarantee that people have used it before calling inverse. In the same
way that we want to force people to consider clipping when mapping points, we
should also force people to consider singular matrices.

[shawnsingh, 2012/11/17 00:38:31]

As mentioned above, I agree with this, but I would like to keep this for
migration purposes for now, to keep migration less complicated. hope that's OK
=)

+    static gfx::Transform to2dTransform(const gfx::Transform&);
+    static gfx::Transform toGfxTransform(const WebKit::WebTransformationMatrix&);
+    // Note carefully: the args here are labeled as per Webcore indexing conventions.
+    static gfx::Transform createGfxTransform(float m11, float m12, float m13, float m14,
+                                             float m21, float m22, float m23, float m24,
+                                             float m31, float m32, float m33, float m34,
+                                             float m41, float m42, float m43, float m44);

[Ian Vollick, 2012/11/16 13:44:46]

This is a bit of a matter of preference, but I prefer to interpret WebCore's mXY
as column X, row Y -- that is, I like to think of us multipling our
points/vectors on the right.  So m41 (i.e., translateX) would be in the upper
right -- as in, http://www.songho.ca/opengl/gl_transform.html. It's the way I'm
used to thinking about transformation matrices. That said, other people think
about things transposed and multiply their vectors on the left -- D3D does:
http://msdn.microsoft.com/en-us/library/windows/desktop/bb172573(v=vs.85).aspx.
Although this layout of arguments may be consistent with our storage,  I'd
prefer to transpose them. Also, the comments in layer_tree_host_common also
suggest that we accumulate matrices on the right, so transposing these would
make us consistent with that comment.

[shawnsingh, 2012/11/17 00:38:31]

Same goes for this comment - this wrapper simply exists so that migration is
simpler.  We can discuss transposing it after migration.  I like the idea that
it would be formatted visually so that rows are actually rows in the code.

+
+    static gfx::Transform createGfxTransform(float a, float b, float c,
+                                             float d, float e, float f);
 };
 
+// TODO(shawnsingh, vollick) this is a temporary home, should eventually
+// be phased out in favor of gfx::Transform API.
+gfx::Transform operator*(const gfx::Transform&, const gfx::Transform&);
+
 } // namespace cc
 
 #endif  // CC_MATH_UTIL_H_