Force use of and cache render surface.

cc/surfaces/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 "cc/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 55 matching lines @@
   gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
   bool inverse_valid = quad_to_root_transform.GetInverse(&inverse_transform);
   if (!inverse_valid)
     return false;
 
   *quad_space_damage_rect = MathUtil::ProjectEnclosingClippedRect(
       inverse_transform, root_damage_rect);
   return true;
 }
 
+// Recursively update the flag |has_damage_on_surface_quad|.
+bool UpdateHasDamageOnSurfaceQuadRecursive(

[weiliangc, 2017/06/07 21:19:01]

Since UpdateHasDamageOnSurfaceQuad is called at the end of CopyPasses, we could
push the information about has_damage bottom up, instead of add recursive walk
here?

[wutao, 2017/06/09 02:31:32]

Will push the info up in CopyQuadsToPass and HandleSurfaceQuad.

+    RenderPass* pass,
+    base::flat_map<int, std::unique_ptr<RenderPass>>* passes_id_map,
+    base::flat_set<int>* updated_passes_id) {
+  if (updated_passes_id->count(pass->id))
+    return pass->has_damage_on_surface_quad;
+
+  updated_passes_id->insert(pass->id);
+  bool has_damage_on_surface_quad = false;
+  if (pass->has_damage_on_surface_quad)
+    has_damage_on_surface_quad = true;
+  for (auto* quad : pass->quad_list) {
+    if (quad->material == DrawQuad::RENDER_PASS) {
+      const RenderPassDrawQuad* pass_quad =
+          RenderPassDrawQuad::MaterialCast(quad);
+      if (!pass_quad)

[jbauman, 2017/05/30 22:04:07]

DCHECK instead of if

[wutao, 2017/05/30 23:12:52]

Will do.

+        continue;
+      auto iter = passes_id_map->find(pass_quad->render_pass_id);
+      if (iter == passes_id_map->end())
+        continue;
+      auto* ref_pass = iter->second.get();
+      if (!ref_pass)
+        continue;
+
+      has_damage_on_surface_quad |= UpdateHasDamageOnSurfaceQuadRecursive(
+          ref_pass, passes_id_map, updated_passes_id);

[jbauman, 2017/05/30 22:04:07]

Could you check the performance on SurfaceAggregatorPerfTest* in cc_perftests?
This requires every quad be walked an extra time that we didn't need to do
before.

[wutao, 2017/05/30 23:12:52]

Comparing the changes with ToT:

It is very similar (some times even faster) with +-2% variations when I run with
release build: out/Release/cc_perftests
--gtest_filter="SurfaceAggregatorPerfTest.*"

There is about 10% slower in debug build.

+    }
+  }
+  pass->has_damage_on_surface_quad = has_damage_on_surface_quad;
+  return has_damage_on_surface_quad;
+}
+
+void UpdateHasDamageOnSurfaceQuad(
+    RenderPassList* dest_pass_list_,
+    std::vector<int>* dest_pass_id_list,
+    base::flat_map<int, std::unique_ptr<RenderPass>>* passes_id_map) {
+  base::flat_set<int> updated_passes_id;
+  for (int pass_id : *dest_pass_id_list) {
+    UpdateHasDamageOnSurfaceQuadRecursive(

[weiliangc, 2017/06/07 21:19:00]

We only need the bool has_damage_in_on_surface_quad update when we are in a
render pass that is in force_render_pass state, right?

[wutao, 2017/06/09 02:31:32]

Yes.

+        passes_id_map->find(pass_id)->second.get(), passes_id_map,
+        &updated_passes_id);
+  }
+
+  for (int pass_id : *dest_pass_id_list) {
+    dest_pass_list_->push_back(std::move(passes_id_map->find(pass_id)->second));
+  }
+}
+
 }  // namespace
 
 SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
                                      ResourceProvider* provider,
                                      bool aggregate_only_damaged)
     : manager_(manager),
       provider_(provider),
       next_render_pass_id_(1),
       aggregate_only_damaged_(aggregate_only_damaged),
       weak_factory_(this) {
@@ skipping 173 matching lines @@
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     std::unique_ptr<RenderPass> copy_pass(
         RenderPass::Create(sqs_size, dq_size));
 
     int 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.force_render_surface,
+                      source.has_property_change_on_contributing_render_surface,
+                      source.has_damage_on_surface_quad);
 
     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) &&
+        !force_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)) {
         gfx::Rect damage_rect_in_render_pass_space =
             MathUtil::ProjectEnclosingClippedRect(inverse_transform,
                                                   root_damage_rect_);
         copy_pass->damage_rect.Intersect(damage_rect_in_render_pass_space);
       }
     }
 
