Force use of and cache render surface.

cc/surfaces/surface_aggregator.cc

Index: cc/surfaces/surface_aggregator.cc
diff --git a/cc/surfaces/surface_aggregator.cc b/cc/surfaces/surface_aggregator.cc
index ea051825092b0d90bdab987861ba131e9b0ab055..fd6b33726a2e93a04224715c60b78c3df08a074e 100644
--- a/cc/surfaces/surface_aggregator.cc
+++ b/cc/surfaces/surface_aggregator.cc
@@ -265,7 +265,9 @@ void SurfaceAggregator::HandleSurfaceQuad(
     copy_pass->SetAll(remapped_pass_id, source.output_rect, source.output_rect,
                       source.transform_to_root_target, source.filters,
                       source.background_filters, blending_color_space_,
-                      source.has_transparent_background);
+                      source.has_transparent_background,
+                      source.cache_render_surface,
+                      source.has_damage_from_contributing_content);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
@@ -283,6 +285,7 @@ void SurfaceAggregator::HandleSurfaceQuad(
                     copy_pass.get(), surface_id);
 
     if (!copy_request_passes_.count(remapped_pass_id) &&
+        !cache_render_surface_passes_.count(remapped_pass_id) &&
         !moved_pixel_passes_.count(remapped_pass_id)) {
       gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
       if (copy_pass->transform_to_root_target.GetInverse(&inverse_transform)) {
@@ -293,6 +296,7 @@ void SurfaceAggregator::HandleSurfaceQuad(
       }
     }
 
+    passes_id_map.insert(std::make_pair(copy_pass->id, copy_pass.get()));
     dest_pass_list_->push_back(std::move(copy_pass));
   }
 
