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

cc/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 504 matching lines @@
 {
     CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     gfx::Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
     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);
 
     // FIXME: Cache this value so that we don't have to do it for both the surface and its replica.
     // Apply filters to the contents texture.
     SkBitmap filterBitmap;
     if (quad->filter) {
         filterBitmap = applyImageFilter(this, quad->filter.get(), contentsTexture, m_client->hasImplThread());
     } else {
         filterBitmap = applyFilters(this, quad->filters, contentsTexture, m_client->hasImplThread());
@@ skipping 316 matching lines @@
         float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
         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.
     } else {
         // Move fragment shader transform to vertex shader. We can do this while
         // still producing correct results as fragmentTexTransformLocation
         // should always be non-negative when tiles are transformed in a way
         // that could result in sampling outside the layer.
         vertexTexScaleX *= fragmentTexScaleX;
         vertexTexScaleY *= fragmentTexScaleY;
@@ skipping 914 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc