Revert "Getting rid of DelegatedFrameData"

cc/surfaces/surface_aggregator_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/output/compositor_frame.h"
+#include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
@@ skipping 55 matching lines @@
   SurfaceFactory factory_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
   LocalFrameId local_frame_id(7, base::UnguessableToken::Create());
   SurfaceId one_id(kArbitraryFrameSinkId, local_frame_id);
   factory_.Create(local_frame_id);
 
   CompositorFrame frame = aggregator_.Aggregate(one_id);
-  EXPECT_TRUE(frame.render_pass_list.empty());
+  EXPECT_FALSE(frame.delegated_frame_data);
 
   factory_.Destroy(local_frame_id);
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
         child_factory_(kArbitraryChildFrameSinkId,
                        &manager_,
@@ skipping 14 matching lines @@
     SurfaceAggregatorTest::TearDown();
   }
 
   void AggregateAndVerify(test::Pass* expected_passes,
                           size_t expected_pass_count,
                           SurfaceId* surface_ids,
                           size_t expected_surface_count) {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(
         SurfaceId(factory_.frame_sink_id(), root_local_frame_id_));
 
-    TestPassesMatchExpectations(expected_passes, expected_pass_count,
-                                &aggregated_frame.render_pass_list);
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    TestPassesMatchExpectations(
+        expected_passes, expected_pass_count, &frame_data->render_pass_list);
 
     // Ensure no duplicate pass ids output.
     std::set<RenderPassId> used_passes;
-    for (const auto& pass : aggregated_frame.render_pass_list) {
+    for (const auto& pass : frame_data->render_pass_list) {
       EXPECT_TRUE(used_passes.insert(pass->id).second);
     }
 
     EXPECT_EQ(expected_surface_count,
               aggregator_.previous_contained_surfaces().size());
     for (size_t i = 0; i < expected_surface_count; i++) {
       EXPECT_TRUE(
           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
           aggregator_.previous_contained_surfaces().end());
     }
   }
 
   void SubmitPassListAsFrame(SurfaceFactory* factory,
                              const LocalFrameId& local_frame_id,
                              RenderPassList* pass_list) {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    pass_list->swap(frame_data->render_pass_list);
+
     CompositorFrame frame;
-    pass_list->swap(frame.render_pass_list);
+    frame.delegated_frame_data = std::move(frame_data);
 
     factory->SubmitCompositorFrame(local_frame_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   void SubmitCompositorFrame(SurfaceFactory* factory,
                              test::Pass* passes,
                              size_t pass_count,
                              const LocalFrameId& local_frame_id) {
     RenderPassList pass_list;
     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
     SubmitPassListAsFrame(factory, local_frame_id, &pass_list);
   }
 
   void QueuePassAsFrame(std::unique_ptr<RenderPass> pass,
                         const LocalFrameId& local_frame_id) {
+    std::unique_ptr<DelegatedFrameData> delegated_frame_data(
+        new DelegatedFrameData);
+    delegated_frame_data->render_pass_list.push_back(std::move(pass));
+
     CompositorFrame child_frame;
-    child_frame.render_pass_list.push_back(std::move(pass));
+    child_frame.delegated_frame_data = std::move(delegated_frame_data);
 
     factory_.SubmitCompositorFrame(local_frame_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
  protected:
   LocalFrameId root_local_frame_id_;
   Surface* root_surface_;
   SurfaceIdAllocator allocator_;
   EmptySurfaceFactoryClient empty_child_client_;
@@ skipping 37 matching lines @@
 
   test::Quad quads[] = {test::Quad::SurfaceQuad(embedded_surface_id, .5f)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitCompositorFrame(&factory_, passes, arraysize(passes),
                         root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  RenderPassList& render_pass_list(aggregated_frame.render_pass_list);
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  RenderPassList& render_pass_list(frame_data->render_pass_list);
   ASSERT_EQ(2u, render_pass_list.size());
   SharedQuadStateList& shared_quad_state_list(
       render_pass_list[0]->shared_quad_state_list);
   ASSERT_EQ(2u, shared_quad_state_list.size());
   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(0)->opacity);
   EXPECT_EQ(1.f, shared_quad_state_list.ElementAt(1)->opacity);
 
   SharedQuadStateList& shared_quad_state_list2(
       render_pass_list[1]->shared_quad_state_list);
   ASSERT_EQ(1u, shared_quad_state_list2.size());
@@ skipping 80 matching lines @@
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
   SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes),
                         root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
   test::Quad expected_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorWHITE),
-      test::Quad::RenderPassQuad(aggregated_frame.render_pass_list[0]->id),
+      test::Quad::RenderPassQuad(frame_data->render_pass_list[0]->id),
       test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass expected_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads)),
       test::Pass(expected_quads, arraysize(expected_quads))};
-  TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),
-                              &aggregated_frame.render_pass_list);
-  ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());
-  ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());
+  TestPassesMatchExpectations(expected_passes,
+                              arraysize(expected_passes),
+                              &frame_data->render_pass_list);
+  ASSERT_EQ(2u, frame_data->render_pass_list.size());
+  ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
   DCHECK_EQ(copy_request_ptr,
-            aggregated_frame.render_pass_list[0]->copy_requests[0].get());
+            frame_data->render_pass_list[0]->copy_requests[0].get());
 
   SurfaceId surface_ids[] = {root_surface_id, embedded_surface_id};
   EXPECT_EQ(arraysize(surface_ids),
             aggregator_.previous_contained_surfaces().size());
   for (size_t i = 0; i < arraysize(surface_ids); i++) {
     EXPECT_TRUE(
         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
         aggregator_.previous_contained_surfaces().end());
   }
 
