Changes the bounds being sent for occlusion from physical pixels to DIP

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 30 matching lines @@
   gfx::RectF floored_rect(std::floor(r.x()), std::floor(r.y()),
                           std::floor(r.width()), std::floor(r.height()));
   return floored_rect == r;
 }
 
 void LayerTestCommon::VerifyQuadsExactlyCoverRect(const QuadList& quads,
                                                   const gfx::Rect& rect) {
   Region remaining = rect;
 
   for (auto iter = quads.cbegin(); iter != quads.cend(); ++iter) {
+    EXPECT_TRUE(iter->rect.Contains(iter->visible_rect));

[danakj, 2017/02/10 20:35:44]

In order to exactly cover, would the rects not need to be equal? Or am I
thinking about this wrong.

[malaykeshav, 2017/02/10 21:02:50]

I think its: all the |quads| (visible) combined should exactly cover |remaining|
region.

[danakj, 2017/02/10 22:06:45]

OK I think you're right, and checking that the visible rect isn't exceeding the
quads is good.

+
     gfx::RectF quad_rectf = MathUtil::MapClippedRect(
         iter->shared_quad_state->quad_to_target_transform,
-        gfx::RectF(iter->rect));
+        gfx::RectF(iter->visible_rect));
 
     // Before testing for exact coverage in the integer world, assert that
     // rounding will not round the rect incorrectly.
     ASSERT_TRUE(CanRectFBeSafelyRoundedToRect(quad_rectf));
 
     gfx::Rect quad_rect = gfx::ToEnclosingRect(quad_rectf);
 
     EXPECT_TRUE(rect.Contains(quad_rect)) << quad_string << iter.index()
                                           << " rect: " << rect.ToString()
                                           << " quad: " << quad_rect.ToString();
@@ skipping 143 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