Removed QuadSink and MockQuadCuller

cc/layers/tiled_layer_impl.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_impl.h"
 
 #include "base/basictypes.h"
 #include "base/strings/stringprintf.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/layers/append_quads_data.h"
-#include "cc/layers/quad_sink.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_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/trees/occlusion_tracker.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/quad_f.h"
 
 namespace cc {
 
 class DrawableTile : public LayerTilingData::Tile {
  public:
   static scoped_ptr<DrawableTile> Create() {
     return make_scoped_ptr(new DrawableTile());
@@ skipping 116 matching lines @@
 
 bool TiledLayerImpl::WillDraw(DrawMode draw_mode,
                               ResourceProvider* resource_provider) {
   if (!tiler_ || tiler_->has_empty_bounds() ||
       visible_content_rect().IsEmpty() ||
       draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
-void TiledLayerImpl::AppendQuads(QuadSink* quad_sink,
-                                 AppendQuadsData* append_quads_data) {
+void TiledLayerImpl::AppendQuads(
+    RenderPass* render_pass,
+    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    AppendQuadsData* append_quads_data) {
   DCHECK(tiler_);
   DCHECK(!tiler_->has_empty_bounds());
   DCHECK(!visible_content_rect().IsEmpty());
 
   gfx::Rect content_rect = visible_content_rect();
-  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  SharedQuadState* shared_quad_state =
+      render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
 
   AppendDebugBorderQuad(
-      quad_sink, content_bounds(), shared_quad_state, append_quads_data);
+      render_pass, content_bounds(), shared_quad_state, append_quads_data);
 
   int left, top, right, bottom;
   tiler_->ContentRectToTileIndices(content_rect, &left, &top, &right, &bottom);
 
   if (ShowDebugBorders()) {
     for (int j = top; j <= bottom; ++j) {
       for (int i = left; i <= right; ++i) {
         DrawableTile* tile = TileAt(i, j);
         gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
         gfx::Rect visible_tile_rect = tile_rect;
         SkColor border_color;
         float border_width;
 
         if (skips_draw_ || !tile || !tile->resource_id()) {
           border_color = DebugColors::MissingTileBorderColor();
           border_width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
         } else {
           border_color = DebugColors::HighResTileBorderColor();
           border_width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         }
         scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
             DebugBorderDrawQuad::Create();
         debug_border_quad->SetNew(shared_quad_state,
                                   tile_rect,
                                   visible_tile_rect,
                                   border_color,
                                   border_width);
-        quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
+        render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
       }
     }
   }
 
   if (skips_draw_)
     return;
 
   for (int j = top; j <= bottom; ++j) {
     for (int i = left; i <= right; ++i) {
       DrawableTile* tile = TileAt(i, j);
       gfx::Rect tile_rect = tiler_->tile_bounds(i, j);
       gfx::Rect display_rect = tile_rect;
       tile_rect.Intersect(content_rect);
 
       // Skip empty tiles.
       if (tile_rect.IsEmpty())
         continue;
 
       gfx::Rect visible_tile_rect =
-          quad_sink->UnoccludedContentRect(tile_rect, draw_transform());
+          occlusion_tracker.UnoccludedContentRect(tile_rect, draw_transform());
       if (visible_tile_rect.IsEmpty())
         continue;
 
       if (!tile || !tile->resource_id()) {
         SkColor checker_color;
         if (ShowDebugBorders()) {
           checker_color =
               tile ? DebugColors::InvalidatedTileCheckerboardColor()
                    : DebugColors::EvictedTileCheckerboardColor();
         } else {
           checker_color = DebugColors::DefaultCheckerboardColor();
         }
 
         scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
             CheckerboardDrawQuad::Create();
         checkerboard_quad->SetNew(
             shared_quad_state, tile_rect, visible_tile_rect, checker_color);
-        quad_sink->Append(checkerboard_quad.PassAs<DrawQuad>());
+        render_pass->AppendDrawQuad(checkerboard_quad.PassAs<DrawQuad>());
         append_quads_data->num_missing_tiles++;
         continue;
       }
 
       gfx::Rect tile_opaque_rect =
           contents_opaque() ? tile_rect : gfx::IntersectRects(
                                               tile->opaque_rect(), tile_rect);
 
       // Keep track of how the top left has moved, so the texture can be
       // offset the same amount.
       gfx::Vector2d display_offset = tile_rect.origin() - display_rect.origin();
       gfx::Vector2d texture_offset =
           tiler_->texture_offset(i, j) + display_offset;
       gfx::RectF tex_coord_rect = gfx::RectF(tile_rect.size()) + texture_offset;
 
       float tile_width = static_cast<float>(tiler_->tile_size().width());
       float tile_height = static_cast<float>(tiler_->tile_size().height());
       gfx::Size texture_size(tile_width, tile_height);
 
       scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
       quad->SetNew(shared_quad_state,
                    tile_rect,
                    tile_opaque_rect,
                    visible_tile_rect,
                    tile->resource_id(),
                    tex_coord_rect,
                    texture_size,
                    tile->contents_swizzled());
-      quad_sink->Append(quad.PassAs<DrawQuad>());
+      render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     }
   }
 }
 
 void TiledLayerImpl::SetTilingData(const LayerTilingData& tiler) {
   if (tiler_) {
     tiler_->reset();
   } else {
     tiler_ = LayerTilingData::Create(tiler.tile_size(),
                                      tiler.has_border_texels()
@@ skipping 36 matching lines @@
 
 void TiledLayerImpl::ReleaseResources() {
   tiler_->reset();
 }
 
 const char* TiledLayerImpl::LayerTypeAsString() const {
   return "cc::TiledLayerImpl";
 }
 
 }  // namespace cc