@@ skipping 21 matching lines @@
   CopyOutputRequest* copy_request2_ptr = copy_request2.get();
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Quad root_quads2[] = {test::Quad::SolidColorQuad(SK_ColorRED)};
   test::Pass root_passes[] = {
       test::Pass(root_quads, arraysize(root_quads), RenderPassId(1, 1)),
       test::Pass(root_quads2, arraysize(root_quads2), RenderPassId(1, 2))};
   {
+    RenderPassList pass_list;
+    AddPasses(&pass_list,
+              gfx::Rect(SurfaceSize()),
+              root_passes,
+              arraysize(root_passes));
+    pass_list[0]->copy_requests.push_back(std::move(copy_request));
+    pass_list[1]->copy_requests.push_back(std::move(copy_request2));
+
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    pass_list.swap(frame_data->render_pass_list);
+
     CompositorFrame frame;
-    AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
-              arraysize(root_passes));
-    frame.render_pass_list[0]->copy_requests.push_back(std::move(copy_request));
-    frame.render_pass_list[1]->copy_requests.push_back(
-        std::move(copy_request2));
+    frame.delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                                  test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads)),
       test::Pass(root_quads2, arraysize(root_quads2))};
-  TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),
-                              &aggregated_frame.render_pass_list);
-  ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());
-  ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());
+  TestPassesMatchExpectations(expected_passes,
+                              arraysize(expected_passes),
+                              &frame_data->render_pass_list);
+  ASSERT_EQ(2u, frame_data->render_pass_list.size());
+  ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
   DCHECK_EQ(copy_request_ptr,
-            aggregated_frame.render_pass_list[0]->copy_requests[0].get());
-  ASSERT_EQ(1u, aggregated_frame.render_pass_list[1]->copy_requests.size());
+            frame_data->render_pass_list[0]->copy_requests[0].get());
+  ASSERT_EQ(1u, frame_data->render_pass_list[1]->copy_requests.size());
   DCHECK_EQ(copy_request2_ptr,
-            aggregated_frame.render_pass_list[1]->copy_requests[0].get());
+            frame_data->render_pass_list[1]->copy_requests[0].get());
 
   SurfaceId surface_ids[] = {root_surface_id, embedded_surface_id};
   EXPECT_EQ(arraysize(surface_ids),
             aggregator_.previous_contained_surfaces().size());
   for (size_t i = 0; i < arraysize(surface_ids); i++) {
     EXPECT_TRUE(
         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
         aggregator_.previous_contained_surfaces().end());
   }
 
   // Ensure copy requests have been removed from root surface.
   const CompositorFrame& original_frame =
       manager_.GetSurfaceForId(root_surface_id)->GetEligibleFrame();
-  const RenderPassList& original_pass_list = original_frame.render_pass_list;
+  RenderPassList& original_pass_list =
+      original_frame.delegated_frame_data->render_pass_list;
   ASSERT_EQ(2u, original_pass_list.size());
   DCHECK(original_pass_list[0]->copy_requests.empty());
   DCHECK(original_pass_list[1]->copy_requests.empty());
 
   factory_.Destroy(embedded_local_frame_id);
 }
 
 TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {
   LocalFrameId embedded_local_frame_id = allocator_.GenerateId();
   SurfaceId embedded_surface_id(factory_.frame_sink_id(),
@@ skipping 19 matching lines @@
   factory_.Create(parent_local_frame_id);
 
   test::Quad parent_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorWHITE),
       test::Quad::SurfaceQuad(embedded_surface_id, 1.f),
       test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass parent_passes[] = {
       test::Pass(parent_quads, arraysize(parent_quads))};
 
   {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
+              parent_passes, arraysize(parent_passes));
+
     CompositorFrame frame;
-
-    AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), parent_passes,
-              arraysize(parent_passes));
-
+    frame.delegated_frame_data = std::move(frame_data);
     frame.metadata.referenced_surfaces.push_back(embedded_surface_id);
 
     factory_.SubmitCompositorFrame(parent_local_frame_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),
                              test::Quad::SolidColorQuad(SK_ColorBLACK)};
   test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
   {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
+              root_passes, arraysize(root_passes));
+
     CompositorFrame frame;
