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

cc/layers/surface_layer_impl_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/layers/surface_layer_impl.h"
 
 #include <stddef.h>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/test/layer_test_common.h"
+#include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
 
+TEST(SurfaceLayerImplTest, OcclusionWithDSF) {
+  float device_scale_factor = 1.25f;
+
+  gfx::Size layer_size(1000, 1000);
+  gfx::Size scaled_layer_size(

[weiliangc, 2017/02/09 18:25:32]

nit: Rename to scaled_surface_size, since scaled_layer_size sounds like it might
be in same space as layer_size.

[malaykeshav, 2017/02/09 21:00:41]

done

+      gfx::ScaleToCeiledSize(layer_size, device_scale_factor));
+  gfx::Size viewport_size(1250, 1250);
+
+  const LocalSurfaceId kArbitraryLocalSurfaceId(
+      9, base::UnguessableToken::Create());
+
+  LayerTestCommon::LayerImplTest impl;
+
+  SurfaceLayerImpl* surface_layer_impl =
+      impl.AddChildToRoot<SurfaceLayerImpl>();
+  surface_layer_impl->SetBounds(layer_size);
+  surface_layer_impl->SetDrawsContent(true);
+  SurfaceId surface_id(kArbitraryFrameSinkId, kArbitraryLocalSurfaceId);
+  surface_layer_impl->SetSurfaceInfo(
+      SurfaceInfo(surface_id, device_scale_factor, scaled_layer_size));
+
+  LayerImplList layer_list;
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      impl.root_layer_for_testing(), viewport_size, device_scale_factor,
+      &layer_list);
+  LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
+
+  {
+    SCOPED_TRACE("No occlusion");
+    gfx::Rect occluded;
+    impl.AppendQuadsWithOcclusion(surface_layer_impl, occluded);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
+                                                 gfx::Rect(scaled_layer_size));
+    EXPECT_EQ(1u, impl.quad_list().size());
+  }
+
+  {
+    SCOPED_TRACE("Full occlusion");
+    gfx::Rect occluded(scaled_layer_size);
+    impl.AppendQuadsWithOcclusion(surface_layer_impl, occluded);
+
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
+    EXPECT_EQ(impl.quad_list().size(), 0u);
+  }
+
+  {
+    SCOPED_TRACE("Partial occlusion");
+    gfx::Rect occluded(gfx::ScaleToEnclosedRect(gfx::Rect(200, 0, 800, 1000),

[weiliangc, 2017/02/09 18:25:32]

I don't think this test really reflects the bug.

The bug is where there is occlusion that is inside viewport, but outside layer,
it covers up layer when dsf is not 1.

Possibly add another case here similar to the partial occlusion test case, bug
make sure the occluded rect is outside layer_rect, but still inside viewport.
And even w/ dsf, the end result is similar to no occlusion case.

To make sure the unittest actually catches the bug, you can comment out your fix
in real code, and check to see if the unittest not fails.

[malaykeshav, 2017/02/09 21:00:41]

Yes. But without the patch these 3 tests failed as well. 
The occlusion from outside is a result/combination of these 3.

Keeping these tests and adding a 4th that occludes from outside.

+                                                device_scale_factor));
+    impl.AppendQuadsWithOcclusion(surface_layer_impl, occluded);
+
+    size_t partially_occluded_count = 0;
+    LayerTestCommon::VerifyQuadsAreOccluded(impl.quad_list(), occluded,
+                                            &partially_occluded_count);
+    // The layer outputs one quad, which is partially occluded.
+    EXPECT_EQ(1u, impl.quad_list().size());
+    EXPECT_EQ(1u, partially_occluded_count);
+  }
+}
+
 TEST(SurfaceLayerImplTest, Occlusion) {
   gfx::Size layer_size(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
   const LocalSurfaceId kArbitraryLocalSurfaceId(
       9, base::UnguessableToken::Create());
 
   LayerTestCommon::LayerImplTest impl;
 
   SurfaceLayerImpl* surface_layer_impl =
       impl.AddChildToRoot<SurfaceLayerImpl>();
@@ skipping 92 matching lines @@
   gfx::RectF layer_rect(layer_size.width(), layer_size.height());
   gfx::RectF transformed_layer_rect =
       MathUtil::MapClippedRect(target_space_transform, layer_rect);
 
   // Check if quad rect in target space matches layer rect in target space
   EXPECT_EQ(transformed_quad_rect, transformed_layer_rect);
 }
 
 }  // namespace
 }  // namespace cc