[cc] Fix CompositorFrameSinkSupport BeginFrameAck interface.

cc/surfaces/compositor_frame_sink_support_unittest.cc

 // Copyright 2017 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 "cc/surfaces/compositor_frame_sink_support.h"
 
 #include "base/debug/stack_trace.h"
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/surfaces/compositor_frame_sink_support_client.h"
@@ skipping 53 matching lines @@
 std::vector<SurfaceId> empty_surface_ids() {
   return std::vector<SurfaceId>();
 }
 
 SurfaceId MakeSurfaceId(const FrameSinkId& frame_sink_id, uint32_t local_id) {
   return SurfaceId(
       frame_sink_id,
       LocalSurfaceId(local_id, base::UnguessableToken::Deserialize(0, 1u)));
 }
 
+CompositorFrame MakeCompositorFrame() {
+  CompositorFrame compositor_frame;
+  compositor_frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, 1, 0, true);
+  return compositor_frame;
+}
+
 CompositorFrame MakeCompositorFrame(
     std::vector<SurfaceId> referenced_surfaces) {
   CompositorFrame compositor_frame;
+  compositor_frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, 1, 0, true);
   compositor_frame.metadata.referenced_surfaces =
       std::move(referenced_surfaces);
   return compositor_frame;
 }
 
 CompositorFrame MakeCompositorFrameWithResources(
     std::vector<SurfaceId> referenced_surfaces,
     TransferableResourceArray resource_list) {
   CompositorFrame compositor_frame;
+  compositor_frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, 1, 0, true);
   compositor_frame.metadata.referenced_surfaces =
       std::move(referenced_surfaces);
   compositor_frame.resource_list = std::move(resource_list);
   return compositor_frame;
 }
 
 TransferableResource MakeResource(ResourceId id,
                                   ResourceFormat format,
                                   uint32_t filter,
                                   const gfx::Size& size) {
@@ skipping 663 matching lines @@
   const int64_t latency_id1 = 234;
   const int64_t latency_sequence_number1 = 5645432;
   const ui::LatencyComponentType latency_type2 = ui::TAB_SHOW_COMPONENT;
   const int64_t latency_id2 = 31434351;
   const int64_t latency_sequence_number2 = 663788;
 
   // Submit a frame with latency info
   ui::LatencyInfo info;
   info.AddLatencyNumber(latency_type1, latency_id1, latency_sequence_number1);
 
-  CompositorFrame frame;
+  CompositorFrame frame = MakeCompositorFrame();
   frame.metadata.latency_info.push_back(info);
 
   parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
                                          std::move(frame));
 
   // Verify that the old surface has an active frame and no pending frame.
   Surface* old_surface = surface_manager().GetSurfaceForId(parent_id1);
   ASSERT_NE(nullptr, old_surface);
   EXPECT_TRUE(old_surface->HasActiveFrame());
   EXPECT_FALSE(old_surface->HasPendingFrame());
 
   // Submit another frame with some other latency info and a different
   // LocalSurfaceId.
   ui::LatencyInfo info2;
   info2.AddLatencyNumber(latency_type2, latency_id2, latency_sequence_number2);
 
-  CompositorFrame frame2;
+  CompositorFrame frame2 = MakeCompositorFrame();
   frame2.metadata.latency_info.push_back(info2);
 
   parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
                                          std::move(frame2));
 
   // Verify that the new surface has an active frame and no pending frames.
   Surface* surface = surface_manager().GetSurfaceForId(parent_id2);
   ASSERT_NE(nullptr, surface);
   EXPECT_TRUE(surface->HasActiveFrame());
   EXPECT_FALSE(surface->HasPendingFrame());
@@ skipping 26 matching lines @@
   const int64_t latency_id1 = 234;
   const int64_t latency_sequence_number1 = 5645432;
   const ui::LatencyComponentType latency_type2 = ui::TAB_SHOW_COMPONENT;
   const int64_t latency_id2 = 31434351;
   const int64_t latency_sequence_number2 = 663788;
 
   // Submit a frame with no unresolved dependecy.
   ui::LatencyInfo info;
   info.AddLatencyNumber(latency_type1, latency_id1, latency_sequence_number1);
 
