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 40 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() {}
+
+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 413 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().get();
     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 auto& surface_id : 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::CopyUndrawnSurfaces(PrewalkResult* prewalk_result) {
+  // undrawn_surfaces are Surfaces that were identified by prewalk as being
+  // referenced by a drawn Surface, but aren't contained in a SurfaceDrawQuad.
+  // They need to be iterated over to ensure that any copy requests on them
+  // (or on Surfaces they reference) are executed.
+  std::vector<SurfaceId> surfaces_to_copy(
+      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 surface_has_copy_requests = false;
+    for (const auto& render_pass :
+         surface_frame->delegated_frame_data->render_pass_list) {
+      surface_has_copy_requests |= !render_pass->copy_requests.empty();
+    }
+    if (!surface_has_copy_requests) {
+      // Children are not necessarily included in undrawn_surfaces (because
+      // they weren't referenced directly from a drawn surface), but may have
+      // copy requests, so make sure to check them as well.
+      for (const auto& child_id : surface_frame->metadata.referenced_surfaces) {
+        // Don't iterate over the child Surface if it was already listed as a
+        // child of a different Surface, or in the case where there's infinite
+        // recursion.
+        if (!prewalk_result->undrawn_surfaces.count(child_id)) {
+          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;
 
+  CopyUndrawnSurfaces(&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