-    AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
-              arraysize(root_passes));
-
+    frame.delegated_frame_data = std::move(frame_data);
     frame.metadata.referenced_surfaces.push_back(parent_surface_id);
     // Reference to Surface ID of a Surface that doesn't exist should be
     // included in previous_contained_surfaces, but otherwise ignored.
     frame.metadata.referenced_surfaces.push_back(nonexistent_surface_id);
 
     factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
   // First pass should come from surface that had a copy request but was not
   // referenced directly. The second pass comes from the root surface.
   // parent_quad should be ignored because it is neither referenced through a
   // SurfaceDrawQuad nor has a copy request on it.
   test::Pass expected_passes[] = {
       test::Pass(embedded_quads, arraysize(embedded_quads)),
       test::Pass(root_quads, arraysize(root_quads))};
   TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),
-                              &aggregated_frame.render_pass_list);
-  ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());
-  ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());
+                              &frame_data->render_pass_list);
+  ASSERT_EQ(2u, frame_data->render_pass_list.size());
+  ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());
   DCHECK_EQ(copy_request_ptr,
-            aggregated_frame.render_pass_list[0]->copy_requests[0].get());
+            frame_data->render_pass_list[0]->copy_requests[0].get());
 
   SurfaceId surface_ids[] = {
       SurfaceId(factory_.frame_sink_id(), root_local_frame_id_),
       parent_surface_id, embedded_surface_id, nonexistent_surface_id};
   EXPECT_EQ(arraysize(surface_ids),
             aggregator_.previous_contained_surfaces().size());
   for (size_t i = 0; i < arraysize(surface_ids); i++) {
     EXPECT_TRUE(
         aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
         aggregator_.previous_contained_surfaces().end());
@@ skipping 34 matching lines @@
       test::Pass(root_quads[0], arraysize(root_quads[0]), pass_ids[0]),
       test::Pass(root_quads[1], arraysize(root_quads[1]), pass_ids[1]),
       test::Pass(root_quads[2], arraysize(root_quads[2]), pass_ids[2])};
 
   SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes),
                         root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(5u, aggregated_pass_list.size());
   RenderPassId actual_pass_ids[] = {
       aggregated_pass_list[0]->id, aggregated_pass_list[1]->id,
       aggregated_pass_list[2]->id, aggregated_pass_list[3]->id,
       aggregated_pass_list[4]->id};
   for (size_t i = 0; i < 5; ++i) {
     for (size_t j = 0; j < i; ++j) {
       EXPECT_NE(actual_pass_ids[i], actual_pass_ids[j]);
     }
@@ skipping 221 matching lines @@
   test::Pass parent_passes[] = {
       test::Pass(parent_quad[0], arraysize(parent_quad[0]), parent_pass_id[0]),
       test::Pass(parent_quad[1], arraysize(parent_quad[1]), parent_pass_id[1])};
 
   SubmitCompositorFrame(&factory_, parent_passes, arraysize(parent_passes),
                         root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(3u, aggregated_pass_list.size());
   RenderPassId actual_pass_ids[] = {aggregated_pass_list[0]->id,
                                     aggregated_pass_list[1]->id,
                                     aggregated_pass_list[2]->id};
   // Make sure the aggregated frame's pass IDs are all unique.
   for (size_t i = 0; i < 3; ++i) {
     for (size_t j = 0; j < i; ++j) {
       EXPECT_NE(actual_pass_ids[j], actual_pass_ids[i]) << "pass ids " << i
                                                         << " and " << j;
@@ skipping 143 matching lines @@
                                  gfx::Rect(SurfaceSize()),
                                  child_two_surface_id);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[6]);
 
   QueuePassAsFrame(std::move(root_pass), root_local_frame_id_);
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(1u, aggregated_pass_list.size());
 
   const QuadList& aggregated_quad_list = aggregated_pass_list[0]->quad_list;
 
   ASSERT_EQ(7u, aggregated_quad_list.size());
 
   for (auto iter = aggregated_quad_list.cbegin();
        iter != aggregated_quad_list.cend();
        ++iter) {
@@ skipping 32 matching lines @@
     RenderPassId child_pass_id[] = {RenderPassId(1, 1), RenderPassId(1, 2)};
     test::Quad child_quads[][1] = {
         {test::Quad::SolidColorQuad(SK_ColorGREEN)},
         {test::Quad::RenderPassQuad(child_pass_id[0])},
     };
     test::Pass child_passes[] = {
         test::Pass(child_quads[0], arraysize(child_quads[0]), child_pass_id[0]),
         test::Pass(child_quads[1], arraysize(child_quads[1]),
                    child_pass_id[1])};
 
-    CompositorFrame child_frame;
-    AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              child_passes, arraysize(child_passes));
+    RenderPassList child_pass_list;
+    AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
+              arraysize(child_passes));
 
-    RenderPass* child_nonroot_pass = child_frame.render_pass_list[0].get();
+    RenderPass* child_nonroot_pass = child_pass_list[0].get();
     child_nonroot_pass->transform_to_root_target.Translate(8, 0);
     SharedQuadState* child_nonroot_pass_sqs =
         child_nonroot_pass->shared_quad_state_list.front();
     child_nonroot_pass_sqs->quad_to_target_transform.Translate(5, 0);
 
-    RenderPass* child_root_pass = child_frame.render_pass_list[1].get();
+    RenderPass* child_root_pass = child_pass_list[1].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass_sqs->is_clipped = true;
     child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);
 
