Calculate damage rects before aggregating frame data.

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 <map>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 113 matching lines @@
       provider_->SetChildNeedsSyncPoints(
           child_id, surface->factory()->needs_sync_points());
     }
     surface_id_to_resource_child_id_[surface->surface_id()] = child_id;
     return child_id;
   } else {
     return it->second;
   }
 }
 
-bool SurfaceAggregator::ValidateResources(
-    Surface* surface,
-    const DelegatedFrameData* frame_data) {
-  if (!provider_)  // TODO(jamesr): hack for unit tests that don't set up rp
-    return false;
-
-  int child_id = ChildIdForSurface(surface);
-  if (surface->factory())
-    surface->factory()->RefResources(frame_data->resource_list);
-  provider_->ReceiveFromChild(child_id, frame_data->resource_list);
-
-  ResourceProvider::ResourceIdSet referenced_resources;
-  size_t reserve_size = frame_data->resource_list.size();
-#if defined(COMPILER_MSVC)
-  referenced_resources.reserve(reserve_size);
-#elif defined(COMPILER_GCC)
-  // Pre-standard hash-tables only implement resize, which behaves similarly
-  // to reserve for these keys. Resizing to 0 may also be broken (particularly
-  // on stlport).
-  // TODO(jbauman): Replace with reserve when C++11 is supported everywhere.
-  if (reserve_size)
-    referenced_resources.resize(reserve_size);
-#endif
-
-  bool invalid_frame = false;
-  const ResourceProvider::ResourceIdMap& child_to_parent_map =
-      provider_->GetChildToParentMap(child_id);
-  for (const auto& render_pass : frame_data->render_pass_list) {
-    for (const auto& quad : render_pass->quad_list) {
-      for (ResourceId resource_id : quad->resources) {
-        ResourceProvider::ResourceIdMap::const_iterator it =
-            child_to_parent_map.find(resource_id);
-        if (it == child_to_parent_map.end()) {
-          invalid_frame = true;
-          break;
-        }
-        referenced_resources.insert(resource_id);
-      }
-    }
-  }
-
-  if (!invalid_frame)
-    provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
-
-  return invalid_frame;
-}
 
 gfx::Rect SurfaceAggregator::DamageRectForSurface(const Surface* surface,
                                                   const RenderPass& source,
                                                   const gfx::Rect& full_rect) {
   int previous_index = previous_contained_surfaces_[surface->surface_id()];
   if (previous_index == surface->frame_index())
     return gfx::Rect();
   else if (previous_index == surface->frame_index() - 1)
     return source.damage_rect;
   return full_rect;
@@ skipping 19 matching lines @@
   if (!frame)
     return;
   const DelegatedFrameData* frame_data = frame->delegated_frame_data.get();
   if (!frame_data)
     return;
 
   std::multimap<RenderPassId, CopyOutputRequest*> copy_requests;
   surface->TakeCopyOutputRequests(&copy_requests);
 
   const RenderPassList& render_pass_list = frame_data->render_pass_list;
-  bool invalid_frame = ValidateResources(surface, frame_data);
-  if (invalid_frame) {
+  if (!surface_validity_[surface->surface_id()]) {
     for (auto& request : copy_requests) {
       request.second->SendEmptyResult();
       delete request.second;
     }
     return;
   }
 
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
   // 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;
   bool merge_pass =
       surface_quad->shared_quad_state->opacity == 1.f && copy_requests.empty();
 
-  gfx::Rect surface_damage = DamageRectForSurface(
-      surface, *render_pass_list.back(), surface_quad->visible_rect);
   const RenderPassList& referenced_passes = render_pass_list;
   size_t passes_to_copy =
       merge_pass ? referenced_passes.size() - 1 : referenced_passes.size();
   for (size_t j = 0; j < passes_to_copy; ++j) {
     const RenderPass& source = *referenced_passes[j];
 
     size_t sqs_size = source.shared_quad_state_list.size();
     size_t dq_size = source.quad_list.size();
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
@@ skipping 11 matching lines @@
     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 (j == referenced_passes.size() - 1)
-      surface_damage = gfx::UnionRects(surface_damage, copy_pass->damage_rect);
-
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 
   gfx::Transform surface_transform =
       surface_quad->shared_quad_state->quad_to_target_transform;
   surface_transform.ConcatTransform(target_transform);
 
   const RenderPass& last_pass = *render_pass_list.back();
   if (merge_pass) {
     // TODO(jamesr): Clean up last pass special casing.
@@ skipping 31 matching lines @@
                  surface_quad->visible_rect,
                  remapped_pass_id,
                  0,
                  gfx::Vector2dF(),
                  gfx::Size(),
                  FilterOperations(),
                  gfx::Vector2dF(),
                  FilterOperations());
   }
 
-  dest_pass->damage_rect = gfx::UnionRects(
-      dest_pass->damage_rect,
-      MathUtil::MapEnclosingClippedRect(surface_transform, surface_damage));
 
   referenced_surfaces_.erase(it);
 }
 
 void SurfaceAggregator::CopySharedQuadState(
     const SharedQuadState* source_sqs,
     const gfx::Transform& target_transform,
     const ClipData& clip_rect,
     RenderPass* dest_render_pass) {
   SharedQuadState* copy_shared_quad_state =
@@ skipping 44 matching lines @@
         last_copied_source_shared_quad_state = quad->shared_quad_state;
       }
       DrawQuad* dest_quad;
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
         RenderPassId original_pass_id = pass_quad->render_pass_id;
         RenderPassId remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
 
-        gfx::Rect pass_damage;
-        for (const auto* pass : *dest_pass_list_) {
-          if (pass->id == remapped_pass_id) {
-            pass_damage = pass->damage_rect;
-            break;
-          }
-        }
-
         dest_quad = dest_pass->CopyFromAndAppendRenderPassDrawQuad(
             pass_quad, dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
-        dest_pass->damage_rect = gfx::UnionRects(
-            dest_pass->damage_rect,
-            MathUtil::MapEnclosingClippedRect(
-                dest_quad->shared_quad_state->quad_to_target_transform,
-                pass_damage));
       } else {
         dest_quad = dest_pass->CopyFromAndAppendDrawQuad(
             quad, dest_pass->shared_quad_state_list.back());
       }
       if (!child_to_parent_map.empty()) {
         for (ResourceId& resource_id : dest_quad->resources) {
           ResourceProvider::ResourceIdMap::const_iterator it =
               child_to_parent_map.find(resource_id);
           DCHECK(it != child_to_parent_map.end());
 
           DCHECK_EQ(it->first, resource_id);
           ResourceId remapped_id = it->second;
           resource_id = remapped_id;
         }
       }
     }
   }
 }
 
 void SurfaceAggregator::CopyPasses(const DelegatedFrameData* frame_data,
                                    Surface* surface) {
   // The root surface is allowed to have copy output requests, so grab them
   // off its render passes.
   std::multimap<RenderPassId, CopyOutputRequest*> copy_requests;
   surface->TakeCopyOutputRequests(&copy_requests);
 
   const RenderPassList& source_pass_list = frame_data->render_pass_list;
-  bool invalid_frame = ValidateResources(surface, frame_data);
-  DCHECK(!invalid_frame);
-  if (invalid_frame)
+  DCHECK(surface_validity_[surface->surface_id()]);
+  if (!surface_validity_[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;
   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();
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create(sqs_size, dq_size));
 
     MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);
 
     RenderPassId remapped_pass_id =
         RemapPassId(source.id, surface->surface_id());
 
-    gfx::Rect damage_rect =
-        (i < source_pass_list.size() - 1)
-            ? gfx::Rect()
-            : DamageRectForSurface(surface, source, source.output_rect);
-    copy_pass->SetAll(remapped_pass_id, source.output_rect, damage_rect,
+    copy_pass->SetAll(remapped_pass_id, source.output_rect, gfx::Rect(),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list, source.shared_quad_state_list,
                     child_to_parent_map, gfx::Transform(), ClipData(),
                     copy_pass.get(), surface->surface_id());
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 }
 
 void SurfaceAggregator::RemoveUnreferencedChildren() {
   for (const auto& surface : previous_contained_surfaces_) {
     if (!contained_surfaces_.count(surface.first)) {
       SurfaceToResourceChildIdMap::iterator 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);
       }
 
       Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
       if (surface_ptr)
         surface_ptr->RunDrawCallbacks(SurfaceDrawStatus::DRAW_SKIPPED);
     }
   }
 }
 
