Skip to content

GitLab

T
tangled
Commit 30a805f4 authored by kylechar's avatar kylechar Committed by Commit Bot
Browse files
Options

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: default avatarTimothy Dresser <tdresser@chromium.org>
Reviewed-by: default avatarBo <boliu@chromium.org>
Reviewed-by: default avatarFady Samuel <fsamuel@chromium.org>
Commit-Queue: kylechar <kylechar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521774}
parent 6fd1cd67
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 506 additions and 350 deletions
android_webview/browser/test/rendering_test.cc
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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
View file @ 30a805f4
......@@ -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();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment