cc: Remove the RenderPassId field from AppendQuadsData.

This field is redundant now that we pass a RenderPass* to AppendQuads.

A few tests were passing a different id and the same RenderPass* to
test DelegatedRendererLayerImpl, so I had to adjust the tests to
pass different RenderPass* instead.

R=vmpstr

Review URL: https://codereview.chromium.org/879423002

Cr-Commit-Position: refs/heads/master@{#313630}

cc/layers/append_quads_data.h

@@ -15,15 +15,7 @@ struct AppendQuadsData {
       : num_incomplete_tiles(0),
         num_missing_tiles(0),
         visible_content_area(0),
-        approximated_visible_content_area(0),
-        render_pass_id(0, 0) {}
-
-  explicit AppendQuadsData(RenderPassId render_pass_id)
-      : num_incomplete_tiles(0),
-        num_missing_tiles(0),
-        visible_content_area(0),
-        approximated_visible_content_area(0),
-        render_pass_id(render_pass_id) {}
+        approximated_visible_content_area(0) {}
 
   // Set by the layer appending quads.
   int64 num_incomplete_tiles;
@@ -33,8 +25,6 @@ struct AppendQuadsData {
   int64 visible_content_area;
   // Set by the layer appending quads.
   int64 approximated_visible_content_area;
-  // Given to the layer appending quads.
-  const RenderPassId render_pass_id;
 };
 
 }  // namespace cc

cc/layers/delegated_renderer_layer_impl.cc

@@ -257,13 +257,13 @@ void DelegatedRendererLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const Occlusion& occlusion_in_content_space,
     AppendQuadsData* append_quads_data) {
-  AppendRainbowDebugBorder(render_pass, append_quads_data);
+  AppendRainbowDebugBorder(render_pass);
 
   // This list will be empty after a lost context until a new frame arrives.
   if (render_passes_in_draw_order_.empty())
     return;
 
-  RenderPassId target_render_pass_id = append_quads_data->render_pass_id;
+  RenderPassId target_render_pass_id = render_pass->id;
 
   const RenderPass* root_delegated_render_pass =
       render_passes_in_draw_order_.back();
@@ -283,7 +283,6 @@ void DelegatedRendererLayerImpl::AppendQuads(
 
     AppendRenderPassQuads(render_pass,
                           occlusion_in_content_space,
-                          append_quads_data,
                           root_delegated_render_pass,
                           frame_size);
   } else {
@@ -295,15 +294,13 @@ void DelegatedRendererLayerImpl::AppendQuads(
         render_passes_in_draw_order_[render_pass_index];
     AppendRenderPassQuads(render_pass,
                           occlusion_in_content_space,
-                          append_quads_data,
                           delegated_render_pass,
                           frame_size);
   }
 }
 
 void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
-    RenderPass* render_pass,
-    AppendQuadsData* append_quads_data) {
+    RenderPass* render_pass) {
   if (!ShowDebugBorders())
     return;
 
@@ -385,7 +382,6 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     RenderPass* render_pass,
     const Occlusion& occlusion_in_content_space,
-    AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
     const gfx::Size& frame_size) const {
   const SharedQuadState* delegated_shared_quad_state = nullptr;
@@ -467,8 +463,7 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
       // The frame may have a RenderPassDrawQuad that points to a RenderPass not
       // part of the frame. Just ignore these quads.
       if (present) {
-        DCHECK(output_contributing_render_pass_id !=
-               append_quads_data->render_pass_id);
+        DCHECK(output_contributing_render_pass_id != render_pass->id);
 
         RenderPassDrawQuad* output_quad =
             render_pass->CopyFromAndAppendRenderPassDrawQuad(

cc/layers/delegated_renderer_layer_impl.h

@@ -66,8 +66,7 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
  private:
   void ClearChildId();
 
-  void AppendRainbowDebugBorder(RenderPass* render_pass,
-                                AppendQuadsData* append_quads_data);
+  void AppendRainbowDebugBorder(RenderPass* render_pass);
 
   void SetRenderPasses(RenderPassList* render_passes_in_draw_order);
   void ClearRenderPasses();
@@ -79,7 +78,6 @@ class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
 
   void AppendRenderPassQuads(RenderPass* render_pass,
                              const Occlusion& occlusion_in_content_space,
-                             AppendQuadsData* append_quads_data,
                              const RenderPass* delegated_render_pass,
                              const gfx::Size& frame_size) const;
 

cc/layers/delegated_renderer_layer_impl_unittest.cc

@@ -107,10 +107,7 @@ class DelegatedRendererLayerImplTestSimple
                                           gfx::Transform(1, 0, 0, 1, 9, 10));
     AddRenderPassQuad(pass3, pass2);
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        1.f, &delegated_render_passes);
-
-    // The RenderPasses should be taken by the layer.
-    EXPECT_EQ(0u, delegated_render_passes.size());
+        1.f, delegated_render_passes);
 
     root_layer_ = root_layer.get();
     layer_before_ = layer_before.get();
