Add CompositorFrameBuilder for tests.

Add a class that helps build valid CompostiorFrames for tests. Also
convert some tests to use the builder and update existing helper
functions.

Bug: 758707
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel
Change-Id: I293ef25799d2db398e905f34e5eb0650a3525677
Reviewed-on: https://chromium-review.googlesource.com/796931Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Reviewed-by: Bo <boliu@chromium.org>
Reviewed-by: Fady Samuel <fsamuel@chromium.org>
Commit-Queue: kylechar <kylechar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521774}

android_webview/browser/test/rendering_test.cc

@@ -118,13 +118,9 @@ content::SynchronousCompositor* RenderingTest::ActiveCompositor() const {
 }
 
 std::unique_ptr<viz::CompositorFrame> RenderingTest::ConstructEmptyFrame() {
-  auto compositor_frame = std::make_unique<viz::CompositorFrame>(
-      viz::test::MakeEmptyCompositorFrame());
-  std::unique_ptr<viz::RenderPass> root_pass(viz::RenderPass::Create());
   gfx::Rect viewport(browser_view_renderer_->size());
-  root_pass->SetNew(1, viewport, viewport, gfx::Transform());
-  compositor_frame->render_pass_list.push_back(std::move(root_pass));
-  return compositor_frame;
+  return std::make_unique<viz::CompositorFrame>(
+      viz::CompositorFrameBuilder().AddRenderPass(viewport, viewport).Build());
 }
 
 std::unique_ptr<viz::CompositorFrame> RenderingTest::ConstructFrame(

components/viz/host/host_frame_sink_manager_unittest.cc

@@ -257,10 +257,11 @@ TEST_F(HostFrameSinkManagerLocalTest, CommunicateFrameToken) {
   auto support =
       CreateCompositorFrameSinkSupport(kParentFrameSink, true /* is_root */);
 
-  CompositorFrame compositor_frame(
-      test::MakeCompositorFrame({child_id1}, std::vector<SurfaceId>(),
-                                std::vector<TransferableResource>()));
-  compositor_frame.metadata.frame_token = frame_token1;
+  CompositorFrame compositor_frame = CompositorFrameBuilder()
+                                         .AddDefaultRenderPass()
+                                         .SetFrameToken(frame_token1)
+                                         .SetActivationDependencies({child_id1})
+                                         .Build();
   support->SubmitCompositorFrame(parent_id1.local_surface_id(),
                                  std::move(compositor_frame));
 

components/viz/service/display/surface_aggregator_perftest.cc

@@ -62,14 +62,14 @@ class SurfaceAggregatorPerfTest : public testing::Test {
       auto pass = RenderPass::Create();
       pass->output_rect = gfx::Rect(0, 0, 1, 2);
 
-      CompositorFrame frame = test::MakeEmptyCompositorFrame();
+      CompositorFrameBuilder frame_builder;
 
       auto* sqs = pass->CreateAndAppendSharedQuadState();
       for (int j = 0; j < num_textures; j++) {
         TransferableResource resource;
         resource.id = j;
         resource.is_software = true;
-        frame.resource_list.push_back(resource);
+        frame_builder.AddTransferableResource(resource);
 
         auto* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
         const gfx::Rect rect(0, 0, 1, 2);
@@ -99,9 +99,9 @@ class SurfaceAggregatorPerfTest : public testing::Test {
             base::nullopt, SK_ColorWHITE, false);
       }
 
-      frame.render_pass_list.push_back(std::move(pass));
+      frame_builder.AddRenderPass(std::move(pass));
       child_supports[i]->SubmitCompositorFrame(local_surface_id,
-                                               std::move(frame));
+                                               frame_builder.Build());
     }
 
     auto root_support = CompositorFrameSinkSupport::Create(
@@ -110,7 +110,6 @@ class SurfaceAggregatorPerfTest : public testing::Test {
     timer_.Reset();
     do {
       auto pass = RenderPass::Create();
-      CompositorFrame frame = test::MakeEmptyCompositorFrame();
 
       auto* sqs = pass->CreateAndAppendSharedQuadState();
       auto* surface_quad = pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
@@ -127,7 +126,8 @@ class SurfaceAggregatorPerfTest : public testing::Test {
       else
         pass->damage_rect = gfx::Rect(0, 0, 1, 1);
 
-      frame.render_pass_list.push_back(std::move(pass));
+      CompositorFrame frame =
+          CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
       root_support->SubmitCompositorFrame(
           LocalSurfaceId(num_surfaces + 1, kArbitraryToken), std::move(frame));

components/viz/service/display/surface_aggregator_pixeltest.cc

@@ -79,8 +79,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawSimpleFrame) {
   color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
                      SK_ColorGREEN, force_anti_aliasing_off);
 
-  auto root_frame = test::MakeCompositorFrame();
-  root_frame.render_pass_list.push_back(std::move(pass));
+  auto root_frame =
+      CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
   LocalSurfaceId root_local_surface_id = allocator_.GenerateId();
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id);
@@ -131,8 +131,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawSimpleAggregatedFrame) {
     color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
                        SK_ColorYELLOW, force_anti_aliasing_off);
 
-    auto root_frame = test::MakeCompositorFrame();
-    root_frame.render_pass_list.push_back(std::move(pass));
+    auto root_frame =
+        CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
     support_->SubmitCompositorFrame(root_local_surface_id,
                                     std::move(root_frame));
@@ -152,8 +152,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawSimpleAggregatedFrame) {
     color_quad->SetNew(pass->shared_quad_state_list.back(), rect, rect,
                        SK_ColorBLUE, force_anti_aliasing_off);
 
-    auto child_frame = test::MakeCompositorFrame();
-    child_frame.render_pass_list.push_back(std::move(pass));
+    auto child_frame =
+        CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
     child_support->SubmitCompositorFrame(child_local_surface_id,
                                          std::move(child_frame));
@@ -226,8 +226,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
                                right_child_id, base::nullopt, SK_ColorWHITE,
                                false);
 
-    auto root_frame = test::MakeCompositorFrame();
-    root_frame.render_pass_list.push_back(std::move(pass));
+    auto root_frame =
+        CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
     support_->SubmitCompositorFrame(root_local_surface_id,
                                     std::move(root_frame));
@@ -254,8 +254,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
         pass->shared_quad_state_list.back(), gfx::Rect(0, 100, 100, 100),
         gfx::Rect(0, 100, 100, 100), SK_ColorBLUE, force_anti_aliasing_off);
 
