cc serialization perf test: Initialize with valid ID

cc/ipc/cc_serialization_perftest.cc

 // Copyright 2013 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 <utility>
 
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
 #include "cc/ipc/cc_param_traits.h"
 #include "cc/ipc/compositor_frame.mojom.h"
@@ skipping 173 matching lines @@
     RunDeserializationTestStructTraits(test_name, frame);
     RunSerializationTestParamTraits(test_name, frame);
     RunDeserializationTestParamTraits(test_name, frame);
   }
 };
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_4000) {
   CompositorFrame frame;
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
   render_pass->CreateAndAppendSharedQuadState();
   for (int i = 0; i < 4000; ++i) {
     const gfx::Rect bounds(100, 100, 100, 100);
     const bool kForceAntiAliasingOff = true;
     SolidColorDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                  SK_ColorRED, kForceAntiAliasingOff);
   }
 
   frame.delegated_frame_data.reset(new DelegatedFrameData);
   frame.delegated_frame_data->render_pass_list.push_back(
       std::move(render_pass));
 
   RunTest("DelegatedFrame_ManyQuads_1_4000", std::move(frame));
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_1_100000) {
   CompositorFrame frame;
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
   render_pass->CreateAndAppendSharedQuadState();
   for (int i = 0; i < 100000; ++i) {
     const gfx::Rect bounds(100, 100, 100, 100);
     const bool kForceAntiAliasingOff = true;
     SolidColorDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                  SK_ColorRED, kForceAntiAliasingOff);
   }
 
   frame.delegated_frame_data.reset(new DelegatedFrameData);
   frame.delegated_frame_data->render_pass_list.push_back(
       std::move(render_pass));
 
   RunTest("DelegatedFrame_ManyQuads_1_100000", std::move(frame));
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
   CompositorFrame frame;
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
   for (int i = 0; i < 4000; ++i) {
     const gfx::Rect bounds(100, 100, 100, 100);
     const bool kForceAntiAliasingOff = true;
     render_pass->CreateAndAppendSharedQuadState();
     SolidColorDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                  SK_ColorRED, kForceAntiAliasingOff);
   }
 
   frame.delegated_frame_data.reset(new DelegatedFrameData);
   frame.delegated_frame_data->render_pass_list.push_back(
       std::move(render_pass));
 
   RunTest("DelegatedFrame_ManyQuads_4000_4000", std::move(frame));
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
   CompositorFrame frame;
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                      gfx::Transform());
   for (int i = 0; i < 100000; ++i) {
     render_pass->CreateAndAppendSharedQuadState();
     const gfx::Rect bounds(100, 100, 100, 100);
     const bool kForceAntiAliasingOff = true;
     SolidColorDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                  SK_ColorRED, kForceAntiAliasingOff);
   }
 
   frame.delegated_frame_data.reset(new DelegatedFrameData);
   frame.delegated_frame_data->render_pass_list.push_back(
       std::move(render_pass));
 
   RunTest("DelegatedFrame_ManyQuads_100000_100000", std::move(frame));
 }
 
 TEST_F(CCSerializationPerfTest, DelegatedFrame_ManyRenderPasses_10000_100) {
   CompositorFrame frame;
   frame.delegated_frame_data.reset(new DelegatedFrameData);
 
   for (int i = 0; i < 1000; ++i) {
     std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+    render_pass->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
+                        gfx::Transform());
     for (int j = 0; j < 100; ++j) {
       render_pass->CreateAndAppendSharedQuadState();
       const gfx::Rect bounds(100, 100, 100, 100);
       const bool kForceAntiAliasingOff = true;
       SolidColorDrawQuad* quad =
           render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       quad->SetNew(render_pass->shared_quad_state_list.back(), bounds, bounds,
                    SK_ColorRED, kForceAntiAliasingOff);
     }
     frame.delegated_frame_data->render_pass_list.push_back(
         std::move(render_pass));
   }
 
   RunTest("DelegatedFrame_ManyRenderPasses_10000_100", std::move(frame));
 }
 
 }  // namespace
 }  // namespace cc