@@ -577,10 +574,7 @@ class DelegatedRendererLayerImplTestTransform
                        false);
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        delegated_device_scale_factor_, &delegated_render_passes);
-
-    // The RenderPasses should be taken by the layer.
-    EXPECT_EQ(0u, delegated_render_passes.size());
+        delegated_device_scale_factor_, delegated_render_passes);
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
@@ -1013,10 +1007,7 @@ class DelegatedRendererLayerImplTestClip
                        false);
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
-        1.f, &delegated_render_passes);
-
-    // The RenderPasses should be taken by the layer.
-    EXPECT_EQ(0u, delegated_render_passes.size());
+        1.f, delegated_render_passes);
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
@@ -1317,10 +1308,7 @@ TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
   AddRenderPassQuad(pass1, missing_pass.get());
 
   delegated_renderer_layer->SetFrameDataForRenderPasses(
-      1.f, &delegated_render_passes);
-
-  // The RenderPasses should be taken by the layer.
-  EXPECT_EQ(0u, delegated_render_passes.size());
+      1.f, delegated_render_passes);
 
   root_layer->AddChild(delegated_renderer_layer.Pass());
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
@@ -1379,7 +1367,7 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
                     transform,
                     SkXfermode::kSrcOver_Mode);
   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
-      1.f, &delegated_render_passes);
+      1.f, delegated_render_passes);
 
   impl.CalcDrawProps(viewport_size);
 
@@ -1389,21 +1377,21 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
 
     {
       SCOPED_TRACE("Root render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass1_id, occluded);
-      LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass1,
+                                           occluded);
+      LayerTestCommon::VerifyQuadsExactlyCoverRect(pass1->quad_list,
                                                    quad_screen_rect);
-      ASSERT_EQ(1u, impl.quad_list().size());
-      EXPECT_EQ(DrawQuad::RENDER_PASS, impl.quad_list().front()->material);
+      ASSERT_EQ(1u, pass1->quad_list.size());
+      EXPECT_EQ(DrawQuad::RENDER_PASS, pass1->quad_list.front()->material);
     }
     {
       SCOPED_TRACE("Contributing render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass2_id, occluded);
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass2,
+                                           occluded);
       LayerTestCommon::VerifyQuadsExactlyCoverRect(
-          impl.quad_list(), gfx::Rect(quad_screen_rect.size()));
-      ASSERT_EQ(1u, impl.quad_list().size());
-      EXPECT_EQ(DrawQuad::SOLID_COLOR, impl.quad_list().front()->material);
+          pass2->quad_list, gfx::Rect(quad_screen_rect.size()));
+      ASSERT_EQ(1u, pass2->quad_list.size());
+      EXPECT_EQ(DrawQuad::SOLID_COLOR, pass2->quad_list.front()->material);
     }
   }
 
@@ -1413,21 +1401,21 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
 
       SCOPED_TRACE("Root render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass1_id, occluded);
-      LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass1,
+                                           occluded);
+      LayerTestCommon::VerifyQuadsExactlyCoverRect(pass1->quad_list,
                                                    gfx::Rect());
