Split picture layer quads to allow removing more occluded area.

cc/test/layer_test_common.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/test/layer_test_common.h"
 
 #include <stddef.h>
 
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
@@ skipping 68 matching lines @@
         << " quad: " << quad_rect.ToString();
     remaining.Subtract(quad_rect);
   }
 
   EXPECT_TRUE(remaining.IsEmpty());
 }
 
 // static
 void LayerTestCommon::VerifyQuadsAreOccluded(const QuadList& quads,
                                              const gfx::Rect& occluded,
+                                             bool split_quads,
                                              size_t* partially_occluded_count) {
   // No quad should exist if it's fully occluded.
   for (auto* quad : quads) {
     gfx::Rect target_visible_rect = MathUtil::MapEnclosingClippedRect(
         quad->shared_quad_state->quad_to_target_transform, quad->visible_rect);
     EXPECT_FALSE(occluded.Contains(target_visible_rect));
   }
 
   // Quads that are fully occluded on one axis only should be shrunken.
   for (auto* quad : quads) {
     gfx::Rect target_rect = MathUtil::MapEnclosingClippedRect(
         quad->shared_quad_state->quad_to_target_transform, quad->rect);
     if (!quad->shared_quad_state->quad_to_target_transform
              .IsIdentityOrIntegerTranslation()) {
       DCHECK(quad->shared_quad_state->quad_to_target_transform
                  .IsPositiveScaleOrTranslation())
           << quad->shared_quad_state->quad_to_target_transform.ToString();
       gfx::RectF target_rectf = MathUtil::MapClippedRect(
           quad->shared_quad_state->quad_to_target_transform,
           gfx::RectF(quad->rect));
       // Scale transforms allowed, as long as the final transformed rect
       // ends up on integer boundaries for ease of testing.
       ASSERT_EQ(target_rectf, gfx::RectF(target_rect));
     }
 
     bool fully_occluded_horizontal = target_rect.x() >= occluded.x() &&
                                      target_rect.right() <= occluded.right();
     bool fully_occluded_vertical = target_rect.y() >= occluded.y() &&
                                    target_rect.bottom() <= occluded.bottom();
-    bool should_be_occluded =
-        target_rect.Intersects(occluded) &&
-        (fully_occluded_vertical || fully_occluded_horizontal);
+    bool should_be_occluded = target_rect.Intersects(occluded);
+    if (!split_quads && !(fully_occluded_vertical || fully_occluded_horizontal))
+      should_be_occluded = false;
     if (!should_be_occluded) {
       EXPECT_EQ(quad->rect.ToString(), quad->visible_rect.ToString());
     } else {
       EXPECT_NE(quad->rect.ToString(), quad->visible_rect.ToString());
       EXPECT_TRUE(quad->rect.Contains(quad->visible_rect));
       ++(*partially_occluded_count);
     }
   }
 }
 
@@ skipping 98 matching lines @@
 }
 
 void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 void LayerTestCommon::LayerImplTest::RequestCopyOfOutput() {
   root_layer_for_testing()->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 }
 
 }  // namespace cc