Support doing CopyOutputRequests on surfaces.

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"
@@ skipping 158 matching lines @@
   if (!frame_data)
     return;
 
   RenderPassList render_pass_list;
   bool invalid_frame = TakeResources(surface, frame_data, &render_pass_list);
   if (invalid_frame)
     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;
-  for (size_t j = 0; j + 1 < referenced_passes.size(); ++j) {
+  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];
 
     scoped_ptr<RenderPass> copy_pass(RenderPass::Create());
 
     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);
 
     // 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,
                     gfx::Transform(),
                     copy_pass.get(),
                     surface_id);
 
     dest_pass_list_->push_back(copy_pass.Pass());
   }
 
-  // TODO(jamesr): Clean up last pass special casing.
   const RenderPass& last_pass = *render_pass_list.back();
-  const QuadList& quads = last_pass.quad_list;
+  if (merge_pass) {
+    // TODO(jamesr): Clean up last pass special casing.
+    const QuadList& quads = last_pass.quad_list;
 
-  // TODO(jamesr): Make sure clipping is enforced.
-  CopyQuadsToPass(quads,
-                  last_pass.shared_quad_state_list,
-                  surface_quad->quadTransform(),
-                  dest_pass,
-                  surface_id);
+    // 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);
+    scoped_ptr<RenderPassDrawQuad> quad(new RenderPassDrawQuad);
+    quad->SetNew(shared_quad_state,
+                 surface_quad->rect,
+                 surface_quad->visible_rect,
+                 remapped_pass_id,
+                 0,
+                 gfx::RectF(),
+                 FilterOperations(),
+                 gfx::Vector2dF(),
+                 FilterOperations());
+    dest_pass->quad_list.push_back(quad.PassAs<DrawQuad>());
+  }
   dest_pass->damage_rect =
       gfx::UnionRects(dest_pass->damage_rect,
                       MathUtil::MapEnclosingClippedRect(
                           surface_quad->quadTransform(),
                           DamageRectForSurface(surface, last_pass)));
 
   referenced_surfaces_.erase(it);
 }
 
 void SurfaceAggregator::CopySharedQuadState(
@@ skipping 131 matching lines @@
       surface->TakeLatencyInfo(&frame->metadata.latency_info);
   }
 
   // TODO(jamesr): Aggregate all resource references into the returned frame's
   // resource list.
 
   return frame.Pass();
 }
 
 }  // namespace cc