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

cc/direct_renderer.cc

 // Copyright 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.
 
 #include "cc/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
@@ skipping 167 matching lines @@
     renderPassesInDrawOrder.clear();
 }
 
 gfx::RectF DirectRenderer::computeScissorRectForRenderPass(const DrawingFrame& frame)
 {
     gfx::RectF renderPassScissor = frame.currentRenderPass->output_rect;
 
     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)) {

[danakj, 2013/01/02 14:45:16]

I'm still not a fan that after the if() statement, if it was false, you have an
inverseTransform variable that is uninitialized data.

I don't see why setting the transform to identity in GetInverse() when it is
going to return false makes this patch any harder to merge back to M25?

Also, I don't expect it would have any impact on perftest at all?

[shawnsingh, 2013/01/02 18:36:01]

The performance improvement comes from avoiding duplicate initialization,
mostly, with kSkipInitialization.  It possibly also comes from initializing by
reference arg rather than return value, but last I checked RVO was working fine
at least on linux.

Yes, I suppose we can initialize-to-identity in the gfx::Transform::GetInverse()
function itself.  I didn't realize that's what you had intended.   

The "harder to merge" part I was concerned about is the changing of semantics to
properly handle all the cases that we are currently not handling correctly - we
should simply never be using the transform if GetInverse returns false.  This
patch doesn't address that issue, and I don't think it should =)

+        // Only intersect inverse-projected damage if the transform is invertible.
+        gfx::RectF damageRectInRenderPassSpace = MathUtil::projectClippedRect(inverseTransform, frame.rootDamageRect);
+        renderPassScissor.Intersect(damageRectInRenderPassSpace);
+    }
 
     return renderPassScissor;
 }
 
 void DirectRenderer::setScissorStateForQuad(const DrawingFrame& frame, const DrawQuad& quad)
 {
     if (quad.isClipped()) {
         gfx::RectF quadScissorRect = quad.clipRect();
         setScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
     }
@@ skipping 93 matching lines @@
     return pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc