Revert of Make cc::CompositorFrames movable [Part 2 of 2]

cc/surfaces/surface_aggregator_unittest.cc

Index: cc/surfaces/surface_aggregator_unittest.cc
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index 6e633263647547ce40d817f226bf2fc668686abc..2ce40f14332da261bbd5adcaf6c1883e6d758c55 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -81,8 +81,8 @@
   SurfaceId one_id(0, 7, 0);
   factory_.Create(one_id);
 
-  CompositorFrame frame = aggregator_.Aggregate(one_id);
-  EXPECT_FALSE(frame.delegated_frame_data);
+  std::unique_ptr<CompositorFrame> frame = aggregator_.Aggregate(one_id);
+  EXPECT_FALSE(frame);
 
   factory_.Destroy(one_id);
 }
@@ -112,12 +112,14 @@
                           size_t expected_pass_count,
                           SurfaceId* surface_ids,
                           size_t expected_surface_count) {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     TestPassesMatchExpectations(
         expected_passes, expected_pass_count, &frame_data->render_pass_list);
@@ -141,8 +143,8 @@
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
-    CompositorFrame frame;
-    frame.delegated_frame_data = std::move(frame_data);
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
@@ -162,8 +164,8 @@
         new DelegatedFrameData);
     delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
-    CompositorFrame child_frame;
-    child_frame.delegated_frame_data = std::move(delegated_frame_data);
+    std::unique_ptr<CompositorFrame> child_frame(new CompositorFrame);
+    child_frame->delegated_frame_data = std::move(delegated_frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
@@ -211,11 +213,13 @@
 
   SubmitCompositorFrame(passes, arraysize(passes), root_surface_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();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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());
@@ -305,11 +309,13 @@
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_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();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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),
@@ -375,18 +381,20 @@
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list.swap(frame_data->render_pass_list);
 
-    CompositorFrame frame;
-    frame.delegated_frame_data = std::move(frame_data);
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(root_surface_id_, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
-  CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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),
@@ -415,10 +423,10 @@
   }
 
   // Ensure copy requests have been removed from root surface.
-  const CompositorFrame& original_frame =
+  const CompositorFrame* original_frame =
       manager_.GetSurfaceForId(root_surface_id_)->GetEligibleFrame();
   RenderPassList& original_pass_list =
-      original_frame.delegated_frame_data->render_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());
@@ -457,9 +465,9 @@
     AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
               parent_passes, arraysize(parent_passes));
 
-    CompositorFrame frame;
-    frame.delegated_frame_data = std::move(frame_data);
-    frame.metadata.referenced_surfaces.push_back(embedded_surface_id);
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
+    frame->metadata.referenced_surfaces.push_back(embedded_surface_id);
 
     factory_.SubmitCompositorFrame(parent_surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
@@ -474,22 +482,24 @@
     AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),
               root_passes, arraysize(root_passes));
 
-    CompositorFrame frame;
-    frame.delegated_frame_data = std::move(frame_data);
-    frame.metadata.referenced_surfaces.push_back(parent_surface_id);
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    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);
+    frame->metadata.referenced_surfaces.push_back(nonexistent_surface_id);
 
     factory_.SubmitCompositorFrame(root_surface_id_, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
-  CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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.
@@ -551,11 +561,13 @@
 
   SubmitCompositorFrame(root_passes, arraysize(root_passes), root_surface_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();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -785,11 +797,13 @@
   SubmitCompositorFrame(parent_passes, arraysize(parent_passes),
                         root_surface_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();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -946,11 +960,13 @@
 
   QueuePassAsFrame(std::move(root_pass), root_surface_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();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -1025,8 +1041,8 @@
         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);
+    std::unique_ptr<CompositorFrame> child_frame(new CompositorFrame);
+    child_frame->delegated_frame_data = std::move(child_frame_data);
 
     factory_.SubmitCompositorFrame(child_surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
@@ -1057,8 +1073,8 @@
         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);
+    std::unique_ptr<CompositorFrame> middle_frame(new CompositorFrame);
+    middle_frame->delegated_frame_data = std::move(middle_frame_data);
 
     factory_.SubmitCompositorFrame(middle_surface_id, std::move(middle_frame),
                                    SurfaceFactory::DrawCallback());
@@ -1093,17 +1109,19 @@
   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);
+  std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+  root_frame->delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
-  CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -1198,8 +1216,8 @@
   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);
+  std::unique_ptr<CompositorFrame> child_frame(new CompositorFrame);
+  child_frame->delegated_frame_data = std::move(child_frame_data);
 
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id);
@@ -1224,8 +1242,8 @@
       new DelegatedFrameData);
   parent_surface_pass_list.swap(parent_surface_frame_data->render_pass_list);
 
-  CompositorFrame parent_surface_frame;
-  parent_surface_frame.delegated_frame_data =
+  std::unique_ptr<CompositorFrame> parent_surface_frame(new CompositorFrame);
+  parent_surface_frame->delegated_frame_data =
       std::move(parent_surface_frame_data);
 
   SurfaceId parent_surface_id = allocator_.GenerateId();
@@ -1260,17 +1278,19 @@
   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);
+  std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+  root_frame->delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
-  CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -1296,18 +1316,20 @@
         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);
+    std::unique_ptr<CompositorFrame> child_frame(new CompositorFrame);
+    child_frame->delegated_frame_data = std::move(child_frame_data);
 
     factory_.SubmitCompositorFrame(child_surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
 
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1334,8 +1356,8 @@
     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);
+    std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+    root_frame->delegated_frame_data = std::move(root_frame_data);
 
     factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
@@ -1356,18 +1378,20 @@
     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);