+    std::unique_ptr<DelegatedFrameData> child_frame_data(
+        new DelegatedFrameData);
+    child_pass_list.swap(child_frame_data->render_pass_list);
+
+    CompositorFrame child_frame;
+    child_frame.delegated_frame_data = std::move(child_frame_data);
+
     factory_.SubmitCompositorFrame(child_local_frame_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   // Middle child surface.
   LocalFrameId middle_local_frame_id = allocator_.GenerateId();
   SurfaceId middle_surface_id(factory_.frame_sink_id(), middle_local_frame_id);
   factory_.Create(middle_local_frame_id);
   {
     test::Quad middle_quads[] = {
         test::Quad::SurfaceQuad(child_surface_id, 1.f)};
     test::Pass middle_passes[] = {
         test::Pass(middle_quads, arraysize(middle_quads)),
     };
 
-    CompositorFrame middle_frame;
-    AddPasses(&middle_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              middle_passes, arraysize(middle_passes));
+    RenderPassList middle_pass_list;
+    AddPasses(&middle_pass_list, gfx::Rect(SurfaceSize()), middle_passes,
+              arraysize(middle_passes));
 
-    RenderPass* middle_root_pass = middle_frame.render_pass_list[0].get();
+    RenderPass* middle_root_pass = middle_pass_list[0].get();
     middle_root_pass->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 1, 100, 7);
     SharedQuadState* middle_root_pass_sqs =
         middle_root_pass->shared_quad_state_list.front();
     middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3);
 
+    std::unique_ptr<DelegatedFrameData> middle_frame_data(
+        new DelegatedFrameData);
+    middle_pass_list.swap(middle_frame_data->render_pass_list);
+
+    CompositorFrame middle_frame;
+    middle_frame.delegated_frame_data = std::move(middle_frame_data);
+
     factory_.SubmitCompositorFrame(middle_local_frame_id,
                                    std::move(middle_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   // Root surface.
   test::Quad secondary_quads[] = {
       test::Quad::SolidColorQuad(1),
       test::Quad::SurfaceQuad(middle_surface_id, 1.f)};
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(1)};
   test::Pass root_passes[] = {
       test::Pass(secondary_quads, arraysize(secondary_quads)),
       test::Pass(root_quads, arraysize(root_quads))};
 
-  CompositorFrame root_frame;
-  AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
+  RenderPassList root_pass_list;
+  AddPasses(&root_pass_list,
+            gfx::Rect(SurfaceSize()),
+            root_passes,
             arraysize(root_passes));
 
-  root_frame.render_pass_list[0]
+  root_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 7);
-  root_frame.render_pass_list[0]
+  root_pass_list[0]
       ->shared_quad_state_list.ElementAt(1)
       ->quad_to_target_transform.Translate(0, 10);
-  root_frame.render_pass_list[0]->quad_list.ElementAt(1)->visible_rect =
+  root_pass_list[0]->quad_list.ElementAt(1)->visible_rect =
       gfx::Rect(0, 0, 8, 100);
 
-  root_frame.render_pass_list[0]->transform_to_root_target.Translate(10, 5);
+  root_pass_list[0]->transform_to_root_target.Translate(10, 5);
+
+  std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+  root_pass_list.swap(root_frame_data->render_pass_list);
+
+  CompositorFrame root_frame;
+  root_frame.delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(3u, aggregated_pass_list.size());
 
   ASSERT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
 
   // The first pass should have one shared quad state for the one solid color
   // quad.
   EXPECT_EQ(1u, aggregated_pass_list[0]->shared_quad_state_list.size());
   // The second pass should have just two shared quad states. We'll
   // verify the properties through the quads.
@@ skipping 58 matching lines @@
   factory_.Destroy(middle_local_frame_id);
   factory_.Destroy(child_local_frame_id);
 }
 
 // Tests that damage rects are aggregated correctly when surfaces change.
 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
   test::Quad child_quads[] = {test::Quad::RenderPassQuad(RenderPassId(1, 1))};
   test::Pass child_passes[] = {
       test::Pass(child_quads, arraysize(child_quads), RenderPassId(1, 1))};
 
-  CompositorFrame child_frame;
-  AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-            child_passes, arraysize(child_passes));
+  RenderPassList child_pass_list;
+  AddPasses(&child_pass_list,
+            gfx::Rect(SurfaceSize()),
+            child_passes,
+            arraysize(child_passes));
 
-  RenderPass* child_root_pass = child_frame.render_pass_list[0].get();
+  RenderPass* child_root_pass = child_pass_list[0].get();
   SharedQuadState* child_root_pass_sqs =
       child_root_pass->shared_quad_state_list.front();
   child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
 