-  CompositorFrame frame;
+  CompositorFrame frame = MakeCompositorFrame();
   frame.metadata.latency_info.push_back(info);
 
   parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
                                          std::move(frame));
 
   // Submit a frame with unresolved dependencies.
   ui::LatencyInfo info2;
   info2.AddLatencyNumber(latency_type2, latency_id2, latency_sequence_number2);
 
   CompositorFrame frame2 = MakeCompositorFrame({child_id});
   frame2.metadata.latency_info.push_back(info2);
 
   parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
                                          std::move(frame2));
 
   // Verify that the old surface has both an active and a pending frame.
   Surface* old_surface = surface_manager().GetSurfaceForId(parent_id1);
   ASSERT_NE(nullptr, old_surface);
   EXPECT_TRUE(old_surface->HasActiveFrame());
   EXPECT_TRUE(old_surface->HasPendingFrame());
 
   // Submit a frame with a new local surface id.
   parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
 
   // Verify that the new surface has an active frame only.
   Surface* surface = surface_manager().GetSurfaceForId(parent_id2);
   ASSERT_NE(nullptr, surface);
   EXPECT_TRUE(surface->HasActiveFrame());
   EXPECT_FALSE(surface->HasPendingFrame());
 
   // Verify that the new surface has latency info from both active and pending
   // frame of the old surface.
   std::vector<ui::LatencyInfo> info_list;
@@ skipping 23 matching lines @@
   const int64_t latency_id1 = 234;
   const int64_t latency_sequence_number1 = 5645432;
   const ui::LatencyComponentType latency_type2 = ui::TAB_SHOW_COMPONENT;
   const int64_t latency_id2 = 31434351;
   const int64_t latency_sequence_number2 = 663788;
 
   // Submit a frame with no unresolved dependencies.
   ui::LatencyInfo info;
   info.AddLatencyNumber(latency_type1, latency_id1, latency_sequence_number1);
 
-  CompositorFrame frame;
+  CompositorFrame frame = MakeCompositorFrame();
   frame.metadata.latency_info.push_back(info);
 
   parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
                                          std::move(frame));
 
   // Verify that the old surface has an active frame only.
   Surface* old_surface = surface_manager().GetSurfaceForId(parent_id1);
   ASSERT_NE(nullptr, old_surface);
   EXPECT_TRUE(old_surface->HasActiveFrame());
   EXPECT_FALSE(old_surface->HasPendingFrame());
