Implement cc::BeginFrameArgs StructTraits

cc/ipc/struct_traits_unittest.cc

 // Copyright 2016 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 "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/quads/render_pass_id.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
 namespace {
 
 class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
  public:
   StructTraitsTest() {}
 
  protected:
   mojom::TraitsTestServicePtr GetTraitsTestProxy() {
     return traits_test_bindings_.CreateInterfacePtrAndBind(this);
   }
 
  private:
   // TraitsTestService:
+  void EchoBeginFrameArgs(const BeginFrameArgs& b,
+                          const EchoBeginFrameArgsCallback& callback) override {
+    callback.Run(b);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoReturnedResource(
       const ReturnedResource& r,
       const EchoReturnedResourceCallback& callback) override {
     callback.Run(r);
   }
 
   void EchoSurfaceId(const SurfaceId& s,
                      const EchoSurfaceIdCallback& callback) override {
     callback.Run(s);
   }
 
   void EchoTransferableResource(
       const TransferableResource& t,
       const EchoTransferableResourceCallback& callback) override {
     callback.Run(t);
   }
 
   mojo::BindingSet<TraitsTestService> traits_test_bindings_;
 };
 
 }  // namespace
 
+TEST_F(StructTraitsTest, BeginFrameArgs) {
+  const base::TimeTicks frame_time = base::TimeTicks::Now();
+  const base::TimeTicks deadline = base::TimeTicks::Now();
+  const base::TimeDelta interval = base::TimeDelta::FromMilliseconds(1337);
+  const BeginFrameArgs::BeginFrameArgsType type = BeginFrameArgs::NORMAL;
+  const bool on_critical_path = true;
+  BeginFrameArgs input;
+  input.frame_time = frame_time;
+  input.deadline = deadline;
+  input.interval = interval;
+  input.type = type;
+  input.on_critical_path = on_critical_path;
+  base::RunLoop loop;
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  proxy->EchoBeginFrameArgs(
+      input, [frame_time, deadline, interval, type, on_critical_path,
+              &loop](const BeginFrameArgs& pass) {
+        EXPECT_EQ(frame_time, pass.frame_time);
+        EXPECT_EQ(deadline, pass.deadline);
+        EXPECT_EQ(interval, pass.interval);
+        EXPECT_EQ(type, pass.type);
+        EXPECT_EQ(on_critical_path, pass.on_critical_path);
+        loop.Quit();
+      });
+  loop.Run();
+}
+
 TEST_F(StructTraitsTest, RenderPassId) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;
   RenderPassId input(layer_id, index);
   base::RunLoop loop;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   proxy->EchoRenderPassId(input,
                           [layer_id, index, &loop](const RenderPassId& pass) {
                             EXPECT_EQ(layer_id, pass.layer_id);
                             EXPECT_EQ(index, pass.index);
@@ skipping 102 matching lines @@
         EXPECT_EQ(read_lock_fences_enabled, pass.read_lock_fences_enabled);
         EXPECT_EQ(is_software, pass.is_software);
         EXPECT_EQ(gpu_memory_buffer_id, pass.gpu_memory_buffer_id.id);
         EXPECT_EQ(is_overlay_candidate, pass.is_overlay_candidate);
         loop.Quit();
       });
   loop.Run();
 }
 
 }  // namespace cc