Delete old RenderPassId mappings in SurfaceAggregator.

cc/surfaces/surface_aggregator_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/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 242 matching lines @@
 
   SubmitCompositorFrame(&factory_, passes, arraysize(passes),
                         root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   SurfaceId ids[] = {root_surface_id};
 
   AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids));
 }
 
+// Ensure that the render pass ID map properly keeps and deletes entries.
+TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassDeallocation) {
+  test::Quad quads[][2] = {{test::Quad::SolidColorQuad(SK_ColorWHITE),
+                            test::Quad::SolidColorQuad(SK_ColorLTGRAY)},
+                           {test::Quad::SolidColorQuad(SK_ColorGRAY),
+                            test::Quad::SolidColorQuad(SK_ColorDKGRAY)}};
+  test::Pass passes[] = {
+      test::Pass(quads[0], arraysize(quads[0]), RenderPassId(1, 2)),
+      test::Pass(quads[1], arraysize(quads[1]), RenderPassId(1, 1))};
+
+  SubmitCompositorFrame(&factory_, passes, arraysize(passes),
+                        root_local_frame_id_);
+
+  SurfaceId surface_id(factory_.frame_sink_id(), root_local_frame_id_);
+
+  CompositorFrame aggregated_frame;
+  aggregated_frame = aggregator_.Aggregate(surface_id);
+  RenderPassId id0 = aggregated_frame.render_pass_list[0]->id;
+  RenderPassId id1 = aggregated_frame.render_pass_list[1]->id;
+  EXPECT_NE(id1, id0);
+
+  // Aggregated RenderPassIds should remain the same between frames.
+  aggregated_frame = aggregator_.Aggregate(surface_id);
+  EXPECT_EQ(id0, aggregated_frame.render_pass_list[0]->id);
+  EXPECT_EQ(id1, aggregated_frame.render_pass_list[1]->id);
+
+  test::Pass passes2[] = {
+      test::Pass(quads[0], arraysize(quads[0]), RenderPassId(1, 3)),
+      test::Pass(quads[1], arraysize(quads[1]), RenderPassId(1, 1))};
+
+  SubmitCompositorFrame(&factory_, passes2, arraysize(passes2),
+                        root_local_frame_id_);
+
+  // The RenderPass that still exists should keep the same ID.
+  aggregated_frame = aggregator_.Aggregate(surface_id);
+  RenderPassId id2 = aggregated_frame.render_pass_list[0]->id;
+  EXPECT_NE(id2, id1);
+  EXPECT_NE(id2, id0);
+  EXPECT_EQ(id1, aggregated_frame.render_pass_list[1]->id);
+
+  SubmitCompositorFrame(&factory_, passes, arraysize(passes),
+                        root_local_frame_id_);
+
+  // RenderPassId(1, 2) didn't exist in the previous frame, so it should be
+  // mapped to a new ID.
+  aggregated_frame = aggregator_.Aggregate(surface_id);
+  RenderPassId id3 = aggregated_frame.render_pass_list[0]->id;
+  EXPECT_NE(id3, id2);
+  EXPECT_NE(id3, id1);
+  EXPECT_NE(id3, id0);
+  EXPECT_EQ(id1, aggregated_frame.render_pass_list[1]->id);
+}
+
 // This tests very simple embedding. root_surface has a frame containing a few
 // solid color quads and a surface quad referencing embedded_surface.
 // embedded_surface has a frame containing only a solid color quad. The solid
 // color quad should be aggregated into the final frame.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) {
   SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId, &manager_,
                                   &empty_client_);
   LocalFrameId embedded_local_frame_id = allocator_.GenerateId();
   SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(),
                                 embedded_local_frame_id);
@@ skipping 1761 matching lines @@
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   factory1.EvictSurface();
   factory2.EvictSurface();
 }
 
 }  // namespace
 }  // namespace cc