cc::SurfaceDependencyTracker should not crash when a Display goes away

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/surfaces/surface_observer.h"
 #include "cc/test/begin_frame_args_test.h"
@@ skipping 89 matching lines @@
   FakeExternalBeginFrameSource* begin_frame_source() {
     return begin_frame_source_.get();
   }
 
   // testing::Test:
   void SetUp() override {
     testing::Test::SetUp();
 
     begin_frame_source_ =
         base::MakeUnique<FakeExternalBeginFrameSource>(0.f, false);
-    surface_manager_.SetDependencyTracker(
-        base::MakeUnique<SurfaceDependencyTracker>(&surface_manager_,
-                                                   begin_frame_source_.get()));
+    dependency_tracker_ = base::MakeUnique<SurfaceDependencyTracker>(
+        &surface_manager_, begin_frame_source_.get());
+    surface_manager_.SetDependencyTracker(dependency_tracker_.get());
     surface_manager_.AddObserver(this);
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kDisplayFrameSink, kIsRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kParentFrameSink, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kChildFrameSink1, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
     supports_.push_back(CompositorFrameSinkSupport::Create(
         &support_client_, &surface_manager_, kChildFrameSink2, kIsChildRoot,
         kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints));
 
     // Normally, the BeginFrameSource would be registered by the Display. We
     // register it here so that BeginFrames are received by the display support,
     // for use in the PassesOnBeginFrameAcks test. Other supports do not receive
     // BeginFrames, since the frame sink hierarchy is not set up in this test.
     surface_manager_.RegisterBeginFrameSource(begin_frame_source_.get(),
                                               kDisplayFrameSink);
   }
 
   void TearDown() override {
     surface_manager_.RemoveObserver(this);
     surface_manager_.SetDependencyTracker(nullptr);
     surface_manager_.UnregisterBeginFrameSource(begin_frame_source_.get());
 
+    dependency_tracker_.reset();
+
     // SurfaceDependencyTracker depends on this BeginFrameSource and so it must
     // be destroyed AFTER the dependency tracker is destroyed.
     begin_frame_source_.reset();
 
     supports_.clear();
 
     damaged_surfaces_.clear();
   }
 
   bool IsSurfaceDamaged(const SurfaceId& surface_id) const {
     return damaged_surfaces_.count(surface_id) > 0;
   }
 
   // SurfaceObserver implementation:
   void OnSurfaceCreated(const SurfaceInfo& surface_info) override {}
   void OnSurfaceDamaged(const SurfaceId& surface_id, bool* changed) override {
     damaged_surfaces_.insert(surface_id);
   }
   void OnSurfaceDiscarded(const SurfaceId& surface_id) override {}
 
  protected:
   testing::NiceMock<MockCompositorFrameSinkSupportClient> support_client_;
 
  private:
   base::flat_set<SurfaceId> damaged_surfaces_;
   SurfaceManager surface_manager_;
   std::unique_ptr<FakeExternalBeginFrameSource> begin_frame_source_;
+  std::unique_ptr<SurfaceDependencyTracker> dependency_tracker_;
   std::vector<std::unique_ptr<CompositorFrameSinkSupport>> supports_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceSynchronizationTest);
 };
 
 // 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(SurfaceSynchronizationTest, RootSurfaceReceivesReferences) {
   const SurfaceId display_id_first = MakeSurfaceId(kDisplayFrameSink, 1);
   const SurfaceId display_id_second = MakeSurfaceId(kDisplayFrameSink, 2);
@@ skipping 1205 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