@@ -301,6 +305,13 @@ void SurfaceAggregator::HandleSurfaceQuad(
   surface_transform.ConcatTransform(target_transform);
 
   const RenderPass& last_pass = *render_pass_list.back();
+  // Check if the surface_quad has damage.
+  if (dest_pass->cache_render_surface) {
+    dest_pass->has_damage_from_contributing_content |=

[jbauman, 2017/07/11 02:09:44]

Would this work if dest pass contains a surface A that contains a surface B that
has damage, but surface A has no damage (and is not marked as cached)?

[wutao, 2017/07/11 17:50:44]

Yes, it should work since SurfaceAggregator::HandleSurfaceQuad is recursive
call. Any descendant surface damage should be aggregated.

As in the modified test SurfaceAggregatorValidSurfaceTest.AggregateDamageRect,
the setup is root_render_pass > parent_frame (surface A) > child_frame (surface
B). In the first test in {} block starting from line 1491, the child_frame
changed but parent_frame did not change. And on line 1514, the
aggregated_pass_list should have damaged surface.

+        !DamageRectForSurface(surface, last_pass, last_pass.output_rect)
+             .IsEmpty();
+  }
+
   if (merge_pass) {
     // TODO(jamesr): Clean up last pass special casing.
     const QuadList& quads = last_pass.quad_list;
@@ -410,11 +421,12 @@ void SurfaceAggregator::CopyQuadsToPass(
     const SurfaceId& surface_id) {
   const SharedQuadState* last_copied_source_shared_quad_state = nullptr;
   const SharedQuadState* dest_shared_quad_state = nullptr;
-  // If the current frame has copy requests then aggregate the entire
-  // thing, as otherwise parts of the copy requests may be ignored.
-  const bool ignore_undamaged = aggregate_only_damaged_ &&
-                                !has_copy_requests_ &&
-                                !moved_pixel_passes_.count(dest_pass->id);
+  // If the current frame has copy requests or cache render surface, then
+  // aggregate the entire thing, as otherwise parts of the copy requests or
+  // render surface may be ignored.
+  const bool ignore_undamaged =
+      aggregate_only_damaged_ && !has_copy_requests_ &&
+      !has_cache_render_surfaces_ && !moved_pixel_passes_.count(dest_pass->id);
   // Damage rect in the quad space of the current shared quad state.
   // TODO(jbauman): This rect may contain unnecessary area if
   // transform isn't axis-aligned.
@@ -455,7 +467,8 @@ void SurfaceAggregator::CopyQuadsToPass(
         dest_shared_quad_state = CopySharedQuadState(
             quad->shared_quad_state, target_transform, clip_rect, dest_pass);
         last_copied_source_shared_quad_state = quad->shared_quad_state;
-        if (aggregate_only_damaged_ && !has_copy_requests_) {
+        if (aggregate_only_damaged_ && !has_copy_requests_ &&
+            !has_cache_render_surfaces_) {
           damage_rect_in_quad_space_valid = CalculateQuadSpaceDamageRect(
               dest_shared_quad_state->quad_to_target_transform,
               dest_pass->transform_to_root_target, root_damage_rect_,
@@ -475,7 +488,13 @@ void SurfaceAggregator::CopyQuadsToPass(
             RenderPassDrawQuad::MaterialCast(quad);
         int original_pass_id = pass_quad->render_pass_id;
         int remapped_pass_id = RemapPassId(original_pass_id, surface_id);
-
+        if (dest_pass->cache_render_surface) {
+          auto iter = passes_id_map.find(remapped_pass_id);
+          if (iter != passes_id_map.end()) {
+            dest_pass->has_damage_from_contributing_content |=
+                iter->second->has_damage_from_contributing_content;
+          }
+        }
         dest_quad = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad, dest_shared_quad_state, remapped_pass_id);
       } else if (quad->material == DrawQuad::TEXTURE_CONTENT) {
@@ -546,12 +565,15 @@ void SurfaceAggregator::CopyPasses(const CompositorFrame& frame,
     copy_pass->SetAll(remapped_pass_id, source.output_rect, source.output_rect,
                       source.transform_to_root_target, source.filters,
                       source.background_filters, blending_color_space_,
-                      source.has_transparent_background);
+                      source.has_transparent_background,
+                      source.cache_render_surface,
+                      source.has_damage_from_contributing_content);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface->surface_id());
     if (!copy_request_passes_.count(remapped_pass_id) &&
+        !cache_render_surface_passes_.count(remapped_pass_id) &&
         !moved_pixel_passes_.count(remapped_pass_id)) {
       gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
       if (copy_pass->transform_to_root_target.GetInverse(&inverse_transform)) {
@@ -562,6 +584,7 @@ void SurfaceAggregator::CopyPasses(const CompositorFrame& frame,
       }
     }
 
+    passes_id_map.insert(std::make_pair(copy_pass->id, copy_pass.get()));
     dest_pass_list_->push_back(std::move(copy_pass));
   }
 }
@@ -765,10 +788,11 @@ gfx::Rect SurfaceAggregator::PrewalkTree(const SurfaceId& surface_id,
 
   CHECK(debug_weak_this.get());
   for (const auto& render_pass : frame.render_pass_list) {
-    if (!render_pass->copy_requests.empty()) {
-      RenderPassId remapped_pass_id = RemapPassId(render_pass->id, surface_id);
+    RenderPassId remapped_pass_id = RemapPassId(render_pass->id, surface_id);
+    if (!render_pass->copy_requests.empty())
       copy_request_passes_.insert(remapped_pass_id);
-    }
+    if (render_pass->cache_render_surface)
+      cache_render_surface_passes_.insert(remapped_pass_id);
   }
 
   referenced_surfaces_.erase(referenced_surfaces_.find(surface->surface_id()));
@@ -821,18 +845,17 @@ void SurfaceAggregator::CopyUndrawnSurfaces(PrewalkResult* prewalk_result) {
   }
 }
 
-void SurfaceAggregator::PropagateCopyRequestPasses() {
-  std::vector<RenderPassId> copy_requests_to_iterate(
-      copy_request_passes_.begin(), copy_request_passes_.end());
-  while (!copy_requests_to_iterate.empty()) {
-    int first = copy_requests_to_iterate.back();
-    copy_requests_to_iterate.pop_back();
+void SurfaceAggregator::PropagatePasses(base::flat_set<RenderPassId>* passes) {
+  std::vector<RenderPassId> passes_to_iterate(passes->begin(), passes->end());
+  while (!passes_to_iterate.empty()) {
+    RenderPassId first = passes_to_iterate.back();
+    passes_to_iterate.pop_back();
     auto it = render_pass_dependencies_.find(first);
     if (it == render_pass_dependencies_.end())
       continue;
     for (auto pass : it->second) {
-      if (copy_request_passes_.insert(pass).second) {
-        copy_requests_to_iterate.push_back(pass);
+      if (passes->insert(pass).second) {
+        passes_to_iterate.push_back(pass);
       }
     }
   }
@@ -858,8 +881,10 @@ CompositorFrame SurfaceAggregator::Aggregate(const SurfaceId& surface_id) {
   valid_surfaces_.clear();
   PrewalkResult prewalk_result;
   root_damage_rect_ = PrewalkTree(surface_id, false, 0, &prewalk_result);
-  PropagateCopyRequestPasses();
+  PropagatePasses(&copy_request_passes_);
+  PropagatePasses(&cache_render_surface_passes_);
   has_copy_requests_ = !copy_request_passes_.empty();
+  has_cache_render_surfaces_ = !cache_render_surface_passes_.empty();
   frame.metadata.may_contain_video = prewalk_result.may_contain_video;
 
   CopyUndrawnSurfaces(&prewalk_result);
@@ -871,6 +896,7 @@ CompositorFrame SurfaceAggregator::Aggregate(const SurfaceId& surface_id) {
 
   moved_pixel_passes_.clear();
   copy_request_passes_.clear();
+  cache_render_surface_passes_.clear();
   render_pass_dependencies_.clear();
 
   // Remove all render pass mappings that weren't used in the current frame.
@@ -890,6 +916,7 @@ CompositorFrame SurfaceAggregator::Aggregate(const SurfaceId& surface_id) {
     return CompositorFrame();
 
   dest_pass_list_ = NULL;
+  passes_id_map.clear();
   ProcessAddedAndRemovedSurfaces();
   contained_surfaces_.swap(previous_contained_surfaces_);
   contained_surfaces_.clear();