+  std::unique_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
+  child_pass_list.swap(child_frame_data->render_pass_list);
+
+  CompositorFrame child_frame;
+  child_frame.delegated_frame_data = std::move(child_frame_data);
+
   LocalFrameId child_local_frame_id = allocator_.GenerateId();
   SurfaceId child_surface_id(factory_.frame_sink_id(), child_local_frame_id);
   factory_.Create(child_local_frame_id);
   factory_.SubmitCompositorFrame(child_local_frame_id, std::move(child_frame),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad parent_surface_quads[] = {
       test::Quad::SurfaceQuad(child_surface_id, 1.f)};
   test::Pass parent_surface_passes[] = {
       test::Pass(parent_surface_quads, arraysize(parent_surface_quads),
                  RenderPassId(1, 1))};
 
+  RenderPassList parent_surface_pass_list;
+  AddPasses(&parent_surface_pass_list,
+            gfx::Rect(SurfaceSize()),
+            parent_surface_passes,
+            arraysize(parent_surface_passes));
+
   // Parent surface is only used to test if the transform is applied correctly
   // to the child surface's damage.
+  std::unique_ptr<DelegatedFrameData> parent_surface_frame_data(
+      new DelegatedFrameData);
+  parent_surface_pass_list.swap(parent_surface_frame_data->render_pass_list);
+
   CompositorFrame parent_surface_frame;
-  AddPasses(&parent_surface_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-            parent_surface_passes, arraysize(parent_surface_passes));
+  parent_surface_frame.delegated_frame_data =
+      std::move(parent_surface_frame_data);
 
   LocalFrameId parent_local_frame_id = allocator_.GenerateId();
   SurfaceId parent_surface_id(factory_.frame_sink_id(), parent_local_frame_id);
   factory_.Create(parent_local_frame_id);
   factory_.SubmitCompositorFrame(parent_local_frame_id,
                                  std::move(parent_surface_frame),
                                  SurfaceFactory::DrawCallback());
 
   test::Quad root_surface_quads[] = {
       test::Quad::SurfaceQuad(parent_surface_id, 1.f)};
   test::Quad root_render_pass_quads[] = {
       test::Quad::RenderPassQuad(RenderPassId(1, 1))};
 
   test::Pass root_passes[] = {
       test::Pass(root_surface_quads, arraysize(root_surface_quads),
                  RenderPassId(1, 1)),
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads),
                  RenderPassId(2, 1))};
 
-  CompositorFrame root_frame;
-  AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
+  RenderPassList root_pass_list;
+  AddPasses(&root_pass_list,
+            gfx::Rect(SurfaceSize()),
+            root_passes,
             arraysize(root_passes));
 
-  root_frame.render_pass_list[0]
+  root_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 10);
-  root_frame.render_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);
-  root_frame.render_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);
+  root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);
+  root_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);
+
+  std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+  root_pass_list.swap(root_frame_data->render_pass_list);
+
+  CompositorFrame root_frame;
+  root_frame.delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(2u, aggregated_pass_list.size());
 
   // Damage rect for first aggregation should contain entire root surface.
   EXPECT_TRUE(
       aggregated_pass_list[1]->damage_rect.Contains(gfx::Rect(SurfaceSize())));
 
   {
-    CompositorFrame child_frame;
-    AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              child_passes, arraysize(child_passes));
+    AddPasses(&child_pass_list,
+              gfx::Rect(SurfaceSize()),
+              child_passes,
+              arraysize(child_passes));
 
-    RenderPass* child_root_pass = child_frame.render_pass_list[0].get();
+    RenderPass* child_root_pass = child_pass_list[0].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
 
+    std::unique_ptr<DelegatedFrameData> child_frame_data(
+        new DelegatedFrameData);
+    child_pass_list.swap(child_frame_data->render_pass_list);
+
+    CompositorFrame child_frame;
+    child_frame.delegated_frame_data = std::move(child_frame_data);
+
     factory_.SubmitCompositorFrame(child_local_frame_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
 
     SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     // Outer surface didn't change, so transformed inner damage rect should be
     // used.
     EXPECT_EQ(gfx::Rect(10, 20, 10, 10).ToString(),
               aggregated_pass_list[1]->damage_rect.ToString());
   }
 
   {
-    CompositorFrame root_frame;
-    AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              root_passes, arraysize(root_passes));
+    RenderPassList root_pass_list;
+    AddPasses(&root_pass_list,
+              gfx::Rect(SurfaceSize()),
+              root_passes,
+              arraysize(root_passes));
 
-    root_frame.render_pass_list[0]
+    root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
-    root_frame.render_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);
+    root_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);
+
+    std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+    root_pass_list.swap(root_frame_data->render_pass_list);
+
+    CompositorFrame root_frame;
+    root_frame.delegated_frame_data = std::move(root_frame_data);
 
     factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
   }
 
   {
-    CompositorFrame root_frame;
-    AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              root_passes, arraysize(root_passes));
+    RenderPassList root_pass_list;
+    AddPasses(&root_pass_list,
+              gfx::Rect(SurfaceSize()),
+              root_passes,
+              arraysize(root_passes));
 
