cc: Convert non-const reference arguments to pointers.

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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer.h"
@@ skipping 328 matching lines @@
                                                  1.f,
                                                  dummy_max_texture_size,
                                                  false,
                                                  &render_surface_layer_list_);
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(&render_surface_layer_list_);
   }
 
   void EnterLayer(typename Types::LayerType* layer,
-                  typename Types::OcclusionTrackerType& occlusion) {
+                  typename Types::OcclusionTrackerType* occlusion) {
     ASSERT_EQ(layer, *layer_iterator_);
     ASSERT_TRUE(layer_iterator_.represents_itself());
-    occlusion.EnterLayer(layer_iterator_);
+    occlusion->EnterLayer(layer_iterator_);
   }
 
   void LeaveLayer(typename Types::LayerType* layer,
-                  typename Types::OcclusionTrackerType& occlusion) {
+                  typename Types::OcclusionTrackerType* occlusion) {
     ASSERT_EQ(layer, *layer_iterator_);
     ASSERT_TRUE(layer_iterator_.represents_itself());
-    occlusion.LeaveLayer(layer_iterator_);
+    occlusion->LeaveLayer(layer_iterator_);
     ++layer_iterator_;
   }
 
   void VisitLayer(typename Types::LayerType* layer,
-                  typename Types::OcclusionTrackerType& occlusion) {
+                  typename Types::OcclusionTrackerType* occlusion) {
     EnterLayer(layer, occlusion);
     LeaveLayer(layer, occlusion);
   }
 
   void EnterContributingSurface(
       typename Types::LayerType* layer,
-      typename Types::OcclusionTrackerType& occlusion) {
+      typename Types::OcclusionTrackerType* occlusion) {
     ASSERT_EQ(layer, *layer_iterator_);
     ASSERT_TRUE(layer_iterator_.represents_target_render_surface());
-    occlusion.EnterLayer(layer_iterator_);
-    occlusion.LeaveLayer(layer_iterator_);
+    occlusion->EnterLayer(layer_iterator_);
+    occlusion->LeaveLayer(layer_iterator_);
     ++layer_iterator_;
     ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface());
-    occlusion.EnterLayer(layer_iterator_);
+    occlusion->EnterLayer(layer_iterator_);
   }
 
   void LeaveContributingSurface(
       typename Types::LayerType* layer,
-      typename Types::OcclusionTrackerType& occlusion) {
+      typename Types::OcclusionTrackerType* occlusion) {
     ASSERT_EQ(layer, *layer_iterator_);
     ASSERT_TRUE(layer_iterator_.represents_contributing_render_surface());
-    occlusion.LeaveLayer(layer_iterator_);
+    occlusion->LeaveLayer(layer_iterator_);
     ++layer_iterator_;
   }
 
   void VisitContributingSurface(
       typename Types::LayerType* layer,
-      typename Types::OcclusionTrackerType& occlusion) {
+      typename Types::OcclusionTrackerType* occlusion) {
     EnterContributingSurface(layer, occlusion);
     LeaveContributingSurface(layer, occlusion);
   }
 
   void ResetLayerIterator() { layer_iterator_ = layer_iterator_begin_; }
 
   const gfx::Transform identity_matrix;
 
  private:
   void SetBaseProperties(typename Types::LayerType* layer,
@@ skipping 135 matching lines @@
                                  gfx::PointF(30.f, 30.f),
                                  gfx::Size(500, 500),
                                  true);
     parent->SetMasksToBounds(true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000), false);
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 70, 70)));
@@ skipping 45 matching lines @@
     typename Types::ContentLayerType* layer1 = this->CreateDrawingLayer(
         parent, layer_transform, gfx::PointF(), gfx::Size(90, 90), true);
     typename Types::ContentLayerType* layer2 = this->CreateDrawingLayer(
         layer1, layer_transform, gfx::PointF(), gfx::Size(50, 50), true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer2, occlusion);
-    this->EnterLayer(layer1, occlusion);
+    this->VisitLayer(layer2, &occlusion);
+    this->EnterLayer(layer1, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // This checks cases where the quads don't match their "containing"
     // layers, e.g. in terms of transforms or clip rect. This is typical for
     // DelegatedRendererLayer.
 
@@ skipping 66 matching lines @@
                                  gfx::PointF(30.f, 30.f),
                                  gfx::Size(500, 500),
                                  true);
     parent->SetMasksToBounds(true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 30, 70, 70)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 29, 70, 70)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 30, 70, 70)));
@@ skipping 49 matching lines @@
                                  gfx::PointF(30.f, 30.f),
                                  gfx::Size(500, 500),
                                  true);
     parent->SetMasksToBounds(true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(50, 50, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(50, 50, 50, 50)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(49, 50, 50, 50)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(50, 49, 50, 50)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(51, 50, 50, 50)));