-      EXPECT_EQ(impl.quad_list().size(), 0u);
+      EXPECT_EQ(pass1->quad_list.size(), 0u);
     }
     {
       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
 
       SCOPED_TRACE("Contributing render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass2_id, occluded);
-      LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass2,
+                                           occluded);
+      LayerTestCommon::VerifyQuadsExactlyCoverRect(pass2->quad_list,
                                                    gfx::Rect());
-      EXPECT_EQ(impl.quad_list().size(), 0u);
+      EXPECT_EQ(pass2->quad_list.size(), 0u);
     }
   }
 
@@ -1437,14 +1425,14 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
       gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
 
       SCOPED_TRACE("Root render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass1_id, occlusion_in_root_target);
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass1,
+                                           occlusion_in_root_target);
       size_t partially_occluded_count = 0;
-      LayerTestCommon::VerifyQuadsAreOccluded(impl.quad_list(),
+      LayerTestCommon::VerifyQuadsAreOccluded(pass1->quad_list,
                                               occlusion_in_root_target,
                                               &partially_occluded_count);
       // The layer outputs one quad, which is partially occluded.
-      EXPECT_EQ(1u, impl.quad_list().size());
+      EXPECT_EQ(1u, pass1->quad_list.size());
       EXPECT_EQ(1u, partially_occluded_count);
     }
     {
@@ -1454,21 +1442,20 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
           occlusion_in_root_target - quad_screen_rect.OffsetFromOrigin();
 
       SCOPED_TRACE("Contributing render pass");
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass2_id, occlusion_in_root_target);
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass2,
+                                           occlusion_in_root_target);
       size_t partially_occluded_count = 0;
       LayerTestCommon::VerifyQuadsAreOccluded(
-          impl.quad_list(),
-          occlusion_in_target_of_delegated_quad,
+          pass2->quad_list, occlusion_in_target_of_delegated_quad,
           &partially_occluded_count);
       // The layer outputs one quad, which is partially occluded.
-      EXPECT_EQ(1u, impl.quad_list().size());
+      EXPECT_EQ(1u, pass2->quad_list.size());
       EXPECT_EQ(1u, partially_occluded_count);
       // The quad in the contributing surface is at (211,300) in the root.
       // The occlusion extends to 500 in the x-axis, pushing the left of the
       // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
       EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
-                impl.quad_list().front()->visible_rect.ToString());
+                pass2->quad_list.front()->visible_rect.ToString());
     }
     {
       gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
@@ -1486,21 +1473,20 @@ TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
 
       impl.CalcDrawProps(viewport_size);
 
-      impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass2_id, occlusion_in_root_target);
+      impl.AppendQuadsForPassWithOcclusion(delegated_renderer_layer_impl, pass2,
+                                           occlusion_in_root_target);
       size_t partially_occluded_count = 0;
       LayerTestCommon::VerifyQuadsAreOccluded(
-          impl.quad_list(),
-          occlusion_in_target_of_delegated_quad,
+          pass2->quad_list, occlusion_in_target_of_delegated_quad,
           &partially_occluded_count);
       // The layer outputs one quad, which is partially occluded.
-      EXPECT_EQ(1u, impl.quad_list().size());
+      EXPECT_EQ(1u, pass2->quad_list.size());
       EXPECT_EQ(1u, partially_occluded_count);
       // The quad in the contributing surface is at (222,300) in the transformed
       // root. The occlusion extends to 500 in the x-axis, pushing the left of
       // the visible part of the quad to 500 - 222 = 300 - 22 inside the quad.
       EXPECT_EQ(gfx::Rect(300 - 22, 0, 100 + 22, 500).ToString(),
-                impl.quad_list().front()->visible_rect.ToString());
+                pass2->quad_list.front()->visible_rect.ToString());
     }
   }
 }
@@ -1522,7 +1508,7 @@ TEST_F(DelegatedRendererLayerImplTest, PushPropertiesTo) {
                 gfx::Rect(layer_size),
                 gfx::Transform());
   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