-    auto child_frame = test::MakeCompositorFrame();
-    child_frame.render_pass_list.push_back(std::move(pass));
+    auto child_frame =
+        CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
     left_support->SubmitCompositorFrame(left_child_local_id,
                                         std::move(child_frame));
@@ -282,8 +282,8 @@ TEST_F(SurfaceAggregatorPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
         pass->shared_quad_state_list.back(), gfx::Rect(0, 100, 100, 100),
         gfx::Rect(0, 100, 100, 100), SK_ColorGREEN, force_anti_aliasing_off);
 
-    auto child_frame = test::MakeCompositorFrame();
-    child_frame.render_pass_list.push_back(std::move(pass));
+    auto child_frame =
+        CompositorFrameBuilder().AddRenderPass(std::move(pass)).Build();
 
     right_support->SubmitCompositorFrame(right_child_local_id,
                                          std::move(child_frame));

components/viz/service/frame_sinks/compositor_frame_sink_support_unittest.cc

@@ -125,7 +125,7 @@ class CompositorFrameSinkSupportTest : public testing::Test {
 
   void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
                                           size_t num_resource_ids) {
-    auto frame = test::MakeCompositorFrame();
+    auto frame = MakeDefaultCompositorFrame();
     for (size_t i = 0u; i < num_resource_ids; ++i) {
       TransferableResource resource;
       resource.id = resource_ids[i];
@@ -505,14 +505,15 @@ TEST_F(CompositorFrameSinkSupportTest, AddDuringEviction) {
       &mock_client, &manager_, kAnotherArbitraryFrameSinkId, kIsRoot,
       kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(6, kArbitraryToken);
-  support->SubmitCompositorFrame(local_surface_id, test::MakeCompositorFrame());
+  support->SubmitCompositorFrame(local_surface_id,
+                                 MakeDefaultCompositorFrame());
 
   SurfaceManager* surface_manager = manager_.surface_manager();
 
   EXPECT_CALL(mock_client, DidReceiveCompositorFrameAck(_))
       .WillOnce(testing::InvokeWithoutArgs([&]() {
         LocalSurfaceId new_id(7, base::UnguessableToken::Create());
-        support->SubmitCompositorFrame(new_id, test::MakeCompositorFrame());
+        support->SubmitCompositorFrame(new_id, MakeDefaultCompositorFrame());
         surface_manager->GarbageCollectSurfaces();
       }))
       .WillRepeatedly(testing::Return());
@@ -535,8 +536,10 @@ TEST_F(CompositorFrameSinkSupportTest, EvictCurrentSurface) {
   TransferableResource resource;
   resource.id = 1;
   resource.mailbox_holder.texture_target = GL_TEXTURE_2D;
-  auto frame = test::MakeCompositorFrame();
-  frame.resource_list.push_back(resource);
+  auto frame = CompositorFrameBuilder()
+                   .AddDefaultRenderPass()
+                   .AddTransferableResource(resource)
+                   .Build();
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   EXPECT_EQ(surface_observer_.last_created_surface_id().local_surface_id(),
             local_surface_id);
@@ -569,7 +572,7 @@ TEST_F(CompositorFrameSinkSupportTest, EvictSurfaceWithTemporaryReference) {
   frame_sink_manager_client_.SetTemporaryReferenceToAssign(
       surface_id, parent_frame_sink_id);
   support_->SubmitCompositorFrame(local_surface_id,
-                                  test::MakeCompositorFrame());
+                                  MakeDefaultCompositorFrame());
 
   // Verify the temporary reference has prevented the surface from getting
   // destroyed.
@@ -588,9 +591,11 @@ void CopyRequestTestCallback(bool* called,
 
 TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
   {
-    auto frame = test::MakeCompositorFrame();
-    frame.metadata.referenced_surfaces.push_back(
-        SurfaceId(support_->frame_sink_id(), local_surface_id_));
+    const SurfaceId surface_id(support_->frame_sink_id(), local_surface_id_);
+    auto frame = CompositorFrameBuilder()
+                     .AddDefaultRenderPass()
+                     .SetReferencedSurfaces({surface_id})
+                     .Build();
     support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
     EXPECT_EQ(surface_observer_.last_created_surface_id().local_surface_id(),
               local_surface_id_);
@@ -639,17 +644,11 @@ TEST_F(CompositorFrameSinkSupportTest, DuplicateCopyRequest) {
 // Check whether the SurfaceInfo object is created and populated correctly
 // after the frame submission.
 TEST_F(CompositorFrameSinkSupportTest, SurfaceInfo) {
-  auto frame = test::MakeCompositorFrame();
-
-  auto render_pass = RenderPass::Create();
-  render_pass->SetNew(1, gfx::Rect(5, 6), gfx::Rect(), gfx::Transform());
-  frame.render_pass_list.push_back(std::move(render_pass));
-
-  render_pass = RenderPass::Create();
-  render_pass->SetNew(2, gfx::Rect(7, 8), gfx::Rect(), gfx::Transform());
-  frame.render_pass_list.push_back(std::move(render_pass));
-
-  frame.metadata.device_scale_factor = 2.5f;
+  auto frame = CompositorFrameBuilder()
+                   .AddRenderPass(gfx::Rect(5, 6), gfx::Rect())
+                   .AddRenderPass(gfx::Rect(7, 8), gfx::Rect())
+                   .SetDeviceScaleFactor(2.5f)
+                   .Build();
 
   support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
   SurfaceId expected_surface_id(support_->frame_sink_id(), local_surface_id_);
@@ -663,8 +662,8 @@ TEST_F(CompositorFrameSinkSupportTest, SurfaceInfo) {
 // a Surface for it.
 TEST_F(CompositorFrameSinkSupportTest, ZeroFrameSize) {
   SurfaceId id(support_->frame_sink_id(), local_surface_id_);
-  auto frame = test::MakeEmptyCompositorFrame();
-  frame.render_pass_list.push_back(RenderPass::Create());
+  auto frame =
+      CompositorFrameBuilder().AddRenderPass(gfx::Rect(), gfx::Rect()).Build();
   EXPECT_TRUE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   EXPECT_FALSE(GetSurfaceForId(id));
@@ -674,8 +673,10 @@ TEST_F(CompositorFrameSinkSupportTest, ZeroFrameSize) {
 // don't create a Surface for it.
 TEST_F(CompositorFrameSinkSupportTest, ZeroDeviceScaleFactor) {
   SurfaceId id(support_->frame_sink_id(), local_surface_id_);
-  auto frame = test::MakeCompositorFrame();
-  frame.metadata.device_scale_factor = 0.f;
+  auto frame = CompositorFrameBuilder()
+                   .AddDefaultRenderPass()
+                   .SetDeviceScaleFactor(0.f)
+                   .Build();
   EXPECT_TRUE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   EXPECT_FALSE(GetSurfaceForId(id));
@@ -687,20 +688,18 @@ TEST_F(CompositorFrameSinkSupportTest, FrameSizeMismatch) {
   SurfaceId id(support_->frame_sink_id(), local_surface_id_);
 
   // Submit a frame with size (5,5).
-  auto frame = test::MakeEmptyCompositorFrame();
-  auto pass = RenderPass::Create();
-  pass->SetNew(1, gfx::Rect(5, 5), gfx::Rect(), gfx::Transform());
-  frame.render_pass_list.push_back(std::move(pass));
+  auto frame = CompositorFrameBuilder()
+                   .AddRenderPass(gfx::Rect(5, 5), gfx::Rect())
+                   .Build();
   EXPECT_TRUE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   EXPECT_TRUE(GetSurfaceForId(id));
 
   // Submit a frame with size (5,4). This frame should be rejected and the
   // surface should be destroyed.
-  frame = test::MakeEmptyCompositorFrame();
-  pass = RenderPass::Create();
-  pass->SetNew(1, gfx::Rect(5, 4), gfx::Rect(), gfx::Transform());
-  frame.render_pass_list.push_back(std::move(pass));
+  frame = CompositorFrameBuilder()
+              .AddRenderPass(gfx::Rect(5, 4), gfx::Rect())
+              .Build();
   EXPECT_FALSE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   manager_.surface_manager()->GarbageCollectSurfaces();
@@ -714,16 +713,20 @@ TEST_F(CompositorFrameSinkSupportTest, DeviceScaleFactorMismatch) {
   SurfaceId id(support_->frame_sink_id(), local_surface_id_);
 
   // Submit a frame with device scale factor of 0.5.
-  auto frame = test::MakeCompositorFrame();
-  frame.metadata.device_scale_factor = 0.5f;
+  auto frame = CompositorFrameBuilder()
+                   .AddDefaultRenderPass()
+                   .SetDeviceScaleFactor(0.5f)
+                   .Build();
   EXPECT_TRUE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   EXPECT_TRUE(GetSurfaceForId(id));
 
   // Submit a frame with device scale factor of 0.4. This frame should be
   // rejected and the surface should be destroyed.
-  frame = test::MakeCompositorFrame();
-  frame.metadata.device_scale_factor = 0.4f;
+  frame = CompositorFrameBuilder()
+              .AddDefaultRenderPass()
+              .SetDeviceScaleFactor(0.4f)
+              .Build();
   EXPECT_FALSE(
       support_->SubmitCompositorFrame(local_surface_id_, std::move(frame)));
   manager_.surface_manager()->GarbageCollectSurfaces();
@@ -742,8 +745,10 @@ TEST_F(CompositorFrameSinkSupportTest, PassesOnBeginFrameAcks) {
   // Check that the support and SurfaceManager forward the BeginFrameAck
   // attached to a CompositorFrame to the SurfaceObserver.
   BeginFrameAck ack(0, 1, true);
-  auto frame = test::MakeCompositorFrame();
-  frame.metadata.begin_frame_ack = ack;
+  CompositorFrame frame = CompositorFrameBuilder()
+                              .AddDefaultRenderPass()
+                              .SetBeginFrameAck(ack)
+                              .Build();
   support_->SubmitCompositorFrame(local_surface_id_, std::move(frame));
   EXPECT_EQ(ack, surface_observer_.last_ack());
 
@@ -768,14 +773,14 @@ TEST_F(CompositorFrameSinkSupportTest, FrameIndexCarriedOverToNewSurface) {
 
   // Submit a frame to |id1| and record the frame index.
   support_->SubmitCompositorFrame(local_surface_id1,
-                                  test::MakeCompositorFrame());
+                                  MakeDefaultCompositorFrame());
   Surface* surface1 = GetSurfaceForId(id1);
   uint64_t frame_index = surface1->GetActiveFrameIndex();
 
   // Submit a frame to |id2| and verify that the new frame index is one more
   // than what we had before.
   support_->SubmitCompositorFrame(local_surface_id2,
-                                  test::MakeCompositorFrame());
+                                  MakeDefaultCompositorFrame());
   Surface* surface2 = GetSurfaceForId(id2);
   EXPECT_EQ(frame_index + 1, surface2->GetActiveFrameIndex());
 }

components/viz/service/frame_sinks/direct_layer_tree_frame_sink_unittest.cc

@@ -101,13 +101,9 @@ class DirectLayerTreeFrameSinkTest : public testing::Test {
   }
 
   void SwapBuffersWithDamage(const gfx::Rect& damage_rect) {
-    auto render_pass = RenderPass::Create();
-    render_pass->SetNew(1, display_rect_, damage_rect, gfx::Transform());
-
-    CompositorFrame frame = test::MakeEmptyCompositorFrame();
-    frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, true);
-    frame.render_pass_list.push_back(std::move(render_pass));
-
+    auto frame = CompositorFrameBuilder()
+                     .AddRenderPass(display_rect_, damage_rect)
+                     .Build();
     layer_tree_frame_sink_->SubmitCompositorFrame(std::move(frame));
   }
 

components/viz/service/frame_sinks/surface_references_unittest.cc

@@ -51,7 +51,7 @@ class SurfaceReferencesTest : public testing::Test {
     LocalSurfaceId local_surface_id(parent_id,
                                     base::UnguessableToken::Deserialize(0, 1u));
     GetCompositorFrameSinkSupport(frame_sink_id)
-        .SubmitCompositorFrame(local_surface_id, MakeCompositorFrame());
+        .SubmitCompositorFrame(local_surface_id, MakeDefaultCompositorFrame());
     return SurfaceId(frame_sink_id, local_surface_id);
   }
 

components/viz/service/frame_sinks/video_detector_unittest.cc

@@ -92,7 +92,7 @@ class VideoDetectorTest : public testing::Test {
 
     root_frame_sink_ = CreateFrameSink();
     root_frame_sink_->SubmitCompositorFrame(
-        local_surface_id_allocator_.GenerateId(), test::MakeCompositorFrame());
+        local_surface_id_allocator_.GenerateId(), MakeDefaultCompositorFrame());
   }
 
  protected:
@@ -120,7 +120,7 @@ class VideoDetectorTest : public testing::Test {
   }
 
   void SubmitRootFrame() {
-    CompositorFrame frame = test::MakeCompositorFrame();
+    CompositorFrame frame = MakeDefaultCompositorFrame();
     RenderPass* render_pass = frame.render_pass_list.back().get();
     SharedQuadState* shared_quad_state =
         render_pass->CreateAndAppendSharedQuadState();
@@ -182,10 +182,10 @@ class VideoDetectorTest : public testing::Test {
 
  private:
   CompositorFrame MakeDamagedCompositorFrame(const gfx::Rect& damage) {
-    constexpr gfx::Size kFrameSinkSize = gfx::Size(10000, 10000);
-    CompositorFrame frame = test::MakeCompositorFrame(kFrameSinkSize);
-    frame.render_pass_list.back()->damage_rect = damage;
-    return frame;
+    constexpr gfx::Rect kFrameSinkRect(10000, 10000);
+    return CompositorFrameBuilder()
+        .AddRenderPass(kFrameSinkRect, damage)
+        .Build();
   }
 
   FrameSinkManagerImpl frame_sink_manager_;

components/viz/service/surfaces/surface_hittest_unittest.cc

@@ -316,7 +316,7 @@ TEST_F(SurfaceHittestTest, Hittest_InvalidRenderPassDrawQuad) {
 TEST_F(SurfaceHittestTest, Hittest_RenderPassDrawQuad) {
   // Create a CompositorFrame with two RenderPasses.
   gfx::Rect root_rect(300, 300);
-  CompositorFrame root_frame = test::MakeCompositorFrame();
+  CompositorFrame root_frame = MakeDefaultCompositorFrame();
   RenderPassList& render_pass_list = root_frame.render_pass_list;
 
   // Create a child RenderPass.

components/viz/service/surfaces/surface_unittest.cc

@@ -25,7 +25,8 @@ constexpr bool kIsRoot = true;
 constexpr bool kNeedsSyncPoints = true;
 
 TEST(SurfaceTest, PresentationCallback) {
-  const gfx::Size kSurfaceSize(300, 300);
+  constexpr gfx::Size kSurfaceSize(300, 300);
+  constexpr gfx::Rect kDamageRect(0, 0);
   const LocalSurfaceId local_surface_id(6, base::UnguessableToken::Create());
 
   FrameSinkManagerImpl frame_sink_manager;
@@ -34,8 +35,11 @@ TEST(SurfaceTest, PresentationCallback) {
       &client, &frame_sink_manager, kArbitraryFrameSinkId, kIsRoot,
       kNeedsSyncPoints);
   {
-    CompositorFrame frame = test::MakeCompositorFrame(kSurfaceSize);
-    frame.metadata.presentation_token = 1;
+    CompositorFrame frame =
+        CompositorFrameBuilder()
+            .AddRenderPass(gfx::Rect(kSurfaceSize), kDamageRect)
+            .SetPresentationToken(1)
+            .Build();
     EXPECT_CALL(client, DidReceiveCompositorFrameAck(testing::_)).Times(1);
     support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   }
@@ -43,8 +47,11 @@ TEST(SurfaceTest, PresentationCallback) {
   {
     // Replaces previous frame. The previous frame with token 1 will be
     // discarded.
-    CompositorFrame frame = test::MakeCompositorFrame(kSurfaceSize);
-    frame.metadata.presentation_token = 2;
+    CompositorFrame frame =
+        CompositorFrameBuilder()
+            .AddRenderPass(gfx::Rect(kSurfaceSize), kDamageRect)
+            .SetPresentationToken(2)
+            .Build();
     EXPECT_CALL(client, DidDiscardCompositorFrame(1)).Times(1);
     EXPECT_CALL(client, DidReceiveCompositorFrameAck(testing::_)).Times(1);
     support->SubmitCompositorFrame(local_surface_id, std::move(frame));
@@ -53,8 +60,10 @@ TEST(SurfaceTest, PresentationCallback) {
   {
     // Submits a frame with token 3 and different size. This frame with token 3
     // will be discarded immediately.
-    CompositorFrame frame = test::MakeCompositorFrame(gfx::Size(400, 400));
-    frame.metadata.presentation_token = 3;
+    CompositorFrame frame = CompositorFrameBuilder()
+                                .AddRenderPass(gfx::Rect(400, 400), kDamageRect)
+                                .SetPresentationToken(3)
+                                .Build();
     EXPECT_CALL(client, DidDiscardCompositorFrame(3)).Times(1);
     support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   }
@@ -62,9 +71,12 @@ TEST(SurfaceTest, PresentationCallback) {
   {
     // Submits a frame with token 4 and different scale factor, this frame with
     // token 4 will be discarded immediately.
-    CompositorFrame frame = test::MakeCompositorFrame(kSurfaceSize);
-    frame.metadata.device_scale_factor = 2;
-    frame.metadata.presentation_token = 4;
+    CompositorFrame frame =
+        CompositorFrameBuilder()
+            .AddRenderPass(gfx::Rect(kSurfaceSize), kDamageRect)
+            .SetDeviceScaleFactor(2.f)
+            .SetPresentationToken(4)
+            .Build();
     EXPECT_CALL(client, DidDiscardCompositorFrame(4)).Times(1);
     support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   }
@@ -85,7 +97,8 @@ TEST(SurfaceTest, SurfaceLifetime) {
 
   LocalSurfaceId local_surface_id(6, base::UnguessableToken::Create());
   SurfaceId surface_id(kArbitraryFrameSinkId, local_surface_id);
-  support->SubmitCompositorFrame(local_surface_id, test::MakeCompositorFrame());
+  support->SubmitCompositorFrame(local_surface_id,
+                                 MakeDefaultCompositorFrame());
   EXPECT_TRUE(surface_manager->GetSurfaceForId(surface_id));
   support->EvictCurrentSurface();
   frame_sink_manager.surface_manager()->GarbageCollectSurfaces();
@@ -118,7 +131,7 @@ TEST(SurfaceTest, CopyRequestLifetime) {
 
   LocalSurfaceId local_surface_id(6, base::UnguessableToken::Create());
   SurfaceId surface_id(kArbitraryFrameSinkId, local_surface_id);
-  CompositorFrame frame = test::MakeCompositorFrame();
+  CompositorFrame frame = MakeDefaultCompositorFrame();
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   Surface* surface = surface_manager->GetSurfaceForId(surface_id);
   ASSERT_TRUE(!!surface);
@@ -132,7 +145,7 @@ TEST(SurfaceTest, CopyRequestLifetime) {
 
   int max_frame = 3, start_id = 200;
   for (int i = 0; i < max_frame; ++i) {
-    CompositorFrame frame = test::MakeEmptyCompositorFrame();
+    CompositorFrame frame = CompositorFrameBuilder().Build();
     frame.render_pass_list.push_back(RenderPass::Create());
     frame.render_pass_list.back()->id = i * 3 + start_id;
     frame.render_pass_list.push_back(RenderPass::Create());

components/viz/test/DEPS

@@ -4,6 +4,7 @@ include_rules = [
   "+mojo/public/cpp/bindings",
   "+services/viz/privileged/interfaces",
   "+services/viz/public/interfaces",
+  "+ui/latency",
 ]
 
 specific_include_rules = {

components/viz/test/compositor_frame_helpers.cc

@@ -4,42 +4,126 @@
 
 #include "components/viz/test/compositor_frame_helpers.h"
 
-#include "components/viz/common/quads/compositor_frame.h"
-
 namespace viz {
-namespace test {
+namespace {
+
+constexpr gfx::Rect kDefaultOutputRect(20, 20);
+constexpr gfx::Rect kDefaultDamageRect(0, 0);
+
+}  // namespace
+
+CompositorFrameBuilder::CompositorFrameBuilder() : frame_(base::in_place) {
+  frame_->metadata.begin_frame_ack =
+      BeginFrameAck(BeginFrameArgs::kManualSourceId,
+                    BeginFrameArgs::kStartingFrameNumber, true);
+  frame_->metadata.device_scale_factor = 1.f;
+}
+
+CompositorFrameBuilder::~CompositorFrameBuilder() = default;
+
+CompositorFrame CompositorFrameBuilder::Build() {
+  CompositorFrame temp_frame(std::move(frame_.value()));
+  frame_.reset();
+  return temp_frame;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::AddDefaultRenderPass() {
+  return AddRenderPass(kDefaultOutputRect, kDefaultDamageRect);
+}
 
-CompositorFrame MakeCompositorFrame(const gfx::Size& size) {
-  CompositorFrame frame = MakeEmptyCompositorFrame();
+CompositorFrameBuilder& CompositorFrameBuilder::AddRenderPass(
+    const gfx::Rect& output_rect,
+    const gfx::Rect& damage_rect) {
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
-  pass->SetNew(1, gfx::Rect(size), gfx::Rect(), gfx::Transform());
-  frame.render_pass_list.push_back(std::move(pass));
-  return frame;
+  pass->SetNew(next_render_pass_id_++, output_rect, damage_rect,
+               gfx::Transform());
+  frame_->render_pass_list.push_back(std::move(pass));
+  return *this;
 }
 
-CompositorFrame MakeEmptyCompositorFrame() {
-  CompositorFrame frame;
-  frame.metadata.begin_frame_ack.source_id = BeginFrameArgs::kManualSourceId;
-  frame.metadata.begin_frame_ack.sequence_number =
-      BeginFrameArgs::kStartingFrameNumber;
-  frame.metadata.begin_frame_ack.has_damage = true;
-  frame.metadata.device_scale_factor = 1;
-  return frame;
-}
-
-CompositorFrame MakeCompositorFrame(
-    std::vector<SurfaceId> activation_dependencies,
-    std::vector<SurfaceId> referenced_surfaces,
+CompositorFrameBuilder& CompositorFrameBuilder::AddRenderPass(
+    std::unique_ptr<RenderPass> render_pass) {
+  // Give the render pass a unique id if one hasn't been assigned.
+  if (render_pass->id == 0)
+    render_pass->id = next_render_pass_id_++;
+  frame_->render_pass_list.push_back(std::move(render_pass));
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetRenderPassList(
+    RenderPassList render_pass_list) {
+  DCHECK(frame_->render_pass_list.empty());
+  frame_->render_pass_list = std::move(render_pass_list);
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::AddTransferableResource(
+    TransferableResource resource) {
+  frame_->resource_list.push_back(std::move(resource));
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetTransferableResources(
     std::vector<TransferableResource> resource_list) {
-  CompositorFrame compositor_frame = test::MakeCompositorFrame();
-  compositor_frame.metadata.begin_frame_ack = BeginFrameAck(0, 1, true);
-  compositor_frame.metadata.activation_dependencies =
-      std::move(activation_dependencies);
-  compositor_frame.metadata.referenced_surfaces =
-      std::move(referenced_surfaces);
-  compositor_frame.resource_list = std::move(resource_list);
-  return compositor_frame;
+  DCHECK(frame_->resource_list.empty());
+  frame_->resource_list = std::move(resource_list);
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetBeginFrameAck(
+    const BeginFrameAck& ack) {
+  frame_->metadata.begin_frame_ack = ack;
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetDeviceScaleFactor(
+    float device_scale_factor) {
+  frame_->metadata.device_scale_factor = device_scale_factor;
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::AddLatencyInfo(
+    ui::LatencyInfo latency_info) {
+  frame_->metadata.latency_info.push_back(std::move(latency_info));
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetActivationDependencies(
+    std::vector<SurfaceId> activation_dependencies) {
+  frame_->metadata.activation_dependencies = std::move(activation_dependencies);
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetReferencedSurfaces(
+    std::vector<SurfaceId> referenced_surfaces) {
+  frame_->metadata.referenced_surfaces = std::move(referenced_surfaces);
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetFrameToken(
+    uint32_t frame_token) {
+  frame_->metadata.frame_token = frame_token;
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetContentSourceId(
+    uint32_t content_source_id) {
+  frame_->metadata.content_source_id = content_source_id;
+  return *this;
+}
+
+CompositorFrameBuilder& CompositorFrameBuilder::SetPresentationToken(
+    uint32_t presentation_token) {
+  frame_->metadata.presentation_token = presentation_token;
+  return *this;
+}
+
+CompositorFrame MakeDefaultCompositorFrame() {
+  return CompositorFrameBuilder().AddDefaultRenderPass().Build();
+}
+
+CompositorFrame MakeEmptyCompositorFrame() {
+  return CompositorFrameBuilder().Build();
 }
 
-}  // namespace test
 }  // namespace viz

components/viz/test/compositor_frame_helpers.h

@@ -7,27 +7,72 @@
 
 #include <vector>
 
+#include "base/optional.h"
+#include "components/viz/common/quads/compositor_frame.h"
+#include "components/viz/common/quads/render_pass.h"
 #include "components/viz/common/resources/transferable_resource.h"
 #include "components/viz/common/surfaces/surface_id.h"
+#include "ui/latency/latency_info.h"
 
 namespace viz {
-class CompositorFrame;
 
-namespace test {
+// A builder class for constructing CompositorFrames in tests. The initial
+// CompositorFrame will have a valid BeginFrameAck and device_scale_factor of 1.
+// At least one RenderPass must be added for the CompositorFrame to be valid.
+class CompositorFrameBuilder {
+ public:
+  CompositorFrameBuilder();
+  ~CompositorFrameBuilder();
 
-// Creates a valid CompositorFrame.
-CompositorFrame MakeCompositorFrame(const gfx::Size& size = gfx::Size(20, 20));
+  // Builds the CompositorFrame and leaves |this| in an invalid state. This can
+  // only be called once.
+  CompositorFrame Build();
+
+  // Adds a render pass with 20x20 output_rect and empty damage_rect.
+  CompositorFrameBuilder& AddDefaultRenderPass();
+  // Adds a render pass with specified |output_rect| and |damage_rect|.
+  CompositorFrameBuilder& AddRenderPass(const gfx::Rect& output_rect,
+                                        const gfx::Rect& damage_rect);
+  CompositorFrameBuilder& AddRenderPass(
+      std::unique_ptr<RenderPass> render_pass);
+  // Sets list of render passes. The list of render passes must be empty when
+  // this is called.
+  CompositorFrameBuilder& SetRenderPassList(RenderPassList render_pass_list);
+
+  CompositorFrameBuilder& AddTransferableResource(
+      TransferableResource resource);
+  // Sets list of transferable resources. The list of transferable resources
+  // must be empty when this is called.
+  CompositorFrameBuilder& SetTransferableResources(
+      std::vector<TransferableResource> resource_list);
+
+  // Sets the BeginFrameAck. This replaces the default BeginFrameAck.
+  CompositorFrameBuilder& SetBeginFrameAck(const BeginFrameAck& ack);
+  CompositorFrameBuilder& SetDeviceScaleFactor(float device_scale_factor);
+  CompositorFrameBuilder& AddLatencyInfo(ui::LatencyInfo latency_info);
+  CompositorFrameBuilder& SetReferencedSurfaces(
+      std::vector<SurfaceId> referenced_surfaces);
+  CompositorFrameBuilder& SetActivationDependencies(
+      std::vector<SurfaceId> activation_dependencies);
+  CompositorFrameBuilder& SetFrameToken(uint32_t frame_token);
+  CompositorFrameBuilder& SetContentSourceId(uint32_t content_source_id);
+  CompositorFrameBuilder& SetPresentationToken(uint32_t presentation_token);
+
+ private:
+  base::Optional<CompositorFrame> frame_;
+  uint64_t next_render_pass_id_ = 1;
+
+  DISALLOW_COPY_AND_ASSIGN(CompositorFrameBuilder);
+};
+
+// Creates a CompositorFrame that has a render pass with 20x20 output_rect and
+// empty damage_rect. This CompositorFrame is valid and can be sent over IPC.
+CompositorFrame MakeDefaultCompositorFrame();
 
 // Creates a CompositorFrame that will be valid once its render_pass_list is
 // initialized.
 CompositorFrame MakeEmptyCompositorFrame();
 
-CompositorFrame MakeCompositorFrame(
-    std::vector<SurfaceId> activation_dependencies,
-    std::vector<SurfaceId> referenced_surfaces,
-    std::vector<TransferableResource> resource_list);
-
-}  // namespace test
 }  // namespace viz
 
 #endif  // COMPONENTS_VIZ_TEST_COMPOSITOR_FRAME_HELPERS_H_

components/viz/test/surface_hittest_test_helpers.cc

@@ -71,7 +71,7 @@ void CreateRenderPass(int render_pass_id,
 
 CompositorFrame CreateCompositorFrame(const gfx::Rect& root_rect,
                                       RenderPass** render_pass) {
-  CompositorFrame root_frame = MakeCompositorFrame();
+  CompositorFrame root_frame = MakeDefaultCompositorFrame();
   int root_id = 1;
   CreateRenderPass(root_id, root_rect, gfx::Transform(),
                    &root_frame.render_pass_list);

content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc

@@ -14,6 +14,7 @@
 #include "components/viz/common/quads/compositor_frame.h"
 #include "components/viz/host/host_frame_sink_manager.h"
 #include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
+#include "components/viz/test/compositor_frame_helpers.h"
 #include "components/viz/test/fake_host_frame_sink_client.h"
 #include "components/viz/test/mock_compositor_frame_sink_client.h"
 #include "content/browser/compositor/surface_utils.h"
@@ -68,23 +69,6 @@ class StubOffscreenCanvasSurfaceClient
   DISALLOW_COPY_AND_ASSIGN(StubOffscreenCanvasSurfaceClient);
 };
 
-// Create a CompositorFrame suitable to send over IPC.
-viz::CompositorFrame MakeCompositorFrame() {
-  viz::CompositorFrame frame;
-  frame.metadata.begin_frame_ack.source_id =
-      viz::BeginFrameArgs::kManualSourceId;
-  frame.metadata.begin_frame_ack.sequence_number =
-      viz::BeginFrameArgs::kStartingFrameNumber;
-  frame.metadata.device_scale_factor = 1.0f;
-
-  auto render_pass = viz::RenderPass::Create();
-  render_pass->id = 1;
-  render_pass->output_rect = gfx::Rect(100, 100);
-  frame.render_pass_list.push_back(std::move(render_pass));
-
-  return frame;
-}
-
 // Creates a closure that sets |error_variable| true when run.
 base::Closure ConnectionErrorClosure(bool* error_variable) {
   return base::Bind([](bool* error_variable) { *error_variable = true; },
@@ -180,7 +164,7 @@ TEST_F(OffscreenCanvasProviderImplTest,
   // Renderer submits a CompositorFrame with |local_id|.
   const viz::LocalSurfaceId local_id(1, base::UnguessableToken::Create());
   compositor_frame_sink->SubmitCompositorFrame(
-      local_id, MakeCompositorFrame(), nullptr,
+      local_id, viz::MakeDefaultCompositorFrame(), nullptr,
       base::TimeTicks::Now().since_origin().InMicroseconds());
 
   RunUntilIdle();