cc: Reject CompositorFrames to old child surfaces

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/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/surfaces/compositor_frame_sink_support_client.h"
 #include "cc/surfaces/frame_sink_id.h"
@@ skipping 93 matching lines @@
     std::vector<SurfaceId> activation_dependencies,
     std::vector<SurfaceId> referenced_surfaces) {
   return MakeCompositorFrame(std::move(activation_dependencies),
                              std::move(referenced_surfaces),
                              TransferableResourceArray());
 }
 
 CompositorFrame MakeCompositorFrameWithResources(
     std::vector<SurfaceId> activation_dependencies,
     TransferableResourceArray resource_list) {
-  return MakeCompositorFrame(activation_dependencies, activation_dependencies,
+  return MakeCompositorFrame(activation_dependencies, empty_surface_ids(),
                              std::move(resource_list));
 }
 
 TransferableResource MakeResource(ResourceId id,
                                   ResourceFormat format,
                                   uint32_t filter,
                                   const gfx::Size& size) {
   TransferableResource resource;
   resource.id = id;
   resource.format = format;
@@ skipping 161 matching lines @@
 }
 
 // The parent Surface is blocked on |child_id1| and |child_id2|.
 TEST_F(CompositorFrameSinkSupportTest, DisplayCompositorLockingBlockedOnTwo) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
-      MakeCompositorFrame({child_id1, child_id2}));
+      MakeCompositorFrame({child_id1, child_id2}, empty_surface_ids()));
 
   // parent_support is blocked on |child_id1| and |child_id2|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1, child_id2));
 
   // Submit a CompositorFrame without any dependencies to |child_id1|.
   // parent_support should now only be blocked on |child_id2|.
-  child_support1().SubmitCompositorFrame(
-      child_id1.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
+                                         MakeCompositorFrame());
 
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // Submit a CompositorFrame without any dependencies to |child_id2|.
   // parent_support should be activated.
-  child_support2().SubmitCompositorFrame(
-      child_id2.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support2().SubmitCompositorFrame(child_id2.local_surface_id(),
+                                         MakeCompositorFrame());
 
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
 }
 
 // The parent Surface is blocked on |child_id2| which is blocked on |child_id3|.
 TEST_F(CompositorFrameSinkSupportTest, DisplayCompositorLockingBlockedChain) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({child_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({child_id1}, empty_surface_ids()));
 
   // parent_support is blocked on |child_id1|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
   // The parent should not report damage until it activates.
   EXPECT_FALSE(IsSurfaceDamaged(parent_id));
 
-  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
 
   // child_support1 should now be blocked on |child_id2|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(child_surface1()->HasActiveFrame());
   EXPECT_TRUE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
   // The parent and child should not report damage until they activate.
   EXPECT_FALSE(IsSurfaceDamaged(parent_id));
   EXPECT_FALSE(IsSurfaceDamaged(child_id1));
@@ skipping 26 matching lines @@
   EXPECT_TRUE(IsSurfaceDamaged(child_id2));
 }
 
 // parent_surface and child_surface1 are blocked on |child_id2|.
 TEST_F(CompositorFrameSinkSupportTest,
        DisplayCompositorLockingTwoBlockedOnOne) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
 
   // parent_support is blocked on |child_id2|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // child_support1 should now be blocked on |child_id2|.
-  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
 
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(child_surface1()->HasActiveFrame());
   EXPECT_TRUE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // The parent should still be blocked on |child_id2|.
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // Submit a CompositorFrame without any dependencies to |child_id2|.
   // parent_support should be activated.
-  child_support2().SubmitCompositorFrame(
-      child_id2.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support2().SubmitCompositorFrame(child_id2.local_surface_id(),
+                                         MakeCompositorFrame());
 
   EXPECT_FALSE(dependency_tracker().has_deadline());
 
   // child_surface1 should now be active.
   EXPECT_TRUE(child_surface1()->HasActiveFrame());
   EXPECT_FALSE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(), IsEmpty());
 
   // parent_surface should now be active.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
 }
 
 // parent_surface is blocked on |child_id1|, and child_surface2 is blocked on
 // |child_id2| until the deadline hits.
 TEST_F(CompositorFrameSinkSupportTest, DisplayCompositorLockingDeadlineHits) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({child_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({child_id1}, empty_surface_ids()));
 
   // parent_support is blocked on |child_id1|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
 
-  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
 
   // child_support1 should now be blocked on |child_id2|.
   EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(child_surface1()->HasActiveFrame());
   EXPECT_TRUE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // The parent should still be blocked on |child_id1| because it's pending.
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
@@ skipping 38 matching lines @@
 
 // Verifies that the deadline does not reset if we submit CompositorFrames
 // to new Surfaces with unresolved dependencies.
 TEST_F(CompositorFrameSinkSupportTest,
        DisplayCompositorLockingFramesSubmittedAfterDeadlineSet) {
   const SurfaceId arbitrary_id = MakeSurfaceId(kArbitraryFrameSink, 1);
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
   for (int i = 0; i < 3; ++i) {
     LocalSurfaceId local_surface_id(1, base::UnguessableToken::Create());
-    support(i).SubmitCompositorFrame(local_surface_id,
-                                     MakeCompositorFrame({arbitrary_id}));
+    support(i).SubmitCompositorFrame(
+        local_surface_id,
+        MakeCompositorFrame({arbitrary_id}, empty_surface_ids()));
     // The deadline has been set.
     EXPECT_TRUE(dependency_tracker().has_deadline());
 
     // support(i) should be blocked on arbitrary_id.
     EXPECT_FALSE(surface(i)->HasActiveFrame());
     EXPECT_TRUE(surface(i)->HasPendingFrame());
     EXPECT_THAT(surface(i)->blocking_surfaces(),
                 UnorderedElementsAre(arbitrary_id));
 
     // Issue a BeginFrame to get closer to the deadline.
@@ skipping 10 matching lines @@
 }
 
 // This test verifies at the Surface activates once a CompositorFrame is
 // submitted that has no unresolved dependencies.
 TEST_F(CompositorFrameSinkSupportTest,
        DisplayCompositorLockingNewFrameOverridesOldDependencies) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId arbitrary_id = MakeSurfaceId(kArbitraryFrameSink, 1);
 
   // Submit a CompositorFrame that depends on |arbitrary_id|.
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({arbitrary_id}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({arbitrary_id}, empty_surface_ids()));
 
   // Verify that the CompositorFrame is blocked on |arbitrary_id|.
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(arbitrary_id));
 
   // Submit a CompositorFrame that has no dependencies.
-  parent_support().SubmitCompositorFrame(
-      parent_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame());
 
   // Verify that the CompositorFrame has been activated.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
 }
 
 // This test verifies that a pending CompositorFrame does not affect surface
 // references. A new surface from a child will continue to exist as a temporary
 // reference until the parent's frame activates.
@@ skipping 19 matching lines @@
   EXPECT_TRUE(HasTemporaryReference(child_id1));
 
   // parent_support submits a CompositorFrame that depends on |child_id1|
   // (which is already active) and |child_id2|. Thus, the parent should not
   // activate immediately. DidReceiveCompositorFrameAck should not be called
   // immediately because the parent CompositorFrame is also blocked on
   // |child_id2|.
   EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck(_)).Times(0);
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
-      MakeCompositorFrame({child_id1, child_id2}));
+      MakeCompositorFrame({child_id2}, {child_id1}));
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
   EXPECT_THAT(GetChildReferences(parent_id), IsEmpty());
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 
   // Verify that there's a temporary reference for |child_id1| that still
   // exists.
   EXPECT_TRUE(HasTemporaryReference(child_id1));
@@ skipping 10 matching lines @@
   EXPECT_TRUE(child_surface1()->HasActiveFrame());
   EXPECT_FALSE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(), IsEmpty());
 
   // Verify that the parent surface's CompositorFrame has activated and that the
   // temporary reference has been replaced by a permanent one.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
   EXPECT_FALSE(HasTemporaryReference(child_id1));
