Move temporary MathUtil wrappers to permanent home in gfx::Transform

cc/layer_tree_host_common.cc

 // Copyright 2011 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.
 
 #include "cc/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 67 matching lines @@
 
 template<typename LayerType>
 static bool isLayerBackFaceVisible(LayerType* layer)
 {
     // The current W3C spec on CSS transforms says that backface visibility should be
     // determined differently depending on whether the layer is in a "3d rendering
     // context" or not. For Chromium code, we can determine whether we are in a 3d
     // rendering context by checking if the parent preserves 3d.
 
     if (layerIsInExisting3DRenderingContext(layer))
-        return MathUtil::isBackFaceVisible(layer->drawTransform());
+        return layer->drawTransform().IsBackFaceVisible();
 
     // In this case, either the layer establishes a new 3d rendering context, or is not in
     // a 3d rendering context at all.
-    return MathUtil::isBackFaceVisible(layer->transform());
+    return layer->transform().IsBackFaceVisible();
 }
 
 template<typename LayerType>
 static bool isSurfaceBackFaceVisible(LayerType* layer, const gfx::Transform& drawTransform)
 {
     if (layerIsInExisting3DRenderingContext(layer))
-        return MathUtil::isBackFaceVisible(drawTransform);
+        return drawTransform.IsBackFaceVisible();
 
     if (isRootLayerOfNewRenderingContext(layer))
-        return MathUtil::isBackFaceVisible(layer->transform());
+        return layer->transform().IsBackFaceVisible();
 
     // If the renderSurface is not part of a new or existing rendering context, then the
     // layers that contribute to this surface will decide back-face visibility for themselves.
     return false;
 }
 
 template<typename LayerType>
 static inline bool layerClipsSubtree(LayerType* layer)
 {
     return layer->masksToBounds() || layer->maskLayer();
@@ skipping 20 matching lines @@
         targetSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(layer->renderTarget()->renderSurface()->drawTransform()), layer->renderTarget()->renderSurface()->clipRect()));
         targetSurfaceClipRect.Intersect(layer->drawableContentRect());
     }
 
     if (targetSurfaceClipRect.IsEmpty())
         return gfx::Rect();
 
     return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, gfx::Rect(gfx::Point(), layer->contentBounds()), layer->drawTransform());
 }
 
-static bool isScaleOrTranslation(const gfx::Transform& m)
-{
-    return !m.matrix().getDouble(1, 0) && !m.matrix().getDouble(2, 0) && !m.matrix().getDouble(3, 0)
-           && !m.matrix().getDouble(0, 1) && !m.matrix().getDouble(2, 1) && !m.matrix().getDouble(3, 1)
-           && !m.matrix().getDouble(0, 2) && !m.matrix().getDouble(1, 2) && !m.matrix().getDouble(2, 3)
-           && m.matrix().getDouble(3, 3);
-}
-
 static inline bool transformToParentIsKnown(LayerImpl*)
 {
     return true;
 }
 
 static inline bool transformToParentIsKnown(Layer* layer)
 {
     return !layer->transformIsAnimating();
 }
 
@@ skipping 382 matching lines @@
 
     gfx::RectF contentRect(gfx::PointF(), layer->contentBounds());
 
     // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurfaceImpl's space.
     // nextHierarchyMatrix will only change if this layer uses a new RenderSurfaceImpl, otherwise remains the same.
     gfx::Transform nextHierarchyMatrix = fullHierarchyMatrix;
     gfx::Transform sublayerMatrix;
 
     gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
 
-    if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
+    if (subtreeShouldRenderToSeparateSurface(layer, combinedTransform.IsScaleOrTranslation())) {
         // Check back-face visibility before continuing with this surface and its subtree
         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
             return;
 
         if (!layer->renderSurface())
             layer->createRenderSurface();
 
         RenderSurfaceType* renderSurface = layer->renderSurface();
         renderSurface->clearLayerLists();
 
@@ skipping 422 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 }  // namespace cc