Chromium Code Reviews Chromium Code Reviews
Issue 2795683003:
[cc]Replace use of SurfaceFactory with CompositorFrameSinkSupport in tests (Closed)
| Index: cc/surfaces/surface_aggregator_unittest.cc |
| diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc |
| index 0e4e133ae7beb2db1ec84a16e4ae47ab2feee39d..41cecfb0aa657c8545ae54f9047edb649f3f9700 100644 |
| --- a/cc/surfaces/surface_aggregator_unittest.cc |
| +++ b/cc/surfaces/surface_aggregator_unittest.cc |
| @@ -18,11 +18,11 @@ |
| #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_factory.h" |
| -#include "cc/surfaces/surface_factory_client.h" |
| #include "cc/surfaces/surface_manager.h" |
| +#include "cc/test/empty_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" |
| @@ -35,10 +35,16 @@ namespace cc { |
| namespace { |
| constexpr FrameSinkId kArbitraryRootFrameSinkId(1, 1); |
| -constexpr FrameSinkId kArbitraryChildFrameSinkId1(2, 2); |
| -constexpr FrameSinkId kArbitraryChildFrameSinkId2(3, 3); |
| +constexpr FrameSinkId kArbitraryFrameSinkId1(2, 2); |
| +constexpr FrameSinkId kArbitraryFrameSinkId2(3, 3); |
| constexpr FrameSinkId kArbitraryMiddleFrameSinkId(4, 4); |
| +constexpr FrameSinkId kArbitraryReservedFrameSinkId(5, 5); |
| +constexpr FrameSinkId kArbitraryFrameSinkId3(6, 6); |
| const base::UnguessableToken kArbitraryToken = base::UnguessableToken::Create(); |
| +constexpr bool is_root = true; |
|
danakj
2017/04/07 15:52:44
right, consts out in the namespace (or class) scop
Alex Z.
2017/04/07 20:43:58
Done.
|
| +constexpr bool is_root_child = false; |
| +constexpr bool handles_frame_sink_id_invalidation = true; |
| +constexpr bool needs_sync_points = false; |
| SurfaceId InvalidSurfaceId() { |
| static SurfaceId invalid(FrameSinkId(), |
| @@ -51,47 +57,35 @@ gfx::Size SurfaceSize() { |
| return size; |
| } |
| -class EmptySurfaceFactoryClient : public SurfaceFactoryClient { |
| - public: |
| - void ReturnResources(const ReturnedResourceArray& resources) override {} |
| - |
| - void WillDrawSurface(const LocalSurfaceId& id, |
| - const gfx::Rect& damage_rect) override { |
| - last_local_surface_id_ = id; |
| - last_damage_rect_ = damage_rect; |
| - } |
| - |
| - void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {} |
| - |
| - gfx::Rect last_damage_rect_; |
| - LocalSurfaceId last_local_surface_id_; |
| -}; |
| - |
| class SurfaceAggregatorTest : public testing::Test { |
| public: |
| explicit SurfaceAggregatorTest(bool use_damage_rect) |
| - : factory_(kArbitraryRootFrameSinkId, &manager_, &empty_client_), |
| + : support_(&empty_client_, |
| + &manager_, |
| + kArbitraryRootFrameSinkId, |
| + is_root, |
| + handles_frame_sink_id_invalidation, |
| + needs_sync_points), |
| aggregator_(&manager_, NULL, use_damage_rect) {} |
| SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {} |
| void TearDown() override { |
| - factory_.EvictSurface(); |
| + support_.EvictFrame(); |
| testing::Test::TearDown(); |
| } |
| protected: |
| SurfaceManager manager_; |
| - EmptySurfaceFactoryClient empty_client_; |
| - SurfaceFactory factory_; |
| + EmptyCompositorFrameSinkSupportClient empty_client_; |
| + CompositorFrameSinkSupport support_; |
| SurfaceAggregator aggregator_; |
| }; |
| TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) { |
| LocalSurfaceId local_surface_id(7, base::UnguessableToken::Create()); |
| SurfaceId one_id(kArbitraryRootFrameSinkId, local_surface_id); |
| - factory_.SubmitCompositorFrame(local_surface_id, CompositorFrame(), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(local_surface_id, CompositorFrame()); |
| CompositorFrame frame = aggregator_.Aggregate(one_id); |
| EXPECT_TRUE(frame.render_pass_list.empty()); |
| @@ -101,9 +95,12 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest { |
| public: |
| explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect) |
| : SurfaceAggregatorTest(use_damage_rect), |
| - child_factory_(kArbitraryChildFrameSinkId1, |
| + child_support_(nullptr, |
| &manager_, |
| - &empty_child_client_) {} |
| + kArbitraryReservedFrameSinkId, |
| + is_root_child, |
| + handles_frame_sink_id_invalidation, |
| + needs_sync_points) {} |
| SurfaceAggregatorValidSurfaceTest() |
| : SurfaceAggregatorValidSurfaceTest(false) {} |
| @@ -111,11 +108,11 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest { |
| SurfaceAggregatorTest::SetUp(); |
| root_local_surface_id_ = allocator_.GenerateId(); |
| root_surface_ = manager_.GetSurfaceForId( |
| - SurfaceId(factory_.frame_sink_id(), root_local_surface_id_)); |
| + SurfaceId(support_.frame_sink_id(), root_local_surface_id_)); |
| } |
| void TearDown() override { |
| - child_factory_.EvictSurface(); |
| + child_support_.EvictFrame(); |
| SurfaceAggregatorTest::TearDown(); |
| } |
| @@ -124,7 +121,7 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest { |
| SurfaceId* surface_ids, |
| size_t expected_surface_count) { |
| CompositorFrame aggregated_frame = aggregator_.Aggregate( |
| - SurfaceId(factory_.frame_sink_id(), root_local_surface_id_)); |
| + SurfaceId(support_.frame_sink_id(), root_local_surface_id_)); |
| TestPassesMatchExpectations(expected_passes, expected_pass_count, |
| &aggregated_frame.render_pass_list); |
| @@ -144,41 +141,38 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest { |
| } |
| } |
| - void SubmitPassListAsFrame(SurfaceFactory* factory, |
| + void SubmitPassListAsFrame(CompositorFrameSinkSupport* support, |
| const LocalSurfaceId& local_surface_id, |
| RenderPassList* pass_list) { |
| CompositorFrame frame; |
| pass_list->swap(frame.render_pass_list); |
| - factory->SubmitCompositorFrame(local_surface_id, std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support->SubmitCompositorFrame(local_surface_id, std::move(frame)); |
| } |
| - void SubmitCompositorFrame(SurfaceFactory* factory, |
| + 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(factory, local_surface_id, &pass_list); |
| + SubmitPassListAsFrame(support, local_surface_id, &pass_list); |
| } |
| void QueuePassAsFrame(std::unique_ptr<RenderPass> pass, |
| const LocalSurfaceId& local_surface_id, |
| - SurfaceFactory* factory) { |
| + CompositorFrameSinkSupport* support) { |
| CompositorFrame child_frame; |
| child_frame.render_pass_list.push_back(std::move(pass)); |
| - factory->SubmitCompositorFrame(local_surface_id, std::move(child_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support->SubmitCompositorFrame(local_surface_id, std::move(child_frame)); |
| } |
| protected: |
| LocalSurfaceId root_local_surface_id_; |
| Surface* root_surface_; |
| LocalSurfaceIdAllocator allocator_; |
| - EmptySurfaceFactoryClient empty_child_client_; |
| - SurfaceFactory child_factory_; |
| + CompositorFrameSinkSupport child_support_; |
| LocalSurfaceIdAllocator child_allocator_; |
| }; |
| @@ -189,24 +183,25 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleFrame) { |
| test::Quad::SolidColorQuad(SK_ColorBLUE)}; |
| test::Pass passes[] = {test::Pass(quads, arraysize(quads))}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id}; |
| AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids)); |
| // Check that WillDrawSurface was called. |
| - EXPECT_EQ(gfx::Rect(SurfaceSize()), empty_client_.last_damage_rect_); |
| - EXPECT_EQ(root_local_surface_id_, empty_client_.last_local_surface_id_); |
| + EXPECT_EQ(gfx::Rect(SurfaceSize()), empty_client_.last_damage_rect()); |
| + EXPECT_EQ(root_local_surface_id_, empty_client_.last_local_surface_id()); |
| } |
| TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) { |
| - SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport embedded_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(), |
| + SurfaceId embedded_surface_id(embedded_support.frame_sink_id(), |
| embedded_local_surface_id); |
| test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN), |
| @@ -214,17 +209,17 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) { |
| test::Pass embedded_passes[] = { |
| test::Pass(embedded_quads, arraysize(embedded_quads))}; |
| - SubmitCompositorFrame(&embedded_factory, embedded_passes, |
| + SubmitCompositorFrame(&embedded_support, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| test::Quad quads[] = { |
| test::Quad::SurfaceQuad(embedded_surface_id, InvalidSurfaceId(), .5f)}; |
| test::Pass passes[] = {test::Pass(quads, arraysize(quads))}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id); |
| RenderPassList& render_pass_list(aggregated_frame.render_pass_list); |
| @@ -240,7 +235,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) { |
| ASSERT_EQ(1u, shared_quad_state_list2.size()); |
| EXPECT_EQ(.5f, shared_quad_state_list2.ElementAt(0)->opacity); |
| - embedded_factory.EvictSurface(); |
| + embedded_support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSimpleFrame) { |
| @@ -251,10 +246,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSimpleFrame) { |
| test::Pass passes[] = {test::Pass(quads[0], arraysize(quads[0]), 1), |
| test::Pass(quads[1], arraysize(quads[1]), 2)}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id}; |
| AggregateAndVerify(passes, arraysize(passes), ids, arraysize(ids)); |
| @@ -269,10 +264,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassDeallocation) { |
| test::Pass passes[] = {test::Pass(quads[0], arraysize(quads[0]), 2), |
| test::Pass(quads[1], arraysize(quads[1]), 1)}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| - SurfaceId surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame; |
| aggregated_frame = aggregator_.Aggregate(surface_id); |
| @@ -288,7 +283,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassDeallocation) { |
| test::Pass passes2[] = {test::Pass(quads[0], arraysize(quads[0]), 3), |
| test::Pass(quads[1], arraysize(quads[1]), 1)}; |
| - SubmitCompositorFrame(&factory_, passes2, arraysize(passes2), |
| + SubmitCompositorFrame(&support_, passes2, arraysize(passes2), |
| root_local_surface_id_); |
| // The RenderPass that still exists should keep the same ID. |
| @@ -298,7 +293,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassDeallocation) { |
| EXPECT_NE(id2, id0); |
| EXPECT_EQ(id1, aggregated_frame.render_pass_list[1]->id); |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| // |id1| didn't exist in the previous frame, so it should be |
| @@ -316,17 +311,18 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassDeallocation) { |
| // embedded_surface has a frame containing only a solid color quad. The solid |
| // color quad should be aggregated into the final frame. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) { |
| - SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport embedded_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(), |
| + SurfaceId embedded_surface_id(embedded_support.frame_sink_id(), |
| embedded_local_surface_id); |
| test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)}; |
| test::Pass embedded_passes[] = { |
| test::Pass(embedded_quads, arraysize(embedded_quads))}; |
| - SubmitCompositorFrame(&embedded_factory, embedded_passes, |
| + SubmitCompositorFrame(&embedded_support, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| test::Quad root_quads[] = { |
| @@ -335,7 +331,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) { |
| test::Quad::SolidColorQuad(SK_ColorBLACK)}; |
| test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))}; |
| - SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes), |
| + SubmitCompositorFrame(&support_, root_passes, arraysize(root_passes), |
| root_local_surface_id_); |
| test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE), |
| @@ -343,28 +339,30 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleSurfaceReference) { |
| test::Quad::SolidColorQuad(SK_ColorBLACK)}; |
| test::Pass expected_passes[] = { |
| test::Pass(expected_quads, arraysize(expected_quads))}; |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id, embedded_surface_id}; |
| AggregateAndVerify( |
| expected_passes, arraysize(expected_passes), ids, arraysize(ids)); |
| - embedded_factory.EvictSurface(); |
| + embedded_support.EvictFrame(); |
| } |
| // This test verifies that in the absence of a primary Surface, |
| // SurfaceAggregator will embed a fallback Surface, if available. If the primary |
| // Surface is available, though, the fallback will not be used. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| - SurfaceFactory primary_child_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport primary_child_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId primary_child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId primary_child_surface_id(primary_child_factory.frame_sink_id(), |
| + SurfaceId primary_child_surface_id(primary_child_support.frame_sink_id(), |
| primary_child_local_surface_id); |
| - SurfaceFactory fallback_child_factory(kArbitraryChildFrameSinkId2, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport fallback_child_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId2, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId fallback_child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId fallback_child_surface_id(fallback_child_factory.frame_sink_id(), |
| + SurfaceId fallback_child_surface_id(fallback_child_support.frame_sink_id(), |
| fallback_child_local_surface_id); |
| test::Quad fallback_child_quads[] = {test::Quad::SolidColorQuad(SK_ColorRED)}; |
| @@ -373,7 +371,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| // Submit a CompositorFrame to the fallback Surface containing a red |
| // SolidColorDrawQuad. |
| - SubmitCompositorFrame(&fallback_child_factory, fallback_child_passes, |
| + SubmitCompositorFrame(&fallback_child_support, fallback_child_passes, |
| arraysize(fallback_child_passes), |
| fallback_child_local_surface_id); |
| @@ -383,7 +381,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| primary_child_surface_id, fallback_child_surface_id, 1.f)}; |
| test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))}; |
| - SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes), |
| + SubmitCompositorFrame(&support_, root_passes, arraysize(root_passes), |
| root_local_surface_id_); |
| // There is no CompositorFrame submitted to |primary_child_surface_id| and so |
| @@ -393,7 +391,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| test::Pass expected_passes1[] = { |
| test::Pass(expected_quads1, arraysize(expected_quads1))}; |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id, primary_child_surface_id, |
| fallback_child_surface_id}; |
| AggregateAndVerify(expected_passes1, arraysize(expected_passes1), ids, |
| @@ -406,7 +404,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| // Submit a CompositorFrame to the primary Surface containing a green |
| // SolidColorDrawQuad. |
| - SubmitCompositorFrame(&primary_child_factory, primary_child_passes, |
| + SubmitCompositorFrame(&primary_child_support, primary_child_passes, |
| arraysize(primary_child_passes), |
| primary_child_local_surface_id); |
| @@ -419,17 +417,18 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReference) { |
| AggregateAndVerify(expected_passes2, arraysize(expected_passes2), ids, |
| arraysize(ids)); |
| - primary_child_factory.EvictSurface(); |
| - fallback_child_factory.EvictSurface(); |
| + primary_child_support.EvictFrame(); |
| + fallback_child_support.EvictFrame(); |
| } |
| // This test verifies that in the presence of both primary Surface and fallback |
| // Surface, the fallback will not be used. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) { |
| - SurfaceFactory primary_child_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport primary_child_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId primary_child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId primary_child_surface_id(primary_child_factory.frame_sink_id(), |
| + SurfaceId primary_child_surface_id(primary_child_support.frame_sink_id(), |
| primary_child_local_surface_id); |
| test::Quad primary_child_quads[] = { |
| test::Quad::SolidColorQuad(SK_ColorGREEN)}; |
| @@ -438,14 +437,15 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) { |
| // Submit a CompositorFrame to the primary Surface containing a green |
| // SolidColorDrawQuad. |
| - SubmitCompositorFrame(&primary_child_factory, primary_child_passes, |
| + SubmitCompositorFrame(&primary_child_support, primary_child_passes, |
| arraysize(primary_child_passes), |
| primary_child_local_surface_id); |
| - SurfaceFactory fallback_child_factory(kArbitraryChildFrameSinkId2, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport fallback_child_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId2, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId fallback_child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId fallback_child_surface_id(fallback_child_factory.frame_sink_id(), |
| + SurfaceId fallback_child_surface_id(fallback_child_support.frame_sink_id(), |
| fallback_child_local_surface_id); |
| test::Quad fallback_child_quads[] = {test::Quad::SolidColorQuad(SK_ColorRED)}; |
| @@ -454,7 +454,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) { |
| // Submit a CompositorFrame to the fallback Surface containing a red |
| // SolidColorDrawQuad. |
| - SubmitCompositorFrame(&fallback_child_factory, fallback_child_passes, |
| + SubmitCompositorFrame(&fallback_child_support, fallback_child_passes, |
| arraysize(fallback_child_passes), |
| fallback_child_local_surface_id); |
| @@ -464,7 +464,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) { |
| primary_child_surface_id, fallback_child_surface_id, 1.f)}; |
| test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))}; |
| - SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes), |
| + SubmitCompositorFrame(&support_, root_passes, arraysize(root_passes), |
| root_local_surface_id_); |
| // The CompositorFrame is submitted to |primary_child_surface_id|, so |
| @@ -474,33 +474,34 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, FallbackSurfaceReferenceWithPrimary) { |
| test::Pass expected_passes1[] = { |
| test::Pass(expected_quads1, arraysize(expected_quads1))}; |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id, primary_child_surface_id, |
| fallback_child_surface_id}; |
| AggregateAndVerify(expected_passes1, arraysize(expected_passes1), ids, |
| arraysize(ids)); |
| - primary_child_factory.EvictSurface(); |
| - fallback_child_factory.EvictSurface(); |
| + primary_child_support.EvictFrame(); |
| + fallback_child_support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) { |
| - SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport embedded_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(), |
| + SurfaceId embedded_surface_id(embedded_support.frame_sink_id(), |
| embedded_local_surface_id); |
| test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)}; |
| test::Pass embedded_passes[] = { |
| test::Pass(embedded_quads, arraysize(embedded_quads))}; |
| - SubmitCompositorFrame(&embedded_factory, embedded_passes, |
| + SubmitCompositorFrame(&embedded_support, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| std::unique_ptr<CopyOutputRequest> copy_request( |
| CopyOutputRequest::CreateEmptyRequest()); |
| CopyOutputRequest* copy_request_ptr = copy_request.get(); |
| - embedded_factory.RequestCopyOfSurface(std::move(copy_request)); |
| + embedded_support.RequestCopyOfSurface(std::move(copy_request)); |
| test::Quad root_quads[] = { |
| test::Quad::SolidColorQuad(SK_ColorWHITE), |
| @@ -508,10 +509,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) { |
| test::Quad::SolidColorQuad(SK_ColorBLACK)}; |
| test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))}; |
| - SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes), |
| + SubmitCompositorFrame(&support_, root_passes, arraysize(root_passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id); |
| test::Quad expected_quads[] = { |
| @@ -537,22 +538,23 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) { |
| aggregator_.previous_contained_surfaces().end()); |
| } |
| - embedded_factory.EvictSurface(); |
| + embedded_support.EvictFrame(); |
| } |
| // Root surface may contain copy requests. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) { |
| - SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport embedded_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId2, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(), |
| + SurfaceId embedded_surface_id(embedded_support.frame_sink_id(), |
| embedded_local_surface_id); |
| test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)}; |
| test::Pass embedded_passes[] = { |
| test::Pass(embedded_quads, arraysize(embedded_quads))}; |
| - SubmitCompositorFrame(&embedded_factory, embedded_passes, |
| + SubmitCompositorFrame(&embedded_support, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| std::unique_ptr<CopyOutputRequest> copy_request( |
| CopyOutputRequest::CreateEmptyRequest()); |
| @@ -577,11 +579,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) { |
| frame.render_pass_list[1]->copy_requests.push_back( |
| std::move(copy_request2)); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, std::move(frame)); |
| } |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id); |
| test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE), |
| @@ -617,33 +618,35 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) { |
| DCHECK(original_pass_list[0]->copy_requests.empty()); |
| DCHECK(original_pass_list[1]->copy_requests.empty()); |
| - embedded_factory.EvictSurface(); |
| + embedded_support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) { |
| - SurfaceFactory embedded_factory(kArbitraryChildFrameSinkId1, &manager_, |
| - &empty_client_); |
| - SurfaceFactory parent_factory(kArbitraryRootFrameSinkId, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport embedded_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport parent_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId2, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId embedded_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(embedded_factory.frame_sink_id(), |
| + SurfaceId embedded_surface_id(embedded_support.frame_sink_id(), |
| embedded_local_surface_id); |
| - SurfaceId nonexistent_surface_id(factory_.frame_sink_id(), |
| + SurfaceId nonexistent_surface_id(support_.frame_sink_id(), |
| allocator_.GenerateId()); |
| test::Quad embedded_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN)}; |
| test::Pass embedded_passes[] = { |
| test::Pass(embedded_quads, arraysize(embedded_quads))}; |
| - SubmitCompositorFrame(&embedded_factory, embedded_passes, |
| + SubmitCompositorFrame(&embedded_support, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| std::unique_ptr<CopyOutputRequest> copy_request( |
| CopyOutputRequest::CreateEmptyRequest()); |
| CopyOutputRequest* copy_request_ptr = copy_request.get(); |
| - embedded_factory.RequestCopyOfSurface(std::move(copy_request)); |
| + embedded_support.RequestCopyOfSurface(std::move(copy_request)); |
| LocalSurfaceId parent_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId parent_surface_id(parent_factory.frame_sink_id(), |
| + SurfaceId parent_surface_id(parent_support.frame_sink_id(), |
| parent_local_surface_id); |
| test::Quad parent_quads[] = { |
| @@ -661,9 +664,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) { |
| frame.metadata.referenced_surfaces.push_back(embedded_surface_id); |
| - parent_factory.SubmitCompositorFrame(parent_local_surface_id, |
| - std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + parent_support.SubmitCompositorFrame(parent_local_surface_id, |
| + std::move(frame)); |
| } |
| test::Quad root_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE), |
| @@ -680,11 +682,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) { |
| // included in previous_contained_surfaces, but otherwise ignored. |
| frame.metadata.referenced_surfaces.push_back(nonexistent_surface_id); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, std::move(frame)); |
| } |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id); |
| // First pass should come from surface that had a copy request but was not |
| @@ -702,7 +703,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) { |
| aggregated_frame.render_pass_list[0]->copy_requests[0].get()); |
| SurfaceId surface_ids[] = { |
| - SurfaceId(factory_.frame_sink_id(), root_local_surface_id_), |
| + SurfaceId(support_.frame_sink_id(), root_local_surface_id_), |
| parent_surface_id, embedded_surface_id, nonexistent_surface_id}; |
| EXPECT_EQ(arraysize(surface_ids), |
| aggregator_.previous_contained_surfaces().size()); |
| @@ -712,14 +713,14 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) { |
| aggregator_.previous_contained_surfaces().end()); |
| } |
| - embedded_factory.EvictSurface(); |
| - parent_factory.EvictSurface(); |
| + embedded_support.EvictFrame(); |
| + parent_support.EvictFrame(); |
| } |
| // This tests referencing a surface that has multiple render passes. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) { |
| LocalSurfaceId embedded_local_surface_id = child_allocator_.GenerateId(); |
| - SurfaceId embedded_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId embedded_surface_id(child_support_.frame_sink_id(), |
| embedded_local_surface_id); |
| int pass_ids[] = {1, 2, 3}; |
| @@ -733,7 +734,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) { |
| test::Pass(embedded_quads[1], arraysize(embedded_quads[1]), pass_ids[1]), |
| test::Pass(embedded_quads[2], arraysize(embedded_quads[2]), pass_ids[2])}; |
| - SubmitCompositorFrame(&child_factory_, embedded_passes, |
| + SubmitCompositorFrame(&child_support_, embedded_passes, |
| arraysize(embedded_passes), embedded_local_surface_id); |
| test::Quad root_quads[][2] = { |
| @@ -746,10 +747,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) { |
| test::Pass(root_quads[1], arraysize(root_quads[1]), pass_ids[1]), |
| test::Pass(root_quads[2], arraysize(root_quads[2]), pass_ids[2])}; |
| - SubmitCompositorFrame(&factory_, root_passes, arraysize(root_passes), |
| + SubmitCompositorFrame(&support_, root_passes, arraysize(root_passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -861,14 +862,14 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, InvalidSurfaceReference) { |
| test::Quad::SolidColorQuad(SK_ColorBLUE)}; |
| test::Pass passes[] = {test::Pass(quads, arraysize(quads))}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN), |
| test::Quad::SolidColorQuad(SK_ColorBLUE)}; |
| test::Pass expected_passes[] = { |
| test::Pass(expected_quads, arraysize(expected_quads))}; |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id, InvalidSurfaceId()}; |
| AggregateAndVerify( |
| @@ -879,7 +880,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, InvalidSurfaceReference) { |
| // should also just be dropped. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) { |
| LocalSurfaceId empty_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId surface_with_no_frame_id(factory_.frame_sink_id(), |
| + SurfaceId surface_with_no_frame_id(support_.frame_sink_id(), |
| empty_local_surface_id); |
| test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN), |
| @@ -888,14 +889,14 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) { |
| test::Quad::SolidColorQuad(SK_ColorBLUE)}; |
| test::Pass passes[] = {test::Pass(quads, arraysize(quads))}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN), |
| test::Quad::SolidColorQuad(SK_ColorBLUE)}; |
| test::Pass expected_passes[] = { |
| test::Pass(expected_quads, arraysize(expected_quads))}; |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| SurfaceId ids[] = {root_surface_id, surface_with_no_frame_id}; |
| AggregateAndVerify( |
| expected_passes, arraysize(expected_passes), ids, arraysize(ids)); |
| @@ -904,13 +905,13 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, ValidSurfaceReferenceWithNoFrame) { |
| // Tests a surface quad referencing itself, generating a trivial cycle. |
| // The quad creating the cycle should be dropped from the final frame. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleCyclicalReference) { |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| test::Quad quads[] = { |
| test::Quad::SurfaceQuad(root_surface_id, InvalidSurfaceId(), 1.f), |
| test::Quad::SolidColorQuad(SK_ColorYELLOW)}; |
| test::Pass passes[] = {test::Pass(quads, arraysize(quads))}; |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorYELLOW)}; |
| @@ -924,7 +925,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SimpleCyclicalReference) { |
| // Tests a more complex cycle with one intermediate surface. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) { |
| LocalSurfaceId child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support_.frame_sink_id(), |
| child_local_surface_id); |
| test::Quad parent_quads[] = { |
| @@ -934,17 +935,17 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) { |
| test::Pass parent_passes[] = { |
| test::Pass(parent_quads, arraysize(parent_quads))}; |
| - SubmitCompositorFrame(&factory_, parent_passes, arraysize(parent_passes), |
| + SubmitCompositorFrame(&support_, parent_passes, arraysize(parent_passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId root_surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| test::Quad child_quads[] = { |
| test::Quad::SolidColorQuad(SK_ColorGREEN), |
| test::Quad::SurfaceQuad(root_surface_id, InvalidSurfaceId(), 1.f), |
| test::Quad::SolidColorQuad(SK_ColorMAGENTA)}; |
| test::Pass child_passes[] = {test::Pass(child_quads, arraysize(child_quads))}; |
| - SubmitCompositorFrame(&child_factory_, child_passes, arraysize(child_passes), |
| + SubmitCompositorFrame(&child_support_, child_passes, arraysize(child_passes), |
| child_local_surface_id); |
| // The child surface's reference to the root_surface_ will be dropped, so |
| @@ -968,7 +969,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, TwoSurfaceCyclicalReference) { |
| // namespace and update RenderPassDrawQuad's id references to match. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) { |
| LocalSurfaceId child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support_.frame_sink_id(), |
| child_local_surface_id); |
| int child_pass_id[] = {1, 2}; |
| @@ -978,7 +979,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) { |
| test::Pass(child_quad[0], arraysize(child_quad[0]), child_pass_id[0]), |
| test::Pass(child_quad[1], arraysize(child_quad[1]), child_pass_id[1])}; |
| - SubmitCompositorFrame(&child_factory_, surface_passes, |
| + SubmitCompositorFrame(&child_support_, surface_passes, |
| arraysize(surface_passes), child_local_surface_id); |
| // Pass IDs from the parent surface may collide with ones from the child. |
| @@ -990,10 +991,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) { |
| test::Pass(parent_quad[0], arraysize(parent_quad[0]), parent_pass_id[0]), |
| test::Pass(parent_quad[1], arraysize(parent_quad[1]), parent_pass_id[1])}; |
| - SubmitCompositorFrame(&factory_, parent_passes, arraysize(parent_passes), |
| + SubmitCompositorFrame(&support_, parent_passes, arraysize(parent_passes), |
| root_local_surface_id_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1085,20 +1086,21 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| SkBlendMode::kSrcIn, // 5 |
| SkBlendMode::kDstIn, // 6 |
| }; |
| - |
| - SurfaceFactory grandchild_factory(FrameSinkId(2, 2), &manager_, |
| - &empty_client_); |
| - SurfaceFactory child_one_factory(FrameSinkId(3, 3), &manager_, |
| - &empty_client_); |
| - SurfaceFactory child_two_factory(FrameSinkId(4, 4), &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport grandchild_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport child_one_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId2, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport child_two_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId3, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| int pass_id = 1; |
| LocalSurfaceId grandchild_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId grandchild_surface_id(grandchild_factory.frame_sink_id(), |
| + SurfaceId grandchild_surface_id(grandchild_support.frame_sink_id(), |
| grandchild_local_surface_id); |
| - grandchild_factory.SubmitCompositorFrame(grandchild_local_surface_id, |
| - CompositorFrame(), |
| - SurfaceFactory::DrawCallback()); |
| + grandchild_support.SubmitCompositorFrame(grandchild_local_surface_id, |
| + CompositorFrame()); |
| std::unique_ptr<RenderPass> grandchild_pass = RenderPass::Create(); |
| gfx::Rect output_rect(SurfaceSize()); |
| gfx::Rect damage_rect(SurfaceSize()); |
| @@ -1108,14 +1110,13 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| AddSolidColorQuadWithBlendMode( |
| SurfaceSize(), grandchild_pass.get(), blend_modes[2]); |
| QueuePassAsFrame(std::move(grandchild_pass), grandchild_local_surface_id, |
| - &grandchild_factory); |
| + &grandchild_support); |
| LocalSurfaceId child_one_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_one_surface_id(child_one_factory.frame_sink_id(), |
| + SurfaceId child_one_surface_id(child_one_support.frame_sink_id(), |
| child_one_local_surface_id); |
| - child_one_factory.SubmitCompositorFrame(child_one_local_surface_id, |
| - CompositorFrame(), |
| - SurfaceFactory::DrawCallback()); |
| + child_one_support.SubmitCompositorFrame(child_one_local_surface_id, |
| + CompositorFrame()); |
| std::unique_ptr<RenderPass> child_one_pass = RenderPass::Create(); |
| child_one_pass->SetNew(pass_id, output_rect, damage_rect, |
| @@ -1131,14 +1132,13 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| AddSolidColorQuadWithBlendMode( |
| SurfaceSize(), child_one_pass.get(), blend_modes[3]); |
| QueuePassAsFrame(std::move(child_one_pass), child_one_local_surface_id, |
| - &child_one_factory); |
| + &child_one_support); |
| LocalSurfaceId child_two_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_two_surface_id(child_two_factory.frame_sink_id(), |
| + SurfaceId child_two_surface_id(child_two_support.frame_sink_id(), |
| child_two_local_surface_id); |
| - child_two_factory.SubmitCompositorFrame(child_two_local_surface_id, |
| - CompositorFrame(), |
| - SurfaceFactory::DrawCallback()); |
| + child_two_support.SubmitCompositorFrame(child_two_local_surface_id, |
| + CompositorFrame()); |
| std::unique_ptr<RenderPass> child_two_pass = RenderPass::Create(); |
| child_two_pass->SetNew(pass_id, output_rect, damage_rect, |
| @@ -1146,7 +1146,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| AddSolidColorQuadWithBlendMode( |
| SurfaceSize(), child_two_pass.get(), blend_modes[5]); |
| QueuePassAsFrame(std::move(child_two_pass), child_two_local_surface_id, |
| - &child_two_factory); |
| + &child_two_support); |
| std::unique_ptr<RenderPass> root_pass = RenderPass::Create(); |
| root_pass->SetNew(pass_id, output_rect, damage_rect, |
| @@ -1171,9 +1171,9 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| AddSolidColorQuadWithBlendMode( |
| SurfaceSize(), root_pass.get(), blend_modes[6]); |
| - QueuePassAsFrame(std::move(root_pass), root_local_surface_id_, &factory_); |
| + QueuePassAsFrame(std::move(root_pass), root_local_surface_id_, &support_); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1192,9 +1192,9 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| << iter.index(); |
| } |
| - grandchild_factory.EvictSurface(); |
| - child_one_factory.EvictSurface(); |
| - child_two_factory.EvictSurface(); |
| + grandchild_support.EvictFrame(); |
| + child_one_support.EvictFrame(); |
| + child_two_support.EvictFrame(); |
| } |
| // This tests that when aggregating a frame with multiple render passes that we |
| @@ -1216,11 +1216,12 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) { |
| // contributing render pass' transform in the aggregate frame should not be |
| // affected. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) { |
| - SurfaceFactory middle_factory(kArbitraryMiddleFrameSinkId, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport middle_support( |
| + nullptr, &manager_, kArbitraryMiddleFrameSinkId, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| // Innermost child surface. |
| LocalSurfaceId child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support_.frame_sink_id(), |
| child_local_surface_id); |
| { |
| int child_pass_id[] = {1, 2}; |
| @@ -1250,14 +1251,13 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) { |
| child_root_pass_sqs->is_clipped = true; |
| child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5); |
| - child_factory_.SubmitCompositorFrame(child_local_surface_id, |
| - std::move(child_frame), |
| - SurfaceFactory::DrawCallback()); |
| + child_support_.SubmitCompositorFrame(child_local_surface_id, |
| + std::move(child_frame)); |
| } |
| // Middle child surface. |
| LocalSurfaceId middle_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId middle_surface_id(middle_factory.frame_sink_id(), |
| + SurfaceId middle_surface_id(middle_support.frame_sink_id(), |
| middle_local_surface_id); |
| { |
| test::Quad middle_quads[] = { |
| @@ -1277,9 +1277,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) { |
| middle_root_pass->shared_quad_state_list.front(); |
| middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3); |
| - middle_factory.SubmitCompositorFrame(middle_local_surface_id, |
| - std::move(middle_frame), |
| - SurfaceFactory::DrawCallback()); |
| + middle_support.SubmitCompositorFrame(middle_local_surface_id, |
| + std::move(middle_frame)); |
| } |
| // Root surface. |
| @@ -1306,10 +1305,9 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) { |
| root_frame.render_pass_list[0]->transform_to_root_target.Translate(10, 5); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame)); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1382,13 +1380,14 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) { |
| ->shared_quad_state_list.ElementAt(1) |
| ->clip_rect.ToString()); |
| - middle_factory.EvictSurface(); |
| + middle_support.EvictFrame(); |
| } |
| // Tests that damage rects are aggregated correctly when surfaces change. |
| TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| - SurfaceFactory parent_factory(kArbitraryMiddleFrameSinkId, &manager_, |
| - &empty_client_); |
| + CompositorFrameSinkSupport parent_support( |
| + nullptr, &manager_, kArbitraryMiddleFrameSinkId, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| test::Quad child_quads[] = {test::Quad::RenderPassQuad(1)}; |
| test::Pass child_passes[] = { |
| test::Pass(child_quads, arraysize(child_quads), 1)}; |
| @@ -1403,11 +1402,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| child_root_pass_sqs->quad_to_target_transform.Translate(8, 0); |
| LocalSurfaceId child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support_.frame_sink_id(), |
| child_local_surface_id); |
| - child_factory_.SubmitCompositorFrame(child_local_surface_id, |
| - std::move(child_frame), |
| - SurfaceFactory::DrawCallback()); |
| + 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)}; |
| @@ -1421,11 +1419,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| parent_surface_passes, arraysize(parent_surface_passes)); |
| LocalSurfaceId parent_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId parent_surface_id(parent_factory.frame_sink_id(), |
| + SurfaceId parent_surface_id(parent_support.frame_sink_id(), |
| parent_local_surface_id); |
| - parent_factory.SubmitCompositorFrame(parent_local_surface_id, |
| - std::move(parent_surface_frame), |
| - SurfaceFactory::DrawCallback()); |
| + 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)}; |
| @@ -1445,10 +1442,9 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| 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); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame)); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1471,11 +1467,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| child_root_pass_sqs->quad_to_target_transform.Translate(8, 0); |
| child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10); |
| - child_factory_.SubmitCompositorFrame(child_local_surface_id, |
| - std::move(child_frame), |
| - SurfaceFactory::DrawCallback()); |
| + child_support_.SubmitCompositorFrame(child_local_surface_id, |
| + std::move(child_frame)); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1499,9 +1494,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| ->quad_to_target_transform.Translate(0, 10); |
| root_frame.render_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, |
| - std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, |
| + std::move(root_frame)); |
| } |
| { |
| @@ -1514,11 +1508,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| ->quad_to_target_transform.Translate(0, 10); |
| root_frame.render_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, |
| - std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, |
| + std::move(root_frame)); |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1534,7 +1527,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| // No Surface changed, so no damage should be given. |
| { |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1560,7 +1553,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) { |
| gfx::Rect(SurfaceSize()))); |
| } |
| - parent_factory.EvictSurface(); |
| + parent_support.EvictFrame(); |
| } |
| // Check that damage is correctly calculated for surfaces. |
| @@ -1576,11 +1569,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) { |
| root_frame.render_pass_list[0]->damage_rect = gfx::Rect(5, 5, 100, 100); |
| - factory_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(root_local_surface_id_, std::move(root_frame)); |
| { |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1594,7 +1586,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) { |
| } |
| LocalSurfaceId second_root_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId second_root_surface_id(factory_.frame_sink_id(), |
| + SurfaceId second_root_surface_id(support_.frame_sink_id(), |
| second_root_local_surface_id); |
| { |
| test::Quad root_render_pass_quads[] = {test::Quad::SolidColorQuad(1)}; |
| @@ -1608,9 +1600,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) { |
| root_frame.render_pass_list[0]->damage_rect = gfx::Rect(1, 2, 3, 4); |
| - factory_.SubmitCompositorFrame(second_root_local_surface_id, |
| - std::move(root_frame), |
| - SurfaceFactory::DrawCallback()); |
| + support_.SubmitCompositorFrame(second_root_local_surface_id, |
| + std::move(root_frame)); |
| } |
| { |
| CompositorFrame aggregated_frame = |
| @@ -1647,7 +1638,7 @@ class SurfaceAggregatorPartialSwapTest |
| // Tests that quads outside the damage rect are ignored. |
| TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| LocalSurfaceId child_local_surface_id = allocator_.GenerateId(); |
| - SurfaceId child_surface_id(child_factory_.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support_.frame_sink_id(), |
| child_local_surface_id); |
| // The child surface has three quads, one with a visible rect of 13,13 4x4 and |
| // the other other with a visible rect of 10,10 2x2 (relative to root target |
| @@ -1685,7 +1676,7 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| child_pass_list[2]->quad_list.ElementAt(0)->visible_rect = |
| gfx::Rect(0, 0, 2, 2); |
| - SubmitPassListAsFrame(&child_factory_, child_local_surface_id, |
| + SubmitPassListAsFrame(&child_support_, child_local_surface_id, |
| &child_pass_list); |
| } |
| @@ -1704,10 +1695,10 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| ->quad_to_target_transform.Translate(10, 10); |
| root_pass->damage_rect = gfx::Rect(0, 0, 1, 1); |
| - SubmitPassListAsFrame(&factory_, root_local_surface_id_, &root_pass_list); |
| + SubmitPassListAsFrame(&support_, root_local_surface_id_, &root_pass_list); |
| } |
| - SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + 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 = |
| @@ -1736,7 +1727,7 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| root_pass->shared_quad_state_list.front() |
| ->quad_to_target_transform.Translate(10, 10); |
| root_pass->damage_rect = gfx::Rect(10, 10, 2, 2); |
| - SubmitPassListAsFrame(&factory_, root_local_surface_id_, &root_pass_list); |
| + SubmitPassListAsFrame(&support_, root_local_surface_id_, &root_pass_list); |
| } |
| { |
| @@ -1786,7 +1777,7 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| child_root_pass->copy_requests.push_back( |
| CopyOutputRequest::CreateEmptyRequest()); |
| child_root_pass->damage_rect = gfx::Rect(); |
| - SubmitPassListAsFrame(&child_factory_, child_local_surface_id, |
| + SubmitPassListAsFrame(&child_support_, child_local_surface_id, |
| &child_pass_list); |
| } |
| @@ -1846,7 +1837,7 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| RenderPass* root_pass = root_pass_list[2].get(); |
| filter_pass->filters.Append(FilterOperation::CreateBlurFilter(2)); |
| root_pass->damage_rect = gfx::Rect(10, 10, 2, 2); |
| - SubmitPassListAsFrame(&factory_, root_local_surface_id_, &root_pass_list); |
| + SubmitPassListAsFrame(&support_, root_local_surface_id_, &root_pass_list); |
| } |
| { |
| @@ -1894,7 +1885,7 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) { |
| ->quad_to_target_transform.Translate(10, 10); |
| pass->background_filters.Append(FilterOperation::CreateBlurFilter(2)); |
| root_pass->damage_rect = gfx::Rect(10, 10, 2, 2); |
| - SubmitPassListAsFrame(&factory_, root_local_surface_id_, &root_pass_list); |
| + SubmitPassListAsFrame(&support_, root_local_surface_id_, &root_pass_list); |
| } |
| { |
| @@ -1938,32 +1929,11 @@ class SurfaceAggregatorWithResourcesTest : public testing::Test { |
| std::unique_ptr<SurfaceAggregator> aggregator_; |
| }; |
| -class ResourceTrackingSurfaceFactoryClient : public SurfaceFactoryClient { |
| - public: |
| - ResourceTrackingSurfaceFactoryClient() {} |
| - ~ResourceTrackingSurfaceFactoryClient() override {} |
| - |
| - void ReturnResources(const ReturnedResourceArray& resources) override { |
| - returned_resources_ = resources; |
| - } |
| - |
| - ReturnedResourceArray returned_resources() const { |
| - return returned_resources_; |
| - } |
| - |
| - void SetBeginFrameSource(BeginFrameSource* begin_frame_source) override {} |
| - |
| - private: |
| - ReturnedResourceArray returned_resources_; |
| - |
| - DISALLOW_COPY_AND_ASSIGN(ResourceTrackingSurfaceFactoryClient); |
| -}; |
| - |
| void SubmitCompositorFrameWithResources(ResourceId* resource_ids, |
| size_t num_resource_ids, |
| bool valid, |
| SurfaceId child_id, |
| - SurfaceFactory* factory, |
| + CompositorFrameSinkSupport* support, |
| SurfaceId surface_id) { |
| CompositorFrame frame; |
| std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
| @@ -2002,27 +1972,28 @@ void SubmitCompositorFrameWithResources(ResourceId* resource_ids, |
| nearest_neighbor, secure_output_only); |
| } |
| frame.render_pass_list.push_back(std::move(pass)); |
| - factory->SubmitCompositorFrame(surface_id.local_surface_id(), |
| - std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support->SubmitCompositorFrame(surface_id.local_surface_id(), |
| + std::move(frame)); |
| } |
| TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) { |
| - ResourceTrackingSurfaceFactoryClient client; |
| - SurfaceFactory factory(kArbitraryRootFrameSinkId, &manager_, &client); |
| + EmptyCompositorFrameSinkSupportClient client; |
| + CompositorFrameSinkSupport support( |
| + &client, &manager_, kArbitraryRootFrameSinkId, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId local_surface_id(7u, base::UnguessableToken::Create()); |
| - SurfaceId surface_id(factory.frame_sink_id(), local_surface_id); |
| + SurfaceId surface_id(support.frame_sink_id(), local_surface_id); |
| ResourceId ids[] = {11, 12, 13}; |
| SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(), |
| - &factory, surface_id); |
| + &support, surface_id); |
| CompositorFrame frame = aggregator_->Aggregate(surface_id); |
| // Nothing should be available to be returned yet. |
| EXPECT_TRUE(client.returned_resources().empty()); |
| - SubmitCompositorFrameWithResources(NULL, 0u, true, SurfaceId(), &factory, |
| + SubmitCompositorFrameWithResources(NULL, 0u, true, SurfaceId(), &support, |
| surface_id); |
| frame = aggregator_->Aggregate(surface_id); |
| @@ -2035,14 +2006,16 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) { |
| EXPECT_THAT(returned_ids, |
| testing::WhenSorted(testing::ElementsAreArray(ids))); |
| - factory.EvictSurface(); |
| + support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) { |
| - ResourceTrackingSurfaceFactoryClient client; |
| - SurfaceFactory factory(kArbitraryRootFrameSinkId, &manager_, &client); |
| + EmptyCompositorFrameSinkSupportClient client; |
| + CompositorFrameSinkSupport support( |
| + &client, &manager_, kArbitraryRootFrameSinkId, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId local_surface_id(7u, base::UnguessableToken::Create()); |
| - SurfaceId surface_id(factory.frame_sink_id(), local_surface_id); |
| + SurfaceId surface_id(support.frame_sink_id(), local_surface_id); |
| CompositorFrame frame; |
| std::unique_ptr<RenderPass> pass = RenderPass::Create(); |
| @@ -2054,42 +2027,45 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) { |
| resource.is_software = false; |
| frame.resource_list.push_back(resource); |
| frame.render_pass_list.push_back(std::move(pass)); |
| - factory.SubmitCompositorFrame(local_surface_id, std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support.SubmitCompositorFrame(local_surface_id, std::move(frame)); |
| CompositorFrame returned_frame = aggregator_->Aggregate(surface_id); |
| // Nothing should be available to be returned yet. |
| EXPECT_TRUE(client.returned_resources().empty()); |
| - SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory, |
| + SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &support, |
| surface_id); |
| ASSERT_EQ(1u, client.returned_resources().size()); |
| EXPECT_EQ(11u, client.returned_resources()[0].id); |
| - factory.EvictSurface(); |
| + support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) { |
| - ResourceTrackingSurfaceFactoryClient client; |
| - SurfaceFactory factory1(FrameSinkId(1, 1), &manager_, &client); |
| - SurfaceFactory factory2(FrameSinkId(2, 2), &manager_, &client); |
| + EmptyCompositorFrameSinkSupportClient client; |
| + CompositorFrameSinkSupport support1( |
| + &client, &manager_, FrameSinkId(1, 1), is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport support2( |
| + &client, &manager_, FrameSinkId(2, 2), is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId local_frame1_id(7u, base::UnguessableToken::Create()); |
| - SurfaceId surface1_id(factory1.frame_sink_id(), local_frame1_id); |
| + SurfaceId surface1_id(support1.frame_sink_id(), local_frame1_id); |
| LocalSurfaceId local_frame2_id(8u, base::UnguessableToken::Create()); |
| - SurfaceId surface2_id(factory2.frame_sink_id(), local_frame2_id); |
| + SurfaceId surface2_id(support2.frame_sink_id(), local_frame2_id); |
| ResourceId ids[] = {11, 12, 13}; |
| SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(), |
| - &factory1, surface1_id); |
| + &support1, surface1_id); |
| ResourceId ids2[] = {14, 15, 16}; |
| SubmitCompositorFrameWithResources(ids2, arraysize(ids2), true, SurfaceId(), |
| - &factory2, surface2_id); |
| + &support2, surface2_id); |
| CompositorFrame frame = aggregator_->Aggregate(surface1_id); |
| - SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &factory1, |
| + SubmitCompositorFrameWithResources(NULL, 0, true, SurfaceId(), &support1, |
| surface1_id); |
| // Nothing should be available to be returned yet. |
| @@ -2107,40 +2083,44 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) { |
| testing::WhenSorted(testing::ElementsAreArray(ids))); |
| EXPECT_EQ(3u, resource_provider_->num_resources()); |
| - factory1.EvictSurface(); |
| - factory2.EvictSurface(); |
| + support1.EvictFrame(); |
| + support2.EvictFrame(); |
| } |
| // Ensure that aggregator completely ignores Surfaces that reference invalid |
| // resources. |
| TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) { |
| - ResourceTrackingSurfaceFactoryClient client; |
| - SurfaceFactory root_factory(kArbitraryRootFrameSinkId, &manager_, &client); |
| - SurfaceFactory middle_factory(kArbitraryMiddleFrameSinkId, &manager_, |
| - &client); |
| - SurfaceFactory child_factory(kArbitraryChildFrameSinkId1, &manager_, &client); |
| + CompositorFrameSinkSupport root_support( |
| + nullptr, &manager_, kArbitraryRootFrameSinkId, is_root, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport middle_support( |
| + nullptr, &manager_, kArbitraryMiddleFrameSinkId, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport child_support( |
| + nullptr, &manager_, kArbitraryFrameSinkId1, is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId root_local_surface_id(7u, kArbitraryToken); |
| - SurfaceId root_surface_id(root_factory.frame_sink_id(), |
| + SurfaceId root_surface_id(root_support.frame_sink_id(), |
| root_local_surface_id); |
| LocalSurfaceId middle_local_surface_id(8u, kArbitraryToken); |
| - SurfaceId middle_surface_id(middle_factory.frame_sink_id(), |
| + SurfaceId middle_surface_id(middle_support.frame_sink_id(), |
| middle_local_surface_id); |
| LocalSurfaceId child_local_surface_id(9u, kArbitraryToken); |
| - SurfaceId child_surface_id(child_factory.frame_sink_id(), |
| + SurfaceId child_surface_id(child_support.frame_sink_id(), |
| child_local_surface_id); |
| ResourceId ids[] = {14, 15, 16}; |
| SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(), |
| - &child_factory, child_surface_id); |
| + &child_support, child_surface_id); |
| ResourceId ids2[] = {17, 18, 19}; |
| SubmitCompositorFrameWithResources(ids2, arraysize(ids2), false, |
| - child_surface_id, &middle_factory, |
| + child_surface_id, &middle_support, |
| middle_surface_id); |
| ResourceId ids3[] = {20, 21, 22}; |
| SubmitCompositorFrameWithResources(ids3, arraysize(ids3), true, |
| - middle_surface_id, &root_factory, |
| + middle_surface_id, &root_support, |
| root_surface_id); |
| CompositorFrame frame; |
| @@ -2151,7 +2131,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) { |
| EXPECT_EQ(1u, pass_list->back()->shared_quad_state_list.size()); |
| EXPECT_EQ(3u, pass_list->back()->quad_list.size()); |
| SubmitCompositorFrameWithResources(ids2, arraysize(ids), true, |
| - child_surface_id, &middle_factory, |
| + child_surface_id, &middle_support, |
| middle_surface_id); |
| frame = aggregator_->Aggregate(root_surface_id); |
| @@ -2161,24 +2141,27 @@ TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) { |
| EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size()); |
| EXPECT_EQ(9u, pass_list->back()->quad_list.size()); |
| - root_factory.EvictSurface(); |
| - middle_factory.EvictSurface(); |
| - child_factory.EvictSurface(); |
| + root_support.EvictFrame(); |
| + middle_support.EvictFrame(); |
| + child_support.EvictFrame(); |
| } |
| TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) { |
| - ResourceTrackingSurfaceFactoryClient client; |
| - SurfaceFactory factory1(FrameSinkId(1, 1), &manager_, &client); |
| - SurfaceFactory factory2(FrameSinkId(2, 2), &manager_, &client); |
| + CompositorFrameSinkSupport support1( |
| + nullptr, &manager_, FrameSinkId(1, 1), is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| + CompositorFrameSinkSupport support2( |
| + nullptr, &manager_, FrameSinkId(2, 2), is_root_child, |
| + handles_frame_sink_id_invalidation, needs_sync_points); |
| LocalSurfaceId local_frame1_id(7u, base::UnguessableToken::Create()); |
| - SurfaceId surface1_id(factory1.frame_sink_id(), local_frame1_id); |
| + SurfaceId surface1_id(support1.frame_sink_id(), local_frame1_id); |
| LocalSurfaceId local_frame2_id(8u, base::UnguessableToken::Create()); |
| - SurfaceId surface2_id(factory2.frame_sink_id(), local_frame2_id); |
| + SurfaceId surface2_id(support2.frame_sink_id(), local_frame2_id); |
| ResourceId ids[] = {11, 12, 13}; |
| SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(), |
| - &factory1, surface1_id); |
| + &support1, surface1_id); |
| CompositorFrame frame = aggregator_->Aggregate(surface1_id); |
| @@ -2201,8 +2184,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) { |
| CompositorFrame frame; |
| frame.render_pass_list.push_back(std::move(pass)); |
| - factory2.SubmitCompositorFrame(local_frame2_id, std::move(frame), |
| - SurfaceFactory::DrawCallback()); |
| + support2.SubmitCompositorFrame(local_frame2_id, std::move(frame)); |
| } |
| frame = aggregator_->Aggregate(surface2_id); |
| @@ -2228,8 +2210,8 @@ TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) { |
| // Output is insecure, so texture should be drawn. |
| EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material); |
| - factory1.EvictSurface(); |
| - factory2.EvictSurface(); |
| + support1.EvictFrame(); |
| + support2.EvictFrame(); |
| } |
| // Ensure that the render passes have correct color spaces. |
| @@ -2244,10 +2226,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, ColorSpaceTest) { |
| gfx::ColorSpace color_space2 = gfx::ColorSpace::CreateSRGB(); |
| gfx::ColorSpace color_space3 = gfx::ColorSpace::CreateSCRGBLinear(); |
| - SubmitCompositorFrame(&factory_, passes, arraysize(passes), |
| + SubmitCompositorFrame(&support_, passes, arraysize(passes), |
| root_local_surface_id_); |
| - SurfaceId surface_id(factory_.frame_sink_id(), root_local_surface_id_); |
| + SurfaceId surface_id(support_.frame_sink_id(), root_local_surface_id_); |
| CompositorFrame aggregated_frame; |
| aggregator_.SetOutputColorSpace(color_space1, color_space1); |