-      2.f, &delegated_render_passes);
+      2.f, delegated_render_passes);
   EXPECT_EQ(0.5f, delegated_renderer_layer_impl->inverse_device_scale_factor());
 
   scoped_ptr<DelegatedRendererLayerImpl> other_layer =

cc/test/fake_delegated_renderer_layer_impl.cc

@@ -53,10 +53,10 @@ void NoopReturnCallback(const ReturnedResourceArray& returned,
 
 void FakeDelegatedRendererLayerImpl::SetFrameDataForRenderPasses(
     float device_scale_factor,
-    RenderPassList* pass_list) {
+    const RenderPassList& pass_list) {
   scoped_ptr<DelegatedFrameData> delegated_frame(new DelegatedFrameData);
   delegated_frame->device_scale_factor = device_scale_factor;
-  delegated_frame->render_pass_list.swap(*pass_list);
+  RenderPass::CopyAll(pass_list, &delegated_frame->render_pass_list);
 
   ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
 

cc/test/fake_delegated_renderer_layer_impl.h

@@ -26,7 +26,8 @@ class FakeDelegatedRendererLayerImpl : public DelegatedRendererLayerImpl {
   ResourceProvider::ResourceIdSet Resources() const;
 
   void SetFrameDataForRenderPasses(float device_scale_factor,
-                                   RenderPassList* pass_list);
+                                   const RenderPassList& pass_list);
+
  protected:
   FakeDelegatedRendererLayerImpl(LayerTreeImpl* tree_impl, int id);
 };

cc/test/layer_test_common.cc

@@ -137,19 +137,19 @@ void LayerTestCommon::LayerImplTest::AppendQuadsWithOcclusion(
 
 void LayerTestCommon::LayerImplTest::AppendQuadsForPassWithOcclusion(
     LayerImpl* layer_impl,
-    const RenderPassId& id,
+    RenderPass* given_render_pass,
     const gfx::Rect& occluded) {
-  AppendQuadsData data(id);
+  AppendQuadsData data;
 
-  render_pass_->quad_list.clear();
-  render_pass_->shared_quad_state_list.clear();
+  given_render_pass->quad_list.clear();
+  given_render_pass->shared_quad_state_list.clear();
 
   Occlusion occlusion(layer_impl->draw_transform(),
                       SimpleEnclosedRegion(occluded),
                       SimpleEnclosedRegion());
 
   layer_impl->WillDraw(DRAW_MODE_HARDWARE, resource_provider());
-  layer_impl->AppendQuads(render_pass_.get(), occlusion, &data);
+  layer_impl->AppendQuads(given_render_pass, occlusion, &data);
   layer_impl->DidDraw(resource_provider());
 }
 

cc/test/layer_test_common.h

@@ -107,7 +107,7 @@ class LayerTestCommon {
     void AppendQuadsWithOcclusion(LayerImpl* layer_impl,
                                   const gfx::Rect& occluded);
     void AppendQuadsForPassWithOcclusion(LayerImpl* layer_impl,
-                                         const RenderPassId& id,
+                                         RenderPass* given_render_pass,
                                          const gfx::Rect& occluded);
     void AppendSurfaceQuadsWithOcclusion(RenderSurfaceImpl* surface_impl,
                                          const gfx::Rect& occluded);

cc/trees/layer_tree_host_impl.cc

@@ -752,7 +752,7 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
 
     occlusion_tracker.EnterLayer(it);
 
-    AppendQuadsData append_quads_data(target_render_pass_id);
+    AppendQuadsData append_quads_data;
 
     if (it.represents_target_render_surface()) {
       if (it->HasCopyRequest()) {
@@ -789,7 +789,6 @@ DrawResult LayerTreeHostImpl::CalculateRenderPasses(
             RenderPass* render_pass =
                 frame->render_passes_by_id[contributing_render_pass_id];
 
-            AppendQuadsData append_quads_data(render_pass->id);
             AppendQuadsForLayer(render_pass,
                                 *it,
                                 occlusion_tracker,