+    std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+    root_frame->delegated_frame_data = std::move(root_frame_data);
 
     factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                    SurfaceFactory::DrawCallback());
 
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1381,12 +1405,14 @@
 
   // No Surface changed, so no damage should be given.
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1399,12 +1425,14 @@
   // marked as damaged.
   {
     aggregator_.SetFullDamageForSurface(root_surface_id_);
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1435,19 +1463,21 @@
   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);
+  std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+  root_frame->delegated_frame_data = std::move(root_frame_data);
 
   factory_.SubmitCompositorFrame(root_surface_id_, std::move(root_frame),
                                  SurfaceFactory::DrawCallback());
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1475,8 +1505,8 @@
     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);
+    std::unique_ptr<CompositorFrame> root_frame(new CompositorFrame);
+    root_frame->delegated_frame_data = std::move(root_frame_data);
 
     factory_.Create(second_root_surface_id);
     factory_.SubmitCompositorFrame(second_root_surface_id,
@@ -1485,13 +1515,14 @@
     factory_.SetPreviousFrameSurface(second_root_surface_id, root_surface_id_);
   }
   {
-    CompositorFrame aggregated_frame =
+    std::unique_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(second_root_surface_id);
 
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1502,13 +1533,14 @@
     EXPECT_EQ(gfx::Rect(1, 2, 3, 4), aggregated_pass_list[0]->damage_rect);
   }
   {
-    CompositorFrame aggregated_frame =
+    std::unique_ptr<CompositorFrame> aggregated_frame =
         aggregator_.Aggregate(second_root_surface_id);
 
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1587,11 +1619,13 @@
     SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
   }
 
-  CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-  ASSERT_TRUE(aggregated_frame.delegated_frame_data);
-
-  DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();
+  std::unique_ptr<CompositorFrame> aggregated_frame =
+      aggregator_.Aggregate(root_surface_id_);
+
+  ASSERT_TRUE(aggregated_frame);
+  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;
 
@@ -1621,12 +1655,14 @@
   }
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1675,12 +1711,14 @@
   }
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1700,12 +1738,14 @@
   }
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        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
@@ -1741,12 +1781,14 @@
   }
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1791,12 +1833,14 @@
   }
 
   {
-    CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id_);
-
-    ASSERT_TRUE(aggregated_frame.delegated_frame_data);
+    std::unique_ptr<CompositorFrame> aggregated_frame =
+        aggregator_.Aggregate(root_surface_id_);
+
+    ASSERT_TRUE(aggregated_frame);
+    ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
-        aggregated_frame.delegated_frame_data.get();
+        aggregated_frame->delegated_frame_data.get();
 
     const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;
 
@@ -1907,8 +1951,8 @@
                  nearest_neighbor, secure_output_only);
   }
   frame_data->render_pass_list.push_back(std::move(pass));
-  CompositorFrame frame;
-  frame.delegated_frame_data = std::move(frame_data);
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+  frame->delegated_frame_data = std::move(frame_data);
   factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
@@ -1923,7 +1967,7 @@
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface_id);
 
-  CompositorFrame frame = aggregator_->Aggregate(surface_id);
+  std::unique_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
@@ -1959,12 +2003,13 @@
   resource.is_software = false;
   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);
+  std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+  frame->delegated_frame_data = std::move(frame_data);
   factory.SubmitCompositorFrame(surface_id, std::move(frame),
                                 SurfaceFactory::DrawCallback());
 
-  CompositorFrame returned_frame = aggregator_->Aggregate(surface_id);
+  std::unique_ptr<CompositorFrame> returned_frame =
+      aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
@@ -1993,7 +2038,7 @@
   SubmitCompositorFrameWithResources(ids2, arraysize(ids2), true, SurfaceId(),
                                      &factory, surface2_id);
 
-  CompositorFrame frame = aggregator_->Aggregate(surface1_id);
+  std::unique_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface1_id);
 
   SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory,
                                      surface1_id);
@@ -2042,10 +2087,10 @@
                                      middle_surface_id, &factory,
                                      root_surface_id);
 
-  CompositorFrame frame;
+  std::unique_ptr<CompositorFrame> frame;
   frame = aggregator_->Aggregate(root_surface_id);
 
-  RenderPassList* pass_list = &frame.delegated_frame_data->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());
@@ -2056,7 +2101,7 @@
 
   frame = aggregator_->Aggregate(root_surface_id);
 
-  pass_list = &frame.delegated_frame_data->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());
@@ -2079,10 +2124,10 @@
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
 
-  CompositorFrame frame = aggregator_->Aggregate(surface1_id);
+  std::unique_ptr<CompositorFrame> frame = aggregator_->Aggregate(surface1_id);
 
   RenderPass* render_pass =
-      frame.delegated_frame_data->render_pass_list.back().get();
+      frame->delegated_frame_data->render_pass_list.back().get();
 
   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, render_pass->quad_list.back()->material);
 
@@ -2099,22 +2144,22 @@
     pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
     frame_data->render_pass_list.push_back(std::move(pass));
-    CompositorFrame frame;
-    frame.delegated_frame_data = std::move(frame_data);
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
     factory.SubmitCompositorFrame(surface2_id, std::move(frame),
                                   SurfaceFactory::DrawCallback());
   }
 
   frame = aggregator_->Aggregate(surface2_id);
-  EXPECT_EQ(1u, frame.delegated_frame_data->render_pass_list.size());
-  render_pass = frame.delegated_frame_data->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.delegated_frame_data->render_pass_list.size());
-  render_pass = frame.delegated_frame_data->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,
@@ -2123,7 +2168,7 @@
   aggregator_->set_output_is_secure(false);
 
   frame = aggregator_->Aggregate(surface2_id);
-  render_pass = frame.delegated_frame_data->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);