cc/surfaces/surface_aggregator_unittest.cc - Issue 2449853004: Getting rid of DelegatedFrameData

Unified Diff: cc/surfaces/surface_aggregator_unittest.cc

Issue 2449853004: Getting rid of DelegatedFrameData (Closed)

Patch Set: IsEmpty + rebase Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: cc/surfaces/surface_aggregator_unittest.cc

diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc

index da6a68c01274468c05259f38053d002f7e03458c..8f3146b11fb750c469048a59acf7fc199ec4d682 100644

--- a/cc/surfaces/surface_aggregator_unittest.cc

+++ b/cc/surfaces/surface_aggregator_unittest.cc

@@ -12,7 +12,6 @@

#include "base/macros.h"

#include "base/memory/ptr_util.h"

#include "cc/output/compositor_frame.h"

-#include "cc/output/delegated_frame_data.h"

#include "cc/quads/render_pass.h"

#include "cc/quads/render_pass_draw_quad.h"

#include "cc/quads/solid_color_draw_quad.h"

@@ -85,7 +84,6 @@ TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {

factory_.Create(local_frame_id);

CompositorFrame frame = aggregator_.Aggregate(one_id);

- EXPECT_FALSE(frame.delegated_frame_data);

factory_.Destroy(local_frame_id);

}

@@ -120,17 +118,12 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {

CompositorFrame aggregated_frame = aggregator_.Aggregate(

SurfaceId(factory_.frame_sink_id(), root_local_frame_id_));

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- TestPassesMatchExpectations(

- expected_passes, expected_pass_count, &frame_data->render_pass_list);

+ TestPassesMatchExpectations(expected_passes, expected_pass_count,

+ &aggregated_frame.render_pass_list);

// Ensure no duplicate pass ids output.

std::set<RenderPassId> used_passes;

- for (const auto& pass : frame_data->render_pass_list) {

+ for (const auto& pass : aggregated_frame.render_pass_list) {

EXPECT_TRUE(used_passes.insert(pass->id).second);

}

@@ -146,11 +139,8 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {

void SubmitPassListAsFrame(SurfaceFactory* factory,

const LocalFrameId& local_frame_id,

RenderPassList* pass_list) {

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

- pass_list->swap(frame_data->render_pass_list);

CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ pass_list->swap(frame.render_pass_list);

factory->SubmitCompositorFrame(local_frame_id, std::move(frame),

SurfaceFactory::DrawCallback());

@@ -167,12 +157,8 @@ class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {

void QueuePassAsFrame(std::unique_ptr<RenderPass> pass,

const LocalFrameId& local_frame_id) {

- std::unique_ptr<DelegatedFrameData> delegated_frame_data(

- new DelegatedFrameData);

- delegated_frame_data->render_pass_list.push_back(std::move(pass));

CompositorFrame child_frame;

- child_frame.delegated_frame_data = std::move(delegated_frame_data);

+ child_frame.render_pass_list.push_back(std::move(pass));

factory_.SubmitCompositorFrame(local_frame_id, std::move(child_frame),

SurfaceFactory::DrawCallback());

@@ -230,11 +216,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, OpacityCopied) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- RenderPassList& render_pass_list(frame_data->render_pass_list);

+ RenderPassList& render_pass_list(aggregated_frame.render_pass_list);

ASSERT_EQ(2u, render_pass_list.size());

SharedQuadStateList& shared_quad_state_list(

render_pass_list[0]->shared_quad_state_list);

@@ -335,24 +317,19 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, CopyRequest) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

test::Quad expected_quads[] = {

test::Quad::SolidColorQuad(SK_ColorWHITE),

- test::Quad::RenderPassQuad(frame_data->render_pass_list[0]->id),

+ test::Quad::RenderPassQuad(aggregated_frame.render_pass_list[0]->id),

test::Quad::SolidColorQuad(SK_ColorBLACK)};

test::Pass expected_passes[] = {

test::Pass(embedded_quads, arraysize(embedded_quads)),

test::Pass(expected_quads, arraysize(expected_quads))};

- TestPassesMatchExpectations(expected_passes,

- arraysize(expected_passes),

- &frame_data->render_pass_list);

- ASSERT_EQ(2u, frame_data->render_pass_list.size());

- ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());

+ TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),

+ &aggregated_frame.render_pass_list);

+ ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());

+ ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());

DCHECK_EQ(copy_request_ptr,

- frame_data->render_pass_list[0]->copy_requests[0].get());

+ aggregated_frame.render_pass_list[0]->copy_requests[0].get());

SurfaceId surface_ids[] = {root_surface_id, embedded_surface_id};

EXPECT_EQ(arraysize(surface_ids),

@@ -402,11 +379,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {

pass_list[0]->copy_requests.push_back(std::move(copy_request));

pass_list[1]->copy_requests.push_back(std::move(copy_request2));

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

- pass_list.swap(frame_data->render_pass_list);

CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ pass_list.swap(frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(frame),

SurfaceFactory::DrawCallback());

@@ -415,26 +389,21 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorWHITE),

test::Quad::SolidColorQuad(SK_ColorGREEN),

test::Quad::SolidColorQuad(SK_ColorBLACK)};

test::Pass expected_passes[] = {

test::Pass(expected_quads, arraysize(expected_quads)),

test::Pass(root_quads2, arraysize(root_quads2))};

- TestPassesMatchExpectations(expected_passes,

- arraysize(expected_passes),

- &frame_data->render_pass_list);

- ASSERT_EQ(2u, frame_data->render_pass_list.size());

- ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());

+ TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),

+ &aggregated_frame.render_pass_list);

+ ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());

+ ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());

DCHECK_EQ(copy_request_ptr,

- frame_data->render_pass_list[0]->copy_requests[0].get());

- ASSERT_EQ(1u, frame_data->render_pass_list[1]->copy_requests.size());

+ aggregated_frame.render_pass_list[0]->copy_requests[0].get());

+ ASSERT_EQ(1u, aggregated_frame.render_pass_list[1]->copy_requests.size());

DCHECK_EQ(copy_request2_ptr,

- frame_data->render_pass_list[1]->copy_requests[0].get());

+ aggregated_frame.render_pass_list[1]->copy_requests[0].get());

SurfaceId surface_ids[] = {root_surface_id, embedded_surface_id};

EXPECT_EQ(arraysize(surface_ids),

@@ -448,8 +417,7 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RootCopyRequest) {

// Ensure copy requests have been removed from root surface.

const CompositorFrame& original_frame =

manager_.GetSurfaceForId(root_surface_id)->GetEligibleFrame();

- RenderPassList& original_pass_list =

- original_frame.delegated_frame_data->render_pass_list;

+ const RenderPassList& original_pass_list = original_frame.render_pass_list;

ASSERT_EQ(2u, original_pass_list.size());

DCHECK(original_pass_list[0]->copy_requests.empty());

DCHECK(original_pass_list[1]->copy_requests.empty());

@@ -489,12 +457,11 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {

test::Pass(parent_quads, arraysize(parent_quads))};

{

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

- AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),

- parent_passes, arraysize(parent_passes));

CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), parent_passes,

+ arraysize(parent_passes));

frame.metadata.referenced_surfaces.push_back(embedded_surface_id);

factory_.SubmitCompositorFrame(parent_local_frame_id, std::move(frame),

@@ -506,12 +473,10 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {

test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};

{

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

- AddPasses(&frame_data->render_pass_list, gfx::Rect(SurfaceSize()),

- root_passes, arraysize(root_passes));

CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ AddPasses(&frame.render_pass_list, gfx::Rect(SurfaceSize()), root_passes,

+ arraysize(root_passes));

frame.metadata.referenced_surfaces.push_back(parent_surface_id);

// Reference to Surface ID of a Surface that doesn't exist should be

// included in previous_contained_surfaces, but otherwise ignored.

@@ -524,10 +489,6 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

// First pass should come from surface that had a copy request but was not

// referenced directly. The second pass comes from the root surface.

// parent_quad should be ignored because it is neither referenced through a

@@ -536,11 +497,11 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, UnreferencedSurface) {

test::Pass(embedded_quads, arraysize(embedded_quads)),

test::Pass(root_quads, arraysize(root_quads))};

TestPassesMatchExpectations(expected_passes, arraysize(expected_passes),

- &frame_data->render_pass_list);

- ASSERT_EQ(2u, frame_data->render_pass_list.size());

- ASSERT_EQ(1u, frame_data->render_pass_list[0]->copy_requests.size());

+ &aggregated_frame.render_pass_list);