-    root_frame.render_pass_list[0]
+    root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
-    root_frame.render_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);
+    root_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);
+
+    std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+    root_pass_list.swap(root_frame_data->render_pass_list);
+
+    CompositorFrame root_frame;
+    root_frame.delegated_frame_data = std::move(root_frame_data);
 
     factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
 
     SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     // The root surface was enqueued without being aggregated once, so it should
     // be treated as completely damaged.
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   // No Surface changed, so no damage should be given.
   {
     SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.IsEmpty());
   }
 
   // SetFullDamageRectForSurface should cause the entire output to be
   // marked as damaged.
   {
     aggregator_.SetFullDamageForSurface(root_surface_id);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(2u, aggregated_pass_list.size());
 
     EXPECT_TRUE(aggregated_pass_list[1]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   factory_.Destroy(child_local_frame_id);
 }
 
 // Check that damage is correctly calculated for surfaces with
 // SetPreviousFrameSurface.
 TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {
   test::Quad root_render_pass_quads[] = {test::Quad::SolidColorQuad(1)};
 
   test::Pass root_passes[] = {test::Pass(root_render_pass_quads,
                                          arraysize(root_render_pass_quads),
                                          RenderPassId(2, 1))};
 
-  CompositorFrame root_frame;
-  AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
+  RenderPassList root_pass_list;
+  AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
             arraysize(root_passes));
 
-  root_frame.render_pass_list[0]->damage_rect = gfx::Rect(5, 5, 100, 100);
+  root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 100, 100);
+
+  std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+  root_pass_list.swap(root_frame_data->render_pass_list);
+
+  CompositorFrame root_frame;
+  root_frame.delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   {
     SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(1u, aggregated_pass_list.size());
 
     // Damage rect for first aggregation should contain entire root surface.
     EXPECT_TRUE(aggregated_pass_list[0]->damage_rect.Contains(
         gfx::Rect(SurfaceSize())));
   }
 
   LocalFrameId second_root_local_frame_id = allocator_.GenerateId();
   SurfaceId second_root_surface_id(factory_.frame_sink_id(),
                                    second_root_local_frame_id);
   {
     test::Quad root_render_pass_quads[] = {test::Quad::SolidColorQuad(1)};
 
     test::Pass root_passes[] = {test::Pass(root_render_pass_quads,
                                            arraysize(root_render_pass_quads),
                                            RenderPassId(2, 1))};
 
+    RenderPassList root_pass_list;
+    AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
+              arraysize(root_passes));
+
+    root_pass_list[0]->damage_rect = gfx::Rect(1, 2, 3, 4);
+
+    std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
+    root_pass_list.swap(root_frame_data->render_pass_list);
+
     CompositorFrame root_frame;
-    AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
-              root_passes, arraysize(root_passes));
-
-    root_frame.render_pass_list[0]->damage_rect = gfx::Rect(1, 2, 3, 4);
+    root_frame.delegated_frame_data = std::move(root_frame_data);
 
     factory_.Create(second_root_local_frame_id);
     factory_.SubmitCompositorFrame(second_root_local_frame_id,
                                    std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
     factory_.SetPreviousFrameSurface(second_root_local_frame_id,
                                      root_local_frame_id_);
   }
   {
     CompositorFrame aggregated_frame =
         aggregator_.Aggregate(second_root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(1u, aggregated_pass_list.size());
 
     // Frame from SetPreviousFrameSurface was aggregated last, so damage rect
     // from new surface should be used.
     EXPECT_EQ(gfx::Rect(1, 2, 3, 4), aggregated_pass_list[0]->damage_rect);
   }
   {
     CompositorFrame aggregated_frame =
         aggregator_.Aggregate(second_root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(1u, aggregated_pass_list.size());
 
     // No new frame, so no new damage.
     EXPECT_TRUE(aggregated_pass_list[0]->damage_rect.IsEmpty());
   }
   factory_.Destroy(second_root_local_frame_id);
 }
 
 class SurfaceAggregatorPartialSwapTest
@@ skipping 60 matching lines @@
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     SubmitPassListAsFrame(&factory_, root_local_frame_id_, &root_pass_list);
   }
 
   SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-  const RenderPassList& aggregated_pass_list =
