components/mus/public/interfaces View => Window

mojo/converters/surfaces/tests/surface_unittest.cc

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
index c6a9a88f9a950e9ef2cf3cbbaf51bd3379eee91f..fceaa32393c8d8bc42a3d95151554fdded56f0b0 100644
--- a/mojo/converters/surfaces/tests/surface_unittest.cc
+++ b/mojo/converters/surfaces/tests/surface_unittest.cc
@@ -17,6 +17,47 @@
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
+using mus::mojom::Color;
+using mus::mojom::ColorPtr;
+using mus::mojom::CompositorFrame;
+using mus::mojom::CompositorFramePtr;
+using mus::mojom::CompositorFrameMetadata;
+using mus::mojom::CompositorFrameMetadataPtr;
+using mus::mojom::DebugBorderQuadState;
+using mus::mojom::DebugBorderQuadStatePtr;
+using mus::mojom::Mailbox;
+using mus::mojom::MailboxPtr;
+using mus::mojom::MailboxHolder;
+using mus::mojom::MailboxHolderPtr;
+using mus::mojom::Pass;
+using mus::mojom::PassPtr;
+using mus::mojom::Quad;
+using mus::mojom::QuadPtr;
+using mus::mojom::RenderPassId;
+using mus::mojom::RenderPassIdPtr;
+using mus::mojom::RenderPassQuadState;
+using mus::mojom::RenderPassQuadStatePtr;
+using mus::mojom::ResourceFormat;
+using mus::mojom::ReturnedResource;
+using mus::mojom::ReturnedResourcePtr;
+using mus::mojom::SharedQuadState;
+using mus::mojom::SharedQuadStatePtr;
+using mus::mojom::SolidColorQuadState;
+using mus::mojom::SolidColorQuadStatePtr;
+using mus::mojom::SurfaceId;
+using mus::mojom::SurfaceIdPtr;
+using mus::mojom::SurfaceQuadState;
+using mus::mojom::SurfaceQuadStatePtr;
+using mus::mojom::TextureQuadState;
+using mus::mojom::TextureQuadStatePtr;
+using mus::mojom::TileQuadState;
+using mus::mojom::TileQuadStatePtr;
+using mus::mojom::TransferableResource;
+using mus::mojom::TransferableResourcePtr;
+using mus::mojom::YUVColorSpace;
+using mus::mojom::YUVVideoQuadState;
+using mus::mojom::YUVVideoQuadStatePtr;
+
 namespace mojo {
 namespace {
 
@@ -72,17 +113,17 @@ TEST_F(SurfaceLibQuadTest, ColorQuad) {
                      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);
+  QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*color_quad);
+  ASSERT_FALSE(mus_quad.is_null());
+  EXPECT_EQ(mus::mojom::MATERIAL_SOLID_COLOR, mus_quad->material);
+  EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
+  EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
+  EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
+  EXPECT_EQ(needs_blending, mus_quad->needs_blending);
+  ASSERT_TRUE(mus_quad->solid_color_quad_state);
+  SolidColorQuadStatePtr& mus_color_state = mus_quad->solid_color_quad_state;
+  EXPECT_TRUE(Color::From(arbitrary_color).Equals(mus_color_state->color));
+  EXPECT_EQ(force_anti_aliasing_off, mus_color_state->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
@@ -92,13 +133,12 @@ TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
   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));
+  QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*surface_quad);
+  ASSERT_FALSE(mus_quad.is_null());
+  EXPECT_EQ(mus::mojom::MATERIAL_SURFACE_CONTENT, mus_quad->material);
+  ASSERT_TRUE(mus_quad->surface_quad_state);
+  SurfaceQuadStatePtr& mus_surface_state = mus_quad->surface_quad_state;
+  EXPECT_TRUE(SurfaceId::From(arbitrary_id).Equals(mus_surface_state->surface));
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuad) {
@@ -117,59 +157,58 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
                        uv_top_left, uv_bottom_right, background_color,
                        vertex_opacity, y_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);
+  QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*texture_quad);
+  ASSERT_FALSE(mus_quad.is_null());
+  EXPECT_EQ(mus::mojom::MATERIAL_TEXTURE_CONTENT, mus_quad->material);
+  ASSERT_TRUE(mus_quad->texture_quad_state);
+  TextureQuadStatePtr& mus_texture_state = mus_quad->texture_quad_state;
+  EXPECT_EQ(resource_id, mus_texture_state->resource_id);
+  EXPECT_EQ(premultiplied_alpha, mus_texture_state->premultiplied_alpha);
+  EXPECT_TRUE(PointF::From(uv_top_left).Equals(mus_texture_state->uv_top_left));
   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));
+      PointF::From(uv_bottom_right).Equals(mus_texture_state->uv_bottom_right));
   EXPECT_TRUE(Color::From(background_color)
-                  .Equals(mojo_texture_state->background_color));
+                  .Equals(mus_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(vertex_opacity[i], mus_texture_state->vertex_opacity[i]) << i;
   }
