Force use of and cache render surface.

components/viz/service/display/surface_aggregator.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 "components/viz/service/display/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 247 matching lines @@
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     std::unique_ptr<cc::RenderPass> copy_pass(
         cc::RenderPass::Create(sqs_size, dq_size));
 
     cc::RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     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);
 
     // Contributing passes aggregated in to the pass list need to take the
     // transform of the surface quad into account to update their transform to
     // the root surface.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->shared_quad_state->quad_to_target_transform);
     copy_pass->transform_to_root_target.ConcatTransform(target_transform);
     copy_pass->transform_to_root_target.ConcatTransform(
         dest_pass->transform_to_root_target);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface_id);
 
     if (!copy_request_passes_.count(remapped_pass_id) &&
+        !copy_pass->cache_render_surface &&

[danakj, 2017/07/25 18:55:02]

I feel that each of these 3 conditions needs a comment explaining why it is
here. I tried to understand why this one is here below.. lmk.

[wutao, 2017/07/26 07:48:52]

Do not need this change anymore.

But I try to explain why it is here IIUC.
copy_pass's damage_rect by default is the source.output_rect. See line 265:
copy_pass->SetAll(...source.output_rect...).

When there is no copy_request or moved pixel_pass (I am guessing
moved-pixel-pass also needs full output damage because it can read pixel outside
the render pass?), we try to get the clipped damage rect on the render pass
space by line 295:
copy_pass->damage_rect.Intersect(damage_rect_in_render_pass_space);

This will be used in
DirectRenderer::DrawingFrame::ComputeScissorRectForRenderPass. If there are
partial_swap, then we allow non-root-render-pass damage_rect to be smaller than
the output_rect.

[wutao, 2017/07/27 02:30:13]

Added comments.

         !moved_pixel_passes_.count(remapped_pass_id)) {
       gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
       if (copy_pass->transform_to_root_target.GetInverse(&inverse_transform)) {
         gfx::Rect damage_rect_in_render_pass_space =
             cc::MathUtil::ProjectEnclosingClippedRect(inverse_transform,
                                                       root_damage_rect_);
         copy_pass->damage_rect.Intersect(damage_rect_in_render_pass_space);
       }
     }
 
     dest_pass_list_->push_back(std::move(copy_pass));
   }
 
   gfx::Transform surface_transform =
       surface_quad->shared_quad_state->quad_to_target_transform;
   surface_transform.ConcatTransform(target_transform);
 
   const auto& last_pass = *render_pass_list.back();
+  // This will check if all the surface_quads (including child surfaces) has
+  // damage because HandleSurfaceQuad is a recursive call by calling
+  // CopyQuadsToPass in it. This is different than the damage_rect calculated in

[danakj, 2017/07/25 18:55:03]

I'm not clear why this is talking about Prewalk tree, maybe there's some
indirection here which isn't clear. We're computing damage_rect in this function
too, on line 295. So I was wondering what's different from here to there.

IIUC the difference is:
- Above we are reducing (setting?) the damage on the copy_pass to be the
computed damage for the root aggregated frame being swapped. Since offscreen
copy requests are not being swapped, they are not part of the root aggregated
damage, so in that case we don't know what is damaged there and leave it fully
damaged.

You added cache_render_surface there also for unrelated reasons, which are that
you want to ensure the cached render surface is fully drawn even if not all of
it is damaged? I don't follow the logic for why that's happening - it seems to
imply that we have a render surface already that is now partially damaged, but
we want to redraw the pixels that are already present.. Or can you have a render
surface appear the first time and not all of it is damaged? If so, how would
that happen?

- Below here, we are determining (recursively) if any aggregated frames for
SurfaceDrawQuads have damage. RenderPassDrawQuads are not checked because we
expect the client submitting the RenderPass to do that check.

If this is write can you turn more of this into comments?

[wutao, 2017/07/26 07:48:52]

I should mention Prewalk here. I did just because try to address your comments
in previous patch.
Make sense to me.
You could be totally right here. Thanks! I will test on removing this. Sounds
like the damage_rect only affect drawing/swap, not affect caching.
Yes, we are expecting the client submitting the RenderPass to do that check. But
thinking more with jbauman@'s corner case example below, I think we still need
this code in previous patch:
https://codereview.chromium.org/2873593002/diff/260001/components/viz/service...

+  // PrewalkTree, which also includes all the damage in the top level surface,
+  // containing damage from damage_tracker.

[danakj, 2017/07/25 18:55:03]

"containing damage specified with the CompositorFrame" or something. damage
tracker is part of layer compositor which this code does not know about and
could change arbitrarily.

[wutao, 2017/07/26 07:48:52]

Deleted comments related to PrewalkTree.

+  if (dest_pass->cache_render_surface) {
+    dest_pass->has_damage_from_contributing_content |=

[jbauman, 2017/07/25 20:40:34]

Suppose we have a
Surface 1 with damage, and a surface 2:
Pass A) SurfaceDrawQuad referencing 1
Pass B) RenderPassDrawQuad referencing A

If B has cache_render_surface, shouldn't has_damage_from_contributing_content be
set on it?

Also, what do we do with has_damage_from_contributing_content? I don't see it
used anywhere

[wutao, 2017/07/26 07:48:53]

Yes. we should set the flag. You example makes me think I do need this code in
previous patch:
https://codereview.chromium.org/2873593002/diff/280001/cc/output/direct_rende...
Explained as this:
When we process Pass A, we insert to dest_pass_list_ a render_pass_1 with damage
and flag (has_damage_from_contributing_content) set on it.
When we process Pass B, we have the remapped_pass_id in the
id_to_render_pass_map_, and it is referring to render_pass_1, which has the flag
set, then we will set the render_pass_2 as damaged as well.

I am adding a new test for this.
If has_damage_from_contributing_content is set, then in
DirectRenderer::UseRenderPass, we will not reuse the texture of the render pass:
https://codereview.chromium.org/2873593002/diff/280001/cc/output/direct_rende...

+        !DamageRectForSurface(surface, last_pass, last_pass.output_rect)
+             .IsEmpty();
+  }
+
   if (merge_pass) {
     // TODO(jamesr): Clean up last pass special casing.
     const cc::QuadList& quads = last_pass.quad_list;
 
     // Intersect the transformed visible rect and the clip rect to create a
     // smaller cliprect for the quad.
     ClipData surface_quad_clip_rect(
         true, cc::MathUtil::MapEnclosingClippedRect(
                   surface_quad->shared_quad_state->quad_to_target_transform,
                   surface_quad->visible_rect));
@@ skipping 89 matching lines @@
     const cc::QuadList& source_quad_list,
     const cc::SharedQuadStateList& source_shared_quad_state_list,
     const std::unordered_map<cc::ResourceId, cc::ResourceId>&
         child_to_parent_map,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     cc::RenderPass* dest_pass,
     const SurfaceId& surface_id) {
   const cc::SharedQuadState* last_copied_source_shared_quad_state = nullptr;
   const cc::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, because we want full content.

[danakj, 2017/07/25 18:55:02]

I think this comment is saying what we want as the outcome but not why we need
to do it. For copy requests, it's because of how we aggregate damage for only
surfaces that will be swapped, right? For cached render surfaces, is it possible
to have a surface not fully damaged when it first appears, or is it something
else? DamageRectForSurface() seems to make a surface fully damaged the first
time it appears... do you have a unit test showing why we need
has_cached_render_surfaces_ here, and that we get an incorrect cache result
without it?

Put another way, for each if-condition added in this patch like this, if you
remove it, does some test fail?

I wanted to just mention also that it's unfortunate IMO that this patch is
phrasing things in terms of render surfaces (which are a mostly obsolete term
from layer compositors, they don't even exist anymore except or
RenderSurfaceImpl), instead of render targets and render passes. Especially for
types and variables that are used from SurfaceAggregator for which "Surface" has
a completely different meaning causing confusion, and "RenderSurface" is not
something it could every know about.

[jbauman, 2017/07/25 20:40:34]

I think if the renderpass is partially offscreen initially then it might not
necessarily be completely damaged then, because we start with global
screen-space damage rect and work from there to find the damage rect for the
renderpass.

[wutao, 2017/07/26 07:48:53]

We do not need this change any more for cache render pass.
I renamed the cache render surface to cache render pass in render_pass.cc,
surface aggregator.cc and direct_renderer.cc.

[wutao, 2017/07/27 02:30:13]

Yes, if the render pass is off screen, then it is not fully damaged. We should
avoid this happening.
Added some tests, please see below.
Added several tests to cover all the changes in this patch:
1. HasDamageByChangingChildSurface
for why we need DamageRectForSurface in HandleSurfaceQuad to get child surface
changes.
2. HasDamageByChangingGrandChildSurface
for why we need DamageRectForSurface in HandleSurfaceQuad to get grand child
surface changes.

3. HasDamageFromRenderPassQuads
for the change in if block (from line 499) if (quad->material ==
cc::DrawQuad::RENDER_PASS) in CopyQuadsToPass.
To get damage from RenderPassQuads.

4. DamageRectOfCachedRenderPass
for why we need the change (line 585) !copy_pass->cache_render_pass && in
CopyPasses to make the off screen render pass fully damaged.

5. DamageRectOfCachedRenderPassInChildSurface
for why we need the change (line 293) !copy_pass->cache_render_pass && in
HandleSurfaceQuad to make the off screen render pass fully damaged.

6. NotIgnoreOutsideForCachedRenderPass:
for why we need ignore_undamaged = ... && !has_cached_render_surfaces && ..., so
that we will not ignore outside render pass.

[danakj, 2017/07/27 21:24:33]

Thanks!

+  const bool ignore_undamaged =
+      aggregate_only_damaged_ && !has_copy_requests_ &&
+      !has_cached_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.
   gfx::Rect damage_rect_in_quad_space;
   bool damage_rect_in_quad_space_valid = false;
 
 #if DCHECK_IS_ON()
   // If quads have come in with SharedQuadState out of order, or when quads have
   // invalid SharedQuadState pointer, it should DCHECK.
   auto sqs_iter = source_shared_quad_state_list.cbegin();
@@ skipping 20 matching lines @@
         continue;
 
       HandleSurfaceQuad(surface_quad, target_transform, clip_rect, dest_pass,
                         ignore_undamaged, &damage_rect_in_quad_space,
                         &damage_rect_in_quad_space_valid);
     } else {
       if (quad->shared_quad_state != last_copied_source_shared_quad_state) {
         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_cached_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_,
               &damage_rect_in_quad_space);
         }
       }
 
       if (ignore_undamaged) {
         if (damage_rect_in_quad_space_valid &&
             !damage_rect_in_quad_space.Intersects(quad->visible_rect))
           continue;
       }
 
       cc::DrawQuad* dest_quad;
       if (quad->material == cc::DrawQuad::RENDER_PASS) {
         const auto* pass_quad = cc::RenderPassDrawQuad::MaterialCast(quad);
         int original_pass_id = pass_quad->render_pass_id;
         int remapped_pass_id = RemapPassId(original_pass_id, surface_id);
-
         dest_quad = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad, dest_shared_quad_state, remapped_pass_id);
       } else if (quad->material == cc::DrawQuad::TEXTURE_CONTENT) {
         const auto* texture_quad = cc::TextureDrawQuad::MaterialCast(quad);
         if (texture_quad->secure_output_only &&
             (!output_is_secure_ || copy_request_passes_.count(dest_pass->id))) {
           auto* solid_color_quad =
               dest_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
           solid_color_quad->SetNew(dest_shared_quad_state, quad->rect,
                                    quad->visible_rect, SK_ColorBLACK, false);
@@ skipping 47 matching lines @@
     auto copy_pass = cc::RenderPass::Create(sqs_size, dq_size);
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     cc::RenderPassId remapped_pass_id =
         RemapPassId(source.id, surface->surface_id());
 
     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) &&
+        !copy_pass->cache_render_surface &&

[danakj, 2017/07/25 18:55:03]

I also think each of these needs the same comments explaining why the condition
is here, matching HandleSurfaceQuad() comments if that's the case.

[wutao, 2017/07/26 07:48:53]

Do not need this any more.

[wutao, 2017/07/27 02:30:13]

Added comments.

         !moved_pixel_passes_.count(remapped_pass_id)) {
       gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
       if (copy_pass->transform_to_root_target.GetInverse(&inverse_transform)) {
         gfx::Rect damage_rect_in_render_pass_space =
             cc::MathUtil::ProjectEnclosingClippedRect(inverse_transform,
                                                       root_damage_rect_);
         copy_pass->damage_rect.Intersect(damage_rect_in_render_pass_space);
       }
     }
 
