mojo/converters/surfaces/tests/surface_unittest.cc - Issue 1534693002: Delete the Surfaces service.

Unified Diff: mojo/converters/surfaces/tests/surface_unittest.cc

Issue 1534693002: Delete the Surfaces service. (Closed) Base URL: git@github.com:domokit/mojo.git@cl-2d

Patch Set: rebase Created 5 years 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: mojo/converters/surfaces/tests/surface_unittest.cc

diff --git a/mojo/converters/surfaces/tests/surface_unittest.cc b/mojo/converters/surfaces/tests/surface_unittest.cc

deleted file mode 100644

index 7e0a85092a92fd258aca04404ea243f2536bc45a..0000000000000000000000000000000000000000

--- a/mojo/converters/surfaces/tests/surface_unittest.cc

+++ /dev/null

@@ -1,467 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "cc/quads/render_pass.h"

-#include "cc/quads/solid_color_draw_quad.h"

-#include "cc/quads/surface_draw_quad.h"

-#include "cc/quads/texture_draw_quad.h"

-#include "gpu/command_buffer/common/mailbox.h"

-#include "gpu/command_buffer/common/mailbox_holder.h"

-#include "mojo/converters/geometry/geometry_type_converters.h"

-#include "mojo/converters/surfaces/surfaces_type_converters.h"

-#include "testing/gtest/include/gtest/gtest.h"

-#include "third_party/skia/include/core/SkColor.h"

-#include "third_party/skia/include/core/SkXfermode.h"

