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_pass,
+                      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 the render pass has copy requests, or should be cached, or has
+    // moving-pixel filters, or in a moving-pixel surface, we should damage the
+    // whole output rect so that we always drawn the full content. Otherwise, we
+    // might have incompleted copy request, or cached patially drawn render pass
+    // .

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

this period should be attached to a word :) so wrap the word instead

[wutao, 2017/07/28 17:05:16]

Done

     if (!copy_request_passes_.count(remapped_pass_id) &&
+        !copy_pass->cache_render_pass &&
         !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);
       }
     }
 
+    id_to_render_pass_map_[copy_pass->id] = copy_pass.get();

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

one thought here: it seems like this map is only used to check for the bool
has_damage_from_contributing_content. So instead you could make this a set of
RenderPassIds, and only insert if has_damage_from_contributing_content was true,
then code just checks to see if the id is present or not later? Or can that bool
change after it was inserted into the map here?

If we can, then that'd eliminate any map inserts here in the common case.

[wutao, 2017/07/28 17:05:16]

Very nice, thank you.
The bool should not change after it becomes true and be inserted.

     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.
+  dest_pass->has_damage_from_contributing_content |=
+      !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 cahced render passes, then

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

cached

[wutao, 2017/07/28 17:05:16]

Done.

+  // aggregate the entire thing, as otherwise parts of the copy requests may be
+  // ignored and we could cache partially drawn render pass.
+  const bool ignore_undamaged =
+      aggregate_only_damaged_ && !has_copy_requests_ &&
+      !has_cached_render_passes_ && !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_passes_) {
           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);
+        cc::RenderPassId original_pass_id = pass_quad->render_pass_id;
+        cc::RenderPassId remapped_pass_id =
+            RemapPassId(original_pass_id, surface_id);
+
+        // If the RenderPassDrawQuad is referring to other render pass with the
+        // |has_damage_from_contributing_content| set on it, then the dest_pass
+        // should have the flag set on it as well.
+        auto iter = id_to_render_pass_map_.find(remapped_pass_id);
+        if (iter != id_to_render_pass_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 == 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,
@@ skipping 48 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_pass,
+                      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 the render pass has copy requests, or should be cached, or has
+    // moving-pixel filters, or in a moving-pixel surface, we should damage the
+    // whole output rect so that we always drawn the full content. Otherwise, we
+    // might have incompleted copy request, or cached patially drawn render pass
+    // .

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

this one also

[wutao, 2017/07/28 17:05:16]

Done.

     if (!copy_request_passes_.count(remapped_pass_id) &&
+        !copy_pass->cache_render_pass &&
         !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);
       }
     }
 
+    id_to_render_pass_map_[copy_pass->id] = copy_pass.get();
     dest_pass_list_->push_back(std::move(copy_pass));
   }
 }
 
 void SurfaceAggregator::ProcessAddedAndRemovedSurfaces() {
   for (const auto& surface : previous_contained_surfaces_) {
     if (!contained_surfaces_.count(surface.first)) {
       // Release resources of removed surface.
       auto it = surface_id_to_resource_child_id_.find(surface.first);
       if (it != surface_id_to_resource_child_id_.end()) {
@@ skipping 190 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_pass)
+      cached_render_passes_.insert(remapped_pass_id);

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

it seems like we're building this structure just to ask if it's empty, so we
could just use a bool?

[wutao, 2017/07/28 17:05:16]

Good point, done.

   }
 
   // TODO(jbauman): Remove when https://crbug.com/745684 fixed.
   CHECK(surface->surface_id() == surface_id);
   auto it = referenced_surfaces_.find(surface_id);
   // TODO(jbauman): Remove when https://crbug.com/745684 fixed.
   CHECK(referenced_surfaces_.end() != it);
   referenced_surfaces_.erase(it);
   if (!damage_rect.IsEmpty() && frame.metadata.may_contain_video)
     result->may_contain_video = true;
@@ skipping 78 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_passes_ = !cached_render_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();
@@ skipping 10 matching lines @@
       it = render_pass_allocator_map_.erase(it);
     }
   }
 
   DCHECK(referenced_surfaces_.empty());
 
   if (dest_pass_list_->empty())
     return {};
 
   dest_pass_list_ = NULL;
+  id_to_render_pass_map_.clear();
   ProcessAddedAndRemovedSurfaces();
   contained_surfaces_.swap(previous_contained_surfaces_);
   contained_surfaces_.clear();
 
   for (auto it : previous_contained_surfaces_) {
     Surface* surface = manager_->GetSurfaceForId(it.first);
     if (surface)
       surface->TakeLatencyInfo(&frame.metadata.latency_info);
   }
 
@@ skipping 33 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