-  EXPECT_THAT(GetChildReferences(parent_id),
-              UnorderedElementsAre(child_id1, child_id2));
+  EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id1));
 }
 
 // This test verifies that we do not double count returned resources when a
 // CompositorFrame starts out as pending, then becomes active, and then is
 // replaced with another active CompositorFrame.
 TEST_F(CompositorFrameSinkSupportTest,
        DisplayCompositorLockingResourcesOnlyReturnedOnce) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 1);
 
@@ skipping 42 matching lines @@
 
 // The parent Surface is blocked on |child_id2| which is blocked on |child_id3|.
 // child_support1 evicts its blocked Surface. The parent surface should
 // activate.
 TEST_F(CompositorFrameSinkSupportTest, EvictSurfaceWithPendingFrame) {
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
   // Submit a CompositorFrame that depends on |child_id1|.
-  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id1.local_surface_id(),
+      MakeCompositorFrame({child_id1}, empty_surface_ids()));
 
   // Verify that the CompositorFrame is blocked on |child_id1|.
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
 
   // Submit a CompositorFrame that depends on |child_id2|.
-  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
 
   // Verify that the CompositorFrame is blocked on |child_id2|.
   EXPECT_FALSE(child_surface1()->HasActiveFrame());
   EXPECT_TRUE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
 
   // Evict child_support1's current Surface.
   // TODO(fsamuel): EvictFrame => EvictCurrentSurface.
   child_support1().EvictFrame();
@@ skipping 11 matching lines @@
 // updated allowing garbage collection of surfaces that are no longer
 // referenced.
 TEST_F(CompositorFrameSinkSupportTest, DropStaleReferencesAfterActivation) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
   const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink2, 1);
 
   // The parent submits a CompositorFrame that depends on |child_id1| before the
   // child submits a CompositorFrame.
   EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck(_)).Times(0);
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({child_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({child_id1}, empty_surface_ids()));
 
   // Verify that the CompositorFrame is blocked on |child_id|.
   EXPECT_FALSE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id1));
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 
   // Verify that no references are added while the CompositorFrame is pending.
   EXPECT_THAT(GetChildReferences(parent_id), IsEmpty());
 
   // DidReceiveCompositorFrameAck should get called twice: once for the child
   // and once for the now active parent CompositorFrame.
   EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck(_)).Times(2);
-  child_support1().SubmitCompositorFrame(
-      child_id1.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support1().SubmitCompositorFrame(child_id1.local_surface_id(),
+                                         MakeCompositorFrame());
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 
   // Verify that the child CompositorFrame activates immediately.
   EXPECT_TRUE(child_surface1()->HasActiveFrame());
   EXPECT_FALSE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces(), IsEmpty());
 
   // Verify that the parent Surface has activated.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
 
+  // Submit a new parent CompositorFrame to add a reference.
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame(empty_surface_ids(), {child_id1}));
+
+  // Verify that the parent Surface has activated.
+  EXPECT_TRUE(parent_surface()->HasActiveFrame());
+  EXPECT_FALSE(parent_surface()->HasPendingFrame());
+  EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
+
   // Verify that there is no temporary reference for the child and that
   // the reference from the parent to the child still exists.
   EXPECT_FALSE(HasTemporaryReference(child_id1));
   EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id1));
 
   // The parent submits another CompositorFrame that depends on |child_id2|.
   // Submitting a pending CompositorFrame will not trigger a CompositorFrameAck.
   EXPECT_CALL(support_client_, DidReceiveCompositorFrameAck(_)).Times(0);
-  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
-                                         MakeCompositorFrame({child_id2}));
+  parent_support().SubmitCompositorFrame(
+      parent_id.local_surface_id(),
+      MakeCompositorFrame({child_id2}, empty_surface_ids()));
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 
   // The parent surface should now have both a pending and activate
   // CompositorFrame. Verify that the set of child references from
   // |parent_id| are only from the active CompositorFrame.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(),
               UnorderedElementsAre(child_id2));
   EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id1));
 