-      aggregated_frame.render_pass_list;
+  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+
+  const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
   ASSERT_EQ(3u, aggregated_pass_list.size());
 
   // Damage rect for first aggregation should contain entire root surface.
   EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[2]->damage_rect);
   EXPECT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
   EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
   EXPECT_EQ(1u, aggregated_pass_list[2]->quad_list.size());
 
   // Create a root surface with a smaller damage rect.
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
     RenderPass* root_pass = root_pass_list[0].get();
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
     SubmitPassListAsFrame(&factory_, root_local_frame_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     // Only first quad from surface is inside damage rect and should be
     // included.
     EXPECT_EQ(gfx::Rect(10, 10, 2, 2), aggregated_pass_list[2]->damage_rect);
     EXPECT_EQ(0u, aggregated_pass_list[0]->quad_list.size());
     EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     EXPECT_EQ(gfx::Rect(0, 0, 2, 2),
               aggregated_pass_list[1]->quad_list.back()->visible_rect);
@@ skipping 28 matching lines @@
 
     child_root_pass->copy_requests.push_back(
         CopyOutputRequest::CreateEmptyRequest());
     child_root_pass->damage_rect = gfx::Rect();
     SubmitPassListAsFrame(&factory_, child_local_frame_id, &child_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     // Output frame should have no damage, but all quads included.
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[0]->damage_rect);
     EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[1]->damage_rect);
     EXPECT_TRUE(aggregated_pass_list[2]->damage_rect.IsEmpty());
     ASSERT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
     ASSERT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     EXPECT_EQ(gfx::Rect(1, 1, 2, 2),
               aggregated_pass_list[0]->quad_list.ElementAt(0)->visible_rect);
     EXPECT_EQ(gfx::Rect(0, 0, 2, 2),
               aggregated_pass_list[1]->quad_list.ElementAt(0)->visible_rect);
     ASSERT_EQ(1u, aggregated_pass_list[2]->quad_list.size());
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
     // There were no changes since last aggregation, so output should be empty
     // and have no damage.
     ASSERT_EQ(1u, aggregated_pass_list.size());
     EXPECT_TRUE(aggregated_pass_list[0]->damage_rect.IsEmpty());
     ASSERT_EQ(0u, aggregated_pass_list[0]->quad_list.size());
   }
 
   // Root surface has smaller damage rect, but filter on render pass means all
   // of it should be aggregated.
   {
@@ skipping 15 matching lines @@
     RenderPassDrawQuad* quad =
         static_cast<RenderPassDrawQuad*>(root_pass->quad_list.front());
     quad->filters.Append(FilterOperation::CreateBlurFilter(2));
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
     SubmitPassListAsFrame(&factory_, root_local_frame_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[0]->damage_rect);
     EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[1]->damage_rect);
     EXPECT_EQ(gfx::Rect(10, 10, 2, 2), aggregated_pass_list[2]->damage_rect);
     EXPECT_EQ(1u, aggregated_pass_list[0]->quad_list.size());
     EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
     // First render pass draw quad is outside damage rect, so shouldn't be
     // drawn.
@@ skipping 24 matching lines @@
     RenderPassDrawQuad* quad =
         static_cast<RenderPassDrawQuad*>(root_pass->quad_list.front());
     quad->background_filters.Append(FilterOperation::CreateBlurFilter(2));
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
     SubmitPassListAsFrame(&factory_, root_local_frame_id_, &root_pass_list);
   }
 
   {
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
-    const RenderPassList& aggregated_pass_list =
-        aggregated_frame.render_pass_list;
+    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+
+    DelegatedFrameData* frame_data =
+        aggregated_frame.delegated_frame_data.get();
+
+    const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
     ASSERT_EQ(3u, aggregated_pass_list.size());
 
     // Pass 0 is solid color quad from root, but outside damage rect.
     EXPECT_EQ(gfx::Rect(10, 10, 2, 2), aggregated_pass_list[0]->damage_rect);
     EXPECT_EQ(0u, aggregated_pass_list[0]->quad_list.size());
     EXPECT_EQ(gfx::Rect(SurfaceSize()), aggregated_pass_list[1]->damage_rect);
     EXPECT_EQ(1u, aggregated_pass_list[1]->quad_list.size());
 
     // First render pass draw quad is outside damage rect, so shouldn't be
@@ skipping 45 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ResourceTrackingSurfaceFactoryClient);
 };
 
 void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
                                         size_t num_resource_ids,
                                         bool valid,
                                         SurfaceId child_id,
                                         SurfaceFactory* factory,
                                         SurfaceId surface_id) {
-  CompositorFrame frame;
+  std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = RenderPassId(1, 1);
   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   sqs->opacity = 1.f;
   if (child_id.is_valid()) {
     SurfaceDrawQuad* surface_quad =
         pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
     surface_quad->SetNew(sqs, gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1),
                          child_id);
   }
 
   for (size_t i = 0u; i < num_resource_ids; ++i) {
     TransferableResource resource;
     resource.id = resource_ids[i];
     // ResourceProvider is software, so only software resources are valid.
     resource.is_software = valid;
-    frame.resource_list.push_back(resource);
+    frame_data->resource_list.push_back(resource);
     TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     const gfx::Rect rect;
     const gfx::Rect opaque_rect;
     const gfx::Rect visible_rect;
     bool needs_blending = false;
     bool premultiplied_alpha = false;
     const gfx::PointF uv_top_left;
     const gfx::PointF uv_bottom_right;
     SkColor background_color = SK_ColorGREEN;
     const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
     bool flipped = false;
     bool nearest_neighbor = false;
     bool secure_output_only = true;
     quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                  resource_ids[i], gfx::Size(), premultiplied_alpha, uv_top_left,
                  uv_bottom_right, background_color, vertex_opacity, flipped,
                  nearest_neighbor, secure_output_only);
   }