@@ skipping 107 matching lines @@
 void SurfaceAggregator::CopyQuadsToPass(
     const QuadList& source_quad_list,
     const SharedQuadStateList& source_shared_quad_state_list,
     const ResourceProvider::ResourceIdMap& child_to_parent_map,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_pass,
     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 force use of 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_force_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.
   SharedQuadStateList::ConstIterator sqs_iter =
@@ skipping 12 matching lines @@
       const SurfaceDrawQuad* surface_quad = SurfaceDrawQuad::MaterialCast(quad);
       // HandleSurfaceQuad may add other shared quad state, so reset the
       // current data.
       last_copied_source_shared_quad_state = nullptr;
 
       // The primary SurfaceDrawQuad should have already dealt with the fallback
       // DrawQuad.
       if (surface_quad->surface_draw_quad_type == SurfaceDrawQuadType::FALLBACK)
         continue;
 
+      // Check if the surface_quad has damage.
+      Surface* surface = manager_->GetSurfaceForId(surface_quad->surface_id);
+      if (surface->HasActiveFrame()) {
+        RenderPass* last_pass =
+            surface->GetActiveFrame().render_pass_list.back().get();
+        gfx::Rect damage_rect =
+            DamageRectForSurface(surface, *last_pass, last_pass->output_rect);
+        dest_pass->has_damage_on_surface_quad |= !damage_rect.IsEmpty();
+      }
+
       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_force_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))
@@ skipping 54 matching lines @@
   DCHECK(valid_surfaces_.count(surface->surface_id()));
   if (!valid_surfaces_.count(surface->surface_id()))
     return;
 
   // TODO(vmpstr): provider check is a hack for unittests that don't set up a
   // resource provider.
   ResourceProvider::ResourceIdMap empty_map;
   const ResourceProvider::ResourceIdMap& child_to_parent_map =
       provider_ ? provider_->GetChildToParentMap(ChildIdForSurface(surface))
                 : empty_map;
+  std::vector<int> temp_dest_pass_id_list;
+  base::flat_map<int, std::unique_ptr<RenderPass>> passes_id_map;
   for (size_t i = 0; i < source_pass_list.size(); ++i) {
     const RenderPass& source = *source_pass_list[i];
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     std::unique_ptr<RenderPass> copy_pass(
         RenderPass::Create(sqs_size, dq_size));
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     int 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.force_render_surface,
+                      source.has_property_change_on_contributing_render_surface,
+                      source.has_damage_on_surface_quad);
 
     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) &&
+        !force_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)) {
         gfx::Rect damage_rect_in_render_pass_space =
             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));
+    temp_dest_pass_id_list.push_back(copy_pass->id);
+    passes_id_map.insert(std::make_pair(copy_pass->id, std::move(copy_pass)));
   }
+
+  UpdateHasDamageOnSurfaceQuad(dest_pass_list_, &temp_dest_pass_id_list,
+                               &passes_id_map);
 }
 
 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()) {
         provider_->DestroyChild(it->second);
         surface_id_to_resource_child_id_.erase(it);
@@ skipping 181 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);
 
   CHECK(debug_weak_this.get());
   for (const auto& render_pass : frame.render_pass_list) {
-    if (!render_pass->copy_requests.empty()) {
-      int remapped_pass_id = RemapPassId(render_pass->id, surface_id);
+    int 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->force_render_surface)
+      force_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 30 matching lines @@
         }
       }
     } else {
       auto it = referenced_surfaces_.insert(surface_id).first;
       CopyPasses(frame, surface);
       referenced_surfaces_.erase(it);
     }
   }
 }
 
-void SurfaceAggregator::PropagateCopyRequestPasses() {
-  std::vector<int> copy_requests_to_iterate(copy_request_passes_.begin(),
-                                            copy_request_passes_.end());
+void SurfaceAggregator::PropagatePasses(base::flat_set<int>* passes) {
+  std::vector<int> copy_requests_to_iterate(passes->begin(), passes->end());
   while (!copy_requests_to_iterate.empty()) {
     int first = copy_requests_to_iterate.back();
     copy_requests_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) {
+      if (passes->insert(pass).second) {
         copy_requests_to_iterate.push_back(pass);
       }
     }
   }
 }
 
 CompositorFrame SurfaceAggregator::Aggregate(const SurfaceId& surface_id) {
   uma_stats_.Reset();
 
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   DCHECK(surface);
   contained_surfaces_[surface_id] = surface->frame_index();
 
   if (!surface->HasActiveFrame())
     return CompositorFrame();
 
   const CompositorFrame& root_surface_frame = surface->GetActiveFrame();
   TRACE_EVENT0("cc", "SurfaceAggregator::Aggregate");
 
   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();
+  PropagatePasses(&copy_request_passes_);
+  PropagatePasses(&force_render_surface_passes_);
   has_copy_requests_ = !copy_request_passes_.empty();
+  has_force_render_surfaces_ = !force_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();
+  force_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 48 matching lines @@
 }
 
 void SurfaceAggregator::SetOutputColorSpace(
     const gfx::ColorSpace& blending_color_space,
     const gfx::ColorSpace& output_color_space) {
   blending_color_space_ = blending_color_space;
   output_color_space_ = output_color_space;
 }
 
 }  // namespace cc