[cc] Pass on BeginFrameAcks from CompositorEBFS through RWHVAura, DFH.

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/input/selection.h"
 #include "cc/ipc/copy_output_request_struct_traits.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
+#include "cc/test/begin_frame_args_test.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkString.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.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 EchoBeginFrameAck(const BeginFrameAck& b,
+                         const EchoBeginFrameAckCallback& callback) override {
+    callback.Run(b);
+  }
+
   void EchoCompositorFrame(
       CompositorFrame c,
       const EchoCompositorFrameCallback& callback) override {
     callback.Run(std::move(c));
   }
 
   void EchoCompositorFrameMetadata(
       CompositorFrameMetadata c,
       const EchoCompositorFrameMetadataCallback& callback) override {
     callback.Run(std::move(c));
@@ skipping 108 matching lines @@
 }
 
 }  // 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;
+  const uint32_t source_id = 5;
+  const uint64_t sequence_number = 10;
   BeginFrameArgs input;
+  input.source_id = source_id;
+  input.sequence_number = sequence_number;
   input.frame_time = frame_time;
   input.deadline = deadline;
   input.interval = interval;
   input.type = type;
   input.on_critical_path = on_critical_path;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   BeginFrameArgs output;
   proxy->EchoBeginFrameArgs(input, &output);
+  EXPECT_EQ(source_id, output.source_id);
+  EXPECT_EQ(sequence_number, output.sequence_number);
   EXPECT_EQ(frame_time, output.frame_time);
   EXPECT_EQ(deadline, output.deadline);
   EXPECT_EQ(interval, output.interval);
   EXPECT_EQ(type, output.type);
   EXPECT_EQ(on_critical_path, output.on_critical_path);
 }
 
+TEST_F(StructTraitsTest, BeginFrameAck) {
+  const uint32_t source_id = 5;
+  const uint64_t sequence_number = 10;
+  const uint64_t latest_confirmed_sequence_number = 8;
+  const uint32_t remaining_frames = 1;
+  const bool has_damage = true;
+  BeginFrameAck input;
+  input.source_id = source_id;
+  input.sequence_number = sequence_number;
+  input.latest_confirmed_sequence_number = latest_confirmed_sequence_number;
+  input.remaining_frames = remaining_frames;
+  input.has_damage = has_damage;
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  BeginFrameAck output;
+  proxy->EchoBeginFrameAck(input, &output);
+  EXPECT_EQ(source_id, output.source_id);
+  EXPECT_EQ(sequence_number, output.sequence_number);
+  EXPECT_EQ(latest_confirmed_sequence_number,
+            output.latest_confirmed_sequence_number);
+  // |remaining_frames| and |has_damage| are not transmitted.
+  EXPECT_EQ(0u, output.remaining_frames);
+  EXPECT_FALSE(output.has_damage);
+}
+
 // Note that this is a fairly trivial test of CompositorFrame serialization as
 // most of the heavy lifting has already been done by CompositorFrameMetadata,
 // RenderPass, and QuadListBasic unit tests.
 TEST_F(StructTraitsTest, CompositorFrame) {
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   render_pass->SetNew(1, gfx::Rect(5, 6), gfx::Rect(2, 3), gfx::Transform());
 
   // SharedQuadState.
   const gfx::Transform sqs_quad_to_target_transform(
       1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f, 11.f, 12.f, 13.f, 14.f,
@@ skipping 38 matching lines @@
   resource.buffer_format = tr_buffer_format;
   resource.filter = tr_filter;
   resource.size = tr_size;
 
   // CompositorFrameMetadata constants.
   const float device_scale_factor = 2.6f;
   const gfx::Vector2dF root_scroll_offset(1234.5f, 6789.1f);
   const float page_scale_factor = 1337.5f;
   const gfx::SizeF scrollable_viewport_size(1337.7f, 1234.5f);
   const uint32_t content_source_id = 3;
+  const BeginFrameAck begin_frame_ack(5, 10, 8, 0, false);
 
   CompositorFrame input;
   input.metadata.device_scale_factor = device_scale_factor;
   input.metadata.root_scroll_offset = root_scroll_offset;
   input.metadata.page_scale_factor = page_scale_factor;
   input.metadata.scrollable_viewport_size = scrollable_viewport_size;
   input.render_pass_list.push_back(std::move(render_pass));
   input.resource_list.push_back(resource);
   input.metadata.content_source_id = content_source_id;
+  input.metadata.begin_frame_ack = begin_frame_ack;
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   CompositorFrame output;
   proxy->EchoCompositorFrame(std::move(input), &output);
 
   EXPECT_EQ(device_scale_factor, output.metadata.device_scale_factor);
   EXPECT_EQ(root_scroll_offset, output.metadata.root_scroll_offset);
   EXPECT_EQ(page_scale_factor, output.metadata.page_scale_factor);
   EXPECT_EQ(scrollable_viewport_size, output.metadata.scrollable_viewport_size);
   EXPECT_EQ(content_source_id, output.metadata.content_source_id);
+  EXPECT_EQ(begin_frame_ack, output.metadata.begin_frame_ack);
 
   ASSERT_EQ(1u, output.resource_list.size());
   TransferableResource out_resource = output.resource_list[0];
   EXPECT_EQ(tr_id, out_resource.id);
   EXPECT_EQ(tr_format, out_resource.format);
   EXPECT_EQ(tr_buffer_format, out_resource.buffer_format);
   EXPECT_EQ(tr_filter, out_resource.filter);
   EXPECT_EQ(tr_size, out_resource.size);
 
   EXPECT_EQ(1u, output.render_pass_list.size());
@@ skipping 917 matching lines @@
   EXPECT_EQ(u_plane_resource_id, out_quad->u_plane_resource_id());
   EXPECT_EQ(v_plane_resource_id, out_quad->v_plane_resource_id());
   EXPECT_EQ(a_plane_resource_id, out_quad->a_plane_resource_id());
   EXPECT_EQ(color_space, out_quad->color_space);
   EXPECT_EQ(resource_offset, out_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, out_quad->resource_multiplier);
   EXPECT_EQ(bits_per_channel, out_quad->bits_per_channel);
 }
 
 }  // namespace cc