-namespace mojo {

-namespace {

-TEST(SurfaceLibTest, SurfaceIdConverterNullId) {

- cc::SurfaceId null_id;

- cc::SurfaceId round_trip = SurfaceId::From(null_id).To<cc::SurfaceId>();

- EXPECT_TRUE(round_trip.is_null());

-TEST(SurfaceLibTest, SurfaceIdConverterValidId) {

- cc::SurfaceId valid_id(7);

- cc::SurfaceId round_trip = SurfaceId::From(valid_id).To<cc::SurfaceId>();

- EXPECT_FALSE(round_trip.is_null());

- EXPECT_EQ(valid_id, round_trip);

-TEST(SurfaceLibTest, Color) {

- SkColor arbitrary_color = SK_ColorMAGENTA;

- SkColor round_trip = Color::From(arbitrary_color).To<SkColor>();

- EXPECT_EQ(arbitrary_color, round_trip);

-class SurfaceLibQuadTest : public testing::Test {

- public:

- SurfaceLibQuadTest()

- : rect(5, 7, 13, 19),

- opaque_rect(rect),

- visible_rect(9, 11, 5, 7),

- needs_blending(false) {

- pass = cc::RenderPass::Create();

- sqs = pass->CreateAndAppendSharedQuadState();

- }

- protected:

- 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) {

- cc::SolidColorDrawQuad* color_quad =

- pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();

- SkColor arbitrary_color = SK_ColorGREEN;

- bool force_anti_aliasing_off = true;

- color_quad->SetAll(sqs,

- rect,

- opaque_rect,

- visible_rect,

- needs_blending,

- arbitrary_color,

- force_anti_aliasing_off);

- QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*color_quad);

- ASSERT_FALSE(mojo_quad.is_null());

- EXPECT_EQ(Material::SOLID_COLOR, mojo_quad->material);

- EXPECT_TRUE(Rect::From(rect)->Equals(*mojo_quad->rect));

- EXPECT_TRUE(Rect::From(opaque_rect)->Equals(*mojo_quad->opaque_rect));

- EXPECT_TRUE(Rect::From(visible_rect)->Equals(*mojo_quad->visible_rect));

- EXPECT_EQ(needs_blending, mojo_quad->needs_blending);

- ASSERT_TRUE(mojo_quad->solid_color_quad_state);

- SolidColorQuadStatePtr& mojo_color_state = mojo_quad->solid_color_quad_state;

- EXPECT_TRUE(Color::From(arbitrary_color)->Equals(*mojo_color_state->color));

- EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);

-TEST_F(SurfaceLibQuadTest, SurfaceQuad) {

- 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);

- QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*surface_quad);

- ASSERT_FALSE(mojo_quad.is_null());

- EXPECT_EQ(Material::SURFACE_CONTENT, mojo_quad->material);

- ASSERT_TRUE(mojo_quad->surface_quad_state);

- SurfaceQuadStatePtr& mojo_surface_state = mojo_quad->surface_quad_state;

- EXPECT_TRUE(

- SurfaceId::From(arbitrary_id)->Equals(*mojo_surface_state->surface));

-TEST_F(SurfaceLibQuadTest, TextureQuad) {

- 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;

- bool nearest_neighbor = 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,

- nearest_neighbor);

- QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*texture_quad);

- ASSERT_FALSE(mojo_quad.is_null());

- EXPECT_EQ(Material::TEXTURE_CONTENT, mojo_quad->material);

- ASSERT_TRUE(mojo_quad->texture_quad_state);

- TextureQuadStatePtr& mojo_texture_state = mojo_quad->texture_quad_state;

- EXPECT_EQ(resource_id, mojo_texture_state->resource_id);

- EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha);

- EXPECT_TRUE(

- PointF::From(uv_top_left)->Equals(*mojo_texture_state->uv_top_left));

- EXPECT_TRUE(PointF::From(uv_bottom_right)

- ->Equals(*mojo_texture_state->uv_bottom_right));

- EXPECT_TRUE(Color::From(background_color)

- ->Equals(*mojo_texture_state->background_color));

- for (size_t i = 0; i < 4; ++i) {

- EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;

- }

- EXPECT_EQ(flipped, mojo_texture_state->flipped);

-TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {

- QuadPtr mojo_texture_quad = Quad::New();

- mojo_texture_quad->material = Material::TEXTURE_CONTENT;

- TextureQuadStatePtr mojo_texture_state = TextureQuadState::New();

- mojo_texture_state->background_color = Color::New();

- mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();

- PassPtr mojo_pass = Pass::New();

- mojo_pass->quads.push_back(mojo_texture_quad.Pass());

- SharedQuadStatePtr mojo_sqs = SharedQuadState::New();

- mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());

- scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >();

- EXPECT_FALSE(pass);

-TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {

- QuadPtr mojo_texture_quad = Quad::New();

- mojo_texture_quad->material = Material::TEXTURE_CONTENT;

- TextureQuadStatePtr mojo_texture_state = TextureQuadState::New();

- mojo_texture_state->vertex_opacity = mojo::Array<float>::New(4);

- mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();

- PassPtr mojo_pass = Pass::New();

- mojo_pass->quads.push_back(mojo_texture_quad.Pass());

- SharedQuadStatePtr mojo_sqs = SharedQuadState::New();

- mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());

- scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >();

- EXPECT_FALSE(pass);

-TEST(SurfaceLibTest, SharedQuadState) {

- gfx::Transform content_to_target_transform;

- content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);

- gfx::Size content_bounds(57, 39);

- gfx::Rect visible_content_rect(3, 7, 28, 42);

- gfx::Rect clip_rect(9, 12, 21, 31);

- bool is_clipped = true;

- float opacity = 0.65f;

- int sorting_context_id = 13;

- ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode;

- scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();

- cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();

- sqs->SetAll(content_to_target_transform,

- content_bounds,

- visible_content_rect,

- clip_rect,

- is_clipped,

- opacity,

- blend_mode,

- sorting_context_id);

- SharedQuadStatePtr mojo_sqs = SharedQuadState::From(*sqs);

- ASSERT_FALSE(mojo_sqs.is_null());

- EXPECT_TRUE(Transform::From(content_to_target_transform)

- ->Equals(*mojo_sqs->content_to_target_transform));

- EXPECT_TRUE(Size::From(content_bounds)->Equals(*mojo_sqs->content_bounds));

- EXPECT_TRUE(Rect::From(visible_content_rect)

- ->Equals(*mojo_sqs->visible_content_rect));

- EXPECT_TRUE(Rect::From(clip_rect)->Equals(*mojo_sqs->clip_rect));

- EXPECT_EQ(is_clipped, mojo_sqs->is_clipped);

- EXPECT_EQ(opacity, mojo_sqs->opacity);

- EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id);