+// Validate the resources of the current surface and its descendants, and
+// calculate their combined damage rect.
+gfx::Rect SurfaceAggregator::ValidateAndCalculateDamageRect(
+    SurfaceId surface_id) {
+  if (referenced_surfaces_.count(surface_id))
+    return gfx::Rect();
+  Surface* surface = manager_->GetSurfaceForId(surface_id);
+  if (!surface)
+    return gfx::Rect();
+  const CompositorFrame* surface_frame = surface->GetEligibleFrame();
+  if (!surface_frame)
+    return gfx::Rect();
+  const DelegatedFrameData* frame_data =
+      surface_frame->delegated_frame_data.get();
+  if (!frame_data)
+    return gfx::Rect();
+  SurfaceSet::iterator it =
+      referenced_surfaces_.insert(surface->surface_id()).first;
+
+  int child_id = 0;
+  // TODO(jbauman): hack for unit tests that don't set up rp
+  if (provider_) {
+    child_id = ChildIdForSurface(surface);
+    if (surface->factory())
+      surface->factory()->RefResources(frame_data->resource_list);
+    provider_->ReceiveFromChild(child_id, frame_data->resource_list);
+  }
+
+  ResourceProvider::ResourceIdSet referenced_resources;
+  size_t reserve_size = frame_data->resource_list.size();
+#if defined(COMPILER_MSVC)
+  referenced_resources.reserve(reserve_size);
+#elif defined(COMPILER_GCC)
+  // Pre-standard hash-tables only implement resize, which behaves similarly
+  // to reserve for these keys. Resizing to 0 may also be broken (particularly
+  // on stlport).
+  // TODO(jbauman): Replace with reserve when C++11 is supported everywhere.
+  if (reserve_size)
+    referenced_resources.resize(reserve_size);
+#endif
+
+  bool invalid_frame = false;
+  ResourceProvider::ResourceIdMap empty_map;
+  const ResourceProvider::ResourceIdMap& child_to_parent_map =
+      provider_ ? provider_->GetChildToParentMap(child_id) : empty_map;
+
+  // Each pair in the vector is a child surface and the transform from its
+  // target to the root target.
+  std::vector<std::pair<SurfaceId, gfx::Transform>> child_surfaces;
+  for (const auto& render_pass : frame_data->render_pass_list) {
+    for (const auto& quad : render_pass->quad_list) {
+      if (quad->material == DrawQuad::SURFACE_CONTENT) {
+        const SurfaceDrawQuad* surface_quad =
+            SurfaceDrawQuad::MaterialCast(quad);
+        gfx::Transform target_to_root_transform(
+            surface_quad->shared_quad_state->quad_to_target_transform,
+            render_pass->transform_to_root_target);
+        child_surfaces.push_back(
+            std::make_pair(surface_quad->surface_id, target_to_root_transform));
+      }
+
+      if (!provider_)
+        continue;
+      for (ResourceId resource_id : quad->resources) {
+        ResourceProvider::ResourceIdMap::const_iterator it =
+            child_to_parent_map.find(resource_id);
+        if (it == child_to_parent_map.end()) {
+          invalid_frame = true;
+          break;
+        }
+        referenced_resources.insert(resource_id);
+      }
+    }
+  }
+
+  surface_validity_[surface->surface_id()] = !invalid_frame;
+  if (invalid_frame) {
+    referenced_surfaces_.erase(it);
+    return gfx::Rect();
+  }
+
+  if (provider_)
+    provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
+
+  gfx::Rect damage_rect;
+  if (!frame_data->render_pass_list.empty())

[danakj, 2015/07/06 22:08:43]

{}

[jbauman, 2015/07/06 23:08:15]

Done.

+    damage_rect =
+        DamageRectForSurface(surface, *frame_data->render_pass_list.back(),
+                             frame_data->render_pass_list.back()->output_rect);
+
+  for (const auto& surface_info : child_surfaces) {
+    gfx::Rect surface_damage =
+        ValidateAndCalculateDamageRect(surface_info.first);
+    damage_rect.Union(
+        MathUtil::MapEnclosingClippedRect(surface_info.second, surface_damage));

[danakj, 2015/07/06 22:08:43]

Does this do the right thing with the transform?

The transform in second is to the root. So if you had a child surface, that
function would return a damage rect in the root. Then the parent would use that
and map it from its own space to the root (again), putting it in the wrong
place?

[jbauman, 2015/07/06 23:08:15]

The transform in the second is from the quad space to the root of this surface
(not the overall global root) - in particular transform_to_root_target is always
the identity for the last renderpass in a Surface. The root space of the child
surface is the quad space of its parent surface, so this chain of
transformations should work.

+  }
+  referenced_surfaces_.erase(it);
+  return damage_rect;
+}
+
 scoped_ptr<CompositorFrame> SurfaceAggregator::Aggregate(SurfaceId surface_id) {
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   DCHECK(surface);
   contained_surfaces_[surface_id] = surface->frame_index();
   const CompositorFrame* root_surface_frame = surface->GetEligibleFrame();
   if (!root_surface_frame)
     return nullptr;
   TRACE_EVENT0("cc", "SurfaceAggregator::Aggregate");
 
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
   frame->delegated_frame_data = make_scoped_ptr(new DelegatedFrameData);
 
   DCHECK(root_surface_frame->delegated_frame_data);
 
-  SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
-
   dest_resource_list_ = &frame->delegated_frame_data->resource_list;
   dest_pass_list_ = &frame->delegated_frame_data->render_pass_list;
 
+  surface_validity_.clear();
+  gfx::Rect damage_rect = ValidateAndCalculateDamageRect(surface_id);
+  SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
+
   CopyPasses(root_surface_frame->delegated_frame_data.get(), surface);
 
   referenced_surfaces_.erase(it);
   DCHECK(referenced_surfaces_.empty());
 
   if (dest_pass_list_->empty())
     return nullptr;
+  dest_pass_list_->back()->damage_rect = damage_rect;
 
   dest_pass_list_ = NULL;
   RemoveUnreferencedChildren();
   contained_surfaces_.swap(previous_contained_surfaces_);
   contained_surfaces_.clear();
 
   for (SurfaceIndexMap::iterator it = previous_contained_surfaces_.begin();
        it != previous_contained_surfaces_.end();
        ++it) {
     Surface* surface = manager_->GetSurfaceForId(it->first);
@@ skipping 18 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(SurfaceId surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc