Removed QuadSink and MockQuadCuller

cc/layers/delegated_renderer_layer_impl.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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/append_quads_data.h"
-#include "cc/layers/quad_sink.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "cc/trees/occlusion_tracker.h"
 
 namespace cc {
 
 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* tree_impl,
                                                        int id)
     : LayerImpl(tree_impl, id),
       have_render_passes_to_push_(false),
       inverse_device_scale_factor_(1.0f),
       child_id_(0),
       own_child_id_(false) {
@@ skipping 219 matching lines @@
 }
 
 bool DelegatedRendererLayerImpl::WillDraw(DrawMode draw_mode,
                                           ResourceProvider* resource_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
   return LayerImpl::WillDraw(draw_mode, resource_provider);
 }
 
 void DelegatedRendererLayerImpl::AppendQuads(
-    QuadSink* quad_sink,
+    RenderPass* render_pass,
+    const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
-  AppendRainbowDebugBorder(quad_sink, append_quads_data);
+  AppendRainbowDebugBorder(render_pass, append_quads_data);
 
   // This list will be empty after a lost context until a new frame arrives.
   if (render_passes_in_draw_order_.empty())
     return;
 
   RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
 
   DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
   gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
 
   // If the index of the RenderPassId is 0, then it is a RenderPass generated
   // for a layer in this compositor, not the delegating renderer. Then we want
   // to merge our root RenderPass with the target RenderPass. Otherwise, it is
   // some RenderPass which we added from the delegating renderer.
   bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
   if (should_merge_root_render_pass_with_target) {
     // Verify that the RenderPass we are appending to is created by our
     // render_target.
     DCHECK(target_render_pass_id.layer_id == render_target()->id());
 
-    AppendRenderPassQuads(
-        quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
+    AppendRenderPassQuads(render_pass,
+                          occlusion_tracker,
+                          append_quads_data,
+                          root_delegated_render_pass,
+                          frame_size);
   } else {
     // Verify that the RenderPass we are appending to was created by us.
     DCHECK(target_render_pass_id.layer_id == id());
 
     int render_pass_index = IdToIndex(target_render_pass_id.index);
     const RenderPass* delegated_render_pass =
         render_passes_in_draw_order_[render_pass_index];
-    AppendRenderPassQuads(
-        quad_sink, append_quads_data, delegated_render_pass, frame_size);
+    AppendRenderPassQuads(render_pass,
+                          occlusion_tracker,
+                          append_quads_data,
+                          delegated_render_pass,
+                          frame_size);
   }
 }
 
 void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
-    QuadSink* quad_sink,
+    RenderPass* render_pass,
     AppendQuadsData* append_quads_data) {
   if (!ShowDebugBorders())
     return;
 
-  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  SharedQuadState* shared_quad_state =
+      render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);
 
   SkColor color;
   float border_width;
   GetDebugBorderProperties(&color, &border_width);
 
   SkColor colors[] = {
     0x80ff0000,  // Red.
     0x80ffa500,  // Orange.
     0x80ffff00,  // Yellow.
@@ skipping 26 matching lines @@
                     border_width,
                     height);
 
     if (top.IsEmpty() && left.IsEmpty())
       break;
 
     if (!top.IsEmpty()) {
       scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
       top_quad->SetNew(
           shared_quad_state, top, top, colors[i % kNumColors], false);
-      quad_sink->Append(top_quad.PassAs<DrawQuad>());
+      render_pass->AppendDrawQuad(top_quad.PassAs<DrawQuad>());
 
       scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
       bottom_quad->SetNew(shared_quad_state,
                           bottom,
                           bottom,
                           colors[kNumColors - 1 - (i % kNumColors)],
                           false);
-      quad_sink->Append(bottom_quad.PassAs<DrawQuad>());
+      render_pass->AppendDrawQuad(bottom_quad.PassAs<DrawQuad>());
     }
     if (!left.IsEmpty()) {
       scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
       left_quad->SetNew(shared_quad_state,
                         left,
                         left,
                         colors[kNumColors - 1 - (i % kNumColors)],
                         false);
-      quad_sink->Append(left_quad.PassAs<DrawQuad>());
+      render_pass->AppendDrawQuad(left_quad.PassAs<DrawQuad>());
 
       scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
       right_quad->SetNew(
           shared_quad_state, right, right, colors[i % kNumColors], false);
-      quad_sink->Append(right_quad.PassAs<DrawQuad>());
+      render_pass->AppendDrawQuad(right_quad.PassAs<DrawQuad>());
     }
   }
 }
 
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
-    QuadSink* quad_sink,
+    RenderPass* render_pass,
+    const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
-
   const SharedQuadState* delegated_shared_quad_state = NULL;
   SharedQuadState* output_shared_quad_state = NULL;
 
   for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
     const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
 
     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
-      output_shared_quad_state = quad_sink->CreateSharedQuadState();
+      output_shared_quad_state = render_pass->CreateAndAppendSharedQuadState();
       output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       bool is_root_delegated_render_pass =
           delegated_render_pass == render_passes_in_draw_order_.back();
       if (is_root_delegated_render_pass) {
         gfx::Transform delegated_frame_to_target_transform = draw_transform();
         delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
                                                   inverse_device_scale_factor_);
 
         output_shared_quad_state->content_to_target_transform.ConcatTransform(
@@ skipping 16 matching lines @@
           }
           output_shared_quad_state->clip_rect = clip_rect;
           output_shared_quad_state->is_clipped = true;
         }
 
         output_shared_quad_state->opacity *= draw_opacity();
       }
     }
     DCHECK(output_shared_quad_state);
 
-    gfx::Rect quad_visible_rect = quad_sink->UnoccludedContentRect(
+    gfx::Rect quad_visible_rect = occlusion_tracker.UnoccludedContentRect(
         delegated_quad->visible_rect,
         output_shared_quad_state->content_to_target_transform);
     if (quad_visible_rect.IsEmpty())
       continue;
 
     scoped_ptr<DrawQuad> output_quad;
     if (delegated_quad->material != DrawQuad::RENDER_PASS) {
       output_quad = delegated_quad->Copy(output_shared_quad_state);
       output_quad->visible_rect = quad_visible_rect;
     } else {
@@ skipping 12 matching lines @@
                append_quads_data->render_pass_id);
 
         output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
             output_shared_quad_state,
             output_contributing_render_pass_id).PassAs<DrawQuad>();
         output_quad->visible_rect = quad_visible_rect;
       }
     }
 
     if (output_quad)
-      quad_sink->Append(output_quad.Pass());
+      render_pass->AppendDrawQuad(output_quad.Pass());
   }
 }
 
 const char* DelegatedRendererLayerImpl::LayerTypeAsString() const {
   return "cc::DelegatedRendererLayerImpl";
 }
 
 void DelegatedRendererLayerImpl::ClearChildId() {
   if (!child_id_)
     return;
 
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc