cc: Remove uses of FilterOperations::GetOutsets in unit tests.

cc/trees/occlusion_tracker_unittest.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/trees/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 1419 matching lines @@
   explicit OcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter(
       bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     gfx::Transform scale_by_half;
     scale_by_half.Scale(0.5, 0.5);
 
     FilterOperations filters;
     filters.Append(FilterOperation::CreateBlurFilter(10.f));
 
-    // Save the distance of influence for the blur effect.
-    int outset_top, outset_right, outset_bottom, outset_left;
-    filters.GetOutsets(
-        &outset_top, &outset_right, &outset_bottom, &outset_left);
-
     enum Direction {
       LEFT,
       RIGHT,
       TOP,
       BOTTOM,
       LAST_DIRECTION = BOTTOM,
     };
 
     for (int i = 0; i <= LAST_DIRECTION; ++i) {
       SCOPED_TRACE(i);
@@ skipping 50 matching lines @@
       EXPECT_EQ(occlusion_inside_surface.ToString(),
                 occlusion.occlusion_from_outside_target().ToString());
 
       // The surface has a background blur, so it needs pixels that are
       // currently considered occluded in order to be drawn. So the pixels it
       // needs should be removed some the occluded area so that when we get to
       // the parent they are drawn.
       this->VisitContributingSurface(filtered_surface, &occlusion);
       this->EnterLayer(parent, &occlusion);
 
+      // The spread due to a 10px blur is 30px.
       gfx::Rect expected_occlusion = occlusion_rect;
       switch (i) {
         case LEFT:
-          expected_occlusion.Inset(0, 0, outset_right, 0);
+          expected_occlusion.Inset(0, 0, 30, 0);
           break;
         case RIGHT:
-          expected_occlusion.Inset(outset_right, 0, 0, 0);
+          expected_occlusion.Inset(30, 0, 0, 0);
           break;
         case TOP:
-          expected_occlusion.Inset(0, 0, 0, outset_right);
+          expected_occlusion.Inset(0, 0, 0, 30);
           break;
         case BOTTOM:
-          expected_occlusion.Inset(0, outset_right, 0, 0);
+          expected_occlusion.Inset(0, 30, 0, 0);
           break;
       }
 
       EXPECT_EQ(expected_occlusion.ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
       EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
 
       this->DestroyLayers();
     }
   }
@@ skipping 28 matching lines @@
         gfx::Size(50, 50), true);
 
     // Filters make the layers own surfaces.
     filtered_surface1->test_properties()->force_render_surface = true;
     filtered_surface2->test_properties()->force_render_surface = true;
     FilterOperations filters;
     filters.Append(FilterOperation::CreateBlurFilter(1.f));
     filtered_surface1->test_properties()->background_filters = filters;
     filtered_surface2->test_properties()->background_filters = filters;
 
-    // Save the distance of influence for the blur effect.
-    int outset_top, outset_right, outset_bottom, outset_left;
-    filters.GetOutsets(
-        &outset_top, &outset_right, &outset_bottom, &outset_left);
-
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
 
     this->VisitLayer(occluding_layer_above, &occlusion);
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(100 / 2, 100 / 2, 50 / 2, 50 / 2).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     this->VisitLayer(filtered_surface2, &occlusion);
     this->VisitContributingSurface(filtered_surface2, &occlusion);
     this->VisitLayer(filtered_surface1, &occlusion);
     this->VisitContributingSurface(filtered_surface1, &occlusion);
 
     // Test expectations in the target.
+    int blur_outset = 3;
     gfx::Rect expected_occlusion =
-        gfx::Rect(100 / 2 + outset_right * 2,
-                  100 / 2 + outset_bottom * 2,
-                  50 / 2 - (outset_left + outset_right) * 2,
-                  50 / 2 - (outset_top + outset_bottom) * 2);
+        gfx::Rect(100 / 2 + blur_outset * 2, 100 / 2 + blur_outset * 2,
+                  50 / 2 - blur_outset * 4, 50 / 2 - blur_outset * 4);
     EXPECT_EQ(expected_occlusion.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // Test expectations in the screen are the same as in the target, as the
     // render surface is 1:1 with the screen.
     EXPECT_EQ(expected_occlusion.ToString(),
               occlusion.occlusion_from_outside_target().ToString());
   }
 };
 
@@ skipping 175 matching lines @@
     LayerImpl* beside_replica_layer = this->CreateDrawingLayer(
         parent, this->identity_matrix, gfx::PointF(200.f, 40.f),
         gfx::Size(10, 10), true);
 
     // Filters make the layer own a surface.
     filtered_surface->test_properties()->force_render_surface = true;
     FilterOperations filters;
     filters.Append(FilterOperation::CreateBlurFilter(3.f));
     filtered_surface->test_properties()->background_filters = filters;
 
-    // Save the distance of influence for the blur effect.
-    int outset_top, outset_right, outset_bottom, outset_left;
-    filters.GetOutsets(
-        &outset_top, &outset_right, &outset_bottom, &outset_left);
-
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
 
     this->VisitLayer(beside_replica_layer, &occlusion);
     this->VisitLayer(beside_surface_layer, &occlusion);
     this->VisitLayer(above_replica_layer, &occlusion);
     this->VisitLayer(above_surface_layer, &occlusion);
 
     // The surface has a background blur, so it blurs non-opaque pixels below
     // it.
     this->VisitLayer(filtered_surface, &occlusion);
     this->VisitContributingSurface(filtered_surface, &occlusion);
 
     // The filter in the surface and replica are partially unoccluded. Only the
     // unoccluded parts should reduce occlusion.  This means it will push back
     // the occlusion that touches the unoccluded part (occlusion_above___), but
     // it will not touch occlusion_beside____ since that is not beside the
     // unoccluded part of the surface, even though it is beside the occluded
     // part of the surface.
+    int blur_outset = 9;
     gfx::Rect occlusion_above_surface =
-        gfx::Rect(70 + outset_right, 50, 30 - outset_right, 50);
+        gfx::Rect(70 + blur_outset, 50, 30 - blur_outset, 50);
     gfx::Rect occlusion_above_replica =
-        gfx::Rect(200, 50, 30 - outset_left, 50);
+        gfx::Rect(200, 50, 30 - blur_outset, 50);
     gfx::Rect occlusion_beside_surface = gfx::Rect(90, 40, 10, 10);
     gfx::Rect occlusion_beside_replica = gfx::Rect(200, 40, 10, 10);
 
     SimpleEnclosedRegion expected_occlusion;
     expected_occlusion.Union(occlusion_beside_replica);
     expected_occlusion.Union(occlusion_beside_surface);
     expected_occlusion.Union(occlusion_above_replica);
     expected_occlusion.Union(occlusion_above_surface);
 
     EXPECT_EQ(expected_occlusion.ToString(),
@@ skipping 679 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc