Migrate from MathUtil::inverse() to gfx::Transform::GetInverse()

BUG=159972, 163769

Review URL: https://codereview.chromium.org/11644008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@175363 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 109 insertions, 106 deletions

diff --git a/cc/direct_renderer.cc b/cc/direct_renderer.cc
index 70522f2..e96cc41 100644
--- a/cc/direct_renderer.cc
+++ b/cc/direct_renderer.cc
@@ -185,9 +185,12 @@ gfx::RectF DirectRenderer::computeScissorRectForRenderPass(const DrawingFrame& f
     if (frame.rootDamageRect == frame.rootRenderPass->output_rect)
         return renderPassScissor;
 
-    gfx::Transform inverseTransform = MathUtil::inverse(frame.currentRenderPass->transform_to_root_target);
-    gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransform, frame.rootDamageRect);
-    renderPassScissor.Intersect(damageRectInRenderPassSpace);
+    gfx::Transform inverseTransform(gfx::Transform::kSkipInitialization);
+    if (frame.currentRenderPass->transform_to_root_target.GetInverse(&inverseTransform)) {
+        // Only intersect inverse-projected damage if the transform is invertible.
+        gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransform, frame.rootDamageRect);
+        renderPassScissor.Intersect(damageRectInRenderPassSpace);
+    }
 
     return renderPassScissor;
 }
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index 8f03721..54eef96 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -521,10 +521,10 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
     gfx::Transform contentsDeviceTransform = MathUtil::to2dTransform(frame.windowMatrix * frame.projectionMatrix * quadRectMatrix);
 
     // Can only draw surface if device matrix is invertible.
-    if (!contentsDeviceTransform.IsInvertible())
+    gfx::Transform contentsDeviceTransformInverse(gfx::Transform::kSkipInitialization);
+    if (!contentsDeviceTransform.GetInverse(&contentsDeviceTransformInverse))
         return;
 
-    gfx::Transform contentsDeviceTransformInverse = MathUtil::inverse(contentsDeviceTransform);
     scoped_ptr<ScopedResource> backgroundTexture = drawBackgroundFilters(
         frame, quad, contentsDeviceTransform, contentsDeviceTransformInverse);
 
@@ -861,8 +861,11 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
         LayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
 
         // Map device space quad to local space. deviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
-        gfx::Transform deviceTransformInverse = MathUtil::inverse(deviceTransform);
-        localQuad = MathUtil::mapQuad(deviceTransformInverse, deviceQuad.ToQuadF(), clipped);
+        // We should have already checked that the transform was uninvertible above.
+        gfx::Transform inverseDeviceTransform(gfx::Transform::kSkipInitialization);
+        bool didInvert = deviceTransform.GetInverse(&inverseDeviceTransform);
+        DCHECK(didInvert);
+        localQuad = MathUtil::mapQuad(inverseDeviceTransform, deviceQuad.ToQuadF(), clipped);
 
         // We should not DCHECK(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
         // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.
