cc: Clean up OcclusionTracker template parameters.

cc/layers/tiled_layer.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/layers/tiled_layer.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "build/build_config.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
 #include "cc/resources/layer_updater.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/trees/layer_tree_host.h"
+#include "cc/trees/occlusion_tracker.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 
 // Maximum predictive expansion of the visible area.
 static const int kMaxPredictiveTilesCount = 2;
 
 // Number of rows/columns of tiles to pre-paint.
 // We should increase these further as all textures are
@@ skipping 289 matching lines @@
 bool TiledLayer::TileOnlyNeedsPartialUpdate(UpdatableTile* tile) {
   return !tile->dirty_rect.Contains(tiler_->TileRect(tile)) &&
          tile->managed_resource()->have_backing_texture();
 }
 
 bool TiledLayer::UpdateTiles(int left,
                              int top,
                              int right,
                              int bottom,
                              ResourceUpdateQueue* queue,
-                             const OcclusionTracker* occlusion,
+                             const OcclusionTracker<Layer>* occlusion,
                              bool* updated) {
   CreateUpdaterIfNeeded();
 
   bool ignore_occlusions = !occlusion;
   if (!HaveTexturesForTiles(left, top, right, bottom, ignore_occlusions)) {
     failed_update_ = true;
     return false;
   }
 
   gfx::Rect update_rect;
@@ skipping 11 matching lines @@
   UpdateTileTextures(
       update_rect, paint_rect, left, top, right, bottom, queue, occlusion);
   return true;
 }
 
 void TiledLayer::MarkOcclusionsAndRequestTextures(
     int left,
     int top,
     int right,
     int bottom,
-    const OcclusionTracker* occlusion) {
+    const OcclusionTracker<Layer>* occlusion) {
   // There is some difficult dependancies between occlusions, recording
   // occlusion metrics and requesting memory so those are encapsulated in this
   // function: - We only want to call RequestLate on unoccluded textures (to
   // preserve memory for other layers when near OOM).  - We only want to record
   // occlusion metrics if all memory requests succeed.
 
   int occluded_tile_count = 0;
   bool succeeded = true;
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
@@ skipping 98 matching lines @@
   }
 }
 
 void TiledLayer::UpdateTileTextures(const gfx::Rect& update_rect,
                                     const gfx::Rect& paint_rect,
                                     int left,
                                     int top,
                                     int right,
                                     int bottom,
                                     ResourceUpdateQueue* queue,
-                                    const OcclusionTracker* occlusion) {
+                                    const OcclusionTracker<Layer>* occlusion) {
   // The update_rect should be in layer space. So we have to convert the
   // paint_rect from content space to layer space.
   float width_scale =
       paint_properties().bounds.width() /
       static_cast<float>(content_bounds().width());
   float height_scale =
       paint_properties().bounds.height() /
       static_cast<float>(content_bounds().height());
   update_rect_ = gfx::ScaleRect(update_rect, width_scale, height_scale);
 
@@ skipping 234 matching lines @@
     bound.Inset(-tiler_->tile_size().width() * kMaxPredictiveTilesCount,
                 -tiler_->tile_size().height() * kMaxPredictiveTilesCount);
     bound.Intersect(gfx::Rect(content_bounds()));
     predicted_visible_rect_.Intersect(bound);
   }
   previous_content_bounds_ = content_bounds();
   previous_visible_rect_ = visible_content_rect();
 }
 
 bool TiledLayer::Update(ResourceUpdateQueue* queue,
-                        const OcclusionTracker* occlusion) {
+                        const OcclusionTracker<Layer>* occlusion) {
   DCHECK(!skips_draw_ && !failed_update_);  // Did ResetUpdateState get skipped?
 
   // Tiled layer always causes commits to wait for activation, as it does
   // not support pending trees.
   SetNextCommitWaitsForActivation();
 
   bool updated = false;
 
   {
     base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
@@ skipping 167 matching lines @@
   gfx::Rect prepaint_rect = visible_content_rect();
   prepaint_rect.Inset(-tiler_->tile_size().width() * kPrepaintColumns,
                       -tiler_->tile_size().height() * kPrepaintRows);
   gfx::Rect content_rect(content_bounds());
   prepaint_rect.Intersect(content_rect);
 
   return prepaint_rect;
 }
 
 }  // namespace cc