Revert of cc::CompositorFrame: Implement ParamTraits vs. StructTraits perf test

cc/ipc/cc_param_traits_perftest.cc

Index: cc/ipc/cc_param_traits_perftest.cc
diff --git a/cc/ipc/cc_param_traits_perftest.cc b/cc/ipc/cc_param_traits_perftest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1cf40f1a3a3c199878a0f5a390bdb81ab17890de
--- /dev/null
+++ b/cc/ipc/cc_param_traits_perftest.cc
@@ -0,0 +1,155 @@
+// 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/output/compositor_frame.h"
+#include "cc/quads/picture_draw_quad.h"
+#include "ipc/ipc_message.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
+
+using cc::CompositorFrame;
+using cc::DelegatedFrameData;
+using cc::DrawQuad;
+using cc::PictureDrawQuad;
+using cc::RenderPass;
+using cc::SharedQuadState;
+
+namespace content {
+namespace {
+
+static const int kTimeLimitMillis = 2000;
+static const int kNumWarmupRuns = 20;
+static const int kTimeCheckInterval = 10;
+
+class CCParamTraitsPerfTest : public testing::Test {
+ protected:
+  static void RunTest(const std::string& test_name,
+                      const CompositorFrame& frame) {
+    for (int i = 0; i < kNumWarmupRuns; ++i) {
+      IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
+      IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
+    }
+
+    base::TimeTicks start = base::TimeTicks::Now();
+    base::TimeTicks end =
+        start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
+    base::TimeDelta min_time;
+    int count = 0;
+    while (start < end) {
+      for (int i = 0; i < kTimeCheckInterval; ++i) {
+        IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
+        IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
+        ++count;
+      }
+
+      base::TimeTicks now = base::TimeTicks::Now();
+      if (now - start < min_time || min_time.is_zero())
+        min_time = now - start;
+      start = base::TimeTicks::Now();
+    }
+
+    perf_test::PrintResult(
+        "min_frame_serialization_time", "", test_name,
+        min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us", true);
+  }
+};
+
+TEST_F(CCParamTraitsPerfTest, DelegatedFrame_ManyQuads_1_4000) {
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->CreateAndAppendSharedQuadState();
+  for (int i = 0; i < 4000; ++i) {
+    PictureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+    quad->shared_quad_state = render_pass->shared_quad_state_list.back();
+  }
+
+  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", *frame);
+}
+
+TEST_F(CCParamTraitsPerfTest, DelegatedFrame_ManyQuads_1_100000) {
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  render_pass->CreateAndAppendSharedQuadState();
+  for (int i = 0; i < 100000; ++i) {
+    PictureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+    quad->shared_quad_state = render_pass->shared_quad_state_list.back();
+  }
+
+  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", *frame);
+}
+
+TEST_F(CCParamTraitsPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  for (int i = 0; i < 4000; ++i) {
+    render_pass->CreateAndAppendSharedQuadState();
+    PictureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+    quad->shared_quad_state = render_pass->shared_quad_state_list.back();
+  }
+
+  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", *frame);
+}
+
+TEST_F(CCParamTraitsPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+
+  std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+  for (int i = 0; i < 100000; ++i) {
+    render_pass->CreateAndAppendSharedQuadState();
+    PictureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+    quad->shared_quad_state = render_pass->shared_quad_state_list.back();
+  }
+
+  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", *frame);
+}
+
+TEST_F(CCParamTraitsPerfTest, DelegatedFrame_ManyRenderPasses_10000_100) {
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+  frame->delegated_frame_data.reset(new DelegatedFrameData);
+
+  for (int i = 0; i < 1000; ++i) {
+    std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
+    for (int j = 0; j < 100; ++j) {
+      render_pass->CreateAndAppendSharedQuadState();
+      PictureDrawQuad* quad =
+          render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
+      quad->shared_quad_state = render_pass->shared_quad_state_list.back();
+    }
+    frame->delegated_frame_data->render_pass_list.push_back(
+        std::move(render_pass));
+  }
+
+  RunTest("DelegatedFrame_ManyRenderPasses_10000_100", *frame);
+}
+
+}  // namespace
+}  // namespace content