Don't DCHECK on aggregating quads with noninvertible transforms.

cc/surfaces/surface_aggregator.cc

Index: cc/surfaces/surface_aggregator.cc
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index 1ef8fbe8a6d8e3ce95cb3cadeda56f736faa8939..4b18aa2cdf4fd214e90477f3e2ab239aea60268c 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -313,18 +313,22 @@ SharedQuadState* SurfaceAggregator::CopySharedQuadState(
   return copy_shared_quad_state;
 }
 
-static gfx::Rect CalculateQuadSpaceDamageRect(
+// Returns true if the damage rect is valid.
+static bool CalculateQuadSpaceDamageRect(
     const gfx::Transform& quad_to_target_transform,
     const gfx::Transform& target_to_root_transform,
-    const gfx::Rect& root_damage_rect) {
+    const gfx::Rect& root_damage_rect,
+    gfx::Rect* quad_space_damage_rect) {
   gfx::Transform quad_to_root_transform(target_to_root_transform,
                                         quad_to_target_transform);
   gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
   bool inverse_valid = quad_to_root_transform.GetInverse(&inverse_transform);
-  DCHECK(inverse_valid);
+  if (!inverse_valid)
+    return false;
 
-  return MathUtil::ProjectEnclosingClippedRect(inverse_transform,
-                                               root_damage_rect);
+  *quad_space_damage_rect = MathUtil::ProjectEnclosingClippedRect(
+      inverse_transform, root_damage_rect);
+  return true;
 }
 
 void SurfaceAggregator::CopyQuadsToPass(
@@ -344,6 +348,7 @@ void SurfaceAggregator::CopyQuadsToPass(
   // TODO(jbauman): This rect may contain unnecessary area if
   // transform isn't axis-aligned.
   gfx::Rect damage_rect_in_quad_space;
+  bool damage_rect_in_quad_space_valid = false;
 
 #if DCHECK_IS_ON()
   // If quads have come in with SharedQuadState out of order, or when quads have
@@ -370,10 +375,11 @@ void SurfaceAggregator::CopyQuadsToPass(
         gfx::Transform quad_to_target_transform(
             target_transform,
             quad->shared_quad_state->quad_to_target_transform);
-        damage_rect_in_quad_space = CalculateQuadSpaceDamageRect(
+        damage_rect_in_quad_space_valid = CalculateQuadSpaceDamageRect(
             quad_to_target_transform, dest_pass->transform_to_root_target,
-            root_damage_rect_);
-        if (!damage_rect_in_quad_space.Intersects(quad->visible_rect))
+            root_damage_rect_, &damage_rect_in_quad_space);
+        if (damage_rect_in_quad_space_valid &&

[danakj, 2016/04/13 22:32:46]

Do you want to draw quads with non-invertible damage rects or skip them? Drawing
them seems.. well idk, what was the example that generates these?

+            !damage_rect_in_quad_space.Intersects(quad->visible_rect))
           continue;
       }
       HandleSurfaceQuad(surface_quad, target_transform, clip_rect, dest_pass);
@@ -383,14 +389,16 @@ void SurfaceAggregator::CopyQuadsToPass(
             quad->shared_quad_state, target_transform, clip_rect, dest_pass);
         last_copied_source_shared_quad_state = quad->shared_quad_state;
         if (aggregate_only_damaged_ && !has_copy_requests_) {
-          damage_rect_in_quad_space = CalculateQuadSpaceDamageRect(
+          damage_rect_in_quad_space_valid = CalculateQuadSpaceDamageRect(
               dest_shared_quad_state->quad_to_target_transform,
-              dest_pass->transform_to_root_target, root_damage_rect_);
+              dest_pass->transform_to_root_target, root_damage_rect_,
+              &damage_rect_in_quad_space);
         }
       }
 
       if (ignore_undamaged) {
-        if (!damage_rect_in_quad_space.Intersects(quad->visible_rect))
+        if (damage_rect_in_quad_space_valid &&
+            !damage_rect_in_quad_space.Intersects(quad->visible_rect))
           continue;
       }