Reject frames with invalid BeginFrameAck in CompositorFrameSinkSupport

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/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/compositor_frame_sink_support.h"
 #include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
+#include "cc/test/compositor_frame_helpers.h"
 #include "cc/test/fake_compositor_frame_sink_support_client.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/surface_aggregator_test_helpers.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace cc {
@@ skipping 15 matching lines @@
   static SurfaceId invalid(FrameSinkId(),
                            LocalSurfaceId(0xdeadbeef, kArbitraryToken));
   return invalid;
 }
 
 gfx::Size SurfaceSize() {
   static gfx::Size size(100, 100);
   return size;
 }
 
-CompositorFrame MakeCompositorFrame() {
-  CompositorFrame frame;
-  frame.metadata.begin_frame_ack.source_id = BeginFrameArgs::kManualSourceId;
-  frame.metadata.begin_frame_ack.sequence_number =
-      BeginFrameArgs::kStartingFrameNumber;
-  return frame;
-}
-
 class SurfaceAggregatorTest : public testing::Test {
  public:
   explicit SurfaceAggregatorTest(bool use_damage_rect)
       : support_(
             CompositorFrameSinkSupport::Create(&fake_client_,
                                                &manager_,
                                                kArbitraryRootFrameSinkId,
                                                kRootIsRoot,
                                                kHandlesFrameSinkIdInvalidation,
                                                kNeedsSyncPoints)),
         aggregator_(&manager_, NULL, use_damage_rect) {}
 
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
   void TearDown() override {
     support_->EvictFrame();
     testing::Test::TearDown();
   }
 
  protected:
   SurfaceManager manager_;
   FakeCompositorFrameSinkSupportClient fake_client_;
   std::unique_ptr<CompositorFrameSinkSupport> support_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
   LocalSurfaceId local_surface_id(7, base::UnguessableToken::Create());
   SurfaceId one_id(kArbitraryRootFrameSinkId, local_surface_id);
-  support_->SubmitCompositorFrame(local_surface_id, MakeCompositorFrame());
+  support_->SubmitCompositorFrame(local_surface_id,
+                                  test::MakeCompositorFrame());
 
   CompositorFrame frame = aggregator_.Aggregate(one_id);
   EXPECT_TRUE(frame.render_pass_list.empty());
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
         child_support_(
@@ skipping 39 matching lines @@
     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(CompositorFrameSinkSupport* support,
                              const LocalSurfaceId& local_surface_id,
                              RenderPassList* pass_list) {
-    CompositorFrame frame = MakeCompositorFrame();
+    CompositorFrame frame = test::MakeCompositorFrame();
     pass_list->swap(frame.render_pass_list);
 
     support->SubmitCompositorFrame(local_surface_id, std::move(frame));
   }
 
   void SubmitCompositorFrame(CompositorFrameSinkSupport* support,
                              test::Pass* passes,
                              size_t pass_count,
                              const LocalSurfaceId& local_surface_id) {
     RenderPassList pass_list;
     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
     SubmitPassListAsFrame(support, local_surface_id, &pass_list);
   }
 
   void QueuePassAsFrame(std::unique_ptr<RenderPass> pass,
                         const LocalSurfaceId& local_surface_id,
                         CompositorFrameSinkSupport* support) {
-    CompositorFrame child_frame = MakeCompositorFrame();
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     child_frame.render_pass_list.push_back(std::move(pass));
 
     support->SubmitCompositorFrame(local_surface_id, std::move(child_frame));
   }
 
  protected:
   LocalSurfaceId root_local_surface_id_;
   Surface* root_surface_;
   LocalSurfaceIdAllocator allocator_;
   std::unique_ptr<CompositorFrameSinkSupport> child_support_;
@@ skipping 397 matching lines @@
 
   test::Quad root_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorWHITE),
       test::Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(), 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), 1),
       test::Pass(root_quads2, arraysize(root_quads2), 2)};
   {
-    CompositorFrame frame = MakeCompositorFrame();
+    CompositorFrame frame = test::MakeCompositorFrame();
     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));
 
     support_->SubmitCompositorFrame(root_local_surface_id_, std::move(frame));
   }
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
@@ skipping 66 matching lines @@
                               parent_local_surface_id);
 
   test::Quad parent_quads[] = {
       test::Quad::SolidColorQuad(SK_ColorGRAY),
       test::Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(), 1.f),
       test::Quad::SolidColorQuad(SK_ColorLTGRAY)};
   test::Pass parent_passes[] = {
       test::Pass(parent_quads, arraysize(parent_quads))};
 
   {
-    CompositorFrame frame = MakeCompositorFrame();
+    CompositorFrame frame = test::MakeCompositorFrame();
 
     AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), parent_passes,
               arraysize(parent_passes));
 
     frame.metadata.referenced_surfaces.push_back(embedded_surface_id);
 
     parent_support->SubmitCompositorFrame(parent_local_surface_id,
                                           std::move(frame));
   }
 
   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))};
 
   {
-    CompositorFrame frame = MakeCompositorFrame();
+    CompositorFrame frame = test::MakeCompositorFrame();
     AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
     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);
 
     support_->SubmitCompositorFrame(root_local_surface_id_, std::move(frame));
   }
