Removed QuadSink and MockQuadCuller

cc/layers/render_surface_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/render_surface_impl.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/layers/layer_impl.h"
-#include "cc/layers/quad_sink.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/trees/damage_tracker.h"
+#include "cc/trees/occlusion_tracker.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
     : owning_layer_(owning_layer),
       surface_property_changed_(false),
       draw_opacity_is_animating_(false),
@@ skipping 97 matching lines @@
 
   scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
   pass->SetNew(RenderPassId(),
                content_rect_,
                gfx::IntersectRects(content_rect_,
                                    damage_tracker_->current_damage_rect()),
                screen_space_transform_);
   pass_sink->AppendRenderPass(pass.Pass());
 }
 
-void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
-                                    AppendQuadsData* append_quads_data,
-                                    bool for_replica,
-                                    RenderPass::Id render_pass_id) {
+void RenderSurfaceImpl::AppendQuads(
+    RenderPass* render_pass,
+    const OcclusionTracker<LayerImpl>& occlusion_tracker,
+    AppendQuadsData* append_quads_data,
+    bool for_replica,
+    RenderPass::Id render_pass_id) {
   DCHECK(!for_replica || owning_layer_->has_replica());
 
   const gfx::Transform& draw_transform =
       for_replica ? replica_draw_transform_ : draw_transform_;
   gfx::Rect visible_content_rect =
-      quad_sink->UnoccludedContributingSurfaceContentRect(content_rect_,
-                                                          draw_transform);
+      occlusion_tracker.UnoccludedContributingSurfaceContentRect(
+          content_rect_, draw_transform);
   if (visible_content_rect.IsEmpty())
     return;
 
-  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  SharedQuadState* shared_quad_state =
+      render_pass->CreateAndAppendSharedQuadState();
   shared_quad_state->SetAll(draw_transform,
                             content_rect_.size(),
                             content_rect_,
                             clip_rect_,
                             is_clipped_,
                             draw_opacity_,
                             owning_layer_->blend_mode(),
                             owning_layer_->sorting_context_id());
 
   if (owning_layer_->ShowDebugBorders()) {
     SkColor color = for_replica ?
                     DebugColors::SurfaceReplicaBorderColor() :
                     DebugColors::SurfaceBorderColor();
     float width = for_replica ?
                   DebugColors::SurfaceReplicaBorderWidth(
                       owning_layer_->layer_tree_impl()) :
                   DebugColors::SurfaceBorderWidth(
                       owning_layer_->layer_tree_impl());
     scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
         DebugBorderDrawQuad::Create();
     debug_border_quad->SetNew(
         shared_quad_state, content_rect_, visible_content_rect, color, width);
-    quad_sink->Append(debug_border_quad.PassAs<DrawQuad>());
+    render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
   }
 
   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
   // and its reflection, it's currently not possible to apply a separate mask to
   // the reflection layer or correctly handle opacity in reflections (opacity
   // must be applied after drawing both the layer and its reflection). The
   // solution is to introduce yet another RenderSurfaceImpl to draw the layer
   // and its reflection in. For now we only apply a separate reflection mask if
   // the contents don't have a mask of their own.
   LayerImpl* mask_layer = owning_layer_->mask_layer();
@@ skipping 39 matching lines @@
   quad->SetNew(shared_quad_state,
                content_rect_,
                visible_content_rect,
                render_pass_id,
                for_replica,
                mask_resource_id,
                contents_changed_since_last_frame,
                mask_uv_rect,
                owning_layer_->filters(),
                owning_layer_->background_filters());
-  quad_sink->Append(quad.PassAs<DrawQuad>());
+  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc