Migrate more functions from MathUtil to 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 "base/debug/trace_event.h"
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_sorter.h"
 #include "cc/math_util.h"
 #include "cc/render_surface.h"
 #include "cc/render_surface_impl.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
+#include "ui/gfx/transform_util.h"
 
 namespace cc {
 
 ScrollAndScaleSet::ScrollAndScaleSet()
 {
 }
 
 ScrollAndScaleSet::~ScrollAndScaleSet()
 {
 }
@@ skipping 633 matching lines @@
 
     // The drawTransform that gets computed below is effectively the layer's drawTransform, unless
     // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms.
     layerDrawProperties.target_space_transform = combinedTransform;
     // M[draw] = M[parent] * LT * S[layer2content]
     layerDrawProperties.target_space_transform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     layerDrawProperties.screen_space_transform = fullHierarchyMatrix;
     if (!layer->preserves3D())
-        MathUtil::flattenTransformTo2d(layerDrawProperties.screen_space_transform);
+        gfx::FlattenTransformTo2d(layerDrawProperties.screen_space_transform);
     layerDrawProperties.screen_space_transform.PreconcatTransform(layerDrawProperties.target_space_transform);
 
     // Adjusting text AA method during animation may cause repaints, which in-turn causes jank.
     bool adjustTextAA = !animatingOpacityToScreen && !animatingTransformToScreen;
     // To avoid color fringing, LCD text should only be used on opaque layers with just integral translation.
     bool layerCanUseLCDText = subtreeCanUseLCDText &&
                               (accumulatedDrawOpacity == 1.0) &&
                               layerDrawProperties.target_space_transform.IsIdentityOrIntegerTranslation();
 
     gfx::RectF contentRect(gfx::PointF(), layer->contentBounds());
@@ skipping 133 matching lines @@
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (!layer->preserves3D())
-        MathUtil::flattenTransformTo2d(sublayerMatrix);
+        gfx::FlattenTransformTo2d(sublayerMatrix);
 
     // Apply the sublayer transform at the center of the layer.
     if (!layer->sublayerTransform().IsIdentity()) {
         sublayerMatrix.Translate(0.5 * bounds.width(), 0.5 * bounds.height());
         sublayerMatrix.PreconcatTransform(layer->sublayerTransform());
         sublayerMatrix.Translate(-0.5 * bounds.width(), -0.5 * bounds.height());
     }
 
     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
 
@@ skipping 315 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc