Refactor how temporary references are stored.

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 @@
   }
 
   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];
+  // Returns true if there is a temporary reference for |surface_id|.
+  bool HasTemporaryReference(const SurfaceId& surface_id) {
+    return surface_manager().HasTemporaryReference(surface_id);
   }
 
   SurfaceDependencyTracker& dependency_tracker() {
     return *surface_manager_.dependency_tracker();
   }
 
   FakeExternalBeginFrameSource* begin_frame_source() {
     return begin_frame_source_.get();
   }
 
@@ skipping 62 matching lines @@
   const SurfaceId display_id_first = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId display_id_second = MakeSurfaceId(kDisplayFrameSink, 2);
 
   // Submit a CompositorFrame for the first display root surface.
   display_support().SubmitCompositorFrame(
       display_id_first.local_surface_id(),
       MakeCompositorFrame({MakeSurfaceId(kParentFrameSink, 1)}));
 
   // A surface reference from the top-level root is added and there shouldn't be
   // a temporary reference.
-  EXPECT_THAT(GetTempReferences(kDisplayFrameSink), IsEmpty());
+  EXPECT_FALSE(HasTemporaryReference(display_id_first));
   EXPECT_THAT(GetChildReferences(surface_manager().GetRootSurfaceId()),
               UnorderedElementsAre(display_id_first));
 
   // Submit a CompositorFrame for the second display root surface.
   display_support().SubmitCompositorFrame(
       display_id_second.local_surface_id(),
       MakeCompositorFrame({MakeSurfaceId(kParentFrameSink, 2)}));
 
   // A surface reference from the top-level root to |display_id_second| should
   // be added and the reference to |display_root_first| removed.
-  EXPECT_THAT(GetTempReferences(kDisplayFrameSink), IsEmpty());
+  EXPECT_FALSE(HasTemporaryReference(display_id_second));
   EXPECT_THAT(GetChildReferences(surface_manager().GetRootSurfaceId()),
               UnorderedElementsAre(display_id_second));
 
   // Surface |display_id_first| is unreachable and should get deleted.
   EXPECT_EQ(nullptr, surface_manager().GetSurfaceForId(display_id_first));
 }
 
 // The parent Surface is blocked on |child_id1| and |child_id2|.
 TEST_F(CompositorFrameSinkSupportTest, DisplayCompositorLockingBlockedOnTwo) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
@@ skipping 383 matching lines @@
   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_FALSE(HasTemporaryReference(child_id));
   EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id));
 }
 
 // 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);
@@ skipping 62 matching lines @@
   EXPECT_FALSE(child_surface1()->HasPendingFrame());
   EXPECT_THAT(child_surface1()->blocking_surfaces_for_testing(), IsEmpty());
 
   // Verify that the parent Surface has activated.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_FALSE(parent_surface()->HasPendingFrame());
   EXPECT_THAT(parent_surface()->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_id1.frame_sink_id()), IsEmpty());
+  EXPECT_FALSE(HasTemporaryReference(child_id1));
   EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id1));
 
   // The parent submits another CompositorFrame that depends on |child_id2|.
   parent_support().SubmitCompositorFrame(parent_id.local_surface_id(),
                                          MakeCompositorFrame({child_id2}));
 
   // The parent surface should now have both a pending and activate
   // CompositorFrame. Verify that the set of child references from
   // |parent_id| include both the pending and active CompositorFrames.
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
@@ skipping 10 matching lines @@
   // 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_for_testing(), IsEmpty());
   EXPECT_THAT(GetChildReferences(parent_id), UnorderedElementsAre(child_id2));
 }
 
 }  // namespace test
 }  // namespace cc