cc: Move ownership of surfaces to SurfaceManager

cc/surfaces/surface_synchronization_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 "base/containers/flat_set.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/surface_id.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/compositor_frame_helpers.h"
@@ skipping 58 matching lines @@
 
 class SurfaceSynchronizationTest : public testing::Test {
  public:
   SurfaceSynchronizationTest()
       : surface_manager_(SurfaceManager::LifetimeType::REFERENCES),
         surface_observer_(false) {}
   ~SurfaceSynchronizationTest() override {}
 
   CompositorFrameSinkSupport& display_support() { return *supports_[0]; }
   Surface* display_surface() {
-    return display_support().current_surface_for_testing();
+    return display_support().GetCurrentSurfaceForTesting();
   }
 
   CompositorFrameSinkSupport& parent_support() { return *supports_[1]; }
   Surface* parent_surface() {
-    return parent_support().current_surface_for_testing();
+    return parent_support().GetCurrentSurfaceForTesting();
   }
 
   CompositorFrameSinkSupport& child_support1() { return *supports_[2]; }
   Surface* child_surface1() {
-    return child_support1().current_surface_for_testing();
+    return child_support1().GetCurrentSurfaceForTesting();
   }
 
   CompositorFrameSinkSupport& child_support2() { return *supports_[3]; }
   Surface* child_surface2() {
-    return child_support2().current_surface_for_testing();
+    return child_support2().GetCurrentSurfaceForTesting();
   }
 
   CompositorFrameSinkSupport& support(int index) { return *supports_[index]; }
   Surface* surface(int index) {
-    return support(index).current_surface_for_testing();
+    return support(index).GetCurrentSurfaceForTesting();
   }
 
   SurfaceManager& surface_manager() { return surface_manager_; }
 
   // Returns all the references where |surface_id| is the parent.
   const base::flat_set<SurfaceId>& GetChildReferences(
       const SurfaceId& surface_id) {
     return surface_manager().GetSurfacesReferencedByParent(surface_id);
   }
 
@@ skipping 60 matching lines @@
     // SurfaceDependencyTracker depends on this BeginFrameSource and so it must
     // be destroyed AFTER the dependency tracker is destroyed.
     begin_frame_source_->SetClient(nullptr);
     begin_frame_source_.reset();
 
     supports_.clear();
 
     surface_observer_.Reset();
   }
 
+  bool IsMarkedForDestruction(const SurfaceId& surface_id) {
+    return surface_manager_.IsMarkedForDestruction(surface_id);
+  }
+
  protected:
   testing::NiceMock<MockCompositorFrameSinkSupportClient> support_client_;
 
  private:
   SurfaceManager surface_manager_;
   FakeSurfaceObserver surface_observer_;
   FakeExternalBeginFrameSourceClient begin_frame_source_client_;
   std::unique_ptr<FakeExternalBeginFrameSource> begin_frame_source_;
   std::unique_ptr<SurfaceDependencyTracker> dependency_tracker_;
   std::vector<std::unique_ptr<CompositorFrameSinkSupport>> supports_;
@@ skipping 844 matching lines @@
   // Add a reference from the parent to the child.
   parent_support().SubmitCompositorFrame(
       parent_id.local_surface_id(),
       MakeCompositorFrame({child_id}, {child_id}, TransferableResourceArray()));
 
   // 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().EvictCurrentSurface();
   surface = surface_manager().GetSurfaceForId(child_id);
   EXPECT_NE(nullptr, surface);
-  EXPECT_TRUE(surface->destroyed());
+  EXPECT_TRUE(IsMarkedForDestruction(child_id));
 
   // 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());
+  EXPECT_FALSE(IsMarkedForDestruction(child_id));
 }
 
 // Verifies that if a LocalSurfaceId belonged to a surface that doesn't exist
 // anymore, it can still be reused for new surfaces.
 TEST_F(SurfaceSynchronizationTest, LocalSurfaceIdIsReusable) {
   const SurfaceId parent_id = MakeSurfaceId(kParentFrameSink, 1);
   const SurfaceId child_id = MakeSurfaceId(kChildFrameSink1, 3);
 
   // Submit the first frame. Creates the surface.
   child_support1().SubmitCompositorFrame(child_id.local_surface_id(),
@@ skipping 307 matching lines @@
               DidReceiveCompositorFrameAck(Eq(returned_resources2)));
   child_support1().SubmitCompositorFrame(
       child_id1.local_surface_id(),
       MakeCompositorFrame(empty_surface_ids(), empty_surface_ids(),
                           {resource2}));
   testing::Mock::VerifyAndClearExpectations(&support_client_);
 }
 
 }  // namespace test
 }  // namespace cc