Update from https://crrev.com/314320

cc/layers/delegated_renderer_layer_impl_unittest.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 "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 89 matching lines @@
                                           gfx::Rect(7, 7, 7, 7),
                                           gfx::Transform(1, 0, 0, 1, 7, 8));
     AddQuad(pass2, gfx::Rect(0, 0, 7, 7), 22u);
     AddRenderPassQuad(pass2, pass1);
     TestRenderPass* pass3 = AddRenderPass(&delegated_render_passes,
                                           RenderPassId(9, 8),
                                           gfx::Rect(0, 0, 8, 8),
                                           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();
     layer_after_ = layer_after.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     // Force the delegated RenderPasses to come before the RenderPass from
     // layer_after.
     layer_after->AddChild(delegated_renderer_layer.Pass());
     root_layer->AddChild(layer_after.Pass());
@@ skipping 446 matching lines @@
                        false);
 
     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        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();
 
     root_layer->AddChild(delegated_renderer_layer.Pass());
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
   void VerifyRenderPasses(
       const LayerTreeHostImpl::FrameData& frame,
@@ skipping 412 matching lines @@
                        false);
 
     color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        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();
 
     if (clip_delegated_renderer_layer_) {
       gfx::Rect clip_rect(21, 27, 23, 21);
 
       clip_layer->SetPosition(clip_rect.origin());
       clip_layer->SetBounds(clip_rect.size());
       clip_layer->SetContentBounds(clip_rect.size());
@@ skipping 280 matching lines @@
   scoped_ptr<TestRenderPass> missing_pass(TestRenderPass::Create());
   missing_pass->SetNew(RenderPassId(9, 7),
                        gfx::Rect(7, 7, 7, 7),
                        gfx::Rect(7, 7, 7, 7),
                        gfx::Transform());
 
   // But a render pass quad refers to it.
   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());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
   ASSERT_EQ(1u, frame.render_passes.size());
   ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
@@ skipping 38 matching lines @@
                                         pass1_id,
                                         gfx::Rect(layer_size),
                                         gfx::Transform());
   AddRenderPassQuad(pass1,
                     pass2,
                     0,
                     FilterOperations(),
                     transform,
                     SkXfermode::kSrcOver_Mode);
   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
-      1.f, &delegated_render_passes);
+      1.f, delegated_render_passes);
 
   impl.CalcDrawProps(viewport_size);
 
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
 
     {
       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);
     }
   }
 
   {
     SCOPED_TRACE("Full 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);
     }
   }
 
   {
     SCOPED_TRACE("Partial 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);
     }
     {
       gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
       // Move the occlusion to where it is in the contributing surface.
       gfx::Rect occlusion_in_target_of_delegated_quad =
           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);
       // Move the occlusion to where it is in the contributing surface.
       gfx::Rect occlusion_in_target_of_delegated_quad =
           occlusion_in_root_target - quad_screen_rect.OffsetFromOrigin();
 
       SCOPED_TRACE("Contributing render pass with transformed root");
 
       gfx::Transform layer_transform;
       layer_transform.Translate(11.0, 0.0);
       delegated_renderer_layer_impl->SetTransform(layer_transform);
 
       occlusion_in_target_of_delegated_quad += gfx::Vector2d(11, 0);
 
       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());
     }
   }
 }
 
 TEST_F(DelegatedRendererLayerImplTest, PushPropertiesTo) {
   gfx::Size layer_size(1000, 1000);
 
   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer_impl =
       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 5);
   delegated_renderer_layer_impl->SetBounds(layer_size);
   delegated_renderer_layer_impl->SetContentBounds(layer_size);
   delegated_renderer_layer_impl->SetDrawsContent(true);
 
   RenderPassList delegated_render_passes;
   // |pass1| covers the whole layer.
   RenderPassId pass1_id = RenderPassId(5, 0);
   AddRenderPass(&delegated_render_passes,
                 pass1_id,
                 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 =
       DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
 
   delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
 
   EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());
 }
 
 }  // namespace
 }  // namespace cc