Migrate more functions from MathUtil to gfx::Transform

ui/gfx/transform.h

 // Copyright (c) 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 UI_GFX_TRANSFORM_H_
 #define UI_GFX_TRANSFORM_H_
 
 #include <string>
 
 #include "base/compiler_specific.h"
@@ skipping 19 matching lines @@
   Transform() : matrix_(SkMatrix44::kIdentity_Constructor) {}
 
   // Skips initializing this matrix to avoid overhead, when we know it will be
   // initialized before use.
   Transform(SkipInitialization)
       : matrix_(SkMatrix44::kUninitialized_Constructor) {}
   Transform(const Transform& rhs) : matrix_(rhs.matrix_) {}
   // Initialize with the concatenation of lhs * rhs.
   Transform(const Transform& lhs, const Transform& rhs)
       : matrix_(lhs.matrix_, rhs.matrix_) {}
+  // Constructs a transform from explicit 16 matrix elements. NOTE: Elements

[danakj, 2013/01/11 04:14:12]

nit: drop the NOTE? the variable names kinda say this already.

Or if you feel strongly, just drop the "NOTE: " part..

+  // should be given in row-major order.
+  Transform(double col1row1, double col2row1, double col3row1, double col4row1,
+            double col1row2, double col2row2, double col3row2, double col4row2,
+            double col1row3, double col2row3, double col3row3, double col4row3,
+            double col1row4, double col2row4, double col3row4, double col4row4);
+  // Constructs a transform from explicit 2d elements. All other matrix
+  // elements remain the same as the corresponding elements of an identity
+  // matrix.
+  Transform(double col1row1, double col2row1,
+            double col1row2, double col2row2,
+            double x_translation, double y_translation);
   ~Transform() {}
 
   bool operator==(const Transform& rhs) const { return matrix_ == rhs.matrix_; }
   bool operator!=(const Transform& rhs) const { return matrix_ != rhs.matrix_; }
 
   // Resets this transform to the identity transform.
   void MakeIdentity() { matrix_.setIdentity(); }
 
   // Applies the current transformation on a 2d rotation and assigns the result
   // to |this|.
@@ skipping 63 matching lines @@
   // Returns true if a layer with a forward-facing normal of (0, 0, 1) would
   // have its back side facing frontwards after applying the transform.
   bool IsBackFaceVisible() const;
 
   // Inverts the transform which is passed in. Returns true if successful.
   bool GetInverse(Transform* transform) const WARN_UNUSED_RESULT;
 
   // Transposes this transform in place.
   void Transpose();
 
+  // Set 3rd row and 3rd colum to (0, 0, 1, 0). Note that this flattening
+  // operation is not quite the same as an orthographic projection and is
+  // technically not a linear operation.
+  //
+  // One useful interpretation of doing this operation:
+  //  - For x and y values, the new transform behaves effectively like an
+  //    orthographic projection was added to the matrix sequence.
+  //  - For z values, the new transform overrides any effect that the transform
+  //    had on z, and instead it preserves the z value for any points that are
+  //    transformed.
+  //  - Because of linearity of transforms, this flattened transform also
+  //    preserves the effect that any subsequent (multiplied from the right)
+  //    transforms would have on z values.
+  //
+  void FlattenTo2d();
+
   // Applies the transformation on the point. Returns true if the point is
   // transformed successfully.
   void TransformPoint(Point3F& point) const;
 
   // Applies the transformation on the point. Returns true if the point is
   // transformed successfully. Rounds the result to the nearest point.
   void TransformPoint(Point& point) const;
 
   // Applies the reverse transformation on the point. Returns true if the
   // transformation can be inverted.
@@ skipping 50 matching lines @@
                               Point3F& point) const;
 
   SkMatrix44 matrix_;
 
   // copy/assign are allowed.
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_TRANSFORM_H_