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

cc/occlusion_tracker.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/occlusion_tracker.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 38 matching lines @@
 
     if (layerIterator.representsItself)
         markOccludedBehindLayer(layerIterator.currentLayer);
     else if (layerIterator.representsContributingRenderSurface)
         leaveToRenderTarget(renderTarget);
 }
 
 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();
 
     return gfx::ToEnclosingRect(MathUtil::projectClippedRect(inverseScreenSpaceTransform, screenSpaceClipRect));
 }
 
 template<typename RenderSurfaceType>
 static Region transformSurfaceOpaqueRegion(const Region& region, bool haveClipRect, gfx::Rect clipRectInNewTarget, const gfx::Transform& transform)
 {
     if (region.IsEmpty())
@@ skipping 49 matching lines @@
 
     // We copy the screen occlusion into the new RenderSurface subtree, but we never copy in the
     // occlusion from inside the target, since we are looking at a new RenderSurface target.
 
     // If we are entering a subtree that is going to move pixels around, then the occlusion we've computed
     // so far won't apply to the pixels we're drawing here in the same way. We discard the occlusion thus
     // far to be safe, and ensure we don't cull any pixels that are moved such that they become visible.
     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);
 
     bool enteringRootTarget = newTarget->parent() == NULL;
 
     bool copyOutsideOcclusionForward = m_stack.size() > 1 && !enteringSubtreeThatMovesPixels && haveTransformFromScreenToNewTarget && !enteringRootTarget;
     if (!copyOutsideOcclusionForward)
         return;
 
     int lastIndex = m_stack.size() - 1;
@@ skipping 208 matching lines @@
         return false;
 
     // For tests with no render target.
     if (!renderTarget)
         return false;
 
     DCHECK(renderTarget->renderTarget() == renderTarget);
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
-    gfx::Transform inverseDrawTransform;
+    gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return false;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     gfx::Rect contentRectInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     contentRectInTargetSurface.Intersect(clippedRectInTarget);
     contentRectInTargetSurface.Intersect(screenSpaceClipRectInTargetSurface(renderTarget->renderSurface(), m_screenSpaceClipRect));
 
     Region unoccludedRegionInTargetSurface = contentRectInTargetSurface;
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromInsideTarget);
@@ skipping 22 matching lines @@
         return contentRect;
 
     // For tests with no render target.
     if (!renderTarget)
         return contentRect;
 
     DCHECK(renderTarget->renderTarget() == renderTarget);
     DCHECK(renderTarget->renderSurface());
     DCHECK(renderTarget == m_stack.back().target);
 
-    gfx::Transform inverseDrawTransform;
+    gfx::Transform inverseDrawTransform(gfx::Transform::kSkipInitialization);
     if (!drawTransform.GetInverse(&inverseDrawTransform))
         return contentRect;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     gfx::Rect contentRectInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     contentRectInTargetSurface.Intersect(clippedRectInTarget);
     contentRectInTargetSurface.Intersect(screenSpaceClipRectInTargetSurface(renderTarget->renderSurface(), m_screenSpaceClipRect));
 
     Region unoccludedRegionInTargetSurface = contentRectInTargetSurface;
     unoccludedRegionInTargetSurface.Subtract(m_stack.back().occlusionFromInsideTarget);
@@ skipping 28 matching lines @@
     if (contentRect.IsEmpty())
         return contentRect;
 
     const RenderSurfaceType* surface = layer->renderSurface();
     const LayerType* contributingSurfaceRenderTarget = layer->parent()->renderTarget();
 
     if (!surfaceTransformsToTargetKnown(surface))
         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;
 
     // Take the ToEnclosingRect at each step, as we want to contain any unoccluded partial pixels in the resulting Rect.
     gfx::Rect contentRectInTargetSurface = gfx::ToEnclosingRect(MathUtil::mapClippedRect(drawTransform, gfx::RectF(contentRect)));
     if (surface->isClipped()) {
         contentRectInTargetSurface.Intersect(surface->clipRect());
     } else {
         contentRectInTargetSurface.Intersect(contributingSurfaceRenderTarget->renderSurface()->contentRect());
         contentRectInTargetSurface.Intersect(gfx::ToEnclosingRect(surface->drawableContentRect()));
@@ skipping 35 matching lines @@
 {
     // TODO(danakj): Can we remove this use of drawableContentRect and just use the clipRect() and target surface contentRect?
     return layer->drawableContentRect();
 }
 
 // Instantiate (and export) templates here for the linker.
 template class OcclusionTrackerBase<Layer, RenderSurface>;
 template class OcclusionTrackerBase<LayerImpl, RenderSurfaceImpl>;
 
 }  // namespace cc