-  EXPECT_EQ(y_flipped, mojo_texture_state->y_flipped);
+  EXPECT_EQ(y_flipped, mus_texture_state->y_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->id = RenderPassId::New();
-  mojo_pass->id->layer_id = 1;
-  mojo_pass->id->index = 1u;
-  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> >();
+  QuadPtr mus_texture_quad = Quad::New();
+  mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
+  TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
+  mus_texture_state->background_color = Color::New();
+  mus_texture_quad->texture_quad_state = mus_texture_state.Pass();
+  PassPtr mus_pass = Pass::New();
+  mus_pass->id = RenderPassId::New();
+  mus_pass->id->layer_id = 1;
+  mus_pass->id->index = 1u;
+  mus_pass->quads.push_back(mus_texture_quad.Pass());
+  SharedQuadStatePtr mus_sqs = SharedQuadState::New();
+  mus_pass->shared_quad_states.push_back(mus_sqs.Pass());
+
+  scoped_ptr<cc::RenderPass> pass = mus_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->id = RenderPassId::New();
-  mojo_pass->id->layer_id = 1;
-  mojo_pass->id->index = 1u;
-  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> >();
+  QuadPtr mus_texture_quad = Quad::New();
+  mus_texture_quad->material = mus::mojom::MATERIAL_TEXTURE_CONTENT;
+  TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
+  mus_texture_state->vertex_opacity = mojo::Array<float>::New(4);
+  mus_texture_quad->texture_quad_state = mus_texture_state.Pass();
+  PassPtr mus_pass = Pass::New();
+  mus_pass->id = RenderPassId::New();
+  mus_pass->id->layer_id = 1;
+  mus_pass->id->index = 1u;
+  mus_pass->quads.push_back(mus_texture_quad.Pass());
+  SharedQuadStatePtr mus_sqs = SharedQuadState::New();
+  mus_pass->shared_quad_states.push_back(mus_sqs.Pass());
+
+  scoped_ptr<cc::RenderPass> pass = mus_pass.To<scoped_ptr<cc::RenderPass>>();
   EXPECT_FALSE(pass);
 }
 
@@ -189,18 +228,17 @@ TEST(SurfaceLibTest, SharedQuadState) {
               visible_quad_layer_rect, clip_rect, is_clipped, opacity,
               blend_mode, sorting_context_id);
 
-  SharedQuadStatePtr mojo_sqs = SharedQuadState::From(*sqs);
-  ASSERT_FALSE(mojo_sqs.is_null());
+  SharedQuadStatePtr mus_sqs = SharedQuadState::From(*sqs);
+  ASSERT_FALSE(mus_sqs.is_null());
   EXPECT_TRUE(Transform::From(quad_to_target_transform)
-                  .Equals(mojo_sqs->quad_to_target_transform));
-  EXPECT_TRUE(
-      Size::From(quad_layer_bounds).Equals(mojo_sqs->quad_layer_bounds));
+                  .Equals(mus_sqs->quad_to_target_transform));
+  EXPECT_TRUE(Size::From(quad_layer_bounds).Equals(mus_sqs->quad_layer_bounds));
   EXPECT_TRUE(Rect::From(visible_quad_layer_rect)
-                  .Equals(mojo_sqs->visible_quad_layer_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);
+                  .Equals(mus_sqs->visible_quad_layer_rect));
+  EXPECT_TRUE(Rect::From(clip_rect).Equals(mus_sqs->clip_rect));
+  EXPECT_EQ(is_clipped, mus_sqs->is_clipped);
+  EXPECT_EQ(opacity, mus_sqs->opacity);
+  EXPECT_EQ(sorting_context_id, mus_sqs->sorting_context_id);
 }
 
 TEST(SurfaceLibTest, RenderPass) {
@@ -269,20 +307,20 @@ TEST(SurfaceLibTest, RenderPass) {
                        uv_top_left, uv_bottom_right, background_color,
                        vertex_opacity, y_flipped, nearest_neighbor);
 
-  PassPtr mojo_pass = Pass::From(*pass);
-  ASSERT_FALSE(mojo_pass.is_null());
-  EXPECT_EQ(6u, mojo_pass->id->index);
-  EXPECT_TRUE(Rect::From(output_rect).Equals(mojo_pass->output_rect));
-  EXPECT_TRUE(Rect::From(damage_rect).Equals(mojo_pass->damage_rect));
+  PassPtr mus_pass = Pass::From(*pass);
+  ASSERT_FALSE(mus_pass.is_null());
+  EXPECT_EQ(6u, mus_pass->id->index);
+  EXPECT_TRUE(Rect::From(output_rect).Equals(mus_pass->output_rect));
+  EXPECT_TRUE(Rect::From(damage_rect).Equals(mus_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);
+                  .Equals(mus_pass->transform_to_root_target));
+  EXPECT_EQ(has_transparent_background, mus_pass->has_transparent_background);
+  ASSERT_EQ(1u, mus_pass->shared_quad_states.size());
+  ASSERT_EQ(3u, mus_pass->quads.size());
+  EXPECT_EQ(0u, mus_pass->quads[0]->shared_quad_state_index);
 
   scoped_ptr<cc::RenderPass> round_trip_pass =
-      mojo_pass.To<scoped_ptr<cc::RenderPass> >();
+      mus_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);
@@ -346,17 +384,17 @@ 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));
+  MailboxPtr mus_mailbox = Mailbox::From(mailbox);
+  EXPECT_EQ(0, memcmp(mailbox.name, &mus_mailbox->name.storage()[0], 64));
 
