cc: Clean up OcclusionTracker template parameters.

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 22 matching lines @@
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_painted_scrollbar_layer.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_scoped_ui_resource.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test.h"
-#include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "skia/ext/refptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
@@ skipping 1268 matching lines @@
  public:
   static scoped_refptr<ContentLayerWithUpdateTracking> Create(
       ContentLayerClient* client) {
     return make_scoped_refptr(new ContentLayerWithUpdateTracking(client));
   }
 
   int PaintContentsCount() { return paint_contents_count_; }
   void ResetPaintContentsCount() { paint_contents_count_ = 0; }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker* occlusion) OVERRIDE {
+                      const OcclusionTracker<Layer>* occlusion) OVERRIDE {
     bool updated = ContentLayer::Update(queue, occlusion);
     paint_contents_count_++;
     return updated;
   }
 
  private:
   explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
       : ContentLayer(client), paint_contents_count_(0) {
     SetAnchorPoint(gfx::PointF(0.f, 0.f));
     SetBounds(gfx::Size(10, 10));
@@ skipping 670 matching lines @@
 // Surfaces don't exist with a delegated renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_NOIMPL_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
  public:
   static scoped_refptr<EvictionTestLayer> Create() {
     return make_scoped_refptr(new EvictionTestLayer());
   }
 
-  virtual bool Update(ResourceUpdateQueue*, const OcclusionTracker*) OVERRIDE;
+  virtual bool Update(ResourceUpdateQueue*,
+                      const OcclusionTracker<Layer>*) OVERRIDE;
   virtual bool DrawsContent() const OVERRIDE { return true; }
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       OVERRIDE;
   virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
   virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
 
   bool HaveBackingTexture() const {
     return texture_.get() ? texture_->have_backing_texture() : false;
   }
@@ skipping 40 matching lines @@
 };
 
 void EvictionTestLayer::SetTexturePriorities(const PriorityCalculator&) {
   CreateTextureIfNeeded();
   if (!texture_)
     return;
   texture_->set_request_priority(PriorityCalculator::UIPriority(true));
 }
 
 bool EvictionTestLayer::Update(ResourceUpdateQueue* queue,
-                               const OcclusionTracker*) {
+                               const OcclusionTracker<Layer>* occlusion) {
   CreateTextureIfNeeded();
   if (!texture_)
     return false;
 
   gfx::Rect full_rect(0, 0, 10, 10);
   ResourceUpdate upload = ResourceUpdate::Create(
       texture_.get(), &bitmap_, full_rect, full_rect, gfx::Vector2d());
   queue->AppendFullUpload(upload);
   return true;
 }
@@ skipping 2565 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(LayerTreeHostTestMemoryLimits);
 
 class LayerSetsNeedsFilterContext : public Layer {
  public:
   static scoped_refptr<LayerSetsNeedsFilterContext> Create() {
     return make_scoped_refptr(new LayerSetsNeedsFilterContext());
   }
 
   virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker* occlusion) OVERRIDE {
+                      const OcclusionTracker<Layer>* occlusion) OVERRIDE {
     bool updated = Layer::Update(queue, occlusion);
     if (needs_context_) {
       layer_tree_host()->set_needs_filter_context();
       return true;
     }
     return updated;
   }
 
   void set_needs_context(bool need) { needs_context_ = need; }
 
@@ skipping 398 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 
   FakeContentLayerClient client_;
   scoped_ptr<FakeScopedUIResource> ui_resource_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestHighResRequiredAfterEvictingUIResources);
 
 }  // namespace cc