Allow CopyOutputRequests on all render passes of a 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 "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/blocking_task_runner.h"
 
 namespace cc {
+namespace {
+
+void MoveMatchingRequests(
+    RenderPassId id,
+    std::multimap<RenderPassId, CopyOutputRequest*>* copy_requests,
+    ScopedPtrVector<CopyOutputRequest>* output_requests) {
+  auto request_range = copy_requests->equal_range(id);
+  for (auto it = request_range.first; it != request_range.second; ++it) {
+    DCHECK(it->second);
+    output_requests->push_back(scoped_ptr<CopyOutputRequest>(it->second));
+    it->second = nullptr;
+  }
+  copy_requests->erase(request_range.first, request_range.second);
+}
+
+}  // namespace
 
 SurfaceAggregator::SurfaceAggregator(SurfaceManager* manager,
                                      ResourceProvider* provider)
     : manager_(manager), provider_(provider) {
   DCHECK(manager_);
 }
 
 SurfaceAggregator::~SurfaceAggregator() {}
 
 class SurfaceAggregator::RenderPassIdAllocator {
@@ skipping 124 matching lines @@
     return;
   }
   contained_surfaces_[surface_id] = surface->frame_index();
   const CompositorFrame* frame = surface->GetEligibleFrame();
   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);
+
   RenderPassList render_pass_list;
   bool invalid_frame = TakeResources(surface, frame_data, &render_pass_list);
-  if (invalid_frame)
+  if (invalid_frame) {
+    for (auto& request : copy_requests) {
+      request.second->SendEmptyResult();
+      delete request.second;
+    }
     return;
+  }
 
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
 
-  ScopedPtrVector<CopyOutputRequest> copy_requests;
-  surface->TakeCopyOutputRequests(&copy_requests);
-
   bool merge_pass = copy_requests.empty();
 
   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));
 
     RenderPassId remapped_pass_id = RemapPassId(source.id, surface_id);
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       source.damage_rect,
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
+    MoveMatchingRequests(source.id, &copy_requests, &copy_pass->copy_requests);

[jamesr, 2014/10/15 23:51:24]

the RenderPassIds in copy_requests will be in the surface's ID namespace, right?
 Don't we have to map them into the aggregated namespace (i.e. call RemapPassId)
in order for them to refer to aggregated pass IDs?

+
     // 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.
     // TODO(jamesr): Make sure this is sufficient for surfaces nested several
     // levels deep and add tests.
     copy_pass->transform_to_root_target.ConcatTransform(
         surface_quad->quadTransform());
 
     CopyQuadsToPass(source.quad_list,
                     source.shared_quad_state_list,
@@ skipping 11 matching lines @@
 
     // TODO(jamesr): Make sure clipping is enforced.
     CopyQuadsToPass(quads,
                     last_pass.shared_quad_state_list,
                     surface_quad->quadTransform(),
                     dest_pass,
                     surface_id);
   } else {
     RenderPassId remapped_pass_id = RemapPassId(last_pass.id, surface_id);
 
-    dest_pass_list_->back()->copy_requests.swap(copy_requests);
-
     SharedQuadState* shared_quad_state =
         dest_pass->CreateAndAppendSharedQuadState();
     shared_quad_state->CopyFrom(surface_quad->shared_quad_state);
     RenderPassDrawQuad* quad =
         dest_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     quad->SetNew(shared_quad_state,
                  surface_quad->rect,
                  surface_quad->visible_rect,
                  remapped_pass_id,
                  0,
@@ skipping 71 matching lines @@
             dest_pass->shared_quad_state_list.back(),
             remapped_pass_id);
       } else {
         dest_pass->CopyFromAndAppendDrawQuad(
             &quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }
 }
 
-void SurfaceAggregator::CopyPasses(const RenderPassList& source_pass_list,
-                                   const Surface* surface) {
+void SurfaceAggregator::CopyPasses(const DelegatedFrameData* frame_data,
+                                   Surface* surface) {
+  RenderPassList source_pass_list;
+
+  // 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);
+
+  bool invalid_frame = TakeResources(surface, frame_data, &source_pass_list);
+  DCHECK(!invalid_frame);
+
   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());
 
     copy_pass->SetAll(remapped_pass_id,
                       source.output_rect,
                       DamageRectForSurface(surface, source),
                       source.transform_to_root_target,
                       source.has_transparent_background);
 
     CopyQuadsToPass(source.quad_list,
@@ skipping 13 matching lines @@
   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);
 
-  RenderPassList source_pass_list;
-
   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;
 
-  bool invalid_frame =
-      TakeResources(surface,
-                    root_surface_frame->delegated_frame_data.get(),
-                    &source_pass_list);
-  DCHECK(!invalid_frame);
-
-  CopyPasses(source_pass_list, surface);
+  CopyPasses(root_surface_frame->delegated_frame_data.get(), surface);
 
   referenced_surfaces_.erase(it);
   DCHECK(referenced_surfaces_.empty());
 
   dest_pass_list_ = NULL;
   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);
     if (surface)
       surface->TakeLatencyInfo(&frame->metadata.latency_info);
   }
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame.Pass();
 }
 
 }  // namespace cc