-  child_support2().SubmitCompositorFrame(
-      child_id2.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support2().SubmitCompositorFrame(child_id2.local_surface_id(),
+                                         MakeCompositorFrame());
 
   // Verify that the parent Surface has activated and no longer has a pending
   // CompositorFrame. Also verify that |child_id1| is no longer a child
   // reference of |parent_id|.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces(), IsEmpty());
-  EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id2));
+  // The parent will not immediately refer to the child until it submits a new
+  // CompositorFrame with the reference.
+  EXPECT_THAT(GetChildReferences(parent_id), IsEmpty());
 }
 
 // Checks whether the latency info are moved to the new surface from the old
 // one when LocalSurfaceId changes. No frame has unresolved dependencies.
 TEST_F(CompositorFrameSinkSupportTest,
        LatencyInfoCarriedOverOnResize_NoUnresolvedDependencies) {
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId parent_id2 = MakeSurfaceId(kParentFrameSink, 2);
   const ui::LatencyComponentType latency_type1 =
       ui::BROWSER_SNAPSHOT_FRAME_NUMBER_COMPONENT;
@@ skipping 82 matching lines @@
   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});
+  CompositorFrame frame2 = MakeCompositorFrame({child_id}, empty_surface_ids());
   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());
@@ skipping 62 matching lines @@
   Surface* old_surface = surface_manager().GetSurfaceForId(parent_id1);
   ASSERT_NE(nullptr, old_surface);
   EXPECT_TRUE(old_surface->HasActiveFrame());
   EXPECT_FALSE(old_surface->HasPendingFrame());
 
   // Submit a frame with a new local surface id and with unresolved
   // dependencies.
   ui::LatencyInfo info2;
   info2.AddLatencyNumber(latency_type2, latency_id2, latency_sequence_number2);
 
-  CompositorFrame frame2 = MakeCompositorFrame({child_id});
+  CompositorFrame frame2 = MakeCompositorFrame({child_id}, empty_surface_ids());
   frame2.metadata.latency_info.push_back(info2);
 
   parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
                                          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());
@@ skipping 75 matching lines @@
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          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(),
                                          MakeCompositorFrame());
 
   // Verify that the child surface is created.
   Surface* surface = surface_manager().GetSurfaceForId(child_id);
   EXPECT_NE(nullptr, surface);
 
+  // Add a reference from the parent to the child.
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame({child_id}));
+
   // 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(),
                                          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(),
                                          MakeCompositorFrame());
   EXPECT_NE(nullptr, surface_manager().GetSurfaceForId(child_id));
 
+  // Add a reference from parent.
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame({child_id}));
+
   // Remove the reference from parant. This allows us to destroy the surface.
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          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(),
                                          MakeCompositorFrame());
   EXPECT_NE(nullptr, surface_manager().GetSurfaceForId(child_id));
 }
 
 // This test verifies that a crash does not occur if garbage collection is
 // triggered during surface dependency resolution. This test triggers garbage
 // collection during surface resolution, by causing an activation to remove
 // a surface subtree from the root. Both the old subtree and the new
 // activated subtree refer to the same dependency. The old subtree was activated
 // by deadline, and the new subtree was activated by a dependency finally
 // resolving.
 TEST_F(CompositorFrameSinkSupportTest, DependencyTrackingGarbageCollection) {
   const SurfaceId display_id = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId parent_id2 = MakeSurfaceId(kParentFrameSink, 2);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 1);
 