@@ skipping 410 matching lines @@
   std::unique_ptr<CompositorFrameSinkSupport> child_two_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryFrameSinkId3, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   int pass_id = 1;
   LocalSurfaceId grandchild_local_surface_id = allocator_.GenerateId();
   SurfaceId grandchild_surface_id(grandchild_support->frame_sink_id(),
                                   grandchild_local_surface_id);
 
   grandchild_support->SubmitCompositorFrame(grandchild_local_surface_id,
-                                            MakeCompositorFrame());
+                                            test::MakeCompositorFrame());
   std::unique_ptr<RenderPass> grandchild_pass = RenderPass::Create();
   gfx::Rect output_rect(SurfaceSize());
   gfx::Rect damage_rect(SurfaceSize());
   gfx::Transform transform_to_root_target;
   grandchild_pass->SetNew(pass_id, output_rect, damage_rect,
                           transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), grandchild_pass.get(), blend_modes[2]);
   QueuePassAsFrame(std::move(grandchild_pass), grandchild_local_surface_id,
                    grandchild_support.get());
 
   LocalSurfaceId child_one_local_surface_id = allocator_.GenerateId();
   SurfaceId child_one_surface_id(child_one_support->frame_sink_id(),
                                  child_one_local_surface_id);
   child_one_support->SubmitCompositorFrame(child_one_local_surface_id,
-                                           MakeCompositorFrame());
+                                           test::MakeCompositorFrame());
 
   std::unique_ptr<RenderPass> child_one_pass = RenderPass::Create();
   child_one_pass->SetNew(pass_id, output_rect, damage_rect,
                          transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
   SurfaceDrawQuad* grandchild_surface_quad =
       child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   grandchild_surface_quad->SetNew(
       child_one_pass->shared_quad_state_list.back(), gfx::Rect(SurfaceSize()),
       gfx::Rect(SurfaceSize()), grandchild_surface_id,
       SurfaceDrawQuadType::PRIMARY, nullptr);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
   QueuePassAsFrame(std::move(child_one_pass), child_one_local_surface_id,
                    child_one_support.get());
 
   LocalSurfaceId child_two_local_surface_id = allocator_.GenerateId();
   SurfaceId child_two_surface_id(child_two_support->frame_sink_id(),
                                  child_two_local_surface_id);
   child_two_support->SubmitCompositorFrame(child_two_local_surface_id,
-                                           MakeCompositorFrame());
+                                           test::MakeCompositorFrame());
 
   std::unique_ptr<RenderPass> child_two_pass = RenderPass::Create();
   child_two_pass->SetNew(pass_id, output_rect, damage_rect,
                          transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_two_pass.get(), blend_modes[5]);
   QueuePassAsFrame(std::move(child_two_pass), child_two_local_surface_id,
                    child_two_support.get());
 
   std::unique_ptr<RenderPass> root_pass = RenderPass::Create();
@@ skipping 77 matching lines @@
     int child_pass_id[] = {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 = MakeCompositorFrame();
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               child_passes, arraysize(child_passes));
 
     RenderPass* child_nonroot_pass = child_frame.render_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();