+ ASSERT_EQ(2u, aggregated_frame.render_pass_list.size());

+ ASSERT_EQ(1u, aggregated_frame.render_pass_list[0]->copy_requests.size());

DCHECK_EQ(copy_request_ptr,

- frame_data->render_pass_list[0]->copy_requests[0].get());

+ aggregated_frame.render_pass_list[0]->copy_requests[0].get());

SurfaceId surface_ids[] = {

SurfaceId(factory_.frame_sink_id(), root_local_frame_id_),

@@ -595,11 +556,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, MultiPassSurfaceReference) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(5u, aggregated_pass_list.size());

RenderPassId actual_pass_ids[] = {

@@ -841,11 +799,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, RenderPassIdMapping) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

RenderPassId actual_pass_ids[] = {aggregated_pass_list[0]->id,

@@ -1009,11 +964,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateSharedQuadStateProperties) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(1u, aggregated_pass_list.size());

@@ -1083,12 +1035,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {

child_root_pass_sqs->is_clipped = true;

child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);

- std::unique_ptr<DelegatedFrameData> child_frame_data(

- new DelegatedFrameData);

- child_pass_list.swap(child_frame_data->render_pass_list);

CompositorFrame child_frame;

- child_frame.delegated_frame_data = std::move(child_frame_data);

+ child_pass_list.swap(child_frame.render_pass_list);

danakj 2016/10/27 23:06:56 Can you maybe instead define child_frame earlier a

Saman Sami 2016/10/28 16:47:35 Done.

factory_.SubmitCompositorFrame(child_local_frame_id, std::move(child_frame),

SurfaceFactory::DrawCallback());

@@ -1116,12 +1064,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {

middle_root_pass->shared_quad_state_list.front();

middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3);

- std::unique_ptr<DelegatedFrameData> middle_frame_data(

- new DelegatedFrameData);

- middle_pass_list.swap(middle_frame_data->render_pass_list);

CompositorFrame middle_frame;

danakj 2016/10/27 23:06:56 same

- middle_frame.delegated_frame_data = std::move(middle_frame_data);

+ middle_pass_list.swap(middle_frame.render_pass_list);

factory_.SubmitCompositorFrame(middle_local_frame_id,

std::move(middle_frame),

@@ -1154,11 +1098,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {

root_pass_list[0]->transform_to_root_target.Translate(10, 5);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

danakj 2016/10/27 23:06:56 same

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),

SurfaceFactory::DrawCallback());

@@ -1166,11 +1107,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateMultiplePassWithTransform) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1260,11 +1198,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

child_root_pass->shared_quad_state_list.front();

child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);

- std::unique_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);

- child_pass_list.swap(child_frame_data->render_pass_list);

CompositorFrame child_frame;

danakj 2016/10/27 23:06:56 same

- child_frame.delegated_frame_data = std::move(child_frame_data);

+ child_pass_list.swap(child_frame.render_pass_list);

LocalFrameId child_local_frame_id = allocator_.GenerateId();

SurfaceId child_surface_id(factory_.frame_sink_id(), child_local_frame_id);

@@ -1286,13 +1221,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

// Parent surface is only used to test if the transform is applied correctly

// to the child surface's damage.

- std::unique_ptr<DelegatedFrameData> parent_surface_frame_data(

- new DelegatedFrameData);

- parent_surface_pass_list.swap(parent_surface_frame_data->render_pass_list);

CompositorFrame parent_surface_frame;

danakj 2016/10/27 23:06:56 same

- parent_surface_frame.delegated_frame_data =

- std::move(parent_surface_frame_data);

+ parent_surface_pass_list.swap(parent_surface_frame.render_pass_list);

LocalFrameId parent_local_frame_id = allocator_.GenerateId();

SurfaceId parent_surface_id(factory_.frame_sink_id(), parent_local_frame_id);

@@ -1324,11 +1254,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);

root_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

danakj 2016/10/27 23:06:56 same.. ok u get the idea lol

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),

SurfaceFactory::DrawCallback());

@@ -1336,11 +1263,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(2u, aggregated_pass_list.size());

@@ -1360,12 +1284,8 @@ 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);

- std::unique_ptr<DelegatedFrameData> child_frame_data(

- new DelegatedFrameData);

- child_pass_list.swap(child_frame_data->render_pass_list);

CompositorFrame child_frame;

