Surfaces: Allow parent to refer to child surfaces that don't exist yet.

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 84 matching lines @@
     return child_support2().current_surface_for_testing();
   }
 
   CompositorFrameSinkSupport& support(int index) { return *supports_[index]; }
   Surface* surface(int index) {
     return support(index).current_surface_for_testing();
   }
 
   SurfaceManager& surface_manager() { return surface_manager_; }
 
+  // Returns all the references where |surface_id| is the parent.
+  const SurfaceManager::SurfaceIdSet& GetChildReferences(
+      const SurfaceId& surface_id) {
+    return surface_manager().parent_to_child_refs_[surface_id];
+  }
+
+  // Returns all the temporary references for the given frame sink id.
+  std::vector<LocalSurfaceId> GetTempReferences(
+      const FrameSinkId& frame_sink_id) {
+    return surface_manager().temp_references_[frame_sink_id];
+  }
+
   SurfaceDependencyTracker& dependency_tracker() {
     return *surface_manager_.dependency_tracker();
   }
 
   FakeExternalBeginFrameSource* begin_frame_source() {
     return begin_frame_source_.get();
   }
 
   ReturnedResourceArray& last_returned_resources() {
     return last_returned_resources_;
@@ skipping 402 matching lines @@
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(), MakeCompositorFrame({empty_surface_ids()}));
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces_for_testing(), IsEmpty());
   ReturnedResource returned_resource = resource.ToReturnedResource();
   EXPECT_THAT(last_returned_resources(),
               UnorderedElementsAre(returned_resource));
 }
 
+// This test verifies that a SurfaceReference from parent to child can be added
+// prior to the child submitting a CompositorFrame. This test also verifies that
+// when the child later submits a CompositorFrame,
+TEST_F(CompositorFrameSinkSupportTest,
+       DisplayCompositorLockingReferenceAddedBeforeChildExists) {
+  const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
+  const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 1);
+
+  // The parent submits a CompositorFrame that depends on |child_id| before the
+  // child submits a CompositorFrame.
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame({child_id}));
+
+  // 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_for_testing(),
+              UnorderedElementsAre(child_id));
+
+  // Verify that a SurfaceReference(parent_id, child_id) exists in the
+  // SurfaceManager.
+  EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id));
+
+  child_support1().SubmitCompositorFrame(
+      child_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+
+  // Verify that the child CompositorFrame activates immediately.
+  EXPECT_TRUE(child_surface1()->HasActiveFrame());
+  EXPECT_FALSE(child_surface1()->HasPendingFrame());
+  EXPECT_THAT(child_surface1()->blocking_surfaces_for_testing(), IsEmpty());
+
+  // Verify that there is no temporary reference for the child and that
+  // the reference from the parent to the child still exists.
+  EXPECT_THAT(GetTempReferences(child_id.frame_sink_id()), IsEmpty());
+  EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id));
+}
+
 }  // namespace test
 }  // namespace cc