diff --git a/cc/layer_impl.cc b/cc/layer_impl.cc
index d0eafe3..4ab9989 100644
--- a/cc/layer_impl.cc
+++ b/cc/layer_impl.cc
@@ -245,7 +245,14 @@ InputHandlerClient::ScrollStatus LayerImpl::tryScroll(const gfx::PointF& screenS
 
     if (!nonFastScrollableRegion().IsEmpty()) {
         bool clipped = false;
-        gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(MathUtil::inverse(screenSpaceTransform()), screenSpacePoint, clipped);
+        gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
+        if (!screenSpaceTransform().GetInverse(&inverseScreenSpaceTransform)) {
+            // TODO(shawnsingh): We shouldn't be applying a projection if screen space
+            // transform is uninvertible here. Perhaps we should be returning
+            // ScrollOnMainThread in this case?
+        }
+
+        gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, clipped);
         gfx::PointF hitTestPointInLayerSpace = gfx::ScalePoint(hitTestPointInContentSpace, 1 / contentsScaleX(), 1 / contentsScaleY());
         if (!clipped && nonFastScrollableRegion().Contains(gfx::ToRoundedPoint(hitTestPointInLayerSpace))) {
             TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed nonFastScrollableRegion");
diff --git a/cc/layer_tree_host.cc b/cc/layer_tree_host.cc
index b85429e..390f001 100644
--- a/cc/layer_tree_host.cc
+++ b/cc/layer_tree_host.cc
@@ -780,7 +780,12 @@ gfx::PointF LayerTreeHost::adjustEventPointForPinchZoom(const gfx::PointF& zoome
 
     // Scale to screen space before applying implTransform inverse.
     gfx::PointF zoomedScreenspacePoint = gfx::ScalePoint(zoomedViewportPoint, deviceScaleFactor());
-    gfx::Transform inverseImplTransform = MathUtil::inverse(m_implTransform);
+
+    gfx::Transform inverseImplTransform(gfx::Transform::kSkipInitialization);
+    if (!m_implTransform.GetInverse(&inverseImplTransform)) {
+        // TODO(shawnsingh): Either we need to handle uninvertible transforms
+        // here, or DCHECK that the transform is invertible.
+    }
 
     bool wasClipped = false;
     gfx::PointF unzoomedScreenspacePoint = MathUtil::projectPoint(inverseImplTransform, zoomedScreenspacePoint, wasClipped);
diff --git a/cc/layer_tree_host_common.cc b/cc/layer_tree_host_common.cc
index 2210894..feba747 100644
--- a/cc/layer_tree_host_common.cc
+++ b/cc/layer_tree_host_common.cc
@@ -56,7 +56,12 @@ inline gfx::Rect calculateVisibleRectWithCachedLayerRect(const gfx::Rect& target
     // This bounding rectangle may be larger than it needs to be (being
     // axis-aligned), but is a reasonable filter on the space to consider.
     // Non-invertible transforms will create an empty rect here.
-    const gfx::Transform surfaceToLayer = MathUtil::inverse(transform);
+
+    gfx::Transform surfaceToLayer(gfx::Transform::kSkipInitialization);
+    if (!transform.GetInverse(&surfaceToLayer)) {
+        // TODO(shawnsingh): Either we need to handle uninvertible transforms
+        // here, or DCHECK that the transform is invertible.
+    }
     gfx::Rect layerRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(surfaceToLayer, gfx::RectF(minimalSurfaceRect)));
     layerRect.Intersect(layerBoundRect);
     return layerRect;
@@ -331,7 +336,13 @@ gfx::Transform computeScrollCompensationForThisLayer(LayerImpl* scrollingLayer,
 
     gfx::Transform scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
     scrollCompensationForThisLayer.Translate(scrollingLayer->scrollDelta().x(), scrollingLayer->scrollDelta().y()); // Step 2
-    scrollCompensationForThisLayer.PreconcatTransform(MathUtil::inverse(partialLayerOriginTransform)); // Step 1
+
+    gfx::Transform inversePartialLayerOriginTransform(gfx::Transform::kSkipInitialization);
+    if (!partialLayerOriginTransform.GetInverse(&inversePartialLayerOriginTransform)) {
+        // TODO(shawnsingh): Either we need to handle uninvertible transforms
+        // here, or DCHECK that the transform is invertible.
+    }
+    scrollCompensationForThisLayer.PreconcatTransform(inversePartialLayerOriginTransform); // Step 1
     return scrollCompensationForThisLayer;
 }
 
@@ -383,8 +394,14 @@ gfx::Transform computeScrollCompensationMatrixForChildren(LayerImpl* layer, cons
     //  Step 1 (right-most in the math): transform from the new surface to the original ancestor surface
     //  Step 2: apply the scroll compensation
     //  Step 3: transform back to the new surface.
-    if (layer->renderSurface() && !nextScrollCompensationMatrix.IsIdentity())
-        nextScrollCompensationMatrix = MathUtil::inverse(layer->renderSurface()->drawTransform()) * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
+    if (layer->renderSurface() && !nextScrollCompensationMatrix.IsIdentity()) {
+        gfx::Transform inverseSurfaceDrawTransform(gfx::Transform::kSkipInitialization);
+        if (!layer->renderSurface()->drawTransform().GetInverse(&inverseSurfaceDrawTransform)) {
+            // TODO(shawnsingh): Either we need to handle uninvertible transforms
+            // here, or DCHECK that the transform is invertible.
+        }
+        nextScrollCompensationMatrix = inverseSurfaceDrawTransform * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
+    }
 
     return nextScrollCompensationMatrix;
 }
@@ -746,7 +763,13 @@ static void calculateDrawPropertiesInternal(LayerType* layer, const gfx::Transfo
         renderSurface->setIsClipped(ancestorClipsSubtree);
         if (ancestorClipsSubtree) {
             renderSurface->setClipRect(clipRectFromAncestor);
-            clipRectForSubtreeInDescendantSpace = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(renderSurface->drawTransform()), renderSurface->clipRect()));
+
+            gfx::Transform inverseSurfaceDrawTransform(gfx::Transform::kSkipInitialization);
+            if (!renderSurface->drawTransform().GetInverse(&inverseSurfaceDrawTransform)) {
+                // TODO(shawnsingh): Either we need to handle uninvertible transforms
+                // here, or DCHECK that the transform is invertible.
+            }
+            clipRectForSubtreeInDescendantSpace = gfx::ToEnclosingRect(MathUtil::projectClippedRect(inverseSurfaceDrawTransform, renderSurface->clipRect()));
         } else {
             renderSurface->setClipRect(gfx::Rect());
             clipRectForSubtreeInDescendantSpace = clipRectFromAncestorInDescendantSpace;
@@ -1008,12 +1031,13 @@ void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gf
 static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
-    if (!localSpaceToScreenSpaceTransform.IsInvertible())
+    gfx::Transform inverseLocalSpaceToScreenSpace(gfx::Transform::kSkipInitialization);
+    if (!localSpaceToScreenSpaceTransform.GetInverse(&inverseLocalSpaceToScreenSpace))
         return false;
 
     // Transform the hit test point from screen space to the local space of the given rect.
     bool clipped = false;
-    gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(MathUtil::inverse(localSpaceToScreenSpaceTransform), screenSpacePoint, clipped);
+    gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(inverseLocalSpaceToScreenSpace, screenSpacePoint, clipped);
 
     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect.
     if (clipped)
@@ -1025,12 +1049,13 @@ static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transf
 static bool pointHitsRegion(gfx::PointF screenSpacePoint, const gfx::Transform& screenSpaceTransform, const Region& layerSpaceRegion, float layerContentScaleX, float layerContentScaleY)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this region.
-    if (!screenSpaceTransform.IsInvertible())
+    gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
+    if (!screenSpaceTransform.GetInverse(&inverseScreenSpaceTransform))
         return false;
 
     // Transform the hit test point from screen space to the local space of the given region.
     bool clipped = false;
-    gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(MathUtil::inverse(screenSpaceTransform), screenSpacePoint, clipped);
+    gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, clipped);
     gfx::PointF hitTestPointInLayerSpace = gfx::ScalePoint(hitTestPointInContentSpace, 1 / layerContentScaleX, 1 / layerContentScaleY);
 
     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this region.
diff --git a/cc/layer_tree_host_common_unittest.cc b/cc/layer_tree_host_common_unittest.cc
index 25ff83d..9d5a190 100644
--- a/cc/layer_tree_host_common_unittest.cc
+++ b/cc/layer_tree_host_common_unittest.cc
@@ -209,7 +209,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)
     // Case 6: The layer transform should occur with respect to the anchor point.
     gfx::Transform translationToAnchor;
     translationToAnchor.Translate(5, 0);
-    gfx::Transform expectedResult = translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
+    gfx::Transform expectedResult = translationToAnchor * layerTransform * inverse(translationToAnchor);
     setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, gfx::PointF(0.5, 0), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     executeCalculateDrawProperties(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());
@@ -218,7 +218,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleLayer)
     // Case 7: Verify that position pre-multiplies the layer transform.
     //         The current implementation of calculateDrawProperties does this implicitly, but it is
     //         still worth testing to detect accidental regressions.
