cc: Clean up OcclusionTracker template parameters.

cc/trees/quad_culler_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/quad_culler.h"
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
-#include "cc/test/occlusion_tracker_test_common.h"
+#include "cc/test/test_occlusion_tracker.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
-class TestOcclusionTrackerImpl
-    : public TestOcclusionTrackerBase<LayerImpl, RenderSurfaceImpl> {
- public:
-  TestOcclusionTrackerImpl(const gfx::Rect& scissor_rect_in_screen,
-                           bool record_metrics_for_frame = true)
-      : TestOcclusionTrackerBase(scissor_rect_in_screen,
-                                 record_metrics_for_frame) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestOcclusionTrackerImpl);
-};
-
 typedef LayerIterator<LayerImpl> LayerIteratorType;
 
 class QuadCullerTest : public testing::Test {
  public:
   QuadCullerTest()
       : host_impl_(&proxy_),
         layer_id_(1) {}
 
   scoped_ptr<TiledLayerImpl> MakeLayer(TiledLayerImpl* parent,
                                        const gfx::Transform& draw_transform,
@@ skipping 45 matching lines @@
     }
     layer->draw_properties().drawable_content_rect = rect_in_target;
 
     return layer.Pass();
   }
 
   void AppendQuads(QuadList* quad_list,
                    SharedQuadStateList* shared_state_list,
                    TiledLayerImpl* layer,
                    LayerIteratorType* it,
-                   OcclusionTrackerImpl* occlusion_tracker) {
+                   OcclusionTracker<LayerImpl>* occlusion_tracker) {
     occlusion_tracker->EnterLayer(*it);
     QuadCuller quad_culler(
         quad_list, shared_state_list, layer, *occlusion_tracker, false, false);
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
     occlusion_tracker->LeaveLayer(*it);
     ++it;
   }
 
  protected:
@@ skipping 25 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      gfx::Transform(),
                                                      child_rect,
                                                      1.f,
                                                      false,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 19 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      gfx::Transform(),
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 19 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      0.9f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 19 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      false,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 20 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 45 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 30 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 20 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 24 matching lines @@
                               child_rect.y() + child_rect.height() / 4,
                               child_rect.width() / 2,
                               child_rect.height() / 2);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      false,
                                                      child_opaque_rect,
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 25 matching lines @@
                               child_rect.y() + child_rect.height() / 4,
                               child_rect.width() / 2,
                               child_rect.height() * 3 / 4);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      false,
                                                      child_opaque_rect,
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 25 matching lines @@
                               child_rect.y() + child_rect.height() / 4,
                               child_rect.width() / 2,
                               child_rect.height() / 2);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      false,
                                                      child_opaque_rect,
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 23 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      child_transform,
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 28 matching lines @@
                                                     true,
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      gfx::Transform(),
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 19 matching lines @@
                                                     gfx::Rect(),
                                                     render_surface_layer_list);
   scoped_ptr<TiledLayerImpl> child_layer = MakeLayer(root_layer.get(),
                                                      gfx::Transform(),
                                                      child_rect,
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
   bool record_metrics = false;
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(-100, -100, 1000, 1000),
-                                             record_metrics);
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(
+      gfx::Rect(-100, -100, 1000, 1000), record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   AppendQuads(&quad_list,
               &shared_state_list,
               child_layer.get(),
               &it,
               &occlusion_tracker);
   AppendQuads(&quad_list,
               &shared_state_list,
               root_layer.get(),
@@ skipping 12 matching lines @@
   DECLARE_AND_INITIALIZE_TEST_QUADS();
 
   scoped_ptr<TiledLayerImpl> dummy_layer = MakeLayer(NULL,
                                                      gfx::Transform(),
                                                      gfx::Rect(),
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
 
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(gfx::Rect(1000, 1000),
+                                                    record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   QuadCuller culler(&quad_list,
                     &shared_state_list,
                     dummy_layer.get(),
                     occlusion_tracker,
                     false,
                     false);
 
   SharedQuadState* sqs = culler.UseSharedQuadState(SharedQuadState::Create());
@@ skipping 53 matching lines @@
   DECLARE_AND_INITIALIZE_TEST_QUADS();
 
   scoped_ptr<TiledLayerImpl> dummy_layer = MakeLayer(NULL,
                                                      gfx::Transform(),
                                                      gfx::Rect(),
                                                      1.f,
                                                      true,
                                                      gfx::Rect(),
                                                      render_surface_layer_list);
 
-  TestOcclusionTrackerImpl occlusion_tracker(gfx::Rect(1000, 1000));
+  bool record_metrics = true;
+  TestOcclusionTracker<LayerImpl> occlusion_tracker(gfx::Rect(1000, 1000),
+                                                    record_metrics);
   LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list);
 
   QuadCuller culler(&quad_list,
                     &shared_state_list,
                     dummy_layer.get(),
                     occlusion_tracker,
                     false,
                     false);
 
   SharedQuadState* sqs = culler.UseSharedQuadState(SharedQuadState::Create());
@@ skipping 46 matching lines @@
   EXPECT_EQ(gfx::Rect(15, 10, 5, 11).ToString(),
             quad_list[0]->visible_rect.ToString());
   EXPECT_EQ(gfx::Rect(15, 20, 8, 14).ToString(),
             quad_list[1]->visible_rect.ToString());
   EXPECT_EQ(gfx::Rect(15, 30, 10, 16).ToString(),
             quad_list[2]->visible_rect.ToString());
 }
 
 }  // namespace
 }  // namespace cc