@@ skipping 193 matching lines @@
   CHECK(debug_weak_this.get());
   // TODO(staraz): It shouldn't need to call the callback when the damage is
   // from |surface| and not from |child_surfaces|.
   if (!damage_rect.IsEmpty()) {
     surface->RunWillDrawCallback(damage_rect);
     manager_->SurfaceWillDraw(surface->surface_id());
   }
 
   CHECK(debug_weak_this.get());
   for (const auto& render_pass : frame.render_pass_list) {
-    if (!render_pass->copy_requests.empty()) {
-      cc::RenderPassId remapped_pass_id =
-          RemapPassId(render_pass->id, surface_id);
+    cc::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)
+      cached_render_surface_passes_.insert(remapped_pass_id);
   }
 
   referenced_surfaces_.erase(referenced_surfaces_.find(surface->surface_id()));
   if (!damage_rect.IsEmpty() && frame.metadata.may_contain_video)
     result->may_contain_video = true;
   return damage_rect;
 }
 
 void SurfaceAggregator::CopyUndrawnSurfaces(PrewalkResult* prewalk_result) {
   // undrawn_surfaces are Surfaces that were identified by prewalk as being
@@ skipping 71 matching lines @@
 
   cc::CompositorFrame frame;
 
   dest_pass_list_ = &frame.render_pass_list;
 
   valid_surfaces_.clear();
   PrewalkResult prewalk_result;
   root_damage_rect_ = PrewalkTree(surface_id, false, 0, &prewalk_result);
   PropagateCopyRequestPasses();
   has_copy_requests_ = !copy_request_passes_.empty();
+  has_cached_render_surfaces_ = !cached_render_surface_passes_.empty();
   frame.metadata.may_contain_video = prewalk_result.may_contain_video;
 
   CopyUndrawnSurfaces(&prewalk_result);
   referenced_surfaces_.insert(surface_id);
   CopyPasses(root_surface_frame, surface);
   // CopyPasses may have mutated container, need to re-query to erase.
   referenced_surfaces_.erase(referenced_surfaces_.find(surface_id));
   AddColorConversionPass();
 
   moved_pixel_passes_.clear();
   copy_request_passes_.clear();
+  cached_render_surface_passes_.clear();
   render_pass_dependencies_.clear();
 
   // Remove all render pass mappings that weren't used in the current frame.
   for (auto it = render_pass_allocator_map_.begin();
        it != render_pass_allocator_map_.end();) {
     if (it->second.in_use) {
       it->second.in_use = false;
       it++;
     } else {
       it = render_pass_allocator_map_.erase(it);
@@ skipping 52 matching lines @@
     const gfx::ColorSpace& output_color_space) {
   blending_color_space_ = blending_color_space.IsValid()
                               ? blending_color_space
                               : gfx::ColorSpace::CreateSRGB();
   output_color_space_ = output_color_space.IsValid()
                             ? output_color_space
                             : gfx::ColorSpace::CreateSRGB();
 }
 
 }  // namespace viz