List all child surfaces (including occluded) in CompositorFrame

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 41 matching lines @@
       aggregate_only_damaged_(aggregate_only_damaged) {
   DCHECK(manager_);
 }
 
 SurfaceAggregator::~SurfaceAggregator() {
   // Notify client of all surfaces being removed.
   contained_surfaces_.clear();
   ProcessAddedAndRemovedSurfaces();
 }
 
+SurfaceAggregator::PrewalkResult::PrewalkResult() : has_copy_requests(false) {}
+
+SurfaceAggregator::PrewalkResult::~PrewalkResult() {}
+
 // Create a clip rect for an aggregated quad from the original clip rect and
 // the clip rect from the surface it's on.
 SurfaceAggregator::ClipData SurfaceAggregator::CalculateClipRect(
     const ClipData& surface_clip,
     const ClipData& quad_clip,
     const gfx::Transform& target_transform) {
   ClipData out_clip;
   if (surface_clip.is_clipped)
     out_clip = surface_clip;
 
@@ skipping 415 matching lines @@
       Surface* surface_ptr = manager_->GetSurfaceForId(surface.first);
       if (surface_ptr)
         client_->AddSurface(surface_ptr);
     }
   }
 }
 
 // Walk the Surface tree from surface_id. Validate the resources of the current
 // surface and its descendants, check if there are any copy requests, and
 // return the combined damage rect.
-gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id) {
+gfx::Rect SurfaceAggregator::PrewalkTree(SurfaceId surface_id,
+                                         PrewalkResult* result) {
   if (referenced_surfaces_.count(surface_id))
     return gfx::Rect();
   Surface* surface = manager_->GetSurfaceForId(surface_id);
   if (!surface) {
     contained_surfaces_[surface_id] = 0;
     return gfx::Rect();
   }
   contained_surfaces_[surface_id] = surface->frame_index();
   const CompositorFrame* surface_frame = surface->GetEligibleFrame();
   if (!surface_frame)
@@ skipping 57 matching lines @@
   }
 
   if (invalid_frame)
     return gfx::Rect();
   valid_surfaces_.insert(surface->surface_id());
 
   if (provider_)
     provider_->DeclareUsedResourcesFromChild(child_id, referenced_resources);
 
   for (const auto& render_pass : frame_data->render_pass_list)
-    has_copy_requests_ |= !render_pass->copy_requests.empty();
+    result->has_copy_requests |= !render_pass->copy_requests.empty();
 
   gfx::Rect damage_rect;
   if (!frame_data->render_pass_list.empty()) {
     RenderPass* last_pass = frame_data->render_pass_list.back();
     damage_rect =
         DamageRectForSurface(surface, *last_pass, last_pass->output_rect);
   }
 
   // Avoid infinite recursion by adding current surface to
   // referenced_surfaces_.
   SurfaceSet::iterator it =
       referenced_surfaces_.insert(surface->surface_id()).first;
   for (const auto& surface_info : child_surfaces) {
-    gfx::Rect surface_damage = PrewalkTree(surface_info.first);
+    gfx::Rect surface_damage = PrewalkTree(surface_info.first, result);
     damage_rect.Union(
         MathUtil::MapEnclosingClippedRect(surface_info.second, surface_damage));
   }
+
+  for (const SurfaceId surface_id :

[danakj, 2015/11/16 21:45:46]

did you mean const&?

or maybe just auto&?

+       surface_frame->metadata.referenced_surfaces) {
+    if (!contained_surfaces_.count(surface_id)) {
+      result->undrawn_surfaces.insert(surface_id);
+      PrewalkTree(surface_id, result);
+    }
+  }
+
   referenced_surfaces_.erase(it);
   return damage_rect;
 }
 
+void SurfaceAggregator::CopyUnreferencedSurfaces(

[danakj, 2015/11/16 21:45:45]

CopyUndrawnSurfaces?

+    PrewalkResult* prewalk_result) {
+  std::vector<SurfaceId> surfaces_to_copy(

[danakj, 2015/11/16 21:45:45]

Can you leave a comment here to the effect of how the Prewalk step may have
skipped surfaces that would not be drawn, and any such surface would have been
added to this surfaces_to_copy list. But that each of those surfaces may have
children that it would have skipped implicitly, so they won't appear in this
list and we'll have to look for them here?

+      prewalk_result->undrawn_surfaces.begin(),
+      prewalk_result->undrawn_surfaces.end());
+
+  for (size_t i = 0; i < surfaces_to_copy.size(); i++) {
+    SurfaceId surface_id = surfaces_to_copy[i];
+    Surface* surface = manager_->GetSurfaceForId(surface_id);
+    const CompositorFrame* surface_frame = surface->GetEligibleFrame();
+    if (!surface_frame)
+      continue;
+    bool has_copy_requests = false;

[danakj, 2015/11/16 21:45:45]

can you name this somehow differently to not almost-collide with
has_copy_requests_? surface_has_copy_requests?

+    for (const auto& render_pass :
+         surface_frame->delegated_frame_data->render_pass_list) {
+      has_copy_requests |= !render_pass->copy_requests.empty();
+    }
+    if (!has_copy_requests) {
+      // Children may have copy requests, so make sure to check them as well.
+      for (const SurfaceId child_id :

[danakj, 2015/11/16 21:45:45]

ditto?

+           surface_frame->metadata.referenced_surfaces) {
+        if (!prewalk_result->undrawn_surfaces.count(child_id)) {

[danakj, 2015/11/16 21:45:45]

Why this if? How could a child of an undrawn surface be drawn itself?

+          surfaces_to_copy.push_back(child_id);
+          prewalk_result->undrawn_surfaces.insert(child_id);
+        }
+      }
+    } else {
+      SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
+      CopyPasses(surface_frame->delegated_frame_data.get(), surface);
+      referenced_surfaces_.erase(it);
+    }
+  }
+}
+
 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);
 
   dest_resource_list_ = &frame->delegated_frame_data->resource_list;
   dest_pass_list_ = &frame->delegated_frame_data->render_pass_list;
 
   valid_surfaces_.clear();
-  has_copy_requests_ = false;
-  root_damage_rect_ = PrewalkTree(surface_id);
+  PrewalkResult prewalk_result;
+  root_damage_rect_ = PrewalkTree(surface_id, &prewalk_result);
+  has_copy_requests_ = prewalk_result.has_copy_requests;
 
+  CopyUnreferencedSurfaces(&prewalk_result);
   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 = root_damage_rect_;
 
@@ skipping 27 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