@@ skipping 10 matching lines @@
                                          std::move(frame2));
 
   // Verify that the new surface has a pending frame and no active frame.
   Surface* surface = surface_manager().GetSurfaceForId(parent_id2);
   ASSERT_NE(nullptr, surface);
   EXPECT_TRUE(surface->HasPendingFrame());
   EXPECT_FALSE(surface->HasActiveFrame());
 
   // Resolve the dependencies. The frame in parent's surface must become active.
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
   EXPECT_FALSE(surface->HasPendingFrame());
   EXPECT_TRUE(surface->HasActiveFrame());
 
   // Both latency info elements must exist in the now-activated frame of the
   // new surface.
   std::vector<ui::LatencyInfo> info_list;
   surface->TakeLatencyInfo(&info_list);
   EXPECT_EQ(2u, info_list.size());
 
   ui::LatencyInfo aggregated_latency_info = info_list[0];
   aggregated_latency_info.AddNewLatencyFrom(info_list[1]);
   EXPECT_EQ(2u, aggregated_latency_info.latency_components().size());
 
   ui::LatencyInfo::LatencyComponent comp1;
   EXPECT_TRUE(
       aggregated_latency_info.FindLatency(latency_type1, latency_id1, &comp1));
   EXPECT_EQ(latency_sequence_number1, comp1.sequence_number);
 }
 
 TEST_F(CompositorFrameSinkSupportTest, PassesOnBeginFrameAcks) {
   // Request BeginFrames.
   display_support().SetNeedsBeginFrame(true);
 
   // Issue a BeginFrame.
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
   begin_frame_source()->TestOnBeginFrame(args);
 
-  // Check that the support forwards our ack to the BeginFrameSource.
+  // Check that the support forwards a BeginFrameDidNotSwap ack to the
+  // BeginFrameSource.
   BeginFrameAck ack(0, 1, 1, 0, false);
-  display_support().DidFinishFrame(ack);
+  display_support().BeginFrameDidNotSwap(ack);
   EXPECT_EQ(ack, begin_frame_source()->LastAckForObserver(&display_support()));
+
+  // TODO(eseckler): Check that the support forwards the BeginFrameAck attached
+  // to a CompositorFrame to the BeginFrameSource.
 }
 
 // Checks whether the resources are returned before we send an ack.
 TEST_F(CompositorFrameSinkSupportTest, ReturnResourcesBeforeAck) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   TransferableResource resource;
   resource.id = 1234;
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
       MakeCompositorFrameWithResources(empty_surface_ids(), {resource}));
   {
     InSequence x;
     EXPECT_CALL(support_client_, ReclaimResources(_));
     EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck());
   }
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
 }
 
 // Verifies that if a surface is marked destroyed and a new frame arrives for
 // it, it will be recovered.
 TEST_F(CompositorFrameSinkSupportTest, SurfaceResurrection) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 3);
 
   // Add a reference from the parent to the child.
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          MakeCompositorFrame({child_id}));
 
   // Create the child surface by submitting a frame to it.
   EXPECT_EQ(nullptr, surface_manager().GetSurfaceForId(child_id));
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
 
   // Verify that the child surface is created.
   Surface* surface = surface_manager().GetSurfaceForId(child_id);
   EXPECT_NE(nullptr, surface);
 
   // Attempt to destroy the child surface. The surface must still exist since
   // the parent needs it but it will be marked as destroyed.
   child_support1().EvictFrame();
   surface = surface_manager().GetSurfaceForId(child_id);
   EXPECT_NE(nullptr, surface);
   EXPECT_TRUE(surface->destroyed());
 
   // Child submits another frame to the same local surface id that is marked
   // destroyed.
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
 
   // Verify that the surface that was marked destroyed is recovered and is being
   // used again.
   Surface* surface2 = surface_manager().GetSurfaceForId(child_id);
   EXPECT_EQ(surface, surface2);
   EXPECT_FALSE(surface2->destroyed());
 }
 
 // Verifies that if a LocalSurfaceId belonged to a surface that doesn't exist
 // anymore, it can still be reused for new surfaces.
 TEST_F(CompositorFrameSinkSupportTest, LocalSurfaceIdIsReusable) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 3);
 
   // Add a reference from parent.
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          MakeCompositorFrame({child_id}));
 
   // Submit the first frame. Creates the surface.
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
   EXPECT_NE(nullptr, surface_manager().GetSurfaceForId(child_id));
 
   // Remove the reference from parant. This allows us to destroy the surface.
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
 
   // Destroy the surface.
   child_support1().EvictFrame();
   EXPECT_EQ(nullptr, surface_manager().GetSurfaceForId(child_id));
 
   // Submit another frame with the same local surface id. This should work fine
   // and a new surface must be created.
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
-                                         CompositorFrame());
+                                         MakeCompositorFrame());
   EXPECT_NE(nullptr, surface_manager().GetSurfaceForId(child_id));
 }
 
 // Checks whether a LocalSurfaceId can be reused after the
 // CompositorFrameSinkSupport is destroyed and recreated with the same
 // FrameSinkId.
 TEST_F(CompositorFrameSinkSupportTest, ReuseSurfaceAfterSupportDestroyed) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kArbitraryFrameSink, 1);
   std::unique_ptr<CompositorFrameSinkSupport> child_support =
@@ skipping 24 matching lines @@
   // be used and destroyed() must return false. The surface must have a factory.
   child_support->SubmitCompositorFrame(
       child_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
   EXPECT_EQ(surface, surface_manager().GetSurfaceForId(child_id));
   EXPECT_TRUE(surface->factory());
   EXPECT_FALSE(surface->destroyed());
 }
 
 }  // namespace test
 }  // namespace cc