viz: Introduce AggregatedFrame to reduce information leaking from CompositorFrame.

This patch adds AggregatedFrame as a return value of
SurfaceAggregator::Aggregate. The reason for this is twofold:
1. It type checks the usage and ensures that we only forward the
   minimum set of things that we populate (one field for example
   was used although never initialized by anything except the ctor).
2. It allows us to separate CompositorFrame::render_pass_list from
   AggregatedFrame::render_pass_list with hopes of (in the future) type
   checking that RenderPassId post aggregation is remapped into a
   global space, whereas RenderPassId in CompositorFrame is local
   to the associated SurfaceId.

R=kylechar@chromium.org, weiliangc@chromium.org
Bug: 1106418

Change-Id: Ie6728d010c2f15171fc74616f064446df752f16f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2302710Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: weiliangc <weiliangc@chromium.org>
Commit-Queue: vmpstr <vmpstr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789479}

components/viz/common/BUILD.gn

@@ -240,6 +240,8 @@ viz_component("common") {
     "resources/transferable_resource.h",
     "skia_helper.cc",
     "skia_helper.h",
+    "surfaces/aggregated_frame.cc",
+    "surfaces/aggregated_frame.h",
     "surfaces/child_local_surface_id_allocator.cc",
     "surfaces/child_local_surface_id_allocator.h",
     "surfaces/frame_sink_id.cc",

components/viz/common/quads/compositor_frame_metadata.h

@@ -7,7 +7,9 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
+
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "build/build_config.h"

components/viz/common/surfaces/DEPS

@@ -2,4 +2,5 @@
 
 include_rules = [
   "+mojo/public/cpp/bindings",
+  "+ui/latency/latency_info.h",
 ]

components/viz/common/surfaces/aggregated_frame.cc

+// Copyright 2020 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 "components/viz/common/surfaces/aggregated_frame.h"
+
+namespace viz {
+
+AggregatedFrame::AggregatedFrame() = default;
+AggregatedFrame::AggregatedFrame(AggregatedFrame&& other) = default;
+AggregatedFrame::~AggregatedFrame() = default;
+
+AggregatedFrame& AggregatedFrame::operator=(AggregatedFrame&& other) = default;
+
+}  // namespace viz

components/viz/common/surfaces/aggregated_frame.h

+// Copyright 2020 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.
+
+#ifndef COMPONENTS_VIZ_COMMON_SURFACES_AGGREGATED_FRAME_H_
+#define COMPONENTS_VIZ_COMMON_SURFACES_AGGREGATED_FRAME_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/optional.h"
+#include "components/viz/common/delegated_ink_metadata.h"
+#include "components/viz/common/quads/render_pass.h"
+#include "components/viz/common/viz_common_export.h"
+#include "ui/gfx/display_color_spaces.h"
+#include "ui/latency/latency_info.h"
+
+namespace viz {
+
+class VIZ_COMMON_EXPORT AggregatedFrame {
+ public:
+  AggregatedFrame();
+  AggregatedFrame(AggregatedFrame&& other);
+  ~AggregatedFrame();
+
+  AggregatedFrame& operator=(AggregatedFrame&& other);
+
+  // The visible height of the top-controls. If the value is not set, then the
+  // visible height should be the same as in the latest submitted frame with a
+  // value set.
+  base::Optional<float> top_controls_visible_height;
+
+  // A list of latency info used for this frame.
+  std::vector<ui::LatencyInfo> latency_info;
+
+  // Indicates the content color usage for this frame.
+  gfx::ContentColorUsage content_color_usage = gfx::ContentColorUsage::kSRGB;
+
+  // Indicates whether any render passes have a copy output request.
+  bool has_copy_requests = false;
+
+  // Indicates whether this frame may contain video.
+  bool may_contain_video = false;
+
+  // Contains the metadata required for drawing a delegated ink trail onto the
+  // end of a rendered ink stroke. This should only be present when two
+  // conditions are met:
+  //   1. The JS API |updateInkTrailStartPoint| is used - This gathers the
+  //     metadata and puts it onto a compositor frame to be sent to viz.
+  //   2. This frame will not be submitted to the root surface - The browser UI
+  //     does not use this, and the frame must be contained within a
+  //     SurfaceDrawQuad.
+  // The ink trail created with this metadata will only last for a single frame
+  // before it disappears, regardless of whether or not the next frame contains
+  // delegated ink metadata.
+  std::unique_ptr<DelegatedInkMetadata> delegated_ink_metadata;
+
+  RenderPassList render_pass_list;
+};
+
+}  // namespace viz
+
+#endif  // COMPONENTS_VIZ_COMMON_SURFACES_AGGREGATED_FRAME_H_

components/viz/service/display/damage_frame_annotator.cc

@@ -8,17 +8,17 @@
 #include <utility>
 
 #include "cc/base/math_util.h"
-#include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/common/quads/debug_border_draw_quad.h"
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/shared_quad_state.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 
 namespace viz {
 
 DamageFrameAnnotator::DamageFrameAnnotator() = default;
 DamageFrameAnnotator::~DamageFrameAnnotator() = default;
 
-void DamageFrameAnnotator::AnnotateAggregatedFrame(CompositorFrame* frame) {
+void DamageFrameAnnotator::AnnotateAggregatedFrame(AggregatedFrame* frame) {
   DCHECK(frame);
   auto* root_render_pass = frame->render_pass_list.back().get();
 

components/viz/service/display/damage_frame_annotator.h

@@ -14,7 +14,7 @@
 
 namespace viz {
 
-class CompositorFrame;
+class AggregatedFrame;
 class RenderPass;
 
 // Draws a red outline around the root RenderPasses damage rect.
@@ -24,7 +24,7 @@ class DamageFrameAnnotator : public SurfaceAggregator::FrameAnnotator {
   ~DamageFrameAnnotator() override;
 
   // SurfaceAggregator::FrameAnnotator implementation.
-  void AnnotateAggregatedFrame(CompositorFrame* frame) override;
+  void AnnotateAggregatedFrame(AggregatedFrame* frame) override;
 
  private:
   struct Highlight {

components/viz/service/display/display.cc

@@ -25,6 +25,7 @@
 #include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/common/quads/draw_quad.h"
 #include "components/viz/common/quads/shared_quad_state.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/common/viz_utils.h"
 #include "components/viz/service/display/damage_frame_annotator.h"
 #include "components/viz/service/display/direct_renderer.h"
@@ -642,7 +643,7 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
 
   base::ElapsedTimer aggregate_timer;
   aggregate_timer.Begin();
-  CompositorFrame frame;
+  AggregatedFrame frame;
   {
     FrameRateDecider::ScopedAggregate scoped_aggregate(
         frame_rate_decider_.get());
@@ -659,24 +660,24 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
   // TODO(vikassoni) : Extend this capability to record whether a video frame is
   // inline or fullscreen.
   UMA_HISTOGRAM_ENUMERATION("Compositing.SurfaceAggregator.FrameContainsVideo",
-                            frame.metadata.may_contain_video
+                            frame.may_contain_video
                                 ? TypeOfVideoInFrame::kVideo
                                 : TypeOfVideoInFrame::kNoVideo);
 
-  if (frame.metadata.delegated_ink_metadata) {
+  if (frame.delegated_ink_metadata) {
     TRACE_EVENT_INSTANT1(
         "viz", "Delegated Ink Metadata was aggregated for DrawAndSwap.",
         TRACE_EVENT_SCOPE_THREAD, "ink metadata",
-        frame.metadata.delegated_ink_metadata->ToString());
+        frame.delegated_ink_metadata->ToString());
     // TODO(1052145): This metadata will be stored here and used to determine
     // which points should be drawn onto the back buffer (via Skia or OS APIs)
     // before being swapped onto the screen.
   }
 
 #if defined(OS_ANDROID)
-  bool wide_color_enabled = display_color_spaces_.GetOutputColorSpace(
-                                frame.metadata.content_color_usage, true) !=
-                            gfx::ColorSpace::CreateSRGB();
+  bool wide_color_enabled =
+      display_color_spaces_.GetOutputColorSpace(
+          frame.content_color_usage, true) != gfx::ColorSpace::CreateSRGB();
   if (wide_color_enabled != last_wide_color_enabled_) {
     client_->SetWideColorEnabled(wide_color_enabled);
     last_wide_color_enabled_ = wide_color_enabled;
@@ -698,13 +699,11 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
   // Run callbacks early to allow pipelining and collect presented callbacks.
   damage_tracker_->RunDrawCallbacks();
 
-  frame.metadata.latency_info.insert(frame.metadata.latency_info.end(),
-                                     stored_latency_info_.begin(),
-                                     stored_latency_info_.end());
+  frame.latency_info.insert(frame.latency_info.end(),
+                            stored_latency_info_.begin(),
+                            stored_latency_info_.end());
   stored_latency_info_.clear();
-  bool have_copy_requests = false;
-  for (const auto& pass : frame.render_pass_list)
-    have_copy_requests |= !pass->copy_requests.empty();
+  bool have_copy_requests = frame.has_copy_requests;
 
   gfx::Size surface_size;
   bool have_damage = false;
@@ -749,8 +748,14 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
         "Compositing.Display.Draw.Occlusion.Calculation.Time",
         draw_occlusion_timer.Elapsed().InMicroseconds());
 
-    bool disable_image_filtering =
-        frame.metadata.is_resourceless_software_draw_with_scroll_or_animation;
+    // TODO(vmpstr): This used to set to
+    // frame.metadata.is_resourceless_software_draw_with_scroll_or_animation
+    // from CompositedFrame. However, after changing this to AggregatedFrame, it
+    // seems that the value is never changed from the default false (i.e.
+    // SurfaceAggregator has no reference to
+    // is_resourceless_software_draw_with_scroll_or_animation). The TODO here is
+    // to clean up the code below or to figure out if this value is important.
+    bool disable_image_filtering = false;
     if (software_renderer_) {
       software_renderer_->SetDisablePictureQuadImageFiltering(
           disable_image_filtering);
@@ -806,18 +811,17 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
     swapped_since_resize_ = true;
 
     ui::LatencyInfo::TraceIntermediateFlowEvents(
-        frame.metadata.latency_info,
+        frame.latency_info,
         perfetto::protos::pbzero::ChromeLatencyInfo::STEP_DRAW_AND_SWAP);
 
     cc::benchmark_instrumentation::IssueDisplayRenderingStatsEvent();
     DirectRenderer::SwapFrameData swap_frame_data;
-    swap_frame_data.latency_info = std::move(frame.metadata.latency_info);
-    if (frame.metadata.top_controls_visible_height.has_value()) {
+    swap_frame_data.latency_info = std::move(frame.latency_info);
+    if (frame.top_controls_visible_height.has_value()) {
       swap_frame_data.top_controls_visible_height_changed =
           last_top_controls_visible_height_ !=
-          *frame.metadata.top_controls_visible_height;
-      last_top_controls_visible_height_ =
-          *frame.metadata.top_controls_visible_height;
+          *frame.top_controls_visible_height;
+      last_top_controls_visible_height_ = *frame.top_controls_visible_height;
     }
 
     // We must notify scheduler and increase |pending_swaps_| before calling
@@ -835,16 +839,15 @@ bool Display::DrawAndSwap(base::TimeTicks expected_display_time) {
 
     if (have_damage) {
       // Do not store more than the allowed size.
-      if (ui::LatencyInfo::Verify(frame.metadata.latency_info,
-                                  "Display::DrawAndSwap")) {
-        stored_latency_info_.swap(frame.metadata.latency_info);
+      if (ui::LatencyInfo::Verify(frame.latency_info, "Display::DrawAndSwap")) {
+        stored_latency_info_.swap(frame.latency_info);
       }
     } else {
       // There was no damage. Terminate the latency info objects.
-      while (!frame.metadata.latency_info.empty()) {
-        auto& latency = frame.metadata.latency_info.back();
+      while (!frame.latency_info.empty()) {
+        auto& latency = frame.latency_info.back();
         latency.Terminate();
-        frame.metadata.latency_info.pop_back();
+        frame.latency_info.pop_back();
       }
     }
 
@@ -1018,7 +1021,7 @@ void Display::SetNeedsOneBeginFrame() {
     scheduler_->SetNeedsOneBeginFrame(false);
 }
 
-void Display::RemoveOverdrawQuads(CompositorFrame* frame) {
+void Display::RemoveOverdrawQuads(AggregatedFrame* frame) {
   if (frame->render_pass_list.empty())
     return;
 

components/viz/service/display/display.h

@@ -45,6 +45,7 @@ class ScopedAllowScheduleGpuTask;
 }
 
 namespace viz {
+class AggregatedFrame;
 class DirectRenderer;
 class DisplayClient;
 class DisplayResourceProvider;
@@ -173,7 +174,7 @@ class VIZ_SERVICE_EXPORT Display : public DisplaySchedulerClient,
 
   void ForceImmediateDrawAndSwapIfPossible();
   void SetNeedsOneBeginFrame();
-  void RemoveOverdrawQuads(CompositorFrame* frame);
+  void RemoveOverdrawQuads(AggregatedFrame* frame);
 
   void SetSupportedFrameIntervals(std::vector<base::TimeDelta> intervals);
 

components/viz/service/display/display_perftest.cc

@@ -13,6 +13,7 @@
 #include "components/viz/common/quads/draw_quad.h"
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/texture_draw_quad.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/common/surfaces/frame_sink_id.h"
 #include "components/viz/service/display/display.h"
 #include "components/viz/service/display/display_scheduler.h"
@@ -151,7 +152,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
     auto reporter = SetUpRemoveOverdrawQuadReporter(story);
     reporter.AddResult(kMetricOverlapThroughputRunsPerS,
                        timer_.LapsPerSecond());
-    frame_ = CompositorFrame();
+    frame_ = AggregatedFrame{};
   }
 
   void CreateOverlapShareQuadStates(int shared_quad_state_count,
@@ -191,7 +192,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
     auto reporter = SetUpRemoveOverdrawQuadReporter(story);
     reporter.AddResult(kMetricIsolatedThroughputRunsPerS,
                        timer_.LapsPerSecond());
-    frame_ = CompositorFrame();
+    frame_ = AggregatedFrame{};
   }
 
   void CreateIsolatedSharedQuadStates(int shared_quad_state_count,
@@ -240,7 +241,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
     auto reporter = SetUpRemoveOverdrawQuadReporter(story);
     reporter.AddResult(kMetricPartialOverlapThroughputRunsPerS,
                        timer_.LapsPerSecond());
-    frame_ = CompositorFrame();
+    frame_ = AggregatedFrame{};
   }
 
   void CreatePartiallyOverlapSharedQuadStates(int shared_quad_state_count,
@@ -287,7 +288,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
     auto reporter = SetUpRemoveOverdrawQuadReporter(story);
     reporter.AddResult(kMetricAdjacentThroughputRunsPerS,
                        timer_.LapsPerSecond());
-    frame_ = CompositorFrame();
+    frame_ = AggregatedFrame{};
   }
 
   void CreateAdjacentSharedQuadStates(int shared_quad_state_count,
@@ -313,7 +314,7 @@ class RemoveOverdrawQuadPerfTest : public testing::Test {
 
  private:
   DebugRendererSettings debug_settings_;
-  CompositorFrame frame_;
+  AggregatedFrame frame_;
   base::LapTimer timer_;
   StubBeginFrameSource begin_frame_source_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;

components/viz/service/display/surface_aggregator.cc

@@ -28,6 +28,7 @@
 #include "components/viz/common/quads/solid_color_draw_quad.h"
 #include "components/viz/common/quads/surface_draw_quad.h"
 #include "components/viz/common/quads/texture_draw_quad.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/common/surfaces/surface_range.h"
 #include "components/viz/service/display/display_resource_provider.h"
 #include "components/viz/service/display/renderer_utils.h"
@@ -1629,7 +1630,7 @@ bool SurfaceAggregator::CanMergeRoundedCorner(
   return true;
 }
 
-CompositorFrame SurfaceAggregator::Aggregate(
+AggregatedFrame SurfaceAggregator::Aggregate(
     const SurfaceId& surface_id,
     base::TimeTicks expected_display_time,
     gfx::OverlayTransform display_transform,
@@ -1660,9 +1661,8 @@ CompositorFrame SurfaceAggregator::Aggregate(
       TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT, "step",
       "SurfaceAggregation", "display_trace", display_trace_id_);
 
-  CompositorFrame frame;
-  frame.metadata.display_transform_hint = display_transform;
-  frame.metadata.top_controls_visible_height =
+  AggregatedFrame frame;
+  frame.top_controls_visible_height =
       root_surface_frame.metadata.top_controls_visible_height;
 
   dest_pass_list_ = &frame.render_pass_list;
@@ -1696,8 +1696,9 @@ CompositorFrame SurfaceAggregator::Aggregate(
 
   PropagateCopyRequestPasses();
   has_copy_requests_ = !copy_request_passes_.empty();
-  frame.metadata.may_contain_video = prewalk_result.may_contain_video;
-  frame.metadata.content_color_usage = prewalk_result.content_color_usage;
+  frame.has_copy_requests = has_copy_requests_;
+  frame.may_contain_video = prewalk_result.may_contain_video;
+  frame.content_color_usage = prewalk_result.content_color_usage;
 
   CopyUndrawnSurfaces(&prewalk_result);
   referenced_surfaces_.insert(surface_id);
@@ -1743,15 +1744,15 @@ CompositorFrame SurfaceAggregator::Aggregate(
     Surface* surface = manager_->GetSurfaceForId(it.first);
     if (surface) {
       surface->allocation_group()->TakeAggregatedLatencyInfoUpTo(
-          surface, &frame.metadata.latency_info);
+          surface, &frame.latency_info);
     }
-    if (!ui::LatencyInfo::Verify(frame.metadata.latency_info,
+    if (!ui::LatencyInfo::Verify(frame.latency_info,
                                  "SurfaceAggregator::Aggregate")) {
       break;
     }
   }
 
-  frame.metadata.delegated_ink_metadata = std::move(delegated_ink_metadata_);
+  frame.delegated_ink_metadata = std::move(delegated_ink_metadata_);
 
   if (frame_annotator_)
     frame_annotator_->AnnotateAggregatedFrame(&frame);

components/viz/service/display/surface_aggregator.h

@@ -27,6 +27,7 @@
 #include "ui/gfx/overlay_transform.h"
 
 namespace viz {
+class AggregatedFrame;
 class CompositorFrame;
 class DisplayResourceProvider;
 class Surface;
@@ -45,7 +46,7 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
    public:
     virtual ~FrameAnnotator() = default;
 
-    virtual void AnnotateAggregatedFrame(CompositorFrame* frame) = 0;
+    virtual void AnnotateAggregatedFrame(AggregatedFrame* frame) = 0;
   };
 
   SurfaceAggregator(SurfaceManager* manager,
@@ -58,7 +59,7 @@ class VIZ_SERVICE_EXPORT SurfaceAggregator {
   // been invalidated. It can be used in cases where we still want to support
   // partial damage but the target surface might need contents outside the
   // damage rect of the root surface.
-  CompositorFrame Aggregate(const SurfaceId& surface_id,
+  AggregatedFrame Aggregate(const SurfaceId& surface_id,
                             base::TimeTicks expected_display_time,
                             gfx::OverlayTransform display_transform,
                             const gfx::Rect& target_damage = gfx::Rect(),

components/viz/service/display/surface_aggregator_perftest.cc

@@ -8,6 +8,7 @@
 #include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/common/quads/surface_draw_quad.h"
 #include "components/viz/common/quads/texture_draw_quad.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/service/display/display_resource_provider.h"
 #include "components/viz/service/display/surface_aggregator.h"
 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
@@ -149,7 +150,7 @@ class SurfaceAggregatorPerfTest : public testing::Test {
       root_support->SubmitCompositorFrame(
           LocalSurfaceId(num_surfaces + 1, root_token), std::move(frame));
 
-      CompositorFrame aggregated = aggregator_->Aggregate(
+      auto aggregated = aggregator_->Aggregate(
           SurfaceId(FrameSinkId(1, num_surfaces + 1),
                     LocalSurfaceId(num_surfaces + 1, root_token)),
           next_fake_display_time, gfx::OVERLAY_TRANSFORM_NONE);

components/viz/service/display/surface_aggregator_pixeltest.cc

@@ -11,6 +11,7 @@
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/quads/solid_color_draw_quad.h"
 #include "components/viz/common/quads/surface_draw_quad.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
 #include "components/viz/service/display/surface_aggregator.h"
 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
@@ -122,7 +123,7 @@ TYPED_TEST(SurfaceAggregatorPixelTest, DrawSimpleFrame) {
 
   SurfaceAggregator aggregator(this->manager_.surface_manager(),
                                this->resource_provider_.get(), true, false);
-  CompositorFrame aggregated_frame = aggregator.Aggregate(
+  auto aggregated_frame = aggregator.Aggregate(
       root_surface_id, this->GetNextDisplayTime(), gfx::OVERLAY_TRANSFORM_NONE);
 
   bool discard_alpha = false;
@@ -202,7 +203,7 @@ TYPED_TEST(SurfaceAggregatorPixelTest, DrawSimpleAggregatedFrame) {
 
   SurfaceAggregator aggregator(this->manager_.surface_manager(),
                                this->resource_provider_.get(), true, false);
-  CompositorFrame aggregated_frame = aggregator.Aggregate(
+  auto aggregated_frame = aggregator.Aggregate(
       root_surface_id, this->GetNextDisplayTime(), gfx::OVERLAY_TRANSFORM_NONE);
 
   bool discard_alpha = false;
@@ -340,7 +341,7 @@ TYPED_TEST(SurfaceAggregatorPixelTest,
 
   SurfaceAggregator aggregator(this->manager_.surface_manager(),
                                this->resource_provider_.get(), true, false);
-  CompositorFrame aggregated_frame = aggregator.Aggregate(
+  auto aggregated_frame = aggregator.Aggregate(
       root_surface_id, this->GetNextDisplayTime(), gfx::OVERLAY_TRANSFORM_NONE);
 
   bool discard_alpha = false;

components/viz/test/compositor_frame_helpers.cc

@@ -4,6 +4,9 @@
 
 #include "components/viz/test/compositor_frame_helpers.h"
 
+#include <memory>
+#include <utility>
+
 namespace viz {
 namespace {
 
@@ -136,6 +139,13 @@ CompositorFrame MakeDefaultCompositorFrame() {
   return CompositorFrameBuilder().AddDefaultRenderPass().Build();
 }
 
+AggregatedFrame MakeDefaultAggregatedFrame() {
+  AggregatedFrame frame;
+  frame.render_pass_list =
+      std::move(MakeDefaultCompositorFrame().render_pass_list);
+  return frame;
+}
+
 CompositorFrame MakeEmptyCompositorFrame() {
   return CompositorFrameBuilder().Build();
 }

components/viz/test/compositor_frame_helpers.h

@@ -5,6 +5,7 @@
 #ifndef COMPONENTS_VIZ_TEST_COMPOSITOR_FRAME_HELPERS_H_
 #define COMPONENTS_VIZ_TEST_COMPOSITOR_FRAME_HELPERS_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/optional.h"
@@ -12,6 +13,7 @@
 #include "components/viz/common/quads/frame_deadline.h"
 #include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/resources/transferable_resource.h"
+#include "components/viz/common/surfaces/aggregated_frame.h"
 #include "components/viz/common/surfaces/surface_id.h"
 #include "ui/latency/latency_info.h"
 
@@ -73,6 +75,9 @@ class CompositorFrameBuilder {
 // empty damage_rect. This CompositorFrame is valid and can be sent over IPC.
 CompositorFrame MakeDefaultCompositorFrame();
 
+// Makes an aggregated frame out of the default compositor frame.
+AggregatedFrame MakeDefaultAggregatedFrame();
+
 // Creates a CompositorFrame that will be valid once its render_pass_list is
 // initialized.
 CompositorFrame MakeEmptyCompositorFrame();