-TEST(SurfaceLibTest, RenderPass) {

- scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();

- cc::RenderPassId pass_id(1, 6);

- gfx::Rect output_rect(4, 9, 13, 71);

- gfx::Rect damage_rect(9, 17, 41, 45);

- gfx::Transform transform_to_root_target;

- transform_to_root_target.SkewY(43.0);

- bool has_transparent_background = false;

- pass->SetAll(pass_id,

- output_rect,

- damage_rect,

- transform_to_root_target,

- has_transparent_background);

- gfx::Transform content_to_target_transform;

- content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);

- gfx::Size content_bounds(57, 39);

- gfx::Rect visible_content_rect(3, 7, 28, 42);

- gfx::Rect clip_rect(9, 12, 21, 31);

- bool is_clipped = true;

- float opacity = 0.65f;

- int sorting_context_id = 13;

- ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode;

- cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();

- sqs->SetAll(content_to_target_transform,

- content_bounds,

- visible_content_rect,

- clip_rect,

- is_clipped,

- opacity,

- 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;

- bool force_anti_aliasing_off = true;

- color_quad->SetAll(pass->shared_quad_state_list.back(),

- rect,

- opaque_rect,

- visible_rect,

- needs_blending,

- 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;

- bool nearest_neighbor = 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,

- nearest_neighbor);

- PassPtr mojo_pass = Pass::From(*pass);

- ASSERT_FALSE(mojo_pass.is_null());

- EXPECT_EQ(6, mojo_pass->id);

- EXPECT_TRUE(Rect::From(output_rect)->Equals(*mojo_pass->output_rect));

- EXPECT_TRUE(Rect::From(damage_rect)->Equals(*mojo_pass->damage_rect));

- EXPECT_TRUE(Transform::From(transform_to_root_target)

- ->Equals(*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(3u, mojo_pass->quads.size());

- EXPECT_EQ(0u, mojo_pass->quads[0]->shared_quad_state_index);

- scoped_ptr<cc::RenderPass> round_trip_pass =

- mojo_pass.To<scoped_ptr<cc::RenderPass> >();

- EXPECT_EQ(pass_id, round_trip_pass->id);

- EXPECT_EQ(output_rect, round_trip_pass->output_rect);

- EXPECT_EQ(damage_rect, round_trip_pass->damage_rect);

- EXPECT_EQ(transform_to_root_target,

- round_trip_pass->transform_to_root_target);

- EXPECT_EQ(has_transparent_background,

- round_trip_pass->has_transparent_background);

- ASSERT_EQ(1u, round_trip_pass->shared_quad_state_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.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::DrawQuad* round_trip_quad = round_trip_pass->quad_list.front();

- // First is solid color quad.

- ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material);

- 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);

- const cc::SolidColorDrawQuad* round_trip_color_quad =

- cc::SolidColorDrawQuad::MaterialCast(round_trip_quad);

- EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);

- EXPECT_EQ(force_anti_aliasing_off,

- round_trip_color_quad->force_anti_aliasing_off);

- round_trip_quad = round_trip_pass->quad_list.ElementAt(1);

- // Second is surface quad.

- ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material);

- const cc::SurfaceDrawQuad* round_trip_surface_quad =

- cc::SurfaceDrawQuad::MaterialCast(round_trip_quad);

- EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);

- round_trip_quad = round_trip_pass->quad_list.ElementAt(2);

- // Third is texture quad.

- ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material);

- const cc::TextureDrawQuad* round_trip_texture_quad =

- cc::TextureDrawQuad::MaterialCast(round_trip_quad);