-  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id}));
-  display_support().SubmitCompositorFrame(display_id.local_surface_id(),
-                                          MakeCompositorFrame({parent_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id1.local_surface_id(),
+      MakeCompositorFrame({child_id}, empty_surface_ids()));
+  display_support().SubmitCompositorFrame(
+      display_id.local_surface_id(),
+      MakeCompositorFrame({parent_id1}, empty_surface_ids()));
 
   EXPECT_TRUE(dependency_tracker().has_deadline());
 
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
 
   // Advance BeginFrames to trigger a deadline.
   for (int i = 0; i < 3; ++i) {
     begin_frame_source()->TestOnBeginFrame(args);
     EXPECT_TRUE(dependency_tracker().has_deadline());
   }
   begin_frame_source()->TestOnBeginFrame(args);
   EXPECT_FALSE(dependency_tracker().has_deadline());
 
   EXPECT_TRUE(display_surface()->HasActiveFrame());
   EXPECT_FALSE(display_surface()->HasPendingFrame());
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
 
-  parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
-                                         MakeCompositorFrame({child_id}));
-  display_support().SubmitCompositorFrame(display_id.local_surface_id(),
-                                          MakeCompositorFrame({parent_id2}));
+  parent_support().SubmitCompositorFrame(
+      parent_id2.local_surface_id(),
+      MakeCompositorFrame({child_id}, empty_surface_ids()));
+  display_support().SubmitCompositorFrame(
+      display_id.local_surface_id(),
+      MakeCompositorFrame({parent_id2}, empty_surface_ids()));
 
   // The display surface now has two CompositorFrames. One that is pending,
   // indirectly blocked on child_id and one that is active, also indirectly
   // referring to child_id, but activated due to the deadline above.
   EXPECT_TRUE(display_surface()->HasActiveFrame());
   EXPECT_TRUE(display_surface()->HasPendingFrame());
 
   // Submitting a CompositorFrame will trigger garbage collection of the
   // |parent_id1| subtree. This should not crash.
-  child_support1().SubmitCompositorFrame(
-      child_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+  child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
+                                         MakeCompositorFrame());
 }
 
 // This test verifies that a crash does not occur if garbage collection is
 // triggered when a deadline forces frame activation. This test triggers garbage
 // collection during deadline activation by causing the activation of a display
 // frame to replace a previously activated display frame that was referring to
 // a now-unreachable surface subtree. That subtree gets garbage collected during
 // deadline activation. SurfaceDependencyTracker is also tracking a surface
 // from that subtree due to an unresolved dependency. This test verifies that
 // this dependency resolution does not crash.
 TEST_F(CompositorFrameSinkSupportTest, GarbageCollectionOnDeadline) {
   const SurfaceId display_id = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId parent_id2 = MakeSurfaceId(kParentFrameSink, 2);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 1);
 
+  // |parent_id1| is blocked on |child_id|.
+  parent_support().SubmitCompositorFrame(
+      parent_id1.local_surface_id(),
+      MakeCompositorFrame({child_id}, empty_surface_ids()));
+
   display_support().SubmitCompositorFrame(display_id.local_surface_id(),
                                           MakeCompositorFrame({parent_id1}));
 
+  EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_TRUE(display_surface()->HasPendingFrame());
-  EXPECT_TRUE(dependency_tracker().has_deadline());
   EXPECT_FALSE(display_surface()->HasActiveFrame());
 
   // Advance BeginFrames to trigger a deadline. This activates the
   // CompositorFrame submitted above.
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
   for (int i = 0; i < 3; ++i) {
     begin_frame_source()->TestOnBeginFrame(args);
     EXPECT_TRUE(dependency_tracker().has_deadline());
   }
   begin_frame_source()->TestOnBeginFrame(args);
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_FALSE(display_surface()->HasPendingFrame());
   EXPECT_TRUE(display_surface()->HasActiveFrame());
 
-  // |parent_id1| is blocked on |child_id|, but |display_id|'s CompositorFrame
-  // has activated due to a deadline. |parent_id1| will be tracked by the
-  // SurfaceDependencyTracker.
-  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id}));
-
   // By submitting a display CompositorFrame, and replacing the parent's
   // CompositorFrame with another surface ID, parent_id1 becomes unreachable and
   // a candidate for garbage collection.
-  display_support().SubmitCompositorFrame(display_id.local_surface_id(),
-                                          MakeCompositorFrame({parent_id2}));
+  display_support().SubmitCompositorFrame(
+      display_id.local_surface_id(),
+      MakeCompositorFrame({parent_id2}, empty_surface_ids()));
 
   // Now |parent_id1| is only kept alive by the active |display_id| frame.
-  parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
-                                         MakeCompositorFrame({child_id}));
+  parent_support().SubmitCompositorFrame(
+      parent_id2.local_surface_id(),
+      MakeCompositorFrame({child_id}, empty_surface_ids()));
 
   // SurfaceDependencyTracker should now be tracking |display_id|, |parent_id1|
   // and |parent_id2|. By activating the pending |display_id| frame by deadline,
   // |parent_id1| becomes unreachable and is garbage collected while
   // SurfaceDependencyTracker is in the process of activating surfaces. This
   // should not cause a crash or use-after-free.
   for (int i = 0; i < 3; ++i) {
     begin_frame_source()->TestOnBeginFrame(args);
     EXPECT_TRUE(dependency_tracker().has_deadline());
   }
   begin_frame_source()->TestOnBeginFrame(args);
   EXPECT_FALSE(dependency_tracker().has_deadline());
 }
 
 // This test verifies that a CompositorFrame will only blocked on embedded
 // surfaces but not on other retained surface IDs in the CompositorFrame.
 TEST_F(CompositorFrameSinkSupportTest, OnlyBlockOnEmbeddedSurfaces) {
   const SurfaceId display_id = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId parent_id2 = MakeSurfaceId(kParentFrameSink, 2);
 
+  // Submitting a CompositorFrame with |parent_id2| so that the display
+  // CompositorFrame can hold a reference to it.
+  parent_support().SubmitCompositorFrame(parent_id2.local_surface_id(),
+                                         MakeCompositorFrame());
+
   display_support().SubmitCompositorFrame(
       display_id.local_surface_id(),
-      MakeCompositorFrame({parent_id1}, {parent_id1, parent_id2}));
+      MakeCompositorFrame({parent_id1}, {parent_id2}));
 
   EXPECT_TRUE(display_surface()->HasPendingFrame());
   EXPECT_FALSE(display_surface()->HasActiveFrame());
   EXPECT_TRUE(dependency_tracker().has_deadline());
 
   // Verify that the display CompositorFrame will only block on |parent_id1| but
   // not |parent_id2|.
   EXPECT_THAT(display_surface()->blocking_surfaces(),
               UnorderedElementsAre(parent_id1));
   // Verify that the display surface holds no references while its
   // CompositorFrame is pending.
   EXPECT_THAT(GetChildReferences(display_id), IsEmpty());
 
   // Submitting a CompositorFrame with |parent_id1| should unblock the display
   // CompositorFrame.
   parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
                                          MakeCompositorFrame());
 
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_FALSE(display_surface()->HasPendingFrame());
   EXPECT_TRUE(display_surface()->HasActiveFrame());
   EXPECT_THAT(display_surface()->blocking_surfaces(), IsEmpty());
-
-  // Only a reference to |parent_id1| is added because |parent_id2| does not
-  // exist.
-  EXPECT_THAT(GetChildReferences(display_id), UnorderedElementsAre(parent_id1));
 }
 
 // This test verifies that a late arriving CompositorFrame activates immediately
 // and does not trigger a new deadline.
 TEST_F(CompositorFrameSinkSupportTest, LateArrivingDependency) {
   const SurfaceId display_id = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
 
-  display_support().SubmitCompositorFrame(display_id.local_surface_id(),
-                                          MakeCompositorFrame({parent_id1}));
+  display_support().SubmitCompositorFrame(
+      display_id.local_surface_id(),
+      MakeCompositorFrame({parent_id1}, empty_surface_ids()));
 
   EXPECT_TRUE(display_surface()->HasPendingFrame());
   EXPECT_FALSE(display_surface()->HasActiveFrame());
   EXPECT_TRUE(dependency_tracker().has_deadline());
 
   // Advance BeginFrames to trigger a deadline. This activates the
   // CompositorFrame submitted above.
   BeginFrameArgs args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
   for (int i = 0; i < 3; ++i) {
     begin_frame_source()->TestOnBeginFrame(args);
     EXPECT_TRUE(dependency_tracker().has_deadline());
   }
   begin_frame_source()->TestOnBeginFrame(args);
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_FALSE(display_surface()->HasPendingFrame());
   EXPECT_TRUE(display_surface()->HasActiveFrame());
 
   // A late arriving CompositorFrame should activate immediately without
   // scheduling a deadline and without waiting for dependencies to resolve.
-  parent_support().SubmitCompositorFrame(parent_id1.local_surface_id(),
-                                         MakeCompositorFrame({child_id1}));
+  parent_support().SubmitCompositorFrame(
+      parent_id1.local_surface_id(),
+      MakeCompositorFrame({child_id1}, empty_surface_ids()));
   EXPECT_FALSE(dependency_tracker().has_deadline());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
 }
 
+// This test verifies that CompositorFrames submitted to a surface referenced
+// by a parent CompositorFrame as a fallback will be rejected and ACK'ed
+// immediately.
+TEST_F(CompositorFrameSinkSupportTest, FallbackSurfacesClosed) {
+  const SurfaceId parent_id1 = MakeSurfaceId(kParentFrameSink, 1);
+  // This is the fallback child surface that the parent holds a reference to.
+  const SurfaceId child_id1 = MakeSurfaceId(kChildFrameSink1, 1);
+  // This is the primary child surface that the parent wants to block on.
+  const SurfaceId child_id2 = MakeSurfaceId(kChildFrameSink1, 2);
+
+  // child_support1 submits a CompositorFrame without any dependencies.
+  // DidReceiveCompositorFrameAck should call on immediate activation.
+  // However, resources will not be returned because this frame is a candidate
+  // for display.
+  TransferableResource resource =
+      MakeResource(1337 /* id */, ALPHA_8 /* format */, 1234 /* filter */,
+                   gfx::Size(1234, 5678));
+  ReturnedResourceArray returned_resources;
+  TransferableResource::ReturnResources({resource}, &returned_resources);
+
+  EXPECT_CALL(support_client_,
+              DidReceiveCompositorFrameAck(Eq(ReturnedResourceArray())));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrameWithResources(empty_surface_ids(), {resource}));
+  testing::Mock::VerifyAndClearExpectations(&support_client_);
+
+  // The parent is blocked on |child_id2| and references |child_id1|. The
+  // surface corresponding to |child_id1| will not accept new CompositorFrames
+  // while the parent CompositorFrame is blocked.
+  parent_support().SubmitCompositorFrame(
+      parent_id1.local_surface_id(),
+      MakeCompositorFrame({child_id2}, {child_id1}));
+  EXPECT_TRUE(dependency_tracker().has_deadline());
+  EXPECT_TRUE(parent_surface()->HasPendingFrame());
+  EXPECT_FALSE(parent_surface()->HasActiveFrame());
+
+  // Resources will be returned immediately because |child_id1|'s surface is
+  // closed.
+  TransferableResource resource2 =
+      MakeResource(1246 /* id */, ALPHA_8 /* format */, 1357 /* filter */,
+                   gfx::Size(8765, 4321));
+  ReturnedResourceArray returned_resources2;
+  TransferableResource::ReturnResources({resource2}, &returned_resources2);
+  EXPECT_CALL(support_client_,
+              DidReceiveCompositorFrameAck(Eq(returned_resources2)));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrameWithResources(empty_surface_ids(), {resource2}));
+  testing::Mock::VerifyAndClearExpectations(&support_client_);
+
+  // Advance BeginFrames to trigger a deadline. This activates the
+  // CompositorFrame submitted to the parent.
+  BeginFrameArgs args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1);
+  for (int i = 0; i < 3; ++i) {
+    begin_frame_source()->TestOnBeginFrame(args);
+    EXPECT_TRUE(dependency_tracker().has_deadline());
+  }
+  begin_frame_source()->TestOnBeginFrame(args);
+  EXPECT_FALSE(dependency_tracker().has_deadline());
+  EXPECT_FALSE(parent_surface()->HasPendingFrame());
+  EXPECT_TRUE(parent_surface()->HasActiveFrame());
+
+  // Resources will be returned immediately because |child_id1|'s surface is
+  // closed forever.
+  EXPECT_CALL(support_client_,
+              DidReceiveCompositorFrameAck(Eq(returned_resources2)));
+  child_support1().SubmitCompositorFrame(
+      child_id1.local_surface_id(),
+      MakeCompositorFrameWithResources(empty_surface_ids(), {resource2}));
+  testing::Mock::VerifyAndClearExpectations(&support_client_);
+}
+
 }  // namespace cc