- child_frame.delegated_frame_data = std::move(child_frame_data);

+ child_pass_list.swap(child_frame.render_pass_list);

factory_.SubmitCompositorFrame(child_local_frame_id, std::move(child_frame),

SurfaceFactory::DrawCallback());

@@ -1373,12 +1293,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(2u, aggregated_pass_list.size());

@@ -1400,11 +1316,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

->quad_to_target_transform.Translate(0, 10);

root_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),

SurfaceFactory::DrawCallback());

@@ -1422,11 +1335,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

->quad_to_target_transform.Translate(0, 10);

root_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),

SurfaceFactory::DrawCallback());

@@ -1434,12 +1344,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(2u, aggregated_pass_list.size());

@@ -1454,12 +1360,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(2u, aggregated_pass_list.size());

@@ -1472,12 +1374,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {

aggregator_.SetFullDamageForSurface(root_surface_id);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(2u, aggregated_pass_list.size());

@@ -1503,11 +1401,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {

root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 100, 100);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.SubmitCompositorFrame(root_local_frame_id_, std::move(root_frame),

SurfaceFactory::DrawCallback());

@@ -1516,12 +1411,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(1u, aggregated_pass_list.size());

@@ -1546,11 +1437,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {

root_pass_list[0]->damage_rect = gfx::Rect(1, 2, 3, 4);

- std::unique_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);

- root_pass_list.swap(root_frame_data->render_pass_list);

CompositorFrame root_frame;

- root_frame.delegated_frame_data = std::move(root_frame_data);

+ root_pass_list.swap(root_frame.render_pass_list);

factory_.Create(second_root_local_frame_id);

factory_.SubmitCompositorFrame(second_root_local_frame_id,

@@ -1563,12 +1451,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {

CompositorFrame aggregated_frame =

aggregator_.Aggregate(second_root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(1u, aggregated_pass_list.size());

@@ -1580,12 +1464,8 @@ TEST_F(SurfaceAggregatorValidSurfaceTest, SwitchSurfaceDamage) {

CompositorFrame aggregated_frame =

aggregator_.Aggregate(second_root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(1u, aggregated_pass_list.size());

@@ -1666,11 +1546,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

SurfaceId root_surface_id(factory_.frame_sink_id(), root_local_frame_id_);

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data = aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1700,12 +1577,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

{

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1754,12 +1627,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

{

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

// Output frame should have no damage, but all quads included.

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1779,12 +1648,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

{

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

// There were no changes since last aggregation, so output should be empty

// and have no damage.

ASSERT_EQ(1u, aggregated_pass_list.size());

@@ -1820,12 +1685,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

{

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1870,12 +1731,8 @@ TEST_F(SurfaceAggregatorPartialSwapTest, IgnoreOutside) {

{

CompositorFrame aggregated_frame = aggregator_.Aggregate(root_surface_id);

- ASSERT_TRUE(aggregated_frame.delegated_frame_data);

- DelegatedFrameData* frame_data =

- aggregated_frame.delegated_frame_data.get();

- const RenderPassList& aggregated_pass_list = frame_data->render_pass_list;

+ const RenderPassList& aggregated_pass_list =

+ aggregated_frame.render_pass_list;

ASSERT_EQ(3u, aggregated_pass_list.size());

@@ -1941,7 +1798,7 @@ void SubmitCompositorFrameWithResources(ResourceId* resource_ids,

SurfaceId child_id,

SurfaceFactory* factory,

SurfaceId surface_id) {

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

+ CompositorFrame frame;

std::unique_ptr<RenderPass> pass = RenderPass::Create();

pass->id = RenderPassId(1, 1);

SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();

@@ -1958,7 +1815,7 @@ void SubmitCompositorFrameWithResources(ResourceId* resource_ids,

resource.id = resource_ids[i];

// ResourceProvider is software, so only software resources are valid.

resource.is_software = valid;

- frame_data->resource_list.push_back(resource);

+ frame.resource_list.push_back(resource);

TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();

const gfx::Rect rect;

const gfx::Rect opaque_rect;

@@ -1977,9 +1834,7 @@ void SubmitCompositorFrameWithResources(ResourceId* resource_ids,

uv_bottom_right, background_color, vertex_opacity, flipped,

nearest_neighbor, secure_output_only);

}

- frame_data->render_pass_list.push_back(std::move(pass));

- CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ frame.render_pass_list.push_back(std::move(pass));

factory->SubmitCompositorFrame(surface_id.local_frame_id(), std::move(frame),

SurfaceFactory::DrawCallback());

}

@@ -2022,7 +1877,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {

SurfaceId surface_id(kArbitraryFrameSinkId, local_frame_id);

factory.Create(local_frame_id);

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

+ CompositorFrame frame;

std::unique_ptr<RenderPass> pass = RenderPass::Create();

pass->id = RenderPassId(1, 1);

TransferableResource resource;

@@ -2030,10 +1885,8 @@ TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {

// ResourceProvider is software but resource is not, so it should be

// ignored.

resource.is_software = false;

- frame_data->resource_list.push_back(resource);

- frame_data->render_pass_list.push_back(std::move(pass));

- CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ frame.resource_list.push_back(resource);

+ frame.render_pass_list.push_back(std::move(pass));

factory.SubmitCompositorFrame(local_frame_id, std::move(frame),

SurfaceFactory::DrawCallback());

@@ -2123,7 +1976,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {

CompositorFrame frame;

frame = aggregator_->Aggregate(root_surface_id);

- RenderPassList* pass_list = &frame.delegated_frame_data->render_pass_list;

+ RenderPassList* pass_list = &frame.render_pass_list;

ASSERT_EQ(1u, pass_list->size());

EXPECT_EQ(1u, pass_list->back()->shared_quad_state_list.size());

EXPECT_EQ(3u, pass_list->back()->quad_list.size());

@@ -2134,7 +1987,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {

frame = aggregator_->Aggregate(root_surface_id);

- pass_list = &frame.delegated_frame_data->render_pass_list;

+ pass_list = &frame.render_pass_list;

ASSERT_EQ(1u, pass_list->size());

EXPECT_EQ(3u, pass_list->back()->shared_quad_state_list.size());

EXPECT_EQ(9u, pass_list->back()->quad_list.size());

@@ -2161,13 +2014,11 @@ TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {

CompositorFrame frame = aggregator_->Aggregate(surface1_id);

- RenderPass* render_pass =

- frame.delegated_frame_data->render_pass_list.back().get();

+ RenderPass* render_pass = frame.render_pass_list.back().get();

EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, render_pass->quad_list.back()->material);

{

- std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);

std::unique_ptr<RenderPass> pass = RenderPass::Create();

pass->id = RenderPassId(1, 1);

SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();

@@ -2178,23 +2029,23 @@ TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {

surface1_id);

pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());

- frame_data->render_pass_list.push_back(std::move(pass));

CompositorFrame frame;

- frame.delegated_frame_data = std::move(frame_data);

+ frame.render_pass_list.push_back(std::move(pass));

factory.SubmitCompositorFrame(local_frame2_id, std::move(frame),

SurfaceFactory::DrawCallback());

}

frame = aggregator_->Aggregate(surface2_id);

- EXPECT_EQ(1u, frame.delegated_frame_data->render_pass_list.size());

- render_pass = frame.delegated_frame_data->render_pass_list.front().get();

+ EXPECT_EQ(1u, frame.render_pass_list.size());

+ render_pass = frame.render_pass_list.front().get();

// Parent has copy request, so texture should not be drawn.

EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);

frame = aggregator_->Aggregate(surface2_id);

- EXPECT_EQ(1u, frame.delegated_frame_data->render_pass_list.size());

- render_pass = frame.delegated_frame_data->render_pass_list.front().get();

+ EXPECT_EQ(1u, frame.render_pass_list.size());

+ render_pass = frame.render_pass_list.front().get();

// Copy request has been executed earlier, so texture should be drawn.

EXPECT_EQ(DrawQuad::TEXTURE_CONTENT,

@@ -2203,7 +2054,7 @@ TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {

aggregator_->set_output_is_secure(false);

frame = aggregator_->Aggregate(surface2_id);

- render_pass = frame.delegated_frame_data->render_pass_list.back().get();

+ render_pass = frame.render_pass_list.back().get();

// Output is insecure, so texture should be drawn.

EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);

« cc/surfaces/surface.cc ('K') | « cc/surfaces/surface_aggregator_perftest.cc ('k') | cc/surfaces/surface_factory.cc » ('j') | cc/surfaces/surface_factory_unittest.cc » ('J')