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

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 110 matching lines @@
         did_request_next_frame_(false),
         did_request_prepare_tiles_(false),
         did_complete_page_scale_animation_(false),
         reduce_memory_result_(true),
         did_request_impl_side_invalidation_(false) {
     media::InitializeMediaLibrary();
   }
 
   LayerTreeSettings DefaultSettings() {
     LayerTreeSettings settings;
+    settings.enable_surface_synchronization = true;
     settings.minimum_occlusion_tracking_size = gfx::Size();
     settings.renderer_settings.texture_id_allocation_chunk_size = 1;
     settings.renderer_settings.buffer_to_texture_target_map =
         DefaultBufferToTextureTargetMapForTesting();
     return settings;
   }
 
   void SetUp() override {
     CreateHostImpl(DefaultSettings(), CreateCompositorFrameSink());
   }
@@ skipping 3305 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf1) {
   SetupMouseMoveAtWithDeviceScale(1.f);
 }
 
 TEST_F(LayerTreeHostImplTest, MouseMoveAtWithDeviceScaleOf2) {
   SetupMouseMoveAtWithDeviceScale(2.f);
 }
 
-// This test verifies that only SurfaceLayers in the viewport are included
-// in CompositorFrameMetadata's |activation_dependencies|.
-TEST_F(LayerTreeHostImplTest, EmbeddedSurfacesInMetadata) {
+// This test verifies that only SurfaceLayers in the viewport and have fallbacks
+// that are different are included in CompositorFrameMetadata's
+// |activation_dependencies|.
+TEST_F(LayerTreeHostImplTest, ActivationDependenciesInMetadata) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   LayerImpl* root = host_impl_->active_tree()->root_layer_for_testing();
 
-  std::vector<SurfaceId> children = {MakeSurfaceId(FrameSinkId(1, 1), 1),
-                                     MakeSurfaceId(FrameSinkId(2, 2), 2),
-                                     MakeSurfaceId(FrameSinkId(3, 3), 3)};
-  for (size_t i = 0; i < children.size(); ++i) {
+  std::vector<SurfaceId> primary_surfaces = {
+      MakeSurfaceId(FrameSinkId(1, 1), 1), MakeSurfaceId(FrameSinkId(2, 2), 2),
+      MakeSurfaceId(FrameSinkId(3, 3), 3)};
+
+  std::vector<SurfaceId> fallback_surfaces = {
+      MakeSurfaceId(FrameSinkId(4, 4), 1), MakeSurfaceId(FrameSinkId(4, 4), 2),
+      MakeSurfaceId(FrameSinkId(4, 4), 3)};
+
+  for (size_t i = 0; i < primary_surfaces.size(); ++i) {
     std::unique_ptr<SurfaceLayerImpl> child =
         SurfaceLayerImpl::Create(host_impl_->active_tree(), i + 6);
     child->SetPosition(gfx::PointF(25.f * i, 0.f));
     child->SetBounds(gfx::Size(1, 1));
     child->SetDrawsContent(true);
     child->SetPrimarySurfaceInfo(
-        SurfaceInfo(children[i], 1.f /* device_scale_factor */,
+        SurfaceInfo(primary_surfaces[i], 1.f /* device_scale_factor */,
+                    gfx::Size(10, 10) /* size_in_pixels */));
+    child->SetFallbackSurfaceInfo(
+        SurfaceInfo(fallback_surfaces[i], 1.f /* device_scale_factor */,
                     gfx::Size(10, 10) /* size_in_pixels */));
     root->test_properties()->AddChild(std::move(child));
   }
 
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   DrawFrame();
 
   FakeCompositorFrameSink* fake_compositor_frame_sink =
       static_cast<FakeCompositorFrameSink*>(
           host_impl_->compositor_frame_sink());
   const CompositorFrameMetadata& metadata =
       fake_compositor_frame_sink->last_sent_frame()->metadata;
-  EXPECT_THAT(metadata.activation_dependencies,
-              testing::UnorderedElementsAre(children[0], children[1]));
+  EXPECT_THAT(
+      metadata.activation_dependencies,
+      testing::UnorderedElementsAre(primary_surfaces[0], primary_surfaces[1]));
   EXPECT_THAT(
       metadata.referenced_surfaces,
-      testing::UnorderedElementsAre(children[0], children[1], children[2]));
+      testing::UnorderedElementsAre(fallback_surfaces[0], fallback_surfaces[1],
+                                    fallback_surfaces[2]));
 }
 
 TEST_F(LayerTreeHostImplTest, CompositorFrameMetadata) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
   DrawFrame();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
@@ skipping 8890 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, RasterColorSpace) {
   LayerTreeSettings settings = DefaultSettings();
   settings.enable_color_correct_rasterization = true;
   CreateHostImpl(settings, CreateCompositorFrameSink());
   EXPECT_EQ(host_impl_->GetRasterColorSpace(), gfx::ColorSpace::CreateSRGB());
 }
 
 }  // namespace
 }  // namespace cc