Skip to content

GitLab

T
tangled
Commit 2260e5bf authored by weiliangc@chromium.org's avatar weiliangc@chromium.org
Browse files
Options

Update Mojo surfaces type converters to use RP for generating DQ and SQS 

In order for RenderPass to own allocation of DrawQuads and
SharedQuadState, update surface type converter code in mojo so when
convert to DrawQuad and SharedQuadState, function takes in pointer to RenderPass
as parameter. Also in unittest, create RenderPass to deal with DrawQuad and
SharedQuadState creation.

Follows 398533002.

BUG=344962

Review URL: https://codereview.chromium.org/393103003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@284104 0039d316-1c4b-4281-b951-d872f2087c98
parent 27e6a21b
Show whitespace changes
Inline Side-by-side
Showing with 184 additions and 149 deletions
mojo/services/public/cpp/surfaces/lib/surfaces_type_converters.cc
View file @ 2260e5bf
......@@ -16,6 +16,80 @@
namespace mojo {
namespace {
cc::SharedQuadState* ConvertToSharedQuadState(
const surfaces::SharedQuadStatePtr& input,
cc::RenderPass* render_pass) {
cc::SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
input->content_bounds.To<gfx::Size>(),
input->visible_content_rect.To<gfx::Rect>(),
input->clip_rect.To<gfx::Rect>(),
input->is_clipped,
input->opacity,
static_cast<SkXfermode::Mode>(input->blend_mode),
input->sorting_context_id);
return state;
}
cc::DrawQuad* ConvertToDrawQuad(const surfaces::QuadPtr& input,
cc::SharedQuadState* sqs,
cc::RenderPass* render_pass) {
switch (input->material) {
case surfaces::MATERIAL_SOLID_COLOR: {
cc::SolidColorDrawQuad* color_quad =
render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
color_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
input->solid_color_quad_state->color.To<SkColor>(),
input->solid_color_quad_state->force_anti_aliasing_off);
return color_quad;
}
case surfaces::MATERIAL_SURFACE_CONTENT: {
cc::SurfaceDrawQuad* surface_quad =
render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
surface_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
input->surface_quad_state->surface.To<cc::SurfaceId>());
return surface_quad;
}
case surfaces::MATERIAL_TEXTURE_CONTENT: {
cc::TextureDrawQuad* texture_quad =
render_pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
surfaces::TextureQuadStatePtr& texture_quad_state =
input->texture_quad_state;
texture_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
texture_quad_state->resource_id,
texture_quad_state->premultiplied_alpha,
texture_quad_state->uv_top_left.To<gfx::PointF>(),
texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
texture_quad_state->background_color.To<SkColor>(),
texture_quad_state->vertex_opacity.storage().data(),
texture_quad_state->flipped);
return texture_quad;
}
default:
NOTREACHED() << "Unsupported material " << input->material;
}
return NULL;
}
} // namespace
// static
surfaces::SurfaceIdPtr
TypeConverter<surfaces::SurfaceIdPtr, cc::SurfaceId>::ConvertFrom(
......@@ -108,58 +182,6 @@ surfaces::QuadPtr TypeConverter<surfaces::QuadPtr, cc::DrawQuad>::ConvertFrom(
return quad.Pass();
}
// static
scoped_ptr<cc::DrawQuad> ConvertTo(const surfaces::QuadPtr& input,
cc::SharedQuadState* sqs) {
switch (input->material) {
case surfaces::MATERIAL_SOLID_COLOR: {
scoped_ptr<cc::SolidColorDrawQuad> color_quad(new cc::SolidColorDrawQuad);
color_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
input->solid_color_quad_state->color.To<SkColor>(),
input->solid_color_quad_state->force_anti_aliasing_off);
return color_quad.PassAs<cc::DrawQuad>();
}
case surfaces::MATERIAL_SURFACE_CONTENT: {
scoped_ptr<cc::SurfaceDrawQuad> surface_quad(new cc::SurfaceDrawQuad);
surface_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
input->surface_quad_state->surface.To<cc::SurfaceId>());
return surface_quad.PassAs<cc::DrawQuad>();
}
case surfaces::MATERIAL_TEXTURE_CONTENT: {
scoped_ptr<cc::TextureDrawQuad> texture_quad(new cc::TextureDrawQuad);
surfaces::TextureQuadStatePtr& texture_quad_state =
input->texture_quad_state;
texture_quad->SetAll(
sqs,
input->rect.To<gfx::Rect>(),
input->opaque_rect.To<gfx::Rect>(),
input->visible_rect.To<gfx::Rect>(),
input->needs_blending,
texture_quad_state->resource_id,
texture_quad_state->premultiplied_alpha,
texture_quad_state->uv_top_left.To<gfx::PointF>(),
texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
texture_quad_state->background_color.To<SkColor>(),
texture_quad_state->vertex_opacity.storage().data(),
texture_quad_state->flipped);
return texture_quad.PassAs<cc::DrawQuad>();
}
default:
NOTREACHED() << "Unsupported material " << input->material;
}
return scoped_ptr<cc::DrawQuad>();
}
// static
surfaces::SharedQuadStatePtr
TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
......@@ -177,21 +199,6 @@ TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState>::ConvertFrom(
return state.Pass();
}
// static
scoped_ptr<cc::SharedQuadState> ConvertTo(
const surfaces::SharedQuadStatePtr& input) {
scoped_ptr<cc::SharedQuadState> state(new cc::SharedQuadState);
state->SetAll(input->content_to_target_transform.To<gfx::Transform>(),
input->content_bounds.To<gfx::Size>(),
input->visible_content_rect.To<gfx::Rect>(),
input->clip_rect.To<gfx::Rect>(),
input->is_clipped,
input->opacity,
static_cast<SkXfermode::Mode>(input->blend_mode),
input->sorting_context_id);
return state.Pass();
}
// static
surfaces::PassPtr TypeConverter<surfaces::PassPtr, cc::RenderPass>::ConvertFrom(
const cc::RenderPass& input) {
......@@ -236,14 +243,13 @@ scoped_ptr<cc::RenderPass> ConvertTo(const surfaces::PassPtr& input) {
cc::SharedQuadStateList& sqs_list = pass->shared_quad_state_list;
sqs_list.reserve(input->shared_quad_states.size());
for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
sqs_list.push_back(ConvertTo(input->shared_quad_states[i]));
ConvertToSharedQuadState(input->shared_quad_states[i], pass.get());
}
cc::QuadList& quad_list = pass->quad_list;
quad_list.reserve(input->quads.size());
pass->quad_list.reserve(input->quads.size());
for (size_t i = 0; i < input->quads.size(); ++i) {
surfaces::QuadPtr quad = input->quads[i].Pass();
quad_list.push_back(
ConvertTo(quad, sqs_list[quad->shared_quad_state_index]));
ConvertToDrawQuad(
quad, sqs_list[quad->shared_quad_state_index], pass.get());
}
return pass.Pass();
}
......
mojo/services/public/cpp/surfaces/surfaces_type_converters.h
View file @ 2260e5bf
......@@ -49,13 +49,6 @@ class MOJO_SURFACES_EXPORT TypeConverter<surfaces::QuadPtr, cc::DrawQuad> {
static surfaces::QuadPtr ConvertFrom(const cc::DrawQuad& input);
};
// This can't use the TypeConverter since it has to return a pointer to a type
// since cc::DrawQuad is polymorphic and needs an additional input. The
// TypeConverter for surfaces::Pass calls this explicitly.
MOJO_SURFACES_EXPORT scoped_ptr<cc::DrawQuad> ConvertTo(
const surfaces::QuadPtr& input,
cc::SharedQuadState* sqs);
template <>
class MOJO_SURFACES_EXPORT
TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState> {
......@@ -64,9 +57,6 @@ TypeConverter<surfaces::SharedQuadStatePtr, cc::SharedQuadState> {
const cc::SharedQuadState& input);
};
MOJO_SURFACES_EXPORT scoped_ptr<cc::SharedQuadState> ConvertTo(
const surfaces::SharedQuadStatePtr& input);
template <>
class MOJO_SURFACES_EXPORT TypeConverter<surfaces::PassPtr, cc::RenderPass> {
public:
......
mojo/services/public/cpp/surfaces/tests/surface_unittest.cc
View file @ 2260e5bf
......@@ -41,25 +41,29 @@ TEST(SurfaceLibTest, Color) {
class SurfaceLibQuadTest : public testing::Test {
public:
SurfaceLibQuadTest()
: sqs(new cc::SharedQuadState),
rect(5, 7, 13, 19),
: rect(5, 7, 13, 19),
opaque_rect(rect),
visible_rect(9, 11, 5, 7),
needs_blending(false) {}
needs_blending(false) {
pass = cc::RenderPass::Create();
sqs = pass->CreateAndAppendSharedQuadState();
}
protected:
scoped_ptr<cc::SharedQuadState> sqs;
gfx::Rect rect;
gfx::Rect opaque_rect;
gfx::Rect visible_rect;
bool needs_blending;
scoped_ptr<cc::RenderPass> pass;
cc::SharedQuadState* sqs;
};
TEST_F(SurfaceLibQuadTest, ColorQuad) {
scoped_ptr<cc::SolidColorDrawQuad> color_quad(new cc::SolidColorDrawQuad);
cc::SolidColorDrawQuad* color_quad =
pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
SkColor arbitrary_color = SK_ColorGREEN;
bool force_anti_aliasing_off = true;
color_quad->SetAll(sqs.get(),
color_quad->SetAll(sqs,
rect,
opaque_rect,
visible_rect,
......@@ -67,8 +71,7 @@ TEST_F(SurfaceLibQuadTest, ColorQuad) {
arbitrary_color,
force_anti_aliasing_off);
cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(color_quad.get());
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*(pass->quad_list.back()));
ASSERT_FALSE(mojo_quad.is_null());
EXPECT_EQ(surfaces::MATERIAL_SOLID_COLOR, mojo_quad->material);
EXPECT_EQ(Rect::From(rect), mojo_quad->rect);
......@@ -80,28 +83,16 @@ TEST_F(SurfaceLibQuadTest, ColorQuad) {
mojo_quad->solid_color_quad_state;
EXPECT_EQ(surfaces::Color::From(arbitrary_color), mojo_color_state->color);
EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);
scoped_ptr<cc::DrawQuad> round_trip_quad =
ConvertTo(mojo_quad.Pass(), sqs.get());
EXPECT_EQ(rect, round_trip_quad->rect);
EXPECT_EQ(opaque_rect, round_trip_quad->opaque_rect);
EXPECT_EQ(visible_rect, round_trip_quad->visible_rect);
EXPECT_EQ(needs_blending, round_trip_quad->needs_blending);
ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material);
const cc::SolidColorDrawQuad* round_trip_color_quad =
cc::SolidColorDrawQuad::MaterialCast(round_trip_quad.get());
EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
EXPECT_EQ(force_anti_aliasing_off,
round_trip_color_quad->force_anti_aliasing_off);
}
TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
scoped_ptr<cc::SurfaceDrawQuad> surface_quad(new cc::SurfaceDrawQuad);
cc::SurfaceDrawQuad* surface_quad =
pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
cc::SurfaceId arbitrary_id(5);
surface_quad->SetAll(
sqs.get(), rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(surface_quad.get());
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*(pass->quad_list.back()));
ASSERT_FALSE(mojo_quad.is_null());
EXPECT_EQ(surfaces::MATERIAL_SURFACE_CONTENT, mojo_quad->material);
ASSERT_TRUE(mojo_quad->surface_quad_state);
......@@ -109,17 +100,11 @@ TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
mojo_quad->surface_quad_state;
EXPECT_EQ(surfaces::SurfaceId::From(arbitrary_id),
mojo_surface_state->surface);
scoped_ptr<cc::DrawQuad> round_trip_quad =
ConvertTo(mojo_quad.Pass(), sqs.get());
ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material);
const cc::SurfaceDrawQuad* round_trip_surface_quad =
cc::SurfaceDrawQuad::MaterialCast(round_trip_quad.get());
EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
}
TEST_F(SurfaceLibQuadTest, TextureQuad) {
scoped_ptr<cc::TextureDrawQuad> texture_quad(new cc::TextureDrawQuad);
cc::TextureDrawQuad* texture_quad =
pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
unsigned resource_id = 9;
bool premultiplied_alpha = true;
gfx::PointF uv_top_left(1.7f, 2.1f);
......@@ -127,7 +112,7 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
SkColor background_color = SK_ColorYELLOW;
float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
bool flipped = false;
texture_quad->SetAll(sqs.get(),
texture_quad->SetAll(sqs,
rect,
opaque_rect,
visible_rect,
......@@ -140,8 +125,7 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
vertex_opacity,
flipped);
cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(texture_quad.get());
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*(pass->quad_list.back()));
ASSERT_FALSE(mojo_quad.is_null());
EXPECT_EQ(surfaces::MATERIAL_TEXTURE_CONTENT, mojo_quad->material);
ASSERT_TRUE(mojo_quad->texture_quad_state);
......@@ -157,22 +141,6 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;
}
EXPECT_EQ(flipped, mojo_texture_state->flipped);
scoped_ptr<cc::DrawQuad> round_trip_quad =
ConvertTo(mojo_quad.Pass(), sqs.get());
ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material);
const cc::TextureDrawQuad* round_trip_surface_quad =
cc::TextureDrawQuad::MaterialCast(round_trip_quad.get());
EXPECT_EQ(resource_id, round_trip_surface_quad->resource_id);
EXPECT_EQ(premultiplied_alpha, round_trip_surface_quad->premultiplied_alpha);
EXPECT_EQ(uv_top_left, round_trip_surface_quad->uv_top_left);
EXPECT_EQ(uv_bottom_right, round_trip_surface_quad->uv_bottom_right);
EXPECT_EQ(background_color, round_trip_surface_quad->background_color);
for (size_t i = 0; i < 4; ++i) {
EXPECT_EQ(vertex_opacity[i], round_trip_surface_quad->vertex_opacity[i])
<< i;
}
EXPECT_EQ(flipped, round_trip_surface_quad->flipped);
}
TEST(SurfaceLibTest, SharedQuadState) {
......@@ -185,7 +153,8 @@ TEST(SurfaceLibTest, SharedQuadState) {
float opacity = 0.65f;
int sorting_context_id = 13;
SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
scoped_ptr<cc::SharedQuadState> sqs(new cc::SharedQuadState);
scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
sqs->SetAll(content_to_target_transform,
content_bounds,
visible_content_rect,
......@@ -205,19 +174,9 @@ TEST(SurfaceLibTest, SharedQuadState) {
EXPECT_EQ(is_clipped, mojo_sqs->is_clipped);
EXPECT_EQ(opacity, mojo_sqs->opacity);
EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id);
scoped_ptr<cc::SharedQuadState> round_trip_sqs = ConvertTo(mojo_sqs.Pass());
EXPECT_EQ(content_to_target_transform,
round_trip_sqs->content_to_target_transform);
EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds);
EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect);
EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect);
EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped);
EXPECT_EQ(opacity, round_trip_sqs->opacity);
EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id);
}
TEST_F(SurfaceLibQuadTest, RenderPass) {
TEST(SurfaceLibTest, RenderPass) {
scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
cc::RenderPass::Id pass_id(1, 6);
gfx::Rect output_rect(4, 9, 13, 71);
......@@ -250,6 +209,11 @@ TEST_F(SurfaceLibQuadTest, RenderPass) {
blend_mode,
sorting_context_id);
gfx::Rect rect(5, 7, 13, 19);
gfx::Rect opaque_rect(rect);
gfx::Rect visible_rect(9, 11, 5, 7);
bool needs_blending = false;
cc::SolidColorDrawQuad* color_quad =
pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
SkColor arbitrary_color = SK_ColorGREEN;
......@@ -262,6 +226,34 @@ TEST_F(SurfaceLibQuadTest, RenderPass) {
arbitrary_color,
force_anti_aliasing_off);
cc::SurfaceDrawQuad* surface_quad =
pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
cc::SurfaceId arbitrary_id(5);
surface_quad->SetAll(
sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
cc::TextureDrawQuad* texture_quad =
pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
unsigned resource_id = 9;
bool premultiplied_alpha = true;
gfx::PointF uv_top_left(1.7f, 2.1f);
gfx::PointF uv_bottom_right(-7.f, 16.3f);
SkColor background_color = SK_ColorYELLOW;
float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
bool flipped = false;
texture_quad->SetAll(sqs,
rect,
opaque_rect,
visible_rect,
needs_blending,
resource_id,
premultiplied_alpha,
uv_top_left,
uv_bottom_right,
background_color,
vertex_opacity,
flipped);
surfaces::PassPtr mojo_pass = surfaces::Pass::From(*pass);
ASSERT_FALSE(mojo_pass.is_null());
EXPECT_EQ(6, mojo_pass->id);
......@@ -271,7 +263,7 @@ TEST_F(SurfaceLibQuadTest, RenderPass) {
mojo_pass->transform_to_root_target);
EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background);
ASSERT_EQ(1u, mojo_pass->shared_quad_states.size());
ASSERT_EQ(1u, mojo_pass->quads.size());
ASSERT_EQ(3u, mojo_pass->quads.size());
EXPECT_EQ(0, mojo_pass->quads[0]->shared_quad_state_index);
scoped_ptr<cc::RenderPass> round_trip_pass = ConvertTo(mojo_pass.Pass());
......@@ -283,9 +275,56 @@ TEST_F(SurfaceLibQuadTest, RenderPass) {
EXPECT_EQ(has_transparent_background,
round_trip_pass->has_transparent_background);
ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size());
ASSERT_EQ(1u, round_trip_pass->quad_list.size());
ASSERT_EQ(3u, round_trip_pass->quad_list.size());
EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(),
round_trip_pass->quad_list[0]->shared_quad_state);
round_trip_pass->quad_list.front()->shared_quad_state);
cc::SharedQuadState* round_trip_sqs =
round_trip_pass->shared_quad_state_list.front();
EXPECT_EQ(content_to_target_transform,
round_trip_sqs->content_to_target_transform);
EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds);
EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect);
EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect);
EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped);
EXPECT_EQ(opacity, round_trip_sqs->opacity);
EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id);
cc::QuadList::iterator dq_iter = round_trip_pass->quad_list.begin();
// First is solid color quad.
ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, (*dq_iter)->material);
EXPECT_EQ(rect, (*dq_iter)->rect);
EXPECT_EQ(opaque_rect, (*dq_iter)->opaque_rect);
EXPECT_EQ(visible_rect, (*dq_iter)->visible_rect);
EXPECT_EQ(needs_blending, (*dq_iter)->needs_blending);
const cc::SolidColorDrawQuad* round_trip_color_quad =
cc::SolidColorDrawQuad::MaterialCast(*dq_iter);
EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
EXPECT_EQ(force_anti_aliasing_off,
round_trip_color_quad->force_anti_aliasing_off);
++dq_iter;
// Second is surface quad.
ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, (*dq_iter)->material);
const cc::SurfaceDrawQuad* round_trip_surface_quad =
cc::SurfaceDrawQuad::MaterialCast(*dq_iter);
EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
++dq_iter;
// Third is texture quad.
ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, (*dq_iter)->material);
const cc::TextureDrawQuad* round_trip_texture_quad =
cc::TextureDrawQuad::MaterialCast(*dq_iter);
EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id);
EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha);
EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left);
EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right);
EXPECT_EQ(background_color, round_trip_texture_quad->background_color);
for (size_t i = 0; i < 4; ++i) {
EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i])
<< i;
}
EXPECT_EQ(flipped, round_trip_texture_quad->flipped);
}
TEST(SurfaceLibTest, Mailbox) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment