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

cc/layers/surface_layer_impl_unittest.cc

 // Copyright 2014 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/layers/surface_layer_impl.h"
 
 #include <stddef.h>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/test/layer_test_common.h"
@@ skipping 129 matching lines @@
     EXPECT_EQ(1u, partially_occluded_count);
   }
 }
 
 TEST(SurfaceLayerImplTest, SurfaceStretchedToLayerBounds) {
   LayerTestCommon::LayerImplTest impl;
   SurfaceLayerImpl* surface_layer_impl =
       impl.AddChildToRoot<SurfaceLayerImpl>();
   const LocalSurfaceId kArbitraryLocalSurfaceId(
       9, base::UnguessableToken::Create());
+  const LocalSurfaceId kArbitraryLocalSurfaceId2(
+      10, base::UnguessableToken::Create());
 
   // Given condition: layer and surface have different size and different
   // aspect ratios.
   gfx::Size layer_size(400, 100);
   gfx::Size surface_size(300, 300);
   gfx::Size viewport_size(1000, 1000);
   float surface_scale = 1.f;
   gfx::Transform target_space_transform(
       surface_layer_impl->draw_properties().target_space_transform);
 
   // The following code is mimicking the PushPropertiesTo from pending to
   // active tree.
   surface_layer_impl->SetBounds(layer_size);
   surface_layer_impl->SetDrawsContent(true);
   SurfaceId surface_id(kArbitraryFrameSinkId, kArbitraryLocalSurfaceId);
+  SurfaceId surface_id2(kArbitraryFrameSinkId, kArbitraryLocalSurfaceId2);
   surface_layer_impl->SetPrimarySurfaceInfo(
       SurfaceInfo(surface_id, surface_scale, surface_size));
+  surface_layer_impl->SetFallbackSurfaceInfo(
+      SurfaceInfo(surface_id2, surface_scale, surface_size));
   surface_layer_impl->SetStretchContentToFillBounds(true);
 
   impl.CalcDrawProps(viewport_size);
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   surface_layer_impl->AppendQuads(render_pass.get(), &data);
   EXPECT_THAT(data.activation_dependencies, UnorderedElementsAre(surface_id));
 
   const QuadList& quads = render_pass->quad_list;
-  ASSERT_EQ(1u, quads.size());
+  ASSERT_EQ(2u, quads.size());
   const SharedQuadState* shared_quad_state = quads.front()->shared_quad_state;
 
   // We expect that the transform for the quad stretches the quad to cover the
   // entire bounds of the layer.
   gfx::Transform expected_transform(target_space_transform);
   float scale_x = static_cast<float>(surface_size.width()) / layer_size.width();
   float scale_y =
       static_cast<float>(surface_size.height()) / layer_size.height();
   expected_transform.Scale(SK_MScalar1 / scale_x, SK_MScalar1 / scale_y);
   EXPECT_EQ(expected_transform, shared_quad_state->quad_to_target_transform);
@@ skipping 153 matching lines @@
   ASSERT_TRUE(surface_draw_quad1);
 
   EXPECT_EQ(SurfaceDrawQuadType::PRIMARY,
             surface_draw_quad1->surface_draw_quad_type);
   EXPECT_EQ(surface_id1, surface_draw_quad1->surface_id);
   EXPECT_FALSE(surface_draw_quad1->fallback_quad);
 }
 
 }  // namespace
 }  // namespace cc