@@ skipping 11 matching lines @@
   LocalSurfaceId middle_local_surface_id = allocator_.GenerateId();
   SurfaceId middle_surface_id(middle_support->frame_sink_id(),
                               middle_local_surface_id);
   {
     test::Quad middle_quads[] = {
         test::Quad::SurfaceQuad(child_surface_id, InvalidSurfaceId(), 1.f)};
     test::Pass middle_passes[] = {
         test::Pass(middle_quads, arraysize(middle_quads)),
     };
 
-    CompositorFrame middle_frame = MakeCompositorFrame();
+    CompositorFrame middle_frame = test::MakeCompositorFrame();
     AddPasses(&middle_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               middle_passes, arraysize(middle_passes));
 
     RenderPass* middle_root_pass = middle_frame.render_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);
 
     middle_support->SubmitCompositorFrame(middle_local_surface_id,
                                           std::move(middle_frame));
   }
 
   // Root surface.
   test::Quad secondary_quads[] = {
       test::Quad::SolidColorQuad(1),
       test::Quad::SurfaceQuad(middle_surface_id, InvalidSurfaceId(), 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 = MakeCompositorFrame();
+  CompositorFrame root_frame = test::MakeCompositorFrame();
   AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
             arraysize(root_passes));
 
   root_frame.render_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 7);
   root_frame.render_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 =
@@ skipping 83 matching lines @@
 // Tests that damage rects are aggregated correctly when surfaces change.
 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
   std::unique_ptr<CompositorFrameSinkSupport> parent_support =
       CompositorFrameSinkSupport::Create(
           nullptr, &manager_, kArbitraryMiddleFrameSinkId, kChildIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   test::Quad child_quads[] = {test::Quad::RenderPassQuad(1)};
   test::Pass child_passes[] = {
       test::Pass(child_quads, arraysize(child_quads), 1)};
 
-  CompositorFrame child_frame = MakeCompositorFrame();
+  CompositorFrame child_frame = test::MakeCompositorFrame();
   AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
             child_passes, arraysize(child_passes));
 
   RenderPass* child_root_pass = child_frame.render_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);
 
   LocalSurfaceId child_local_surface_id = allocator_.GenerateId();
   SurfaceId child_surface_id(child_support_->frame_sink_id(),
                              child_local_surface_id);
   child_support_->SubmitCompositorFrame(child_local_surface_id,
                                         std::move(child_frame));
 
   test::Quad parent_surface_quads[] = {
       test::Quad::SurfaceQuad(child_surface_id, InvalidSurfaceId(), 1.f)};
   test::Pass parent_surface_passes[] = {
       test::Pass(parent_surface_quads, arraysize(parent_surface_quads), 1)};
 
   // Parent surface is only used to test if the transform is applied correctly
   // to the child surface's damage.
-  CompositorFrame parent_surface_frame = MakeCompositorFrame();
+  CompositorFrame parent_surface_frame = test::MakeCompositorFrame();
   AddPasses(&parent_surface_frame.render_pass_list, gfx::Rect(SurfaceSize()),
             parent_surface_passes, arraysize(parent_surface_passes));
 
   LocalSurfaceId parent_local_surface_id = allocator_.GenerateId();
   SurfaceId parent_surface_id(parent_support->frame_sink_id(),
                               parent_local_surface_id);
   parent_support->SubmitCompositorFrame(parent_local_surface_id,
                                         std::move(parent_surface_frame));
 
   test::Quad root_surface_quads[] = {
       test::Quad::SurfaceQuad(parent_surface_id, InvalidSurfaceId(), 1.f)};
   test::Quad root_render_pass_quads[] = {test::Quad::RenderPassQuad(1)};
 
   test::Pass root_passes[] = {
       test::Pass(root_surface_quads, arraysize(root_surface_quads), 1),
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads), 2)};
 
-  CompositorFrame root_frame = MakeCompositorFrame();
+  CompositorFrame root_frame = test::MakeCompositorFrame();
   AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
             arraysize(root_passes));
 
   root_frame.render_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);
 
   support_->SubmitCompositorFrame(root_local_surface_id_,
                                   std::move(root_frame));
 
   SurfaceId root_surface_id(support_->frame_sink_id(), root_local_surface_id_);
   CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
   const RenderPassList& aggregated_pass_list =
       aggregated_frame.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 = MakeCompositorFrame();
+    CompositorFrame child_frame = test::MakeCompositorFrame();
     AddPasses(&child_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               child_passes, arraysize(child_passes));
 
     RenderPass* child_root_pass = child_frame.render_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);
 
     child_support_->SubmitCompositorFrame(child_local_surface_id,
                                           std::move(child_frame));
 
     SurfaceId root_surface_id(support_->frame_sink_id(),
                               root_local_surface_id_);
     CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);
 
     const RenderPassList& aggregated_pass_list =
         aggregated_frame.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 = MakeCompositorFrame();