@@ skipping 50 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(10.f, 10.f),
                                  gfx::Size(500, 500),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterContributingSurface(child, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterContributingSurface(child, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->LeaveContributingSurface(child, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(31, 40, 70, 60)));
@@ skipping 77 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(100.f, 100.f),
                                  gfx::Size(500, 500),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(occluder, occlusion);
-    this->EnterLayer(layer2, occlusion);
+    this->VisitLayer(occluder, &occlusion);
+    this->EnterLayer(layer2, &occlusion);
 
     EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_RECT_EQ(
         gfx::Rect(0, 0, 25, 25),
         occlusion.UnoccludedLayerContentRect(layer2, gfx::Rect(0, 0, 25, 25)));
     EXPECT_RECT_EQ(gfx::Rect(10, 25, 15, 25),
@@ skipping 43 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(30.f, 30.f),
                                  gfx::Size(60, 20),
                                  true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(child2, occlusion);
+    this->VisitLayer(child2, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(30, 30, 60, 20).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitLayer(layer, occlusion);
+    this->VisitLayer(layer, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterContributingSurface(child, occlusion);
+    this->EnterContributingSurface(child, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 440, 20, 60).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // Occlusion in |child2| should get merged with the |child| surface we are
     // leaving now.
-    this->LeaveContributingSurface(child, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(UnionRegions(gfx::Rect(30, 30, 60, 10), gfx::Rect(30, 40, 70, 60))
                   .ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 30, 70, 70)));
     EXPECT_RECT_EQ(gfx::Rect(90, 30, 10, 10),
                    occlusion.UnoccludedLayerContentRect(
@@ skipping 125 matching lines @@
         child, layer_transform, gfx::PointF(), gfx::Size(500, 500), true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     gfx::Rect clipped_layer_in_child = MathUtil::MapClippedRect(
         layer_transform, layer->visible_content_rect());
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterContributingSurface(child, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterContributingSurface(child, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(clipped_layer_in_child.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->LeaveContributingSurface(child, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(75, 55, 1, 1)));
     EXPECT_RECT_EQ(
         gfx::Rect(75, 55, 1, 1),
         occlusion.UnoccludedLayerContentRect(parent, gfx::Rect(75, 55, 1, 1)));
@@ skipping 37 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(10.f, 450.f),
                                  gfx::Size(500, 60),
                                  true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer2, occlusion);
-    this->VisitLayer(layer1, occlusion);
-    this->VisitLayer(child, occlusion);
-    this->EnterContributingSurface(child, occlusion);
+    this->VisitLayer(layer2, &occlusion);
+    this->VisitLayer(layer1, &occlusion);
+    this->VisitLayer(child, &occlusion);
+    this->EnterContributingSurface(child, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(10, 430, 60, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(child, gfx::Rect(10, 430, 60, 70)));
     EXPECT_FALSE(occlusion.OccludedLayer(child, gfx::Rect(9, 430, 60, 70)));
     // These rects are occluded except for the part outside the bounds of the
     // target surface.
@@ skipping 11 matching lines @@
     EXPECT_RECT_EQ(gfx::Rect(),
                    occlusion.UnoccludedLayerContentRect(
                        child, gfx::Rect(10, 429, 60, 70)));
     EXPECT_RECT_EQ(gfx::Rect(),
                    occlusion.UnoccludedLayerContentRect(
                        child, gfx::Rect(11, 430, 60, 70)));
     EXPECT_RECT_EQ(gfx::Rect(),
                    occlusion.UnoccludedLayerContentRect(
                        child, gfx::Rect(10, 431, 60, 70)));
 
-    this->LeaveContributingSurface(child, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(30, 40, 70, 60).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 40, 70, 60)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(29, 40, 70, 60)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(30, 39, 70, 60)));
 
@@ skipping 71 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(-10.f, -10.f),
                                  gfx::Size(510, 510),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer2, occlusion);
-    this->EnterContributingSurface(child2, occlusion);
+    this->VisitLayer(layer2, &occlusion);
+    this->EnterContributingSurface(child2, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 70, 80)));
     EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-11, 420, 70, 80)));
     EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 419, 70, 80)));
     EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 71, 80)));
     EXPECT_TRUE(occlusion.OccludedLayer(child2, gfx::Rect(-10, 420, 70, 81)));
 
     // There is nothing above child2's surface in the z-order.
     EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child2, false, gfx::Rect(-10, 420, 70, 80), NULL));
 
-    this->LeaveContributingSurface(child2, occlusion);
-    this->VisitLayer(layer1, occlusion);
-    this->EnterContributingSurface(child1, occlusion);
+    this->LeaveContributingSurface(child2, &occlusion);
+    this->VisitLayer(layer1, &occlusion);
+    this->EnterContributingSurface(child1, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 430, 70, 80).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(-10, 430, 80, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // child2's contents will occlude child1 below it.
     EXPECT_RECT_EQ(gfx::Rect(-10, 430, 10, 70),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child1, false, gfx::Rect(-10, 430, 80, 70), NULL));
 
-    this->LeaveContributingSurface(child1, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child1, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(UnionRegions(gfx::Rect(30, 20, 70, 10), gfx::Rect(20, 30, 80, 70))
                   .ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(20, 20, 80, 80)));
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(30, 20, 70, 80)));
@@ skipping 72 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(-10.f, -10.f),
                                  gfx::Size(510, 510),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(layer2, occlusion);
-    this->EnterLayer(child2, occlusion);
+    this->VisitLayer(layer2, &occlusion);
+    this->EnterLayer(child2, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(-10, 420, 70, 80).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->LeaveLayer(child2, occlusion);
-    this->EnterContributingSurface(child2, occlusion);
+    this->LeaveLayer(child2, &occlusion);
+    this->EnterContributingSurface(child2, &occlusion);
 
     // There is nothing above child2's surface in the z-order.
     EXPECT_RECT_EQ(gfx::Rect(-10, 420, 70, 80),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child2, false, gfx::Rect(-10, 420, 70, 80), NULL));
 
-    this->LeaveContributingSurface(child2, occlusion);
-    this->VisitLayer(layer1, occlusion);
-    this->EnterContributingSurface(child1, occlusion);
+    this->LeaveContributingSurface(child2, &occlusion);
+    this->VisitLayer(layer1, &occlusion);
+    this->EnterContributingSurface(child1, &occlusion);
 
     EXPECT_EQ(gfx::Rect(420, -10, 70, 80).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(420, -20, 80, 90).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // child2's contents will occlude child1 below it.
     EXPECT_RECT_EQ(gfx::Rect(420, -20, 80, 90),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child1, false, gfx::Rect(420, -20, 80, 90), NULL));
     EXPECT_RECT_EQ(gfx::Rect(490, -10, 10, 80),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child1, false, gfx::Rect(420, -10, 80, 90), NULL));
     EXPECT_RECT_EQ(gfx::Rect(420, -20, 70, 10),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        child1, false, gfx::Rect(420, -20, 70, 90), NULL));
 
