Fix check for changing SurfaceId.

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"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::UnorderedElementsAre;
 using testing::IsEmpty;
 using testing::SizeIs;
 
 namespace cc {
 namespace test {
 namespace {
 
-constexpr FrameSinkId kParentFrameSink(2, 1);
-constexpr FrameSinkId kChildFrameSink1(65563, 1);
-constexpr FrameSinkId kChildFrameSink2(65564, 1);
+constexpr FrameSinkId kDisplayFrameSink(2, 0);
+constexpr FrameSinkId kParentFrameSink(3, 0);
+constexpr FrameSinkId kChildFrameSink1(65563, 0);
+constexpr FrameSinkId kChildFrameSink2(65564, 0);
 constexpr FrameSinkId kArbitraryFrameSink(1337, 7331);
 
 std::vector<SurfaceId> empty_surface_ids() {
   return std::vector<SurfaceId>();
 }
 
 SurfaceId MakeSurfaceId(const FrameSinkId& frame_sink_id, uint32_t local_id) {
   return SurfaceId(
       frame_sink_id,
       LocalSurfaceId(local_id, base::UnguessableToken::Deserialize(0, 1u)));
@@ skipping 31 matching lines @@
 
 }  // namespace
 
 class CompositorFrameSinkSupportTest : public testing::Test,
                                        public CompositorFrameSinkSupportClient {
  public:
   CompositorFrameSinkSupportTest()
       : surface_manager_(SurfaceManager::LifetimeType::REFERENCES) {}
   ~CompositorFrameSinkSupportTest() override {}
 
-  CompositorFrameSinkSupport& parent_support() { return *supports_[0]; }
+  CompositorFrameSinkSupport& display_support() { return *supports_[0]; }
+
+  CompositorFrameSinkSupport& parent_support() { return *supports_[1]; }
   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]; }
+  CompositorFrameSinkSupport& child_support1() { return *supports_[2]; }
   Surface* child_surface1() {
     return child_support1().current_surface_for_testing();
   }
 
-  CompositorFrameSinkSupport& child_support2() { return *supports_[2]; }
+  CompositorFrameSinkSupport& child_support2() { return *supports_[3]; }
   Surface* child_surface2() {
     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_; }
@@ skipping 25 matching lines @@
   // testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
     begin_frame_source_ =
         base::MakeUnique<FakeExternalBeginFrameSource>(0.f, false);
     std::unique_ptr<SurfaceDependencyTracker> dependency_tracker(
         new SurfaceDependencyTracker(&surface_manager_,
                                      begin_frame_source_.get()));
     surface_manager_.SetDependencyTracker(std::move(dependency_tracker));
     supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
+        this, &surface_manager_, kDisplayFrameSink, true /* is_root */,
+        true /* handles_frame_sink_id_invalidation */,
+        true /* needs_sync_points */));
+    supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
         this, &surface_manager_, kParentFrameSink, false /* is_root */,
         true /* handles_frame_sink_id_invalidation */,
         true /* needs_sync_points */));
     supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
         this, &surface_manager_, kChildFrameSink1, false /* is_root */,
         true /* handles_frame_sink_id_invalidation */,
         true /* needs_sync_points */));
     supports_.push_back(base::MakeUnique<CompositorFrameSinkSupport>(
         this, &surface_manager_, kChildFrameSink2, false /* is_root */,
         true /* handles_frame_sink_id_invalidation */,
@@ skipping 21 matching lines @@
 
  private:
   SurfaceManager surface_manager_;
   std::unique_ptr<FakeExternalBeginFrameSource> begin_frame_source_;
   std::vector<std::unique_ptr<CompositorFrameSinkSupport>> supports_;
   ReturnedResourceArray last_returned_resources_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorFrameSinkSupportTest);
 };
 
+// The display root surface should have a surface reference from the top-level
+// root added/removed when a CompositorFrame is submitted with a new SurfaceId.
+TEST_F(CompositorFrameSinkSupportTest, RootSurfaceReceivesReferences) {
+  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_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_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);
   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}));
 
@@ skipping 490 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