+    CompositorFrame root_frame = test::MakeCompositorFrame();
     AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               root_passes, arraysize(root_passes));
 
     root_frame.render_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);
 
     support_->SubmitCompositorFrame(root_local_surface_id_,
                                     std::move(root_frame));
   }
 
   {
-    CompositorFrame root_frame = MakeCompositorFrame();
+    CompositorFrame root_frame = test::MakeCompositorFrame();
     AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()),
               root_passes, arraysize(root_passes));
 
     root_frame.render_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);
 
     support_->SubmitCompositorFrame(root_local_surface_id_,
                                     std::move(root_frame));
@@ skipping 45 matching lines @@
   parent_support->EvictFrame();
 }
 
 // Check that damage is correctly calculated for surfaces.
 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), 2)};
 
-  CompositorFrame root_frame = MakeCompositorFrame();
+  CompositorFrame root_frame = test::MakeCompositorFrame();
   AddPasses(&root_frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,
             arraysize(root_passes));
 
   root_frame.render_pass_list[0]->damage_rect = gfx::Rect(5, 5, 100, 100);
 
   support_->SubmitCompositorFrame(root_local_surface_id_,
                                   std::move(root_frame));
 
   {
     SurfaceId root_surface_id(support_->frame_sink_id(),
@@ skipping 12 matching lines @@
 
   LocalSurfaceId second_root_local_surface_id = allocator_.GenerateId();
   SurfaceId second_root_surface_id(support_->frame_sink_id(),
                                    second_root_local_surface_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), 2)};
 
-    CompositorFrame root_frame = MakeCompositorFrame();
+    CompositorFrame root_frame = test::MakeCompositorFrame();
     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);
 
     support_->SubmitCompositorFrame(second_root_local_surface_id,
                                     std::move(root_frame));
   }
   {
     CompositorFrame aggregated_frame =
@@ skipping 324 matching lines @@
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<SurfaceAggregator> aggregator_;
 };
 
 void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
                                         size_t num_resource_ids,
                                         bool valid,
                                         SurfaceId child_id,
                                         CompositorFrameSinkSupport* support,
                                         SurfaceId surface_id) {
-  CompositorFrame frame = MakeCompositorFrame();
+  CompositorFrame frame = test::MakeCompositorFrame();
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = 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, SurfaceDrawQuadType::PRIMARY, nullptr);
   }
@@ skipping 63 matching lines @@
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
   FakeCompositorFrameSinkSupportClient client;
   std::unique_ptr<CompositorFrameSinkSupport> support =
       CompositorFrameSinkSupport::Create(
           &client, &manager_, kArbitraryRootFrameSinkId, kRootIsRoot,
           kHandlesFrameSinkIdInvalidation, kNeedsSyncPoints);
   LocalSurfaceId local_surface_id(7u, base::UnguessableToken::Create());
   SurfaceId surface_id(support->frame_sink_id(), local_surface_id);
 
-  CompositorFrame frame = MakeCompositorFrame();
+  CompositorFrame frame = test::MakeCompositorFrame();
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = 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));
   support->SubmitCompositorFrame(local_surface_id, std::move(frame));
@@ skipping 150 matching lines @@
     pass->id = 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, SurfaceDrawQuadType::PRIMARY, nullptr);
     pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
-    CompositorFrame frame = MakeCompositorFrame();
+    CompositorFrame frame = test::MakeCompositorFrame();
     frame.render_pass_list.push_back(std::move(pass));
 
     support2->SubmitCompositorFrame(local_frame2_id, std::move(frame));
   }
 
   frame = aggregator_->Aggregate(surface2_id);
   EXPECT_EQ(1u, frame.render_pass_list.size());
   render_pass = frame.render_pass_list.front().get();
 
   // Parent has copy request, so texture should not be drawn.
@@ skipping 53 matching lines @@
   aggregated_frame = aggregator_.Aggregate(surface_id);
   EXPECT_EQ(3u, aggregated_frame.render_pass_list.size());
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[0]->color_space);
   EXPECT_EQ(color_space1, aggregated_frame.render_pass_list[1]->color_space);
   EXPECT_EQ(color_space3, aggregated_frame.render_pass_list[2]->color_space);
 }
 
 }  // namespace
 }  // namespace cc