- 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) {

- gpu::Mailbox mailbox;

- mailbox.Generate();

- MailboxPtr mojo_mailbox = Mailbox::From(mailbox);

- EXPECT_EQ(0, memcmp(mailbox.name, &mojo_mailbox->name.storage()[0], 64));

- gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();

- EXPECT_EQ(mailbox, round_trip_mailbox);

-TEST(SurfaceLibTest, MailboxEmptyName) {

- MailboxPtr mojo_mailbox = Mailbox::New();

- gpu::Mailbox converted_mailbox = mojo_mailbox.To<gpu::Mailbox>();

- EXPECT_TRUE(converted_mailbox.IsZero());

-TEST(SurfaceLibTest, MailboxHolder) {

- gpu::Mailbox mailbox;

- mailbox.Generate();

- uint32_t texture_target = GL_TEXTURE_2D;

- uint32_t sync_point = 7u;

- gpu::MailboxHolder holder(mailbox, texture_target, sync_point);

- MailboxHolderPtr mojo_holder = MailboxHolder::From(holder);

- EXPECT_EQ(texture_target, mojo_holder->texture_target);

- EXPECT_EQ(sync_point, mojo_holder->sync_point);

- gpu::MailboxHolder round_trip_holder = mojo_holder.To<gpu::MailboxHolder>();

- EXPECT_EQ(mailbox, round_trip_holder.mailbox);

- EXPECT_EQ(texture_target, round_trip_holder.texture_target);

- EXPECT_EQ(sync_point, round_trip_holder.sync_point);

-TEST(SurfaceLibTest, TransferableResource) {

- uint32_t id = 7u;

- cc::ResourceFormat format = cc::BGRA_8888;

- uint32_t filter = 123u;

- gfx::Size size(17, 18);

- gpu::MailboxHolder mailbox_holder;

- bool is_repeated = false;

- ;

- bool is_software = false;

- cc::TransferableResource resource;

- resource.id = id;

- resource.format = format;

- resource.filter = filter;

- resource.size = size;

- resource.mailbox_holder = mailbox_holder;

- resource.is_repeated = is_repeated;

- resource.is_software = is_software;

- TransferableResourcePtr mojo_resource = TransferableResource::From(resource);

- EXPECT_EQ(id, mojo_resource->id);

- EXPECT_EQ(static_cast<ResourceFormat>(format),

- mojo_resource->format);

- EXPECT_EQ(filter, mojo_resource->filter);

- EXPECT_TRUE(Size::From(size)->Equals(*mojo_resource->size));

- EXPECT_EQ(is_repeated, mojo_resource->is_repeated);

- EXPECT_EQ(is_software, mojo_resource->is_software);

- cc::TransferableResource round_trip_resource =

- mojo_resource.To<cc::TransferableResource>();

- EXPECT_EQ(id, round_trip_resource.id);

- EXPECT_EQ(format, round_trip_resource.format);

- EXPECT_EQ(filter, round_trip_resource.filter);

- EXPECT_EQ(size, round_trip_resource.size);

- EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox);

- EXPECT_EQ(mailbox_holder.texture_target,

- round_trip_resource.mailbox_holder.texture_target);

- EXPECT_EQ(mailbox_holder.sync_point,

- round_trip_resource.mailbox_holder.sync_point);

- EXPECT_EQ(is_repeated, round_trip_resource.is_repeated);

- EXPECT_EQ(is_software, round_trip_resource.is_software);

-TEST(SurfaceLibTest, ReturnedResource) {

- uint32_t id = 5u;

- uint32_t sync_point = 24u;

- int count = 2;

- bool lost = false;

- cc::ReturnedResource resource;

- resource.id = id;

- resource.sync_point = sync_point;

- resource.count = count;

- resource.lost = lost;

- ReturnedResourcePtr mojo_resource = ReturnedResource::From(resource);

- EXPECT_EQ(id, mojo_resource->id);

- EXPECT_EQ(sync_point, mojo_resource->sync_point);

- EXPECT_EQ(count, mojo_resource->count);

- EXPECT_EQ(lost, mojo_resource->lost);

- cc::ReturnedResource round_trip_resource =

- mojo_resource.To<cc::ReturnedResource>();

- EXPECT_EQ(id, round_trip_resource.id);

- EXPECT_EQ(sync_point, round_trip_resource.sync_point);

- EXPECT_EQ(count, round_trip_resource.count);

- EXPECT_EQ(lost, round_trip_resource.lost);

-} // namespace

-} // namespace mojo

« no previous file with comments | « mojo/converters/surfaces/tests/BUILD.gn ('k') | mojo/services/native_viewport/interfaces/BUILD.gn » ('j') | no next file with comments »