-  gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
+  gpu::Mailbox round_trip_mailbox = mus_mailbox.To<gpu::Mailbox>();
   EXPECT_EQ(mailbox, round_trip_mailbox);
 }
 
 TEST(SurfaceLibTest, MailboxEmptyName) {
-  MailboxPtr mojo_mailbox = Mailbox::New();
+  MailboxPtr mus_mailbox = Mailbox::New();
 
-  gpu::Mailbox converted_mailbox = mojo_mailbox.To<gpu::Mailbox>();
+  gpu::Mailbox converted_mailbox = mus_mailbox.To<gpu::Mailbox>();
   EXPECT_TRUE(converted_mailbox.IsZero());
 }
 
@@ -367,11 +405,11 @@ TEST(SurfaceLibTest, MailboxHolder) {
   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);
+  MailboxHolderPtr mus_holder = MailboxHolder::From(holder);
+  EXPECT_EQ(texture_target, mus_holder->texture_target);
+  EXPECT_EQ(sync_point, mus_holder->sync_point);
 
-  gpu::MailboxHolder round_trip_holder = mojo_holder.To<gpu::MailboxHolder>();
+  gpu::MailboxHolder round_trip_holder = mus_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);
@@ -392,16 +430,15 @@ TEST(SurfaceLibTest, TransferableResource) {
   resource.mailbox_holder = mailbox_holder;
   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_software, mojo_resource->is_software);
+  TransferableResourcePtr mus_resource = TransferableResource::From(resource);
+  EXPECT_EQ(id, mus_resource->id);
+  EXPECT_EQ(static_cast<ResourceFormat>(format), mus_resource->format);
+  EXPECT_EQ(filter, mus_resource->filter);
+  EXPECT_TRUE(Size::From(size).Equals(mus_resource->size));
+  EXPECT_EQ(is_software, mus_resource->is_software);
 
   cc::TransferableResource round_trip_resource =
-      mojo_resource.To<cc::TransferableResource>();
+      mus_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);
@@ -425,14 +462,14 @@ TEST(SurfaceLibTest, ReturnedResource) {
   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);
+  ReturnedResourcePtr mus_resource = ReturnedResource::From(resource);
+  EXPECT_EQ(id, mus_resource->id);
+  EXPECT_EQ(sync_point, mus_resource->sync_point);
+  EXPECT_EQ(count, mus_resource->count);
+  EXPECT_EQ(lost, mus_resource->lost);
 
   cc::ReturnedResource round_trip_resource =
-      mojo_resource.To<cc::ReturnedResource>();
+      mus_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);
@@ -452,19 +489,19 @@ TEST_F(SurfaceLibQuadTest, DebugBorderQuad) {
                             arbitrary_color,
                             width);
 
-  QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*debug_border_quad);
-  ASSERT_FALSE(mojo_quad.is_null());
-  EXPECT_EQ(MATERIAL_DEBUG_BORDER, 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->debug_border_quad_state);
-  DebugBorderQuadStatePtr& mojo_debug_border_state =
-      mojo_quad->debug_border_quad_state;
+  QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*debug_border_quad);
+  ASSERT_FALSE(mus_quad.is_null());
+  EXPECT_EQ(mus::mojom::MATERIAL_DEBUG_BORDER, mus_quad->material);
+  EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
+  EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
+  EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
+  EXPECT_EQ(needs_blending, mus_quad->needs_blending);
+  ASSERT_TRUE(mus_quad->debug_border_quad_state);
+  DebugBorderQuadStatePtr& mus_debug_border_state =
+      mus_quad->debug_border_quad_state;
   EXPECT_TRUE(
-      Color::From(arbitrary_color).Equals(mojo_debug_border_state->color));
-  EXPECT_EQ(width, mojo_debug_border_state->width);
+      Color::From(arbitrary_color).Equals(mus_debug_border_state->color));
+  EXPECT_EQ(width, mus_debug_border_state->width);
 }
 
 }  // namespace