-  frame.render_pass_list.push_back(std::move(pass));
+  frame_data->render_pass_list.push_back(std::move(pass));
+  CompositorFrame frame;
+  frame.delegated_frame_data = std::move(frame_data);
   factory->SubmitCompositorFrame(surface_id.local_frame_id(), std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   LocalFrameId local_frame_id(7u, base::UnguessableToken::Create());
   SurfaceId surface_id(kArbitraryFrameSinkId, local_frame_id);
   factory.Create(local_frame_id);
@@ skipping 22 matching lines @@
   factory.Destroy(local_frame_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   LocalFrameId local_frame_id(7u, base::UnguessableToken::Create());
   SurfaceId surface_id(kArbitraryFrameSinkId, local_frame_id);
   factory.Create(local_frame_id);
 
-  CompositorFrame frame;
+  std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = RenderPassId(1, 1);
   TransferableResource resource;
   resource.id = 11;
   // ResourceProvider is software but resource is not, so it should be
   // ignored.
   resource.is_software = false;
-  frame.resource_list.push_back(resource);
-  frame.render_pass_list.push_back(std::move(pass));
+  frame_data->resource_list.push_back(resource);
+  frame_data->render_pass_list.push_back(std::move(pass));
+  CompositorFrame frame;
+  frame.delegated_frame_data = std::move(frame_data);
   factory.SubmitCompositorFrame(local_frame_id, std::move(frame),
                                 SurfaceFactory::DrawCallback());
 
   CompositorFrame returned_frame = aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory,
                                      surface_id);
@@ skipping 69 matching lines @@
                                      middle_surface_id);
 
   ResourceId ids3[] = {20, 21, 22};
   SubmitCompositorFrameWithResources(ids3, arraysize(ids3), true,
                                      middle_surface_id, &factory,
                                      root_surface_id);
 
   CompositorFrame frame;
   frame = aggregator_->Aggregate(root_surface_id);
 
-  RenderPassList* pass_list = &frame.render_pass_list;
+  RenderPassList* pass_list = &frame.delegated_frame_data->render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(1u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(3u, pass_list->back()->quad_list.size());
   SubmitCompositorFrameWithResources(ids2, arraysize(ids), true,
                                      child_surface_id, &factory,
                                      middle_surface_id);
 
   frame = aggregator_->Aggregate(root_surface_id);
 
-  pass_list = &frame.render_pass_list;
+  pass_list = &frame.delegated_frame_data->render_pass_list;
   ASSERT_EQ(1u, pass_list->size());
   EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size());
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_local_frame_id);
   factory.Destroy(child_local_frame_id);
   factory.Destroy(middle_local_frame_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(kArbitraryFrameSinkId, &manager_, &client);
   LocalFrameId local_frame1_id(7u, base::UnguessableToken::Create());
   SurfaceId surface1_id(kArbitraryFrameSinkId, local_frame1_id);
   factory.Create(local_frame1_id);
 
   LocalFrameId local_frame2_id(8u, base::UnguessableToken::Create());
   SurfaceId surface2_id(kArbitraryFrameSinkId, local_frame2_id);
   factory.Create(local_frame2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
 
   CompositorFrame frame = aggregator_->Aggregate(surface1_id);
 
-  RenderPass* render_pass = frame.render_pass_list.back().get();
+  RenderPass* render_pass =
+      frame.delegated_frame_data->render_pass_list.back().get();
 
   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, render_pass->quad_list.back()->material);
 
   {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     std::unique_ptr<RenderPass> pass = RenderPass::Create();
     pass->id = RenderPassId(1, 1);
     SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
     sqs->opacity = 1.f;
     SurfaceDrawQuad* surface_quad =
         pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
     surface_quad->SetNew(sqs, gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1),
                          surface1_id);
     pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
+    frame_data->render_pass_list.push_back(std::move(pass));
     CompositorFrame frame;
-    frame.render_pass_list.push_back(std::move(pass));
-
+    frame.delegated_frame_data = std::move(frame_data);
     factory.SubmitCompositorFrame(local_frame2_id, std::move(frame),
                                   SurfaceFactory::DrawCallback());
   }
 
   frame = aggregator_->Aggregate(surface2_id);
-  EXPECT_EQ(1u, frame.render_pass_list.size());
-  render_pass = frame.render_pass_list.front().get();
+  EXPECT_EQ(1u, frame.delegated_frame_data->render_pass_list.size());
+  render_pass = frame.delegated_frame_data->render_pass_list.front().get();
 
   // Parent has copy request, so texture should not be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   frame = aggregator_->Aggregate(surface2_id);
-  EXPECT_EQ(1u, frame.render_pass_list.size());
-  render_pass = frame.render_pass_list.front().get();
+  EXPECT_EQ(1u, frame.delegated_frame_data->render_pass_list.size());
+  render_pass = frame.delegated_frame_data->render_pass_list.front().get();
 
   // Copy request has been executed earlier, so texture should be drawn.
   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT,
             render_pass->quad_list.front()->material);
 
   aggregator_->set_output_is_secure(false);
 
   frame = aggregator_->Aggregate(surface2_id);
-  render_pass = frame.render_pass_list.back().get();
+  render_pass = frame.delegated_frame_data->render_pass_list.back().get();
 
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   factory.Destroy(local_frame1_id);
   factory.Destroy(local_frame2_id);
 }
 
 }  // namespace
 }  // namespace cc