CompositorFrame: Implement ParamTraits versus StructTraits deserialization test

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 19 matching lines @@
 
 namespace cc {
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kNumWarmupRuns = 20;
 static const int kTimeCheckInterval = 10;
 
 class CCSerializationPerfTest : public testing::Test {
  protected:
-  static void RunTestParamTraits(const std::string& test_name,
-                                 const CompositorFrame& frame) {
+  static bool ReadMessage(const IPC::Message* msg, CompositorFrame* frame) {
+    base::PickleIterator iter(*msg);
+    return IPC::ParamTraits<CompositorFrame>::Read(msg, &iter, frame);
+  }
+
+  static void RunDeserializationTestParamTraits(const std::string& test_name,
+                                                const CompositorFrame& frame) {
+    IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
+    IPC::ParamTraits<CompositorFrame>::Write(&msg, frame);
+    for (int i = 0; i < kNumWarmupRuns; ++i) {
+      CompositorFrame compositor_frame;
+      ReadMessage(&msg, &compositor_frame);
+    }
+
+    base::TimeTicks start = base::TimeTicks::Now();
+    base::TimeTicks end =
+        start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
+    base::TimeDelta min_time;
+    size_t count = 0;
+    while (start < end) {
+      for (int i = 0; i < kTimeCheckInterval; ++i) {
+        ++count;
+        CompositorFrame compositor_frame;
+        ReadMessage(&msg, &compositor_frame);
+      }
+
+      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(
+        "ParamTraits deserialization: min_frame_deserialization_time", "",
+        test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
+        true);
+    perf_test::PrintResult("ParamTraits deserialization: num runs in 2 seconds",
+                           "", test_name, count, "", true);
+  }
+
+  static void RunSerializationTestParamTraits(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;
     size_t 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(
-        "ParamTraits: min_frame_serialization_time", "", test_name,
-        min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us", true);
-    perf_test::PrintResult("ParamTraits: num runs in 2 seconds", "", test_name,
-                           count, "", true);
+        "ParamTraits serialization: min_frame_serialization_time", "",
+        test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
+        true);
+    perf_test::PrintResult("ParamTraits serialization: num runs in 2 seconds",
+                           "", test_name, count, "", true);
   }
 
-  static void RunTestStructTraits(const std::string& test_name,
-                                  const CompositorFrame& frame) {
+  static void RunDeserializationTestStructTraits(const std::string& test_name,
+                                                 const CompositorFrame& frame) {
+    mojo::Array<uint8_t> data = mojom::CompositorFrame::Serialize(&frame);
+    DCHECK_GT(data.size(), 0u);
+    for (int i = 0; i < kNumWarmupRuns; ++i) {
+      CompositorFrame compositor_frame;
+      mojom::CompositorFrame::Deserialize(data, &compositor_frame);
+    }
+
+    base::TimeTicks start = base::TimeTicks::Now();
+    base::TimeTicks end =
+        start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
+    base::TimeDelta min_time;
+    size_t count = 0;
+    while (start < end) {
+      for (int i = 0; i < kTimeCheckInterval; ++i) {
+        CompositorFrame compositor_frame;
+        mojom::CompositorFrame::Deserialize(data, &compositor_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(
+        "StructTraits deserialization min_frame_deserialization_time", "",
+        test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
+        true);
+    perf_test::PrintResult(
+        "StructTraits deserialization: num runs in 2 seconds", "", test_name,
+        count, "", true);
+  }
+
+  static void RunSerializationTestStructTraits(const std::string& test_name,
+                                               const CompositorFrame& frame) {
     for (int i = 0; i < kNumWarmupRuns; ++i) {
       mojo::Array<uint8_t> data = mojom::CompositorFrame::Serialize(&frame);
       DCHECK_GT(data.size(), 0u);
     }
 
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks end =
         start + base::TimeDelta::FromMilliseconds(kTimeLimitMillis);
     base::TimeDelta min_time;
     size_t count = 0;
     while (start < end) {
       for (int i = 0; i < kTimeCheckInterval; ++i) {
         mojo::Array<uint8_t> data = mojom::CompositorFrame::Serialize(&frame);
         DCHECK_GT(data.size(), 0u);
         ++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(
-        "StructTraits min_frame_serialization_time", "", test_name,
-        min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us", true);
-    perf_test::PrintResult("StructTraits: num runs in 2 seconds", "", test_name,
-                           count, "", true);
+        "StructTraits serialization min_frame_serialization_time", "",
+        test_name, min_time.InMillisecondsF() / kTimeCheckInterval * 1000, "us",
+        true);
+    perf_test::PrintResult("StructTraits serialization: num runs in 2 seconds",
+                           "", test_name, count, "", true);
   }
 
   static void RunTest(const std::string& test_name, CompositorFrame frame) {
-    RunTestStructTraits(test_name, frame);
-    RunTestParamTraits(test_name, frame);
+    RunSerializationTestStructTraits(test_name, frame);
+    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->CreateAndAppendSharedQuadState();
   for (int i = 0; i < 4000; ++i) {
     const gfx::Rect bounds(100, 100, 100, 100);
@@ skipping 91 matching lines @@
     }
     frame.delegated_frame_data->render_pass_list.push_back(
         std::move(render_pass));
   }
 
   RunTest("DelegatedFrame_ManyRenderPasses_10000_100", std::move(frame));
 }
 
 }  // namespace
 }  // namespace cc