Force use of and cache render surface.

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 1449 matching lines @@
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads), 2)};
 
   CompositorFrame root_frame = test::MakeEmptyCompositorFrame();
   AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
             arraysize(root_passes));
 
   root_frame.render_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 10);
   root_frame.render_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);
+  root_frame.render_pass_list[0]->cache_render_surface = true;
   root_frame.render_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);
 
   support_->SubmitCompositorFrame(root_local_surface_id_,
                                   std::move(root_frame));
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
   const RenderPassList& aggregated_pass_list =
       aggregated_frame.render_pass_list;
 
   ASSERT_EQ(2u, aggregated_pass_list.size());
 
+  // First aggregation shold be true.
+  EXPECT_TRUE(aggregated_pass_list[0]->has_damage_from_contributing_content);
   // Damage rect for first aggregation should contain entire root surface.
   EXPECT_TRUE(
       aggregated_pass_list[1]->damage_rect.Contains(gfx::Rect(SurfaceSize())));
 
   {
     CompositorFrame child_frame = test::MakeEmptyCompositorFrame();
     AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               child_passes, arraysize(child_passes));
 
     RenderPass* child_root_pass = child_frame.render_pass_list[0].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
 
     child_support_->SubmitCompositorFrame(child_local_surface_id,
                                           std::move(child_frame));
 
     SurfaceId root_surface_id(support_->frame_sink_id(),
                               root_local_surface_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
     const RenderPassList& aggregated_pass_list =
         aggregated_frame.render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
+    // True for new frame.
+    EXPECT_TRUE(aggregated_pass_list[0]->has_damage_from_contributing_content);
     // Outer surface didn't change, so transformed inner damage rect should be
     // used.
     EXPECT_EQ(gfx::Rect(10, 20, 10, 10).ToString(),
               aggregated_pass_list[1]->damage_rect.ToString());
   }
 
   {
     CompositorFrame root_frame = test::MakeEmptyCompositorFrame();
     AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               root_passes, arraysize(root_passes));
 
     root_frame.render_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
     root_frame.render_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     support_->SubmitCompositorFrame(root_local_surface_id_,
                                     std::move(root_frame));
   }
 
   {
     CompositorFrame root_frame = test::MakeEmptyCompositorFrame();
     AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               root_passes, arraysize(root_passes));
 
     root_frame.render_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
     root_frame.render_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);
+    root_frame.render_pass_list[0]->cache_render_surface = true;
 
     support_->SubmitCompositorFrame(root_local_surface_id_,
                                     std::move(root_frame));
 
     SurfaceId root_surface_id(support_->frame_sink_id(),
                               root_local_surface_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
     const RenderPassList& aggregated_pass_list =
         aggregated_frame.render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
+    // False when the child frame has no change.
+    EXPECT_FALSE(aggregated_pass_list[0]->has_damage_from_contributing_content);
     // The root surface was enqueued without being aggregated once, so it should
     // be treated as completely damaged.
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   // No Surface changed, so no damage should be given.
   {
     SurfaceId root_surface_id(support_->frame_sink_id(),
                               root_local_surface_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
     const RenderPassList& aggregated_pass_list =
         aggregated_frame.render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
+    // False when the child frame has no change.
+    EXPECT_FALSE(aggregated_pass_list[0]->has_damage_from_contributing_content);
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.IsEmpty());
   }
 
   // SetFullDamageRectForSurface should cause the entire output to be
   // marked as damaged.
   {
     aggregator_.SetFullDamageForSurface(root_surface_id);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
     const RenderPassList& aggregated_pass_list =
@@ skipping 712 matching lines @@
   aggregated_frame = aggregator_.Aggregate(surface_id);
   EXPECT_EQ(3u, aggregated_frame.render_pass_list.size());
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[0]->color_space);
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[1]->color_space);
   EXPECT_EQ(color_space3, aggregated_frame.render_pass_list[2]->color_space);
 }
 
 }  // namespace
 }  // namespace cc