Remove QuadSink::MaybeAppend and the QuadCuller unit tests.

The QuadCuller unit tests are now testing the TiledLayerImpl instead of the QuadCuller, and have been superceded by the FooLayerImpl.Occlusion tests for each LayerImpl subclass. R=enne@chromium.org BUG=344962 Review URL: https://codereview.chromium.org/248223002 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@265653 0039d316-1c4b-4281-b951-d872f2087c98
Denger-Network · Apr 23, 2014 · 59be4db · 59be4db
1 parent fc6b05e
commit 59be4db
Show file tree

Hide file tree

Showing 11 changed files with 15 additions and 864 deletions.
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
@@ -108,7 +108,6 @@
       'trees/layer_tree_host_unittest_scroll.cc',
       'trees/layer_tree_host_unittest_video.cc',
       'trees/occlusion_tracker_unittest.cc',
-      'trees/quad_culler_unittest.cc',
       'trees/tree_synchronizer_unittest.cc',
     ],
     'cc_surfaces_unit_tests_source_files': [

diff --git a/cc/layers/quad_sink.h b/cc/layers/quad_sink.h
@@ -37,10 +37,6 @@ class CC_EXPORT QuadSink {
       const gfx::Rect& content_rect,
       const gfx::Transform& draw_transform) = 0;
 
-  // Returns true if the quad is added to the list, and false if the quad is
-  // entirely culled.
-  virtual bool MaybeAppend(scoped_ptr<DrawQuad> draw_quad) = 0;
-
   virtual void Append(scoped_ptr<DrawQuad> draw_quad) = 0;
 };
 

diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc
@@ -76,7 +76,7 @@ void AddTestRenderPassQuad(TestRenderPass* pass,
                gfx::RectF(),
                FilterOperations(),
                FilterOperations());
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
 }
 
 void AddQuadInPass(TestRenderPass* pass, Quad desc) {

diff --git a/cc/test/mock_quad_culler.cc b/cc/test/mock_quad_culler.cc
@@ -60,14 +60,6 @@ gfx::Rect MockQuadCuller::UnoccludedContributingSurfaceContentRect(
   return result;
 }
 
-bool MockQuadCuller::MaybeAppend(scoped_ptr<DrawQuad> draw_quad) {
-  if (!draw_quad->rect.IsEmpty()) {
-    active_quad_list_->push_back(draw_quad.Pass());
-    return true;
-  }
-  return false;
-}
-
 void MockQuadCuller::Append(scoped_ptr<DrawQuad> draw_quad) {
   DCHECK(!draw_quad->rect.IsEmpty());
   DCHECK(!draw_quad->visible_rect.IsEmpty());

diff --git a/cc/test/mock_quad_culler.h b/cc/test/mock_quad_culler.h
@@ -29,7 +29,6 @@ class MockQuadCuller : public QuadSink {
   virtual gfx::Rect UnoccludedContributingSurfaceContentRect(
       const gfx::Rect& content_rect,
       const gfx::Transform& draw_transform) OVERRIDE;
-  virtual bool MaybeAppend(scoped_ptr<DrawQuad> draw_quad) OVERRIDE;
   virtual void Append(scoped_ptr<DrawQuad> draw_quad) OVERRIDE;
 
   const QuadList& quad_list() const { return *active_quad_list_; }

diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
@@ -44,7 +44,7 @@ SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(shared_state, rect, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
   return quad_ptr;
 }
 
@@ -64,7 +64,7 @@ SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(shared_state, rect, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
   return quad_ptr;
 }
 
@@ -80,7 +80,7 @@ SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
   scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
   quad->SetNew(shared_state, rect, rect, color, false);
   SolidColorDrawQuad* quad_ptr = quad.get();
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
   return quad_ptr;
 }
 
@@ -109,7 +109,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                gfx::RectF(),
                FilterOperations(),
                FilterOperations());
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
 }
 
 void AddRenderPassQuad(TestRenderPass* to_pass,
@@ -140,7 +140,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                gfx::RectF(),
                filters,
                FilterOperations());
-  quad_sink.MaybeAppend(quad.PassAs<DrawQuad>());
+  quad_sink.Append(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
@@ -569,12 +569,10 @@ static void AppendQuadsForLayer(
     LayerImpl* layer,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
-  bool for_surface = false;
   QuadCuller quad_culler(&target_render_pass->quad_list,
                          &target_render_pass->shared_quad_state_list,
                          layer,
-                         occlusion_tracker,
-                         for_surface);
+                         occlusion_tracker);
   layer->AppendQuads(&quad_culler, append_quads_data);
 }
 
@@ -584,12 +582,10 @@ static void AppendQuadsForRenderSurfaceLayer(
     const RenderPass* contributing_render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
-  bool for_surface = true;
   QuadCuller quad_culler(&target_render_pass->quad_list,
                          &target_render_pass->shared_quad_state_list,
                          layer,
-                         occlusion_tracker,
-                         for_surface);
+                         occlusion_tracker);
 
   bool is_replica = false;
   layer->render_surface()->AppendQuads(&quad_culler,
@@ -632,12 +628,10 @@ static void AppendQuadsToFillScreen(
     screen_background_color_region.Intersect(root_scroll_layer_rect);
   }
 
-  bool for_surface = false;
   QuadCuller quad_culler(&target_render_pass->quad_list,
                          &target_render_pass->shared_quad_state_list,
                          root_layer,
-                         occlusion_tracker,
-                         for_surface);
+                         occlusion_tracker);
 
   // Manually create the quad state for the gutter quads, as the root layer
   // doesn't have any bounds and so can't generate this itself.

diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -3305,7 +3305,7 @@ class BlendStateCheckLayer : public LayerImpl {
     test_blending_draw_quad->visible_rect = quad_visible_rect_;
     EXPECT_EQ(blend_, test_blending_draw_quad->ShouldDrawWithBlending());
     EXPECT_EQ(has_render_surface_, !!render_surface());
-    quad_sink->MaybeAppend(test_blending_draw_quad.PassAs<DrawQuad>());
+    quad_sink->Append(test_blending_draw_quad.PassAs<DrawQuad>());
   }
 
   void SetExpectation(bool blend, bool has_render_surface) {
@@ -4081,7 +4081,7 @@ class FakeLayerWithQuads : public LayerImpl {
     scoped_ptr<SolidColorDrawQuad> my_quad = SolidColorDrawQuad::Create();
     my_quad->SetNew(
         shared_quad_state, quad_rect, visible_quad_rect, gray, false);
-    quad_sink->MaybeAppend(my_quad.PassAs<DrawQuad>());
+    quad_sink->Append(my_quad.PassAs<DrawQuad>());
   }
 
  private:

diff --git a/cc/trees/quad_culler.cc b/cc/trees/quad_culler.cc
@@ -19,14 +19,13 @@ namespace cc {
 QuadCuller::QuadCuller(QuadList* quad_list,
                        SharedQuadStateList* shared_quad_state_list,
                        const LayerImpl* layer,
-                       const OcclusionTracker<LayerImpl>& occlusion_tracker,
-                       bool for_surface)
+                       const OcclusionTracker<LayerImpl>& occlusion_tracker)
     : quad_list_(quad_list),
       shared_quad_state_list_(shared_quad_state_list),
       layer_(layer),
       occlusion_tracker_(occlusion_tracker),
-      current_shared_quad_state_(NULL),
-      for_surface_(for_surface) {}
+      current_shared_quad_state_(NULL) {
+}
 
 SharedQuadState* QuadCuller::UseSharedQuadState(
     scoped_ptr<SharedQuadState> shared_quad_state) {
@@ -51,46 +50,6 @@ gfx::Rect QuadCuller::UnoccludedContributingSurfaceContentRect(
       layer_, content_rect, draw_transform);
 }
 
-static inline bool AppendQuadInternal(
-    scoped_ptr<DrawQuad> draw_quad,
-    const gfx::Rect& culled_rect,
-    QuadList* quad_list,
-    const OcclusionTracker<LayerImpl>& occlusion_tracker,
-    const LayerImpl* layer) {
-  bool keep_quad = !culled_rect.IsEmpty();
-  if (keep_quad) {
-    draw_quad->visible_rect = culled_rect;
-    quad_list->push_back(draw_quad.Pass());
-  }
-  return keep_quad;
-}
-
-bool QuadCuller::MaybeAppend(scoped_ptr<DrawQuad> draw_quad) {
-  DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_);
-  DCHECK(!shared_quad_state_list_->empty());
-  DCHECK(shared_quad_state_list_->back() == current_shared_quad_state_);
-
-  gfx::Rect culled_rect;
-  if (for_surface_) {
-    RenderSurfaceImpl* surface = layer_->render_surface();
-    const RenderPassDrawQuad* rpdq =
-        RenderPassDrawQuad::MaterialCast(draw_quad.get());
-    gfx::Transform draw_transform = rpdq->is_replica
-                                        ? surface->replica_draw_transform()
-                                        : surface->draw_transform();
-    culled_rect = occlusion_tracker_.UnoccludedContributingSurfaceContentRect(
-        layer_, draw_quad->visible_rect, draw_transform);
-  } else {
-    culled_rect =
-        occlusion_tracker_.UnoccludedContentRect(layer_->render_target(),
-                                                 draw_quad->visible_rect,
-                                                 draw_quad->quadTransform());
-  }
-
-  return AppendQuadInternal(
-      draw_quad.Pass(), culled_rect, quad_list_, occlusion_tracker_, layer_);
-}
-
 void QuadCuller::Append(scoped_ptr<DrawQuad> draw_quad) {
   DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_);
   DCHECK(!shared_quad_state_list_->empty());

diff --git a/cc/trees/quad_culler.h b/cc/trees/quad_culler.h
@@ -20,8 +20,7 @@ class CC_EXPORT QuadCuller : public QuadSink {
   QuadCuller(QuadList* quad_list,
              SharedQuadStateList* shared_quad_state_list,
              const LayerImpl* layer,
-             const OcclusionTracker<LayerImpl>& occlusion_tracker,
-             bool for_surface);
+             const OcclusionTracker<LayerImpl>& occlusion_tracker);
   virtual ~QuadCuller() {}
 
   // QuadSink implementation.
@@ -33,7 +32,6 @@ class CC_EXPORT QuadCuller : public QuadSink {
   virtual gfx::Rect UnoccludedContributingSurfaceContentRect(
       const gfx::Rect& content_rect,
       const gfx::Transform& draw_transform) OVERRIDE;
-  virtual bool MaybeAppend(scoped_ptr<DrawQuad> draw_quad) OVERRIDE;
   virtual void Append(scoped_ptr<DrawQuad> draw_quad) OVERRIDE;
 
  private:
@@ -43,7 +41,6 @@ class CC_EXPORT QuadCuller : public QuadSink {
   const OcclusionTracker<LayerImpl>& occlusion_tracker_;
 
   SharedQuadState* current_shared_quad_state_;
-  bool for_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(QuadCuller);
 };