-    expectedResult = positionTransform * translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
+    expectedResult = positionTransform * translationToAnchor * layerTransform * inverse(translationToAnchor);
     setLayerPropertiesForTesting(layer.get(), layerTransform, identityMatrix, gfx::PointF(0.5, 0), gfx::PointF(0, 1.2f), gfx::Size(10, 12), false);
     executeCalculateDrawProperties(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedResult, layer->drawTransform());
@@ -266,7 +266,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)
     parentLayerTransform.Scale3d(2, 2, 1);
     gfx::Transform parentTranslationToAnchor;
     parentTranslationToAnchor.Translate(2.5, 3);
-    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor);
+    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * inverse(parentTranslationToAnchor);
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, identityMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
@@ -285,8 +285,8 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSimpleHierarchy)
     gfx::Transform parentTranslationToCenter;
     parentTranslationToCenter.Translate(5, 6);
     // Sublayer matrix is applied to the center of the parent layer.
-    parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
-            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
+    parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * inverse(parentTranslationToCenter);
     gfx::Transform flattenedCompositeTransform = MathUtil::to2dTransform(parentCompositeTransform);
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
@@ -335,12 +335,12 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForSingleRenderSurface)
     parentSublayerMatrix.Scale3d(0.9, 1, 3.3);
     gfx::Transform parentTranslationToCenter;
     parentTranslationToCenter.Translate(50, 60);
-    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
-            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
+    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * inverse(parentTranslationToCenter);
     gfx::Vector2dF parentCompositeScale = MathUtil::computeTransform2dScaleComponents(parentCompositeTransform, 1.f);
     gfx::Transform surfaceSublayerTransform;
     surfaceSublayerTransform.Scale(parentCompositeScale.x(), parentCompositeScale.y());
-    gfx::Transform surfaceSublayerCompositeTransform = parentCompositeTransform * MathUtil::inverse(surfaceSublayerTransform);
+    gfx::Transform surfaceSublayerCompositeTransform = parentCompositeTransform * inverse(surfaceSublayerTransform);
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
@@ -394,8 +394,8 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForReplica)
     parentSublayerMatrix.Scale3d(10, 10, 3.3);
     gfx::Transform parentTranslationToCenter;
     parentTranslationToCenter.Translate(5, 6);
-    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * MathUtil::inverse(parentTranslationToAnchor)
-            * parentTranslationToCenter * parentSublayerMatrix * MathUtil::inverse(parentTranslationToCenter);
+    gfx::Transform parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * inverse(parentTranslationToAnchor)
+            * parentTranslationToCenter * parentSublayerMatrix * inverse(parentTranslationToCenter);
     gfx::Transform childTranslationToCenter;
     childTranslationToCenter.Translate(8, 9);
     gfx::Transform replicaLayerTransform;
@@ -403,7 +403,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForReplica)
     gfx::Vector2dF parentCompositeScale = MathUtil::computeTransform2dScaleComponents(parentCompositeTransform, 1.f);
     gfx::Transform surfaceSublayerTransform;
     surfaceSublayerTransform.Scale(parentCompositeScale.x(), parentCompositeScale.y());
-    gfx::Transform replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform * MathUtil::inverse(surfaceSublayerTransform);
+    gfx::Transform replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform * inverse(surfaceSublayerTransform);
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
@@ -481,9 +481,9 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)
     gfx::Transform replicaLayerTransform;
     replicaLayerTransform.Scale3d(-2, 5, 1);
 
-    gfx::Transform A = translationToAnchor * layerTransform * MathUtil::inverse(translationToAnchor);
-    gfx::Transform B = translationToCenter * sublayerTransform * MathUtil::inverse(translationToCenter);
-    gfx::Transform R = A * translationToAnchor * replicaLayerTransform * MathUtil::inverse(translationToAnchor);
+    gfx::Transform A = translationToAnchor * layerTransform * inverse(translationToAnchor);
+    gfx::Transform B = translationToCenter * sublayerTransform * inverse(translationToCenter);
+    gfx::Transform R = A * translationToAnchor * replicaLayerTransform * inverse(translationToAnchor);
 
     gfx::Vector2dF surface1ParentTransformScale = MathUtil::computeTransform2dScaleComponents(A * B, 1.f);
     gfx::Transform surface1SublayerTransform;
@@ -492,7 +492,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)
     // SS1 = transform given to the subtree of renderSurface1
     gfx::Transform SS1 = surface1SublayerTransform;
     // S1 = transform to move from renderSurface1 pixels to the layer space of the owning layer
-    gfx::Transform S1 = MathUtil::inverse(surface1SublayerTransform);
+    gfx::Transform S1 = inverse(surface1SublayerTransform);
 
     gfx::Vector2dF surface2ParentTransformScale = MathUtil::computeTransform2dScaleComponents(SS1 * A * B, 1.f);
     gfx::Transform surface2SublayerTransform;
@@ -501,7 +501,7 @@ TEST(LayerTreeHostCommonTest, verifyTransformsForRenderSurfaceHierarchy)
     // SS2 = transform given to the subtree of renderSurface2
     gfx::Transform SS2 = surface2SublayerTransform;
     // S2 = transform to move from renderSurface2 pixels to the layer space of the owning layer
-    gfx::Transform S2 = MathUtil::inverse(surface2SublayerTransform);
+    gfx::Transform S2 = inverse(surface2SublayerTransform);
 
     setLayerPropertiesForTesting(parent.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, gfx::PointF(0.25, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
@@ -1083,7 +1083,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithI
     // the correct space. This test will fail if the rotation/inverse are backwards, too,
     // so it requires perfect order of operations.
     expectedGreatGrandChildTransform.MakeIdentity();
-    expectedGreatGrandChildTransform.PreconcatTransform(MathUtil::inverse(rotationAboutZ));
+    expectedGreatGrandChildTransform.PreconcatTransform(inverse(rotationAboutZ));
     expectedGreatGrandChildTransform.Translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
     expectedGreatGrandChildTransform.PreconcatTransform(rotationAboutZ);
 
@@ -1191,7 +1191,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithM
     compoundDrawTransform.PreconcatTransform(rotationAboutZ); // rotation of greatGrandChild
 
     expectedFixedPositionChildTransform.MakeIdentity();
-    expectedFixedPositionChildTransform.PreconcatTransform(MathUtil::inverse(compoundDrawTransform));
+    expectedFixedPositionChildTransform.PreconcatTransform(inverse(compoundDrawTransform));
     expectedFixedPositionChildTransform.Translate(10, 30); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
     expectedFixedPositionChildTransform.PreconcatTransform(compoundDrawTransform);
 
@@ -1325,7 +1325,7 @@ TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatH
     // affected by the scrollDelta, so its drawTransform needs to explicitly
     // inverse-compensate for the scroll that's embedded in the target surface.
     gfx::Transform expectedGrandChildTransform;
-    expectedGrandChildTransform.PreconcatTransform(MathUtil::inverse(rotationByZ));
+    expectedGrandChildTransform.PreconcatTransform(inverse(rotationByZ));
     expectedGrandChildTransform.Translate(10, 20); // explicit canceling out the scrollDelta that gets embedded in the fixed position layer's surface.
     expectedGrandChildTransform.PreconcatTransform(rotationByZ);
 
@@ -2064,7 +2064,7 @@ TEST(LayerTreeHostCommonTest, verifyVisibleRectForPerspectiveUnprojection)
     // testing the intended scenario.
     bool clipped = false;
     gfx::RectF clippedRect = MathUtil::mapClippedRect(layerToSurfaceTransform, layerContentRect);
-    MathUtil::projectQuad(MathUtil::inverse(layerToSurfaceTransform), gfx::QuadF(clippedRect), clipped);
+    MathUtil::projectQuad(inverse(layerToSurfaceTransform), gfx::QuadF(clippedRect), clipped);
     ASSERT_TRUE(clipped);
 
     // Only the corner of the layer is not visible on the surface because of being
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 456fa01..7ce1bf1 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -489,8 +489,6 @@ static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* roo
     // doesn't have any bounds and so can't generate this itself.
     // FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
 
-    DCHECK(rootLayer->screenSpaceTransform().IsInvertible());
-
     gfx::Rect rootTargetRect = rootLayer->renderSurface()->contentRect();
     float opacity = 1;
     SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
@@ -502,10 +500,13 @@ static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* roo
                             opacity);
 
     AppendQuadsData appendQuadsData;
-    gfx::Transform transformToLayerSpace = MathUtil::inverse(rootLayer->screenSpaceTransform());
+
+    gfx::Transform transformToLayerSpace(gfx::Transform::kSkipInitialization);
+    bool didInvert = rootLayer->screenSpaceTransform().GetInverse(&transformToLayerSpace);
+    DCHECK(didInvert);
     for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
         // The root layer transform is composed of translations and scales only,
-        // no perspective, so mapping is sufficient.
+        // no perspective, so mapping is sufficient (as opposed to projecting).
         gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
         // Skip the quad culler and just append the quads directly to avoid
         // occlusion checks.
@@ -1257,7 +1258,11 @@ static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewp
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     DCHECK(layerImpl.screenSpaceTransform().IsInvertible());
-    gfx::Transform inverseScreenSpaceTransform = MathUtil::inverse(layerImpl.screenSpaceTransform());
+    gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
+    bool didInvert = layerImpl.screenSpaceTransform().GetInverse(&inverseScreenSpaceTransform);
+    // TODO: With the advent of impl-side crolling for non-root layers, we may
+    // need to explicitly handle uninvertible transforms here.
+    DCHECK(didInvert);
 
     gfx::PointF screenSpacePoint = gfx::ScalePoint(viewportPoint, scaleFromViewportToScreenSpace);
 
diff --git a/cc/math_util.cc b/cc/math_util.cc
index 38b609b..8796504 100644
--- a/cc/math_util.cc
+++ b/cc/math_util.cc
@@ -422,18 +422,6 @@ void MathUtil::rotateEulerAngles(gfx::Transform* transform, double eulerX, doubl
     transform->PreconcatTransform(composite);
 }
 
-gfx::Transform MathUtil::inverse(const gfx::Transform& transform)
-{
-    gfx::Transform result;
-    bool invertedSuccessfully = transform.GetInverse(&result);
-
-    if (invertedSuccessfully)
-        return result;
-
-    // If transform was un-invertible, then just return identity.
-    return gfx::Transform();
-}
-
 gfx::Transform MathUtil::to2dTransform(const gfx::Transform& transform)
 {
     gfx::Transform result = transform;
diff --git a/cc/math_util.h b/cc/math_util.h
index d47c80a..a3a6016 100644
--- a/cc/math_util.h
+++ b/cc/math_util.h
@@ -121,7 +121,6 @@ public:
     // TODO(shawnsingh, vollick) we should phase out as much as possible of
     // these temporary functions, putting functionality into gfx::Transform.
     static void rotateEulerAngles(gfx::Transform*, double eulerX, double eulerY, double eulerZ);
-    static gfx::Transform inverse(const gfx::Transform&);
     static gfx::Transform to2dTransform(const gfx::Transform&);
     // Note carefully: the args here are labeled as per Webcore indexing conventions.
     static gfx::Transform createGfxTransform(double m11, double m12, double m13, double m14,
diff --git a/cc/math_util_unittest.cc b/cc/math_util_unittest.cc
index 0aa0523..6dc2ced 100644
--- a/cc/math_util_unittest.cc
+++ b/cc/math_util_unittest.cc
@@ -325,51 +325,6 @@ TEST(MathUtilGfxTransformTest, verifyCopyConstructor)
     EXPECT_ROW4_EQ(13, 17, 21, 25, B);
 }
 
-TEST(MathUtilGfxTransformTest, verifyMatrixInversion)
-{
-    // Invert a translation
-    gfx::Transform translation;
-    translation.Translate3d(2, 3, 4);
-    EXPECT_TRUE(translation.IsInvertible());
-
-    gfx::Transform inverseTranslation = MathUtil::inverse(translation);
-    EXPECT_ROW1_EQ(1, 0, 0, -2, inverseTranslation);
-    EXPECT_ROW2_EQ(0, 1, 0, -3, inverseTranslation);
-    EXPECT_ROW3_EQ(0, 0, 1, -4, inverseTranslation);
-    EXPECT_ROW4_EQ(0, 0, 0,  1, inverseTranslation);
-
-    // Note that inversion should not have changed the original matrix.
-    EXPECT_ROW1_EQ(1, 0, 0, 2, translation);
-    EXPECT_ROW2_EQ(0, 1, 0, 3, translation);
-    EXPECT_ROW3_EQ(0, 0, 1, 4, translation);
-    EXPECT_ROW4_EQ(0, 0, 0, 1, translation);
-
-    // Invert a non-uniform scale
-    gfx::Transform scale;
-    scale.Scale3d(4, 10, 100);
-    EXPECT_TRUE(scale.IsInvertible());
-
-    gfx::Transform inverseScale = MathUtil::inverse(scale);
-    EXPECT_ROW1_EQ(0.25,   0,    0, 0, inverseScale);
-    EXPECT_ROW2_EQ(0,    .1f,    0, 0, inverseScale);
-    EXPECT_ROW3_EQ(0,      0, .01f, 0, inverseScale);
-    EXPECT_ROW4_EQ(0,      0,    0, 1, inverseScale);
-
-    // Try to invert a matrix that is not invertible.
-    // The inverse() function should simply return an identity matrix.
-    gfx::Transform notInvertible;
-    notInvertible.matrix().setDouble(0, 0, 0);
-    notInvertible.matrix().setDouble(1, 1, 0);
-    notInvertible.matrix().setDouble(2, 2, 0);
-    notInvertible.matrix().setDouble(3, 3, 0);
-    EXPECT_FALSE(notInvertible.IsInvertible());
-
-    gfx::Transform inverseOfNotInvertible;
-    initializeTestMatrix(&inverseOfNotInvertible); // initialize this to something non-identity, to make sure that assignment below actually took place.
-    inverseOfNotInvertible = MathUtil::inverse(notInvertible);
-    EXPECT_TRUE(inverseOfNotInvertible.IsIdentity());
-}
-
 TEST(MathUtilGfxTransformTest, verifyTo2DTransform)
 {
     gfx::Transform A;
diff --git a/cc/occlusion_tracker.cc b/cc/occlusion_tracker.cc
index e71c678..c053fda 100644
--- a/cc/occlusion_tracker.cc
+++ b/cc/occlusion_tracker.cc
@@ -54,7 +54,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::leaveLayer(const LayerI
 template<typename RenderSurfaceType>
 static gfx::Rect screenSpaceClipRectInTargetSurface(const RenderSurfaceType* targetSurface, gfx::Rect screenSpaceClipRect)
 {
-    gfx::Transform inverseScreenSpaceTransform;
+    gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
     if (!targetSurface->screenSpaceTransform().GetInverse(&inverseScreenSpaceTransform))
         return targetSurface->contentRect();
 
@@ -124,7 +124,7 @@ void OcclusionTrackerBase<LayerType, RenderSurfaceType>::enterRenderTarget(const
     bool enteringSubtreeThatMovesPixels = newAncestorThatMovesPixels && newAncestorThatMovesPixels != oldAncestorThatMovesPixels;
 
     bool haveTransformFromScreenToNewTarget = false;
-    gfx::Transform inverseNewTargetScreenSpaceTransform;
+    gfx::Transform inverseNewTargetScreenSpaceTransform(gfx::Transform::kSkipInitialization); // Note carefully, not used if screen space transform is uninvertible.
     if (surfaceTransformsToScreenKnown(newTarget->renderSurface()))
         haveTransformFromScreenToNewTarget = newTarget->renderSurface()->screenSpaceTransform().GetInverse(&inverseNewTargetScreenSpaceTransform);
 
@@ -353,7 +353,7 @@ bool OcclusionTrackerBase<LayerType, RenderSurfaceType>::occluded(const LayerTyp
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
-    gfx::Transform inverseDrawTransform;
+    gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return false;
 
@@ -396,7 +396,7 @@ gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContentR
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
-    gfx::Transform inverseDrawTransform;
+    gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return contentRect;
 
@@ -445,7 +445,7 @@ gfx::Rect OcclusionTrackerBase<LayerType, RenderSurfaceType>::unoccludedContribu
         return contentRect;
 
     gfx::Transform drawTransform = forReplica ? surface->replicaDrawTransform() : surface->drawTransform();
-    gfx::Transform inverseDrawTransform;
+    gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return contentRect;
 
diff --git a/cc/test/geometry_test_utils.cc b/cc/test/geometry_test_utils.cc
index bed04c4..385dbac 100644
--- a/cc/test/geometry_test_utils.cc
+++ b/cc/test/geometry_test_utils.cc
@@ -4,6 +4,7 @@
 
 #include "cc/test/geometry_test_utils.h"
 
+#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformationMatrix.h"
 #include "ui/gfx/transform.h"
@@ -56,4 +57,12 @@ void ExpectTransformationMatrixEq(const gfx::Transform& expected,
     EXPECT_FLOAT_EQ((expected).matrix().getDouble(3, 3), (actual).matrix().getDouble(3, 3));
 }
 
+gfx::Transform inverse(const gfx::Transform& transform)
+{
+    gfx::Transform result(gfx::Transform::kSkipInitialization);
+    bool invertedSuccessfully = transform.GetInverse(&result);
+    DCHECK(invertedSuccessfully);
+    return result;
+}
+
 }  // namespace cc
diff --git a/cc/test/geometry_test_utils.h b/cc/test/geometry_test_utils.h
index 30260c1..0bcb99e 100644
--- a/cc/test/geometry_test_utils.h
+++ b/cc/test/geometry_test_utils.h
@@ -73,6 +73,10 @@ void ExpectTransformationMatrixEq(const WebKit::WebTransformationMatrix& expecte
         cc::ExpectTransformationMatrixEq(expected, actual);          \
     }
 
+// Should be used in test code only, for convenience. Production code should use
+// the gfx::Transform::GetInverse() API.
+gfx::Transform inverse(const gfx::Transform& transform);
+
 }  // namespace cc
 
 #endif  // CC_TEST_GEOMETRY_TEST_UTILS_H_