Don't DCHECK on aggregating quads with noninvertible transforms.

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 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/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 295 matching lines @@
       target_transform);
 
   ClipData new_clip_rect = CalculateClipRect(
       clip_rect, ClipData(source_sqs->is_clipped, source_sqs->clip_rect),
       target_transform);
   copy_shared_quad_state->is_clipped = new_clip_rect.is_clipped;
   copy_shared_quad_state->clip_rect = new_clip_rect.rect;
   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(
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_pass,
     SurfaceId surface_id) {
   const SharedQuadState* last_copied_source_shared_quad_state = nullptr;
   const SharedQuadState* dest_shared_quad_state = nullptr;
   // If the current frame has copy requests then aggregate the entire
   // thing, as otherwise parts of the copy requests may be ignored.
   const bool ignore_undamaged = aggregate_only_damaged_ && !has_copy_requests_;
   // Damage rect in the quad space of the current shared quad state.
   // 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
   // invalid SharedQuadState pointer, it should DCHECK.
   SharedQuadStateList::ConstIterator sqs_iter =
       source_shared_quad_state_list.begin();
   for (const auto& quad : source_quad_list) {
     while (sqs_iter != source_shared_quad_state_list.end() &&
            quad->shared_quad_state != *sqs_iter) {
       ++sqs_iter;
     }
     DCHECK(sqs_iter != source_shared_quad_state_list.end());
   }
 #endif
 
   for (const auto& quad : source_quad_list) {
     if (quad->material == DrawQuad::SURFACE_CONTENT) {
       const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
       // HandleSurfaceQuad may add other shared quad state, so reset the
       // current data.
       last_copied_source_shared_quad_state = nullptr;
 
       if (ignore_undamaged) {
         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);
     } else {
       if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
         dest_shared_quad_state = CopySharedQuadState(
             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;
       }
 
       DrawQuad* dest_quad;
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
         RenderPassId original_pass_id = pass_quad->render_pass_id;
         RenderPassId remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
@@ skipping 307 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(SurfaceId surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc