[cc] CompositorFrameSinkSupport: Defer BeginFrameAck of pending frames.

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 169 matching lines @@
     std::unique_ptr<SurfaceDependencyTracker> dependency_tracker(
         new SurfaceDependencyTracker(&surface_manager_,
                                      begin_frame_source_.get()));
     surface_manager_.SetDependencyTracker(std::move(dependency_tracker));
     supports_.push_back(CreateCompositorFrameSinkSupport(kDisplayFrameSink,
                                                          true /* is_root */));
     supports_.push_back(CreateCompositorFrameSinkSupport(kParentFrameSink));
     supports_.push_back(CreateCompositorFrameSinkSupport(kChildFrameSink1));
     supports_.push_back(CreateCompositorFrameSinkSupport(kChildFrameSink2));
     // Normally, the BeginFrameSource would be registered by the Display. We
-    // register it here so that BeginFrames are received by the display support,
-    // for use in the PassesOnBeginFrameAcks test. Other supports do not receive
-    // BeginFrames, since the frame sink hierarchy is not set up in this test.
+    // register it here so that BeginFrames are received by the supports,
+    // for use in the BeginFrameAck tests.
     surface_manager_.RegisterBeginFrameSource(begin_frame_source_.get(),
                                               kDisplayFrameSink);
+    // Setup hierarchy so that other supports receive BeginFrames, too.
+    surface_manager_.RegisterFrameSinkHierarchy(kDisplayFrameSink,
+                                                kParentFrameSink);
+    surface_manager_.RegisterFrameSinkHierarchy(kParentFrameSink,
+                                                kChildFrameSink1);
+    surface_manager_.RegisterFrameSinkHierarchy(kParentFrameSink,
+                                                kChildFrameSink2);
   }
 
   void TearDown() override {
     surface_manager_.SetDependencyTracker(nullptr);
     surface_manager_.UnregisterBeginFrameSource(begin_frame_source_.get());
 
     // SurfaceDependencyTracker depends on this BeginFrameSource and so it must
     // be destroyed AFTER the dependency tracker is destroyed.
     begin_frame_source_.reset();
 
@@ skipping 746 matching lines @@
   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) {
+  const SurfaceId display_id = MakeSurfaceId(kDisplayFrameSink, 1);
+
   // 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 a BeginFrameDidNotSwap ack to the
   // BeginFrameSource.
   BeginFrameAck ack(0, 1, 1, false);
   display_support().BeginFrameDidNotSwap(ack);
   EXPECT_EQ(ack, begin_frame_source()->LastAckForObserver(&display_support()));
 
-  // TODO(eseckler): Check that the support forwards the BeginFrameAck attached
+  // Issue another BeginFrame.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2);
+  begin_frame_source()->TestOnBeginFrame(args);
+
+  // Check that the support forwards the BeginFrameAck attached
   // to a CompositorFrame to the BeginFrameSource.
+  BeginFrameAck ack2(0, 2, 2, true);
+  CompositorFrame frame = MakeCompositorFrame();
+  frame.metadata.begin_frame_ack = ack2;
+  display_support().SubmitCompositorFrame(display_id.local_surface_id(),
+                                          std::move(frame));
+  EXPECT_EQ(ack2, begin_frame_source()->LastAckForObserver(&display_support()));
+}
+
+TEST_F(CompositorFrameSinkSupportTest,
+       WaitsToPassOnCompositorFrameBeginFrameAckUntilActivated) {
+  const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
+  const SurfaceId parent_id2 = MakeSurfaceId(kParentFrameSink, 2);
+  const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
+  const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink1, 2);
+
+  // Parent client submits a frame with blocked dependency on child.
+  parent_support().SetNeedsBeginFrame(true);
+  BeginFrameArgs args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
+  begin_frame_source()->TestOnBeginFrame(args);
+  CompositorFrame frame = MakeCompositorFrame({child_id1});
+  frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, 1, true);
+  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
+                                         std::move(frame));
+  // Parent doesn't ack immediately.
+  EXPECT_EQ(BeginFrameAck(),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+
+  // Parent client no longer needs BeginFrames, but parent needs to continue
+  // observing.
+  size_t num_observers = begin_frame_source()->num_observers();
+  parent_support().SetNeedsBeginFrame(false);
+  EXPECT_EQ(num_observers, begin_frame_source()->num_observers());
+
+  // On new BeginFrame, parent acknowledges the past one without updates.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2);
+  begin_frame_source()->TestOnBeginFrame(args);
+  EXPECT_EQ(BeginFrameAck(0, 1, 0, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+
+  // Same again. As the client doesn't have updates (isn't requesting
+  // BeginFrames), the pending ack is updated to confirm the last BeginFrame.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3);
+  begin_frame_source()->TestOnBeginFrame(args);
+  EXPECT_EQ(BeginFrameAck(0, 2, 0, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  EXPECT_EQ(2u, parent_support()
+                    .begin_frame_ack_for_pending_frame_for_testing()
+                    ->latest_confirmed_sequence_number);
+
+  // Concurrent DidNotSwapAck from parent client updates pending ack.
+  parent_support().SetNeedsBeginFrame(true);
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4);
+  begin_frame_source()->TestOnBeginFrame(args);
+  // Parent acknowledges prior frame.
+  EXPECT_EQ(BeginFrameAck(0, 3, 0, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  parent_support().BeginFrameDidNotSwap(BeginFrameAck(0, 4, 4, false));
+  // Parent doesn't ack immediately.
+  EXPECT_EQ(BeginFrameAck(0, 3, 0, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  EXPECT_EQ(4u, parent_support()
+                    .begin_frame_ack_for_pending_frame_for_testing()
+                    ->latest_confirmed_sequence_number);
+
+  // When child client unblocks parent, parent sends pending ack.
+  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
+                                         MakeCompositorFrame());
+  EXPECT_EQ(BeginFrameAck(0, 4, 4, true),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+
+  // Parent client submits another frame with blocked dependency on child.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 5);
+  begin_frame_source()->TestOnBeginFrame(args);
+  frame = MakeCompositorFrame({child_id2});
+  frame.metadata.begin_frame_ack = BeginFrameAck(0, 5, 5, true);
+  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
+                                         std::move(frame));
+  // Parent doesn't ack immediately.
+  EXPECT_EQ(BeginFrameAck(0, 4, 4, true),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+
+  // Submission of another CompositorFrame to parent updates pending ack.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 6);
+  begin_frame_source()->TestOnBeginFrame(args);
+  // Parent acknowledges prior frame.
+  EXPECT_EQ(BeginFrameAck(0, 5, 4, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  frame = MakeCompositorFrame({child_id2});
+  frame.metadata.begin_frame_ack = BeginFrameAck(0, 6, 6, true);
+  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
+                                         std::move(frame));
+  // Parent doesn't ack immediately.
+  EXPECT_EQ(BeginFrameAck(0, 5, 4, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  EXPECT_EQ(6u, parent_support()
+                    .begin_frame_ack_for_pending_frame_for_testing()
+                    ->latest_confirmed_sequence_number);
+
+  // Submission of a CompositorFrame to different surface updates pending ack.
+  args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 7);
+  begin_frame_source()->TestOnBeginFrame(args);
+  // Parent acknowledges prior frame.
+  EXPECT_EQ(BeginFrameAck(0, 6, 4, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  frame = MakeCompositorFrame({child_id2});
+  frame.metadata.begin_frame_ack = BeginFrameAck(0, 7, 7, true);
+  parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
+                                         std::move(frame));
+  // Parent doesn't ack immediately.
+  EXPECT_EQ(BeginFrameAck(0, 6, 4, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
+  EXPECT_EQ(7u, parent_support()
+                    .begin_frame_ack_for_pending_frame_for_testing()
+                    ->latest_confirmed_sequence_number);
+
+  // Parent acks immediately but without damage when frame is dropped.
+  parent_support().EvictFrame();
+  EXPECT_EQ(BeginFrameAck(0, 7, 4, false),
+            begin_frame_source()->LastAckForObserver(&parent_support()));
 }
 
 // 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}));
@@ skipping 108 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