Don't DCHECK on aggregating quads with noninvertible transforms.

cc/surfaces/surface_aggregator_unittest.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 <stdint.h>
 
 #include <utility>
@@ skipping 1439 matching lines @@
     : public SurfaceAggregatorValidSurfaceTest {
  public:
   SurfaceAggregatorPartialSwapTest()
       : SurfaceAggregatorValidSurfaceTest(true) {}
 };
 
 // Tests that quads outside the damage rect are ignored.
 TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
-  // The child surface has two quads, one with a visible rect of 13,13 4x4 and
+  // The child surface has three quads, one with a visible rect of 13,13 4x4 and
   // the other other with a visible rect of 10,10 2x2 (relative to root target
-  // space).
+  // space), and one with a non-invertible transform.
   {
     RenderPassId child_pass_id = RenderPassId(1, 1);
     test::Quad child_quads1[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Quad child_quads2[] = {test::Quad::RenderPassQuad(child_pass_id)};
+    test::Quad child_quads3[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Pass child_passes[] = {
         test::Pass(child_quads1, arraysize(child_quads1), child_pass_id),
-        test::Pass(child_quads2, arraysize(child_quads2), child_pass_id)};
+        test::Pass(child_quads2, arraysize(child_quads2), child_pass_id),
+        test::Pass(child_quads3, arraysize(child_quads2), child_pass_id)};
 
     RenderPassList child_pass_list;
     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
               arraysize(child_passes));
 
     child_pass_list[0]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(1, 1, 2, 2);
     SharedQuadState* child_sqs =
         child_pass_list[0]->shared_quad_state_list.ElementAt(0u);
     child_sqs->quad_to_target_transform.Translate(1, 1);
     child_sqs->quad_to_target_transform.Scale(2, 2);
 
     child_pass_list[1]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 0, 2, 2);
 
+    SharedQuadState* child_noninvertible_sqs =
+        child_pass_list[2]->shared_quad_state_list.ElementAt(0u);
+    child_noninvertible_sqs->quad_to_target_transform.matrix().setDouble(0, 0,
+                                                                         0.0);
+    EXPECT_FALSE(
+        child_noninvertible_sqs->quad_to_target_transform.IsInvertible());
+    child_pass_list[2]->quad_list.ElementAt(0)->visible_rect =
+        gfx::Rect(0, 0, 2, 2);
+
     SubmitPassListAsFrame(child_surface_id, &child_pass_list);
   }
 
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
@@ skipping 10 matching lines @@
   std::unique_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
   DelegatedFrameData* frame_data = aggregated_frame->delegated_frame_data.get();
 
   const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
-  ASSERT_EQ(2u, aggregated_pass_list.size());
+  ASSERT_EQ(3u, aggregated_pass_list.size());
 
   // Damage rect for first aggregation should contain entire root surface.
-  EXPECT_EQ(gfx::Rect(0, 0, 15, 15), aggregated_pass_list[1]->damage_rect);
+  EXPECT_EQ(gfx::Rect(0, 0, 15, 15), aggregated_pass_list[2]->damage_rect);
   EXPECT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
   EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
+  EXPECT_EQ(1u, aggregated_pass_list[2]->quad_list.size());
 
   // Create a root surface with a smaller damage rect.
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
@@ skipping 10 matching lines @@
         aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
-    ASSERT_EQ(2u, aggregated_pass_list.size());
+    ASSERT_EQ(3u, aggregated_pass_list.size());
 
     // Only first quad from surface is inside damage rect and should be
     // included.
-    EXPECT_EQ(gfx::Rect(10, 10, 2, 2), aggregated_pass_list[1]->damage_rect);
+    EXPECT_EQ(gfx::Rect(10, 10, 2, 2), aggregated_pass_list[2]->damage_rect);
     EXPECT_EQ(0u, aggregated_pass_list[0]->quad_list.size());
     EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     EXPECT_EQ(gfx::Rect(0, 0, 2, 2),
               aggregated_pass_list[1]->quad_list.back()->visible_rect);
+    EXPECT_EQ(1u, aggregated_pass_list[2]->quad_list.size());
   }
 
   // New child frame has same content and no damage, but has a
   // CopyOutputRequest.
   {
     RenderPassId child_pass_id = RenderPassId(1, 1);
     test::Quad child_quads1[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Quad child_quads2[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Pass child_passes[] = {
         test::Pass(child_quads1, arraysize(child_quads1), child_pass_id),
@@ skipping 36 matching lines @@
     // Output frame should have no damage, but all quads included.
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.IsEmpty());
     ASSERT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
     ASSERT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     EXPECT_EQ(gfx::Rect(1, 1, 2, 2),
               aggregated_pass_list[0]->quad_list.ElementAt(0)->visible_rect);
     EXPECT_EQ(gfx::Rect(0, 0, 2, 2),
               aggregated_pass_list[1]->quad_list.ElementAt(0)->visible_rect);
+    ASSERT_EQ(1u, aggregated_pass_list[2]->quad_list.size());
   }
 
   {
     std::unique_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(root_surface_id_);
 
     ASSERT_TRUE(aggregated_frame);
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
@@ skipping 253 matching lines @@
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 }  // namespace
 }  // namespace cc