Retain references to surfaces from both active AND pending CompositorFrames

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 32 matching lines @@
   compositor_frame.metadata.referenced_surfaces =
       std::move(referenced_surfaces);
   return compositor_frame;
 }
 
 }  // namespace
 
 class CompositorFrameSinkSupportTest : public testing::Test,
                                        public CompositorFrameSinkSupportClient {
  public:
-  CompositorFrameSinkSupportTest() {}
+  CompositorFrameSinkSupportTest()
+      : surface_manager_(SurfaceManager::LifetimeType::REFERENCES) {}
   ~CompositorFrameSinkSupportTest() override {}
 
   CompositorFrameSinkSupport& parent_support() { return *supports_[0]; }
   Surface* parent_surface() {
     return parent_support().current_surface_for_testing();
   }
+  const ReferencedSurfaceTracker& parent_reference_tracker() {
+    return parent_support().ReferenceTrackerForTesting();
+  }
 
   CompositorFrameSinkSupport& child_support1() { return *supports_[1]; }
   Surface* child_surface1() {
     return child_support1().current_surface_for_testing();
   }
 
   CompositorFrameSinkSupport& child_support2() { return *supports_[2]; }
   Surface* child_surface2() {
     return child_support2().current_surface_for_testing();
   }
@@ skipping 28 matching lines @@
     supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
         this, &surface_manager_, kChildFrameSink1, nullptr /* display */,
         nullptr /* display_begin_frame_source */));
     supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
         this, &surface_manager_, kChildFrameSink2, nullptr /* display */,
         nullptr /* display_begin_frame_source */));
   }
 
   void TearDown() override {
     surface_manager_.SetDependencyTracker(nullptr);
+
+    // SurfaceDependencyTracker depends on this BeginFrameSource and so it must
+    // be destroyed AFTER the dependency tracker is destroyed.
     begin_frame_source_.reset();
+
     supports_.clear();
   }
 
   // CompositorFrameSinkSupportClient implementation.
   void DidReceiveCompositorFrameAck() override {}
   void OnBeginFrame(const BeginFrameArgs& args) override {}
   void ReclaimResources(const ReturnedResourceArray& resources) override {}
   void WillDrawSurface() override {}
 
  private:
@@ skipping 261 matching lines @@
   // Submit a CompositorFrame that has no dependencies.
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
 
   // Verify that the CompositorFrame has been activated.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->blocking_surfaces_for_testing(), IsEmpty());
 }
 
+// This test verifies that the set of references from a Surface includes both
+// the pending and active CompositorFrames.
+TEST_F(CompositorFrameSinkSupportTest,
+       DisplayCompositorLockingReferencesFromPendingAndActiveFrames) {
+  const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
+  const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 1);
+  const SurfaceId arbitrary_id = MakeSurfaceId(kArbitraryFrameSink, 1);
+  const SurfaceReference parent_child_reference(parent_id, child_id);
+  const SurfaceReference parent_arbitrary_reference(parent_id, arbitrary_id);
+
+  // child_support1 submits a CompositorFrame without any dependencies.
+  child_support1().SubmitCompositorFrame(
+      child_id.local_surface_id(), MakeCompositorFrame(empty_surface_ids()));
+
+  // Verify that the child surface is not blocked.
+  EXPECT_TRUE(child_surface1()->HasActiveFrame());
+  EXPECT_FALSE(child_surface1()->HasPendingFrame());
+  EXPECT_THAT(child_surface1()->blocking_surfaces_for_testing(), IsEmpty());
+
+  // parent_support submits a CompositorFrame that depends on |child_id1|
+  // which is already active. Thus, this CompositorFrame should activate
+  // immediately.
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame({child_id}));
+  EXPECT_TRUE(parent_surface()->HasActiveFrame());
+  EXPECT_FALSE(parent_surface()->HasPendingFrame());
+  EXPECT_THAT(parent_surface()->blocking_surfaces_for_testing(), IsEmpty());
+  // Verify that the parent will add a reference to the |child_id|.
+  EXPECT_THAT(parent_reference_tracker().references_to_add(),
+              UnorderedElementsAre(parent_child_reference));
+  EXPECT_THAT(parent_reference_tracker().references_to_remove(), IsEmpty());
+
+  // parent_support now submits another CompositorFrame to the same surface
+  // but depends on arbitrary_id. The parent surface should now have both
+  // a pending and active CompositorFrame.
+  parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
+                                         MakeCompositorFrame({arbitrary_id}));
+  EXPECT_TRUE(parent_surface()->HasActiveFrame());
+  EXPECT_TRUE(parent_surface()->HasPendingFrame());
+  EXPECT_THAT(parent_surface()->blocking_surfaces_for_testing(),
+              UnorderedElementsAre(arbitrary_id));
+  // Verify that the parent will add a reference to |arbitrary_id| and will not
+  // remove a reference to |child_id|.
+  EXPECT_THAT(parent_reference_tracker().references_to_add(),
+              UnorderedElementsAre(parent_arbitrary_reference));
+  EXPECT_THAT(parent_reference_tracker().references_to_remove(), IsEmpty());
+}
+
 }  // namespace test
 }  // namespace cc