-    this->LeaveContributingSurface(child1, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(child1, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(10, 20, 90, 80).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     /* Justification for the above occlusion:
                   100
         +---------------------+
         |20                   |       layer1
@@ skipping 67 matching lines @@
     filters.append(WebKit::WebFilterOperation::createOpacityFilter(0.5f));
     opacity_layer->SetFilters(filters);
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // Opacity layer won't contribute to occlusion.
-    this->VisitLayer(opacity_layer, occlusion);
-    this->EnterContributingSurface(opacity_layer, occlusion);
+    this->VisitLayer(opacity_layer, &occlusion);
+    this->EnterContributingSurface(opacity_layer, &occlusion);
 
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
     // And has nothing to contribute to its parent surface.
-    this->LeaveContributingSurface(opacity_layer, occlusion);
+    this->LeaveContributingSurface(opacity_layer, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
     // Opaque layer will contribute to occlusion.
-    this->VisitLayer(opaque_layer, occlusion);
-    this->EnterContributingSurface(opaque_layer, occlusion);
+    this->VisitLayer(opaque_layer, &occlusion);
+    this->EnterContributingSurface(opaque_layer, &occlusion);
 
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_EQ(gfx::Rect(0, 430, 70, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // And it gets translated to the parent surface.
-    this->LeaveContributingSurface(opaque_layer, occlusion);
+    this->LeaveContributingSurface(opaque_layer, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // The blur layer needs to throw away any occlusion from outside its
     // subtree.
-    this->EnterLayer(blur_layer, occlusion);
+    this->EnterLayer(blur_layer, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
     // And it won't contribute to occlusion.
-    this->LeaveLayer(blur_layer, occlusion);
-    this->EnterContributingSurface(blur_layer, occlusion);
+    this->LeaveLayer(blur_layer, &occlusion);
+    this->EnterContributingSurface(blur_layer, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
     // But the opaque layer's occlusion is preserved on the parent.
-    this->LeaveContributingSurface(blur_layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveContributingSurface(blur_layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_EQ(gfx::Rect(30, 30, 70, 70).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestFilters);
 
 template <class Types>
 class OcclusionTrackerTestReplicaDoesOcclude :
@@ skipping 11 matching lines @@
                                    gfx::Size(50, 50),
                                    true);
     this->CreateReplicaLayer(
         surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitContributingSurface(surface, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitContributingSurface(surface, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     // The surface and replica should both be occluding the parent.
     EXPECT_EQ(
         UnionRegions(gfx::Rect(0, 100, 50, 50),
                      gfx::Rect(50, 150, 50, 50)).ToString(),
         occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaDoesOcclude);
@@ skipping 15 matching lines @@
                                    gfx::Size(50, 50),
                                    true);
     this->CreateReplicaLayer(
         surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitContributingSurface(surface, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitContributingSurface(surface, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     // The surface and replica should both be occluding the parent.
     EXPECT_EQ(
         UnionRegions(gfx::Rect(0, 100, 50, 50),
                      gfx::Rect(50, 150, 50, 20)).ToString(),
         occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithClipping);
@@ skipping 14 matching lines @@
                                    true);
     typename Types::LayerType* replica = this->CreateReplicaLayer(
         surface, this->identity_matrix, gfx::PointF(50.f, 50.f), gfx::Size());
     this->CreateMaskLayer(replica, gfx::Size(10, 10));
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitContributingSurface(surface, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitContributingSurface(surface, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     // The replica should not be occluding the parent, since it has a mask
     // applied to it.
     EXPECT_EQ(gfx::Rect(0, 100, 50, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaWithMask);
 
@@ skipping 18 matching lines @@
                                  this->identity_matrix,
                                  gfx::PointF(-200.f, -100.f),
                                  gfx::Size(200, 200),
                                  false);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->EnterLayer(clip, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->EnterLayer(clip, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(-100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, -100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(clip, gfx::Rect(0, 0, 100, 100)));
 
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedLayerContentRect(
                        clip, gfx::Rect(-100, -100, 300, 300)));
@@ skipping 16 matching lines @@
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(200, 100, 100, 100));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(
         occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
@@ skipping 28 matching lines @@
                                    this->identity_matrix,
                                    gfx::PointF(-100.f, -100.f),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
 
     EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterLayer(clip, occlusion);
+    this->EnterLayer(clip, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(0, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(100, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(clip, gfx::Rect(200, 200, 100, 100)));
@@ skipping 19 matching lines @@
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(100, 100, 100, 100));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
@@ skipping 26 matching lines @@
                                    this->identity_matrix,
                                    gfx::PointF(-50.f, -50.f),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 50)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 50, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 50)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 50, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(clip, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(clip, &occlusion);
 
     EXPECT_EQ(gfx::Rect(50, 50, 150, 150).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipRectPartlyOverChild);
 
 template <class Types>
 class OcclusionTrackerTestViewportRectPartlyOverChild :
     public OcclusionTrackerTest<Types> {
  protected:
   OcclusionTrackerTestViewportRectPartlyOverChild(bool opaque_layers)
       : OcclusionTrackerTest<Types>(opaque_layers) {}
   void RunMyTest() {
     typename Types::ContentLayerType* parent = this->CreateRoot(
         this->identity_matrix, gfx::PointF(), gfx::Size(300, 300));
     typename Types::ContentLayerType* layer =
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(50, 50, 200, 200));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
     EXPECT_FALSE(
         occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
     EXPECT_FALSE(
@@ skipping 35 matching lines @@
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(500, 500, 100, 100));
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 100, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 0, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(0, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(100, 200, 100, 100)));
     EXPECT_TRUE(occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
@@ skipping 26 matching lines @@
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     // This layer is translated when drawn into its target. So if the clip rect
     // given from the target surface is not in that target space, then after
     // translating these query rects into the target, they will fall outside the
     // clip and be considered occluded.
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
   }
@@ skipping 14 matching lines @@
         this->CreateDrawingSurface(parent,
                                    this->identity_matrix,
                                    gfx::PointF(),
                                    gfx::Size(200, 200),
                                    false);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 0, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(0, 100, 100, 100)));
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100, 100, 100)));
 
     // Occluded since its outside the surface bounds.
     EXPECT_TRUE(occlusion.OccludedLayer(layer, gfx::Rect(200, 100, 100, 100)));
 
-    this->LeaveLayer(layer, occlusion);
-    this->VisitContributingSurface(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->LeaveLayer(layer, &occlusion);
+    this->VisitContributingSurface(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
   }
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTestOpaqueContentsRegionEmpty);
 
 template <class Types>
 class OcclusionTrackerTestOpaqueContentsRegionNonEmpty :
     public OcclusionTrackerTest<Types> {
@@ skipping 10 matching lines @@
                                  gfx::Size(200, 200),
                                  false);
     this->CalcDrawEtc(parent);
     {
       TestOcclusionTrackerWithClip<typename Types::LayerType,
                                    typename Types::RenderSurfaceType> occlusion(
           gfx::Rect(0, 0, 1000, 1000));
       layer->SetOpaqueContentsRect(gfx::Rect(0, 0, 100, 100));
 
       this->ResetLayerIterator();
-      this->VisitLayer(layer, occlusion);
-      this->EnterLayer(parent, occlusion);
+      this->VisitLayer(layer, &occlusion);
+      this->EnterLayer(parent, &occlusion);
 
       EXPECT_EQ(gfx::Rect(100, 100, 100, 100).ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
 
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
       EXPECT_TRUE(
           occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
     }
     {
       TestOcclusionTrackerWithClip<typename Types::LayerType,
                                    typename Types::RenderSurfaceType> occlusion(
           gfx::Rect(0, 0, 1000, 1000));
       layer->SetOpaqueContentsRect(gfx::Rect(20, 20, 180, 180));
 
       this->ResetLayerIterator();
-      this->VisitLayer(layer, occlusion);
-      this->EnterLayer(parent, occlusion);
+      this->VisitLayer(layer, &occlusion);
+      this->EnterLayer(parent, &occlusion);
 
       EXPECT_EQ(gfx::Rect(120, 120, 180, 180).ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
 
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
       EXPECT_TRUE(
           occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
     }
     {
       TestOcclusionTrackerWithClip<typename Types::LayerType,
                                    typename Types::RenderSurfaceType> occlusion(
           gfx::Rect(0, 0, 1000, 1000));
       layer->SetOpaqueContentsRect(gfx::Rect(150, 150, 100, 100));
 
       this->ResetLayerIterator();
-      this->VisitLayer(layer, occlusion);
-      this->EnterLayer(parent, occlusion);
+      this->VisitLayer(layer, &occlusion);
+      this->EnterLayer(parent, &occlusion);
 
       EXPECT_EQ(gfx::Rect(250, 250, 50, 50).ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
 
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(0, 100, 100, 100)));
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(100, 100, 100, 100)));
       EXPECT_FALSE(
           occlusion.OccludedLayer(parent, gfx::Rect(200, 200, 100, 100)));
@@ skipping 20 matching lines @@
         this->CreateDrawingLayer(container,
                                  transform,
                                  gfx::PointF(100.f, 100.f),
                                  gfx::Size(200, 200),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     // The layer is rotated in 3d but without preserving 3d, so it only gets
     // resized.
     EXPECT_RECT_EQ(
         gfx::Rect(0, 0, 200, 200),
         occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
   }
 };
 
 MAIN_AND_IMPL_THREAD_TEST(OcclusionTrackerTest3dTransform);
@@ skipping 27 matching lines @@
                                  gfx::PointF(50.f, 50.f),
                                  gfx::Size(100, 100),
                                  true);
     parent->SetPreserves3d(true);
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->VisitLayer(child2, occlusion);
+    this->VisitLayer(child2, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
 
-    this->VisitLayer(child1, occlusion);
+    this->VisitLayer(child1, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
   }
 };
 
 // This test will have different layer ordering on the impl thread; the test
 // will only work on the main thread.
 MAIN_THREAD_TEST(OcclusionTrackerTestUnsorted3dLayers);
 
 template <class Types>
@@ skipping 19 matching lines @@
                                  gfx::PointF(100.f, 100.f),
                                  gfx::Size(200, 200),
                                  true);
     container->SetPreserves3d(true);
     layer->SetPreserves3d(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     EXPECT_RECT_EQ(
         gfx::Rect(0, 0, 200, 200),
         occlusion.UnoccludedLayerContentRect(layer, gfx::Rect(0, 0, 200, 200)));
   }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by
 // the occlusion tracker on the main thread. So this test should run on the impl
 // thread.
@@ skipping 22 matching lines @@
         parent, this->identity_matrix, gfx::PointF(), gfx::Size(500, 500));
     typename Types::ContentLayerType* layer = this->CreateDrawingLayer(
         container, transform, gfx::PointF(), gfx::Size(500, 500), true);
     container->SetPreserves3d(true);
     layer->SetPreserves3d(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
 
     // The bottom 11 pixel rows of this layer remain visible inside the
     // container, after translation to the target surface. When translated back,
     // this will include many more pixels but must include at least the bottom
     // 11 rows.
     EXPECT_TRUE(occlusion.UnoccludedLayerContentRect(
         layer, gfx::Rect(0, 0, 500, 500)).Contains(gfx::Rect(0, 489, 500, 11)));
   }
 };
 
@@ skipping 21 matching lines @@
         parent, transform, gfx::PointF(), gfx::Size(100, 100), true);
     parent->SetPreserves3d(true);
     layer->SetPreserves3d(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // The |layer| is entirely behind the camera and should not occlude.
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
     EXPECT_TRUE(occlusion.occlusion_from_inside_target().IsEmpty());
     EXPECT_TRUE(occlusion.occlusion_from_outside_target().IsEmpty());
   }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by
 // the occlusion tracker on the main thread. So this test should run on the impl
 // thread.
 IMPL_THREAD_TEST(OcclusionTrackerTestLayerBehindCameraDoesNotOcclude);
 
@@ skipping 19 matching lines @@
     layer->SetPreserves3d(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // This is very close to the camera, so pixels in its visible_content_rect()
     // will actually go outside of the layer's clip rect.  Ensure that those
     // pixels don't occlude things outside the clip rect.
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
   }
 };
 
 // This test requires accumulating occlusion of 3d layers, which are skipped by
 // the occlusion tracker on the main thread. So this test should run on the impl
 // thread.
@@ skipping 60 matching lines @@
     this->CalcDrawEtc(parent);
 
     EXPECT_TRUE(layer->draw_opacity_is_animating());
     EXPECT_FALSE(surface->draw_opacity_is_animating());
     EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(topmost, occlusion);
-    this->EnterLayer(parent2, occlusion);
+    this->VisitLayer(topmost, &occlusion);
+    this->EnterLayer(parent2, &occlusion);
     // This occlusion will affect all surfaces.
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 250, 300).ToString(),
               occlusion.UnoccludedLayerContentRect(
                   parent2, gfx::Rect(0, 0, 300, 300)).ToString());
-    this->LeaveLayer(parent2, occlusion);
+    this->LeaveLayer(parent2, &occlusion);
 
-    this->VisitLayer(surface_child2, occlusion);
-    this->EnterLayer(surface_child, occlusion);
+    this->VisitLayer(surface_child2, &occlusion);
+    this->EnterLayer(surface_child, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface_child, gfx::Rect(0, 0, 200, 300)));
-    this->LeaveLayer(surface_child, occlusion);
-    this->EnterLayer(surface, occlusion);
+    this->LeaveLayer(surface_child, &occlusion);
+    this->EnterLayer(surface, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface, gfx::Rect(0, 0, 300, 300)));
-    this->LeaveLayer(surface, occlusion);
+    this->LeaveLayer(surface, &occlusion);
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
     // Occlusion within the surface is lost when leaving the animating surface.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 300, 300), NULL));
-    this->LeaveContributingSurface(surface, occlusion);
+    this->LeaveContributingSurface(surface, &occlusion);
 
     // Occlusion from outside the animating surface still exists.
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     // Occlusion is not added for the animating |layer|.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
                    occlusion.UnoccludedLayerContentRect(
                        parent, gfx::Rect(0, 0, 300, 300)));
   }
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity1OnMainThread);
 
@@ skipping 50 matching lines @@
     this->CalcDrawEtc(parent);
 
     EXPECT_TRUE(layer->draw_opacity_is_animating());
     EXPECT_FALSE(surface->draw_opacity_is_animating());
     EXPECT_TRUE(surface->render_surface()->draw_opacity_is_animating());
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(topmost, occlusion);
-    this->EnterLayer(parent2, occlusion);
+    this->VisitLayer(topmost, &occlusion);
+    this->EnterLayer(parent2, &occlusion);
     // This occlusion will affect all surfaces.
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
                    occlusion.UnoccludedLayerContentRect(
                        parent, gfx::Rect(0, 0, 300, 300)));
-    this->LeaveLayer(parent2, occlusion);
+    this->LeaveLayer(parent2, &occlusion);
 
-    this->VisitLayer(surface_child2, occlusion);
-    this->EnterLayer(surface_child, occlusion);
+    this->VisitLayer(surface_child2, &occlusion);
+    this->EnterLayer(surface_child, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(100, 0, 100, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface_child, gfx::Rect(0, 0, 200, 300)));
-    this->LeaveLayer(surface_child, occlusion);
-    this->EnterLayer(surface, occlusion);
+    this->LeaveLayer(surface_child, &occlusion);
+    this->EnterLayer(surface, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 200, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(200, 0, 50, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface, gfx::Rect(0, 0, 300, 300)));
-    this->LeaveLayer(surface, occlusion);
+    this->LeaveLayer(surface, &occlusion);
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
     // Occlusion within the surface is lost when leaving the animating surface.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 300, 300), NULL));
-    this->LeaveContributingSurface(surface, occlusion);
+    this->LeaveContributingSurface(surface, &occlusion);
 
     // Occlusion from outside the animating surface still exists.
     EXPECT_EQ(gfx::Rect(250, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
 
-    this->VisitLayer(layer, occlusion);
-    this->EnterLayer(parent, occlusion);
+    this->VisitLayer(layer, &occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     // Occlusion is not added for the animating |layer|.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 250, 300),
                    occlusion.UnoccludedLayerContentRect(
                        parent, gfx::Rect(0, 0, 300, 300)));
   }
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationOpacity0OnMainThread);
 
@@ skipping 50 matching lines @@
     // The surface owning layer doesn't animate against its own surface.
     EXPECT_FALSE(surface->draw_transform_is_animating());
     EXPECT_TRUE(surface->screen_space_transform_is_animating());
     EXPECT_TRUE(surface_child->draw_transform_is_animating());
     EXPECT_TRUE(surface_child->screen_space_transform_is_animating());
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface2, occlusion);
-    this->EnterContributingSurface(surface2, occlusion);
+    this->VisitLayer(surface2, &occlusion);
+    this->EnterContributingSurface(surface2, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 50, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->LeaveContributingSurface(surface2, occlusion);
-    this->EnterLayer(surface_child2, occlusion);
+    this->LeaveContributingSurface(surface2, &occlusion);
+    this->EnterLayer(surface_child2, &occlusion);
 
     // surface_child2 is moving in screen space but not relative to its target,
     // so occlusion should happen in its target space only.  It also means that
     // things occluding from outside the target (e.g. surface2) cannot occlude
     // this layer.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
 
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface_child2, gfx::Rect(0, 0, 100, 300)));
     EXPECT_FALSE(
         occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
 
-    this->LeaveLayer(surface_child2, occlusion);
-    this->EnterLayer(surface_child, occlusion);
+    this->LeaveLayer(surface_child2, &occlusion);
+    this->EnterLayer(surface_child, &occlusion);
     EXPECT_FALSE(
         occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 100, 300)));
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface, gfx::Rect(0, 0, 300, 300)));
 
     // The surface_child is occluded by the surface_child2, but is moving
     // relative its target, so it can't be occluded.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 200, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface_child, gfx::Rect(0, 0, 200, 300)));
     EXPECT_FALSE(
         occlusion.OccludedLayer(surface_child, gfx::Rect(0, 0, 50, 300)));
 
-    this->LeaveLayer(surface_child, occlusion);
-    this->EnterLayer(surface, occlusion);
+    this->LeaveLayer(surface_child, &occlusion);
+    this->EnterLayer(surface, &occlusion);
     // The surface_child is moving in screen space but not relative to its
     // target, so occlusion should happen from within the target only.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(100, 0, 200, 300),
                    occlusion.UnoccludedLayerContentRect(
                        surface, gfx::Rect(0, 0, 300, 300)));
 
-    this->LeaveLayer(surface, occlusion);
+    this->LeaveLayer(surface, &occlusion);
     // The surface's owning layer is moving in screen space but not relative to
     // its target, so occlusion should happen within the target only.
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 300, 300).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0),
                    occlusion.UnoccludedLayerContentRect(
                        surface, gfx::Rect(0, 0, 300, 300)));
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
     // The contributing |surface| is animating so it can't be occluded.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 300, 300),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 300, 300), NULL));
-    this->LeaveContributingSurface(surface, occlusion);
+    this->LeaveContributingSurface(surface, &occlusion);
 
-    this->EnterLayer(layer, occlusion);
+    this->EnterLayer(layer, &occlusion);
     // The |surface| is moving in the screen and in its target, so all occlusion
     // within the surface is lost when leaving it.
     EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
                    occlusion.UnoccludedLayerContentRect(
                        parent, gfx::Rect(0, 0, 300, 300)));
-    this->LeaveLayer(layer, occlusion);
+    this->LeaveLayer(layer, &occlusion);
 
-    this->EnterLayer(parent, occlusion);
+    this->EnterLayer(parent, &occlusion);
     // The |layer| is animating in the screen and in its target, so no occlusion
     // is added.
     EXPECT_RECT_EQ(gfx::Rect(50, 0, 250, 300),
                    occlusion.UnoccludedLayerContentRect(
                        parent, gfx::Rect(0, 0, 300, 300)));
   }
 };
 
 MAIN_THREAD_TEST(OcclusionTrackerTestAnimationTranslateOnMainThread);
 
@@ skipping 20 matching lines @@
                                    gfx::Size(300, 300),
                                    false);
     surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
     surface2->SetOpaqueContentsRect(gfx::Rect(0, 0, 200, 200));
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface2, occlusion);
-    this->VisitContributingSurface(surface2, occlusion);
+    this->VisitLayer(surface2, &occlusion);
+    this->VisitContributingSurface(surface2, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(50, 50, 200, 200).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // Clear any stored occlusion.
     occlusion.set_occlusion_from_outside_target(Region());
     occlusion.set_occlusion_from_inside_target(Region());
 
-    this->VisitLayer(surface, occlusion);
-    this->VisitContributingSurface(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
+    this->VisitContributingSurface(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 400, 400).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 MAIN_AND_IMPL_THREAD_TEST(
     OcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
@@ skipping 14 matching lines @@
                                    gfx::PointF(),
                                    gfx::Size(500, 300),
                                    false);
     surface->SetOpaqueContentsRect(gfx::Rect(0, 0, 400, 200));
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(surface, occlusion);
-    this->VisitContributingSurface(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
+    this->VisitContributingSurface(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 300, 200).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 MAIN_AND_IMPL_THREAD_TEST(
     OcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping);
@@ skipping 22 matching lines @@
                                  gfx::PointF(0.f, 100.f),
                                  gfx::Size(100, 100),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // |topmost| occludes the replica, but not the surface itself.
-    this->VisitLayer(topmost, occlusion);
+    this->VisitLayer(topmost, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 100, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 100, 100, 100).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
 
     // Surface is not occluded so it shouldn't think it is.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 100, 100), NULL));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestReplicaOccluded);
 
@@ skipping 22 matching lines @@
                                  gfx::PointF(),
                                  gfx::Size(100, 110),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // |topmost| occludes the surface, but not the entire surface's replica.
-    this->VisitLayer(topmost, occlusion);
+    this->VisitLayer(topmost, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 110).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 100, 110).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
 
     // Surface is occluded, but only the top 10px of the replica.
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 100, 100), NULL));
     EXPECT_RECT_EQ(gfx::Rect(0, 10, 100, 90),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, true, gfx::Rect(0, 0, 100, 100), NULL));
   }
 };
@@ skipping 28 matching lines @@
                                  gfx::Size(50, 100),
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // These occlude the surface and replica differently, so we can test each
     // one.
-    this->VisitLayer(over_replica, occlusion);
-    this->VisitLayer(over_surface, occlusion);
+    this->VisitLayer(over_replica, &occlusion);
+    this->VisitLayer(over_surface, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(UnionRegions(gfx::Rect(0, 0, 40, 100), gfx::Rect(0, 100, 50, 100))
                   .ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitLayer(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
 
     EXPECT_EQ(UnionRegions(gfx::Rect(0, 0, 40, 100), gfx::Rect(0, 100, 50, 100))
                   .ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
 
     // Surface and replica are occluded different amounts.
     EXPECT_RECT_EQ(gfx::Rect(40, 0, 60, 100),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 100, 100), NULL));
     EXPECT_RECT_EQ(gfx::Rect(50, 0, 50, 100),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, true, gfx::Rect(0, 0, 100, 100), NULL));
   }
 };
@@ skipping 28 matching lines @@
     typename Types::LayerType* topmost = this->CreateDrawingLayer(
         parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(-100, -100, 1000, 1000));
 
     // |topmost| occludes everything partially so we know occlusion is happening
     // at all.
-    this->VisitLayer(topmost, occlusion);
+    this->VisitLayer(topmost, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
-    this->VisitLayer(surface_child, occlusion);
+    this->VisitLayer(surface_child, &occlusion);
 
     // surface_child increases the occlusion in the screen by a narrow sliver.
     EXPECT_EQ(gfx::Rect(0, -10, 100, 50).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     // In its own surface, surface_child is at 0,0 as is its occlusion.
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // The root layer always has a clip rect. So the parent of |surface| has a
     // clip rect. However, the owning layer for |surface| does not mask to
     // bounds, so it doesn't have a clip rect of its own. Thus the parent of
     // |surface_child| exercises different code paths as its parent does not
     // have a clip rect.
 
-    this->EnterContributingSurface(surface_child, occlusion);
+    this->EnterContributingSurface(surface_child, &occlusion);
     // The surface_child's parent does not have a clip rect as it owns a render
     // surface. Make sure the unoccluded rect does not get clipped away
     // inappropriately.
     EXPECT_RECT_EQ(gfx::Rect(0, 40, 100, 10),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface_child, false, gfx::Rect(0, 0, 100, 50), NULL));
-    this->LeaveContributingSurface(surface_child, occlusion);
+    this->LeaveContributingSurface(surface_child, &occlusion);
 
     // When the surface_child's occlusion is transformed up to its parent, make
     // sure it is not clipped away inappropriately also.
-    this->EnterLayer(surface, occlusion);
+    this->EnterLayer(surface, &occlusion);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 10, 100, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
-    this->LeaveLayer(surface, occlusion);
+    this->LeaveLayer(surface, &occlusion);
 
-    this->EnterContributingSurface(surface, occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
     // The surface's parent does have a clip rect as it is the root layer.
     EXPECT_RECT_EQ(gfx::Rect(0, 50, 100, 50),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        surface, false, gfx::Rect(0, 0, 100, 100), NULL));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfSurface);
 
 template <class Types>
@@ skipping 14 matching lines @@
                                    gfx::PointF(),
                                    gfx::Size(100, 300),
                                    true);
     this->CalcDrawEtc(parent);
     {
       // Make a viewport rect that is larger than the root layer.
       TestOcclusionTrackerWithClip<typename Types::LayerType,
                                    typename Types::RenderSurfaceType> occlusion(
           gfx::Rect(0, 0, 1000, 1000));
 
-      this->VisitLayer(surface, occlusion);
+      this->VisitLayer(surface, &occlusion);
 
       // The root layer always has a clip rect. So the parent of |surface| has a
       // clip rect giving the surface itself a clip rect.
-      this->EnterContributingSurface(surface, occlusion);
+      this->EnterContributingSurface(surface, &occlusion);
       // Make sure the parent's clip rect clips the unoccluded region of the
       // child surface.
       EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 200),
                      occlusion.UnoccludedContributingSurfaceContentRect(
                          surface, false, gfx::Rect(0, 0, 100, 300), NULL));
     }
     this->ResetLayerIterator();
     {
       // Make a viewport rect that is smaller than the root layer.
       TestOcclusionTrackerWithClip<typename Types::LayerType,
                                    typename Types::RenderSurfaceType> occlusion(
           gfx::Rect(0, 0, 100, 100));
 
-      this->VisitLayer(surface, occlusion);
+      this->VisitLayer(surface, &occlusion);
 
       // The root layer always has a clip rect. So the parent of |surface| has a
       // clip rect giving the surface itself a clip rect.
-      this->EnterContributingSurface(surface, occlusion);
+      this->EnterContributingSurface(surface, &occlusion);
       // Make sure the viewport rect clips the unoccluded region of the child
       // surface.
       EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                      occlusion.UnoccludedContributingSurfaceContentRect(
                          surface, false, gfx::Rect(0, 0, 100, 300), NULL));
     }
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(
@@ skipping 27 matching lines @@
     typename Types::LayerType* topmost = this->CreateDrawingLayer(
         parent, this->identity_matrix, gfx::PointF(), gfx::Size(100, 50), true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // |topmost| occludes everything partially so we know occlusion is happening
     // at all.
-    this->VisitLayer(topmost, occlusion);
+    this->VisitLayer(topmost, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // surface_child is not opaque and does not occlude, so we have a non-empty
     // unoccluded area on surface.
-    this->VisitLayer(surface_child, occlusion);
+    this->VisitLayer(surface_child, &occlusion);
 
     EXPECT_EQ(gfx::Rect(0, 0, 80, 50).ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // The root layer always has a clip rect. So the parent of |surface| has a
     // clip rect. However, the owning layer for |surface| does not mask to
     // bounds, so it doesn't have a clip rect of its own. Thus the parent of
     // |surface_child| exercises different code paths as its parent does not
     // have a clip rect.
 
-    this->EnterContributingSurface(surface_child, occlusion);
+    this->EnterContributingSurface(surface_child, &occlusion);
     // The surface_child's parent does not have a clip rect as it owns a render
     // surface.
     EXPECT_EQ(
         gfx::Rect(0, 50, 80, 50).ToString(),
         occlusion.UnoccludedContributingSurfaceContentRect(
             surface_child, false, gfx::Rect(0, 0, 100, 100), NULL).ToString());
-    this->LeaveContributingSurface(surface_child, occlusion);
+    this->LeaveContributingSurface(surface_child, &occlusion);
 
-    this->VisitLayer(surface, occlusion);
-    this->EnterContributingSurface(surface, occlusion);
+    this->VisitLayer(surface, &occlusion);
+    this->EnterContributingSurface(surface, &occlusion);
     // The surface's parent does have a clip rect as it is the root layer.
     EXPECT_EQ(gfx::Rect(0, 50, 80, 50).ToString(),
               occlusion.UnoccludedContributingSurfaceContentRect(
                   surface, false, gfx::Rect(0, 0, 100, 100), NULL).ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestSurfaceChildOfClippingSurface);
 
 template <class Types>
@@ skipping 62 matching lines @@
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // These layers occlude pixels directly beside the filtered_surface. Because
     // filtered surface blends pixels in a radius, it will need to see some of
     // the pixels (up to radius far) underneath the occluding layers.
-    this->VisitLayer(occluding_layer5, occlusion);
-    this->VisitLayer(occluding_layer4, occlusion);
-    this->VisitLayer(occluding_layer3, occlusion);
-    this->VisitLayer(occluding_layer2, occlusion);
-    this->VisitLayer(occluding_layer1, occlusion);
+    this->VisitLayer(occluding_layer5, &occlusion);
+    this->VisitLayer(occluding_layer4, &occlusion);
+    this->VisitLayer(occluding_layer3, &occlusion);
+    this->VisitLayer(occluding_layer2, &occlusion);
+    this->VisitLayer(occluding_layer1, &occlusion);
 
     Region expected_occlusion;
     expected_occlusion.Union(gfx::Rect(0, 0, 300, 50));
     expected_occlusion.Union(gfx::Rect(0, 50, 50, 50));
     expected_occlusion.Union(gfx::Rect(100, 50, 100, 50));
     expected_occlusion.Union(gfx::Rect(250, 50, 50, 50));
     expected_occlusion.Union(gfx::Rect(0, 100, 300, 50));
 
     EXPECT_EQ(expected_occlusion.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
 
-    this->VisitLayer(filtered_surface, occlusion);
+    this->VisitLayer(filtered_surface, &occlusion);
 
     // The filtered layer/replica does not occlude.
     Region expected_occlusion_outside_surface;
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, -50, 300, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, 0, 50, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(50, 0, 100, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(200, 0, 50, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, 50, 300, 50));
 
     EXPECT_EQ(expected_occlusion_outside_surface.ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_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->VisitContributingSurface(filtered_surface, &occlusion);
 
-    this->EnterLayer(parent, occlusion);
+    this->EnterLayer(parent, &occlusion);
 
     Region expected_blurred_occlusion;
     expected_blurred_occlusion.Union(gfx::Rect(0, 0, 300, 50 - outset_top));
     expected_blurred_occlusion.Union(gfx::Rect(
         0, 50 - outset_top, 50 - outset_left, 50 + outset_top + outset_bottom));
     expected_blurred_occlusion.Union(
         gfx::Rect(100 + outset_right,
                   50 - outset_top,
                   100 - outset_right - outset_left,
                   50 + outset_top + outset_bottom));
@@ skipping 121 matching lines @@
     // 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<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(occluding_layer_above, occlusion);
+    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);
+    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.
     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);
     EXPECT_EQ(expected_occlusion.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
@@ skipping 78 matching lines @@
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // These layers occlude pixels directly beside the filtered_surface. Because
     // filtered surface blends pixels in a radius, it will need to see some of
     // the pixels (up to radius far) underneath the occluding layers.
-    this->VisitLayer(occluding_layer5, occlusion);
-    this->VisitLayer(occluding_layer4, occlusion);
-    this->VisitLayer(occluding_layer3, occlusion);
-    this->VisitLayer(occluding_layer2, occlusion);
-    this->VisitLayer(occluding_layer1, occlusion);
+    this->VisitLayer(occluding_layer5, &occlusion);
+    this->VisitLayer(occluding_layer4, &occlusion);
+    this->VisitLayer(occluding_layer3, &occlusion);
+    this->VisitLayer(occluding_layer2, &occlusion);
+    this->VisitLayer(occluding_layer1, &occlusion);
 
     Region expected_occlusion;
     expected_occlusion.Union(gfx::Rect(0, 0, 300, 50));
     expected_occlusion.Union(gfx::Rect(0, 50, 50, 50));
     expected_occlusion.Union(gfx::Rect(100, 50, 100, 50));
     expected_occlusion.Union(gfx::Rect(250, 50, 50, 50));
     expected_occlusion.Union(gfx::Rect(0, 100, 300, 50));
 
     EXPECT_EQ(expected_occlusion.ToString(),
               occlusion.occlusion_from_inside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
 
     // Everything outside the surface/replica is occluded but the
     // surface/replica itself is not.
-    this->VisitLayer(filtered_surface, occlusion);
+    this->VisitLayer(filtered_surface, &occlusion);
 
     // The filtered layer/replica does not occlude.
     Region expected_occlusion_outside_surface;
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, -50, 300, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, 0, 50, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(50, 0, 100, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(200, 0, 50, 50));
     expected_occlusion_outside_surface.Union(gfx::Rect(-50, 50, 300, 50));
 
     EXPECT_EQ(expected_occlusion_outside_surface.ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_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->VisitContributingSurface(filtered_surface, &occlusion);
 
-    this->VisitLayer(clipping_surface, occlusion);
-    this->EnterContributingSurface(clipping_surface, occlusion);
+    this->VisitLayer(clipping_surface, &occlusion);
+    this->EnterContributingSurface(clipping_surface, &occlusion);
 
     Region expected_blurred_occlusion;
     expected_blurred_occlusion.Union(gfx::Rect(0, 0, 300, 50 - outset_top));
     expected_blurred_occlusion.Union(gfx::Rect(
         0, 50 - outset_top, 50 - outset_left, 20 + outset_top + outset_bottom));
     expected_blurred_occlusion.Union(
         gfx::Rect(100 + outset_right,
                   50 - outset_top,
                   100 - outset_right - outset_left,
                   20 + outset_top + outset_bottom));
@@ skipping 142 matching lines @@
     filtered_surface->SetBackgroundFilters(filters);
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
     // The surface has a background blur, so it blurs non-opaque pixels below
     // it.
-    this->VisitLayer(filtered_surface, occlusion);
-    this->VisitContributingSurface(filtered_surface, occlusion);
+    this->VisitLayer(filtered_surface, &occlusion);
+    this->VisitContributingSurface(filtered_surface, &occlusion);
 
-    this->VisitLayer(behind_replica_layer, occlusion);
-    this->VisitLayer(behind_surface_layer, occlusion);
+    this->VisitLayer(behind_replica_layer, &occlusion);
+    this->VisitLayer(behind_surface_layer, &occlusion);
 
     // The layers behind the surface are not blurred, and their occlusion does
     // not change, until we leave the surface.  So it should not be modified by
     // the filter here.
     gfx::Rect occlusion_behind_surface = gfx::Rect(60, 60, 30, 30);
     gfx::Rect occlusion_behind_replica = gfx::Rect(210, 60, 30, 30);
 
     Region expected_opaque_bounds =
         UnionRegions(occlusion_behind_surface, occlusion_behind_replica);
     EXPECT_EQ(expected_opaque_bounds.ToString(),
@@ skipping 52 matching lines @@
     WebKit::WebFilterOperations filters;
     filters.append(WebKit::WebFilterOperation::createBlurFilter(3.f));
     filtered_surface->SetBackgroundFilters(filters);
 
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->VisitLayer(above_replica_layer, occlusion);
-    this->VisitLayer(above_surface_layer, occlusion);
+    this->VisitLayer(above_replica_layer, &occlusion);
+    this->VisitLayer(above_surface_layer, &occlusion);
 
-    this->VisitLayer(filtered_surface, occlusion);
+    this->VisitLayer(filtered_surface, &occlusion);
     {
       // The layers above the filtered surface occlude from outside.
       gfx::Rect occlusion_above_surface = gfx::Rect(0, 0, 50, 50);
       gfx::Rect occlusion_above_replica = gfx::Rect(150, 0, 50, 50);
       Region expected_opaque_region =
           UnionRegions(occlusion_above_surface, occlusion_above_replica);
 
       EXPECT_EQ(gfx::Rect().ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
       EXPECT_EQ(expected_opaque_region.ToString(),
                 occlusion.occlusion_from_outside_target().ToString());
     }
 
     // The surface has a background blur, so it blurs non-opaque pixels below
     // it.
-    this->VisitContributingSurface(filtered_surface, occlusion);
+    this->VisitContributingSurface(filtered_surface, &occlusion);
     {
       // The filter is completely occluded, so it should not blur anything and
       // reduce any occlusion.
       gfx::Rect occlusion_above_surface = gfx::Rect(50, 50, 50, 50);
       gfx::Rect occlusion_above_replica = gfx::Rect(200, 50, 50, 50);
       Region expected_opaque_region =
           UnionRegions(occlusion_above_surface, occlusion_above_replica);
 
       EXPECT_EQ(expected_opaque_region.ToString(),
                 occlusion.occlusion_from_inside_target().ToString());
@@ skipping 68 matching lines @@
     // 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<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> 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);
+    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);
+    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.
     gfx::Rect occlusion_above_surface =
         gfx::Rect(70 + outset_right, 50, 30 - outset_right, 50);
     gfx::Rect occlusion_above_replica =
@@ skipping 47 matching lines @@
                                  below_tracking_size,
                                  true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
     occlusion.set_minimum_tracking_size(tracking_size);
 
     // The small layer is not tracked because it is too small.
-    this->VisitLayer(small, occlusion);
+    this->VisitLayer(small, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
 
     // The large layer is tracked as it is large enough.
-    this->VisitLayer(large, occlusion);
+    this->VisitLayer(large, &occlusion);
 
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect(tracking_size).ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestMinimumTrackingSize);
 
@@ skipping 18 matching lines @@
                                  gfx::PointF(),
                                  gfx::Size(400, 400),
                                  false);
     small->SetMasksToBounds(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 100, 100));
 
-    this->EnterLayer(large, occlusion);
+    this->EnterLayer(large, &occlusion);
 
     bool has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedLayerContentRect(
                        large,
                        gfx::Rect(0, 0, 400, 400),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_FALSE(
         occlusion.OccludedLayer(large,
                                 gfx::Rect(0, 0, 400, 400),
                                 &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
-    this->LeaveLayer(large, occlusion);
-    this->VisitLayer(small, occlusion);
+    this->LeaveLayer(large, &occlusion);
+    this->VisitLayer(small, &occlusion);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedLayerContentRect(
                        small,
                        gfx::Rect(0, 0, 200, 200),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_FALSE(
         occlusion.OccludedLayer(small,
                                 gfx::Rect(0, 0, 200, 200),
                                 &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
-    this->EnterContributingSurface(small, occlusion);
+    this->EnterContributingSurface(small, &occlusion);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        small,
                        false,
                        gfx::Rect(0, 0, 200, 200),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
   }
@@ skipping 31 matching lines @@
                                  false);
     smallest->SetMasksToBounds(true);
     smaller->SetMasksToBounds(true);
     small->SetMasksToBounds(true);
     this->CalcDrawEtc(parent);
 
     TestOcclusionTrackerWithClip<typename Types::LayerType,
                                  typename Types::RenderSurfaceType> occlusion(
         gfx::Rect(0, 0, 1000, 1000));
 
-    this->EnterLayer(large, occlusion);
+    this->EnterLayer(large, &occlusion);
 
     // Clipping from the smaller layer is from outside the target surface.
     bool has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedLayerContentRect(
                        large,
                        gfx::Rect(0, 0, 400, 400),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_FALSE(
         occlusion.OccludedLayer(large,
                                 gfx::Rect(0, 0, 400, 400),
                                 &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
-    this->LeaveLayer(large, occlusion);
-    this->VisitLayer(small, occlusion);
+    this->LeaveLayer(large, &occlusion);
+    this->VisitLayer(small, &occlusion);
 
     // Clipping from the smaller layer is from outside the target surface.
     has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                    occlusion.UnoccludedLayerContentRect(
                        small,
                        gfx::Rect(0, 0, 200, 200),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
     has_occlusion_from_outside_target_surface = false;
     EXPECT_FALSE(
         occlusion.OccludedLayer(small,
                                 gfx::Rect(0, 0, 200, 200),
                                 &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
-    this->EnterContributingSurface(small, occlusion);
+    this->EnterContributingSurface(small, &occlusion);
 
     // The |small| surface is clipped from outside its target by |smallest|.
     has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        small,
                        false,
                        gfx::Rect(0, 0, 200, 200),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_TRUE(has_occlusion_from_outside_target_surface);
 
-    this->LeaveContributingSurface(small, occlusion);
-    this->VisitLayer(smaller, occlusion);
-    this->EnterContributingSurface(smaller, occlusion);
+    this->LeaveContributingSurface(small, &occlusion);
+    this->VisitLayer(smaller, &occlusion);
+    this->EnterContributingSurface(smaller, &occlusion);
 
     // The |smaller| surface is clipped from inside its target by |smallest|.
     has_occlusion_from_outside_target_surface = false;
     EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50),
                    occlusion.UnoccludedContributingSurfaceContentRect(
                        smaller,
                        false,
                        gfx::Rect(0, 0, 100, 100),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_FALSE(has_occlusion_from_outside_target_surface);
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipIsExternalOcclusion)
 
 }  // namespace
 }  // namespace cc