src/mojo/services/public/cpp/surfaces/tests/surface_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/quads/render_pass.h"
   6 #include "cc/quads/solid_color_draw_quad.h"
   7 #include "cc/quads/surface_draw_quad.h"
   8 #include "cc/quads/texture_draw_quad.h"
   9 #include "gpu/command_buffer/common/mailbox.h"
  10 #include "gpu/command_buffer/common/mailbox_holder.h"
  11 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
  12 #include "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "third_party/skia/include/core/SkColor.h"
  15 #include "third_party/skia/include/core/SkXfermode.h"
  16
  17 namespace mojo {
  18 namespace {
  19
  20 TEST(SurfaceLibTest, SurfaceIdConverterNullId) {
  21   cc::SurfaceId null_id;
  22   cc::SurfaceId round_trip = SurfaceId::From(null_id).To<cc::SurfaceId>();
  23   EXPECT_TRUE(round_trip.is_null());
  24 }
  25
  26 TEST(SurfaceLibTest, SurfaceIdConverterValidId) {
  27   cc::SurfaceId valid_id(7);
  28   cc::SurfaceId round_trip = SurfaceId::From(valid_id).To<cc::SurfaceId>();
  29   EXPECT_FALSE(round_trip.is_null());
  30   EXPECT_EQ(valid_id, round_trip);
  31 }
  32
  33 TEST(SurfaceLibTest, Color) {
  34   SkColor arbitrary_color = SK_ColorMAGENTA;
  35   SkColor round_trip = Color::From(arbitrary_color).To<SkColor>();
  36   EXPECT_EQ(arbitrary_color, round_trip);
  37 }
  38
  39 class SurfaceLibQuadTest : public testing::Test {
  40  public:
  41   SurfaceLibQuadTest()
  42       : rect(5, 7, 13, 19),
  43         opaque_rect(rect),
  44         visible_rect(9, 11, 5, 7),
  45         needs_blending(false) {
  46     pass = cc::RenderPass::Create();
  47     sqs = pass->CreateAndAppendSharedQuadState();
  48   }
  49
  50  protected:
  51   gfx::Rect rect;
  52   gfx::Rect opaque_rect;
  53   gfx::Rect visible_rect;
  54   bool needs_blending;
  55   scoped_ptr<cc::RenderPass> pass;
  56   cc::SharedQuadState* sqs;
  57 };
  58
  59 TEST_F(SurfaceLibQuadTest, ColorQuad) {
  60   cc::SolidColorDrawQuad* color_quad =
  61       pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
  62   SkColor arbitrary_color = SK_ColorGREEN;
  63   bool force_anti_aliasing_off = true;
  64   color_quad->SetAll(sqs,
  65                      rect,
  66                      opaque_rect,
  67                      visible_rect,
  68                      needs_blending,
  69                      arbitrary_color,
  70                      force_anti_aliasing_off);
  71
  72   QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
  73   ASSERT_FALSE(mojo_quad.is_null());
  74   EXPECT_EQ(MATERIAL_SOLID_COLOR, mojo_quad->material);
  75   EXPECT_EQ(Rect::From(rect), mojo_quad->rect);
  76   EXPECT_EQ(Rect::From(opaque_rect), mojo_quad->opaque_rect);
  77   EXPECT_EQ(Rect::From(visible_rect), mojo_quad->visible_rect);
  78   EXPECT_EQ(needs_blending, mojo_quad->needs_blending);
  79   ASSERT_TRUE(mojo_quad->solid_color_quad_state);
  80   SolidColorQuadStatePtr& mojo_color_state = mojo_quad->solid_color_quad_state;
  81   EXPECT_EQ(Color::From(arbitrary_color), mojo_color_state->color);
  82   EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);
  83 }
  84
  85 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
  86   cc::SurfaceDrawQuad* surface_quad =
  87       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
  88   cc::SurfaceId arbitrary_id(5);
  89   surface_quad->SetAll(
  90       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
  91
  92   QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
  93   ASSERT_FALSE(mojo_quad.is_null());
  94   EXPECT_EQ(MATERIAL_SURFACE_CONTENT, mojo_quad->material);
  95   ASSERT_TRUE(mojo_quad->surface_quad_state);
  96   SurfaceQuadStatePtr& mojo_surface_state = mojo_quad->surface_quad_state;
  97   EXPECT_EQ(SurfaceId::From(arbitrary_id),
  98             mojo_surface_state->surface);
  99 }
 100
 101 TEST_F(SurfaceLibQuadTest, TextureQuad) {
 102   cc::TextureDrawQuad* texture_quad =
 103       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
 104   unsigned resource_id = 9;
 105   bool premultiplied_alpha = true;
 106   gfx::PointF uv_top_left(1.7f, 2.1f);
 107   gfx::PointF uv_bottom_right(-7.f, 16.3f);
 108   SkColor background_color = SK_ColorYELLOW;
 109   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
 110   bool flipped = false;
 111   texture_quad->SetAll(sqs,
 112                        rect,
 113                        opaque_rect,
 114                        visible_rect,
 115                        needs_blending,
 116                        resource_id,
 117                        premultiplied_alpha,
 118                        uv_top_left,
 119                        uv_bottom_right,
 120                        background_color,
 121                        vertex_opacity,
 122                        flipped);
 123
 124   QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
 125   ASSERT_FALSE(mojo_quad.is_null());
 126   EXPECT_EQ(MATERIAL_TEXTURE_CONTENT, mojo_quad->material);
 127   ASSERT_TRUE(mojo_quad->texture_quad_state);
 128   TextureQuadStatePtr& mojo_texture_state = mojo_quad->texture_quad_state;
 129   EXPECT_EQ(resource_id, mojo_texture_state->resource_id);
 130   EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha);
 131   EXPECT_EQ(PointF::From(uv_top_left), mojo_texture_state->uv_top_left);
 132   EXPECT_EQ(PointF::From(uv_bottom_right), mojo_texture_state->uv_bottom_right);
 133   EXPECT_EQ(Color::From(background_color),
 134             mojo_texture_state->background_color);
 135   for (size_t i = 0; i < 4; ++i) {
 136     EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;
 137   }
 138   EXPECT_EQ(flipped, mojo_texture_state->flipped);
 139 }
 140
 141 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
 142   QuadPtr mojo_texture_quad = Quad::New();
 143   mojo_texture_quad->material = MATERIAL_TEXTURE_CONTENT;
 144   TextureQuadStatePtr mojo_texture_state = TextureQuadState::New();
 145   mojo_texture_state->background_color = Color::New();
 146   mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();
 147   PassPtr mojo_pass = Pass::New();
 148   mojo_pass->quads.push_back(mojo_texture_quad.Pass());
 149   SharedQuadStatePtr mojo_sqs = SharedQuadState::New();
 150   mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
 151
 152   scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
 153   EXPECT_FALSE(pass);
 154 }
 155
 156 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
 157   QuadPtr mojo_texture_quad = Quad::New();
 158   mojo_texture_quad->material = MATERIAL_TEXTURE_CONTENT;
 159   TextureQuadStatePtr mojo_texture_state = TextureQuadState::New();
 160   mojo_texture_state->vertex_opacity = mojo::Array<float>::New(4);
 161   mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();
 162   PassPtr mojo_pass = Pass::New();
 163   mojo_pass->quads.push_back(mojo_texture_quad.Pass());
 164   SharedQuadStatePtr mojo_sqs = SharedQuadState::New();
 165   mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass());
 166
 167   scoped_ptr<cc::RenderPass> pass = ConvertTo(mojo_pass.Pass());
 168   EXPECT_FALSE(pass);
 169 }
 170
 171 TEST(SurfaceLibTest, SharedQuadState) {
 172   gfx::Transform content_to_target_transform;
 173   content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
 174   gfx::Size content_bounds(57, 39);
 175   gfx::Rect visible_content_rect(3, 7, 28, 42);
 176   gfx::Rect clip_rect(9, 12, 21, 31);
 177   bool is_clipped = true;
 178   float opacity = 0.65f;
 179   int sorting_context_id = 13;
 180   ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode;
 181   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
 182   cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
 183   sqs->SetAll(content_to_target_transform,
 184               content_bounds,
 185               visible_content_rect,
 186               clip_rect,
 187               is_clipped,
 188               opacity,
 189               blend_mode,
 190               sorting_context_id);
 191
 192   SharedQuadStatePtr mojo_sqs = SharedQuadState::From(*sqs);
 193   ASSERT_FALSE(mojo_sqs.is_null());
 194   EXPECT_EQ(Transform::From(content_to_target_transform),
 195             mojo_sqs->content_to_target_transform);
 196   EXPECT_EQ(Size::From(content_bounds), mojo_sqs->content_bounds);
 197   EXPECT_EQ(Rect::From(visible_content_rect), mojo_sqs->visible_content_rect);
 198   EXPECT_EQ(Rect::From(clip_rect), mojo_sqs->clip_rect);
 199   EXPECT_EQ(is_clipped, mojo_sqs->is_clipped);
 200   EXPECT_EQ(opacity, mojo_sqs->opacity);
 201   EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id);
 202 }
 203
 204 TEST(SurfaceLibTest, RenderPass) {
 205   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
 206   cc::RenderPass::Id pass_id(1, 6);
 207   gfx::Rect output_rect(4, 9, 13, 71);
 208   gfx::Rect damage_rect(9, 17, 41, 45);
 209   gfx::Transform transform_to_root_target;
 210   transform_to_root_target.SkewY(43.0);
 211   bool has_transparent_background = false;
 212   pass->SetAll(pass_id,
 213                output_rect,
 214                damage_rect,
 215                transform_to_root_target,
 216                has_transparent_background);
 217
 218   gfx::Transform content_to_target_transform;
 219   content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
 220   gfx::Size content_bounds(57, 39);
 221   gfx::Rect visible_content_rect(3, 7, 28, 42);
 222   gfx::Rect clip_rect(9, 12, 21, 31);
 223   bool is_clipped = true;
 224   float opacity = 0.65f;
 225   int sorting_context_id = 13;
 226   ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode;
 227   cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
 228   sqs->SetAll(content_to_target_transform,
 229               content_bounds,
 230               visible_content_rect,
 231               clip_rect,
 232               is_clipped,
 233               opacity,
 234               blend_mode,
 235               sorting_context_id);
 236
 237   gfx::Rect rect(5, 7, 13, 19);
 238   gfx::Rect opaque_rect(rect);
 239   gfx::Rect visible_rect(9, 11, 5, 7);
 240   bool needs_blending = false;
 241
 242   cc::SolidColorDrawQuad* color_quad =
 243       pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
 244   SkColor arbitrary_color = SK_ColorGREEN;
 245   bool force_anti_aliasing_off = true;
 246   color_quad->SetAll(pass->shared_quad_state_list.back(),
 247                      rect,
 248                      opaque_rect,
 249                      visible_rect,
 250                      needs_blending,
 251                      arbitrary_color,
 252                      force_anti_aliasing_off);
 253
 254   cc::SurfaceDrawQuad* surface_quad =
 255       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
 256   cc::SurfaceId arbitrary_id(5);
 257   surface_quad->SetAll(
 258       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
 259
 260   cc::TextureDrawQuad* texture_quad =
 261       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
 262   unsigned resource_id = 9;
 263   bool premultiplied_alpha = true;
 264   gfx::PointF uv_top_left(1.7f, 2.1f);
 265   gfx::PointF uv_bottom_right(-7.f, 16.3f);
 266   SkColor background_color = SK_ColorYELLOW;
 267   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
 268   bool flipped = false;
 269   texture_quad->SetAll(sqs,
 270                        rect,
 271                        opaque_rect,
 272                        visible_rect,
 273                        needs_blending,
 274                        resource_id,
 275                        premultiplied_alpha,
 276                        uv_top_left,
 277                        uv_bottom_right,
 278                        background_color,
 279                        vertex_opacity,
 280                        flipped);
 281
 282   PassPtr mojo_pass = Pass::From(*pass);
 283   ASSERT_FALSE(mojo_pass.is_null());
 284   EXPECT_EQ(6, mojo_pass->id);
 285   EXPECT_EQ(Rect::From(output_rect), mojo_pass->output_rect);
 286   EXPECT_EQ(Rect::From(damage_rect), mojo_pass->damage_rect);
 287   EXPECT_EQ(Transform::From(transform_to_root_target),
 288             mojo_pass->transform_to_root_target);
 289   EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background);
 290   ASSERT_EQ(1u, mojo_pass->shared_quad_states.size());
 291   ASSERT_EQ(3u, mojo_pass->quads.size());
 292   EXPECT_EQ(0, mojo_pass->quads[0]->shared_quad_state_index);
 293
 294   scoped_ptr<cc::RenderPass> round_trip_pass = ConvertTo(mojo_pass.Pass());
 295   EXPECT_EQ(pass_id, round_trip_pass->id);
 296   EXPECT_EQ(output_rect, round_trip_pass->output_rect);
 297   EXPECT_EQ(damage_rect, round_trip_pass->damage_rect);
 298   EXPECT_EQ(transform_to_root_target,
 299             round_trip_pass->transform_to_root_target);
 300   EXPECT_EQ(has_transparent_background,
 301             round_trip_pass->has_transparent_background);
 302   ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size());
 303   ASSERT_EQ(3u, round_trip_pass->quad_list.size());
 304   EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(),
 305             round_trip_pass->quad_list.front()->shared_quad_state);
 306
 307   cc::SharedQuadState* round_trip_sqs =
 308       round_trip_pass->shared_quad_state_list.front();
 309   EXPECT_EQ(content_to_target_transform,
 310             round_trip_sqs->content_to_target_transform);
 311   EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds);
 312   EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect);
 313   EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect);
 314   EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped);
 315   EXPECT_EQ(opacity, round_trip_sqs->opacity);
 316   EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id);
 317
 318   cc::QuadList::iterator dq_iter = round_trip_pass->quad_list.begin();
 319   // First is solid color quad.
 320   ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, (*dq_iter)->material);
 321   EXPECT_EQ(rect, (*dq_iter)->rect);
 322   EXPECT_EQ(opaque_rect, (*dq_iter)->opaque_rect);
 323   EXPECT_EQ(visible_rect, (*dq_iter)->visible_rect);
 324   EXPECT_EQ(needs_blending, (*dq_iter)->needs_blending);
 325   const cc::SolidColorDrawQuad* round_trip_color_quad =
 326       cc::SolidColorDrawQuad::MaterialCast(*dq_iter);
 327   EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
 328   EXPECT_EQ(force_anti_aliasing_off,
 329             round_trip_color_quad->force_anti_aliasing_off);
 330
 331   ++dq_iter;
 332   // Second is surface quad.
 333   ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, (*dq_iter)->material);
 334   const cc::SurfaceDrawQuad* round_trip_surface_quad =
 335       cc::SurfaceDrawQuad::MaterialCast(*dq_iter);
 336   EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
 337
 338   ++dq_iter;
 339   // Third is texture quad.
 340   ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, (*dq_iter)->material);
 341   const cc::TextureDrawQuad* round_trip_texture_quad =
 342       cc::TextureDrawQuad::MaterialCast(*dq_iter);
 343   EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id);
 344   EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha);
 345   EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left);
 346   EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right);
 347   EXPECT_EQ(background_color, round_trip_texture_quad->background_color);
 348   for (size_t i = 0; i < 4; ++i) {
 349     EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i])
 350         << i;
 351   }
 352   EXPECT_EQ(flipped, round_trip_texture_quad->flipped);
 353 }
 354
 355 TEST(SurfaceLibTest, Mailbox) {
 356   gpu::Mailbox mailbox;
 357   mailbox.Generate();
 358
 359   MailboxPtr mojo_mailbox = Mailbox::From(mailbox);
 360   EXPECT_EQ(0, memcmp(mailbox.name, &mojo_mailbox->name.storage()[0], 64));
 361
 362   gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
 363   EXPECT_EQ(mailbox, round_trip_mailbox);
 364 }
 365
 366 TEST(SurfaceLibTest, MailboxEmptyName) {
 367   MailboxPtr mojo_mailbox = Mailbox::New();
 368
 369   gpu::Mailbox converted_mailbox = mojo_mailbox.To<gpu::Mailbox>();
 370   EXPECT_TRUE(converted_mailbox.IsZero());
 371 }
 372
 373 TEST(SurfaceLibTest, MailboxHolder) {
 374   gpu::Mailbox mailbox;
 375   mailbox.Generate();
 376   uint32_t texture_target = GL_TEXTURE_2D;
 377   uint32_t sync_point = 7u;
 378   gpu::MailboxHolder holder(mailbox, texture_target, sync_point);
 379
 380   MailboxHolderPtr mojo_holder = MailboxHolder::From(holder);
 381   EXPECT_EQ(texture_target, mojo_holder->texture_target);
 382   EXPECT_EQ(sync_point, mojo_holder->sync_point);
 383
 384   gpu::MailboxHolder round_trip_holder = mojo_holder.To<gpu::MailboxHolder>();
 385   EXPECT_EQ(mailbox, round_trip_holder.mailbox);
 386   EXPECT_EQ(texture_target, round_trip_holder.texture_target);
 387   EXPECT_EQ(sync_point, round_trip_holder.sync_point);
 388 }
 389
 390 TEST(SurfaceLibTest, TransferableResource) {
 391   uint32_t id = 7u;
 392   cc::ResourceFormat format = cc::BGRA_8888;
 393   uint32_t filter = 123u;
 394   gfx::Size size(17, 18);
 395   gpu::MailboxHolder mailbox_holder;
 396   bool is_repeated = false;
 397   ;
 398   bool is_software = false;
 399   cc::TransferableResource resource;
 400   resource.id = id;
 401   resource.format = format;
 402   resource.filter = filter;
 403   resource.size = size;
 404   resource.mailbox_holder = mailbox_holder;
 405   resource.is_repeated = is_repeated;
 406   resource.is_software = is_software;
 407
 408   TransferableResourcePtr mojo_resource = TransferableResource::From(resource);
 409   EXPECT_EQ(id, mojo_resource->id);
 410   EXPECT_EQ(static_cast<ResourceFormat>(format),
 411             mojo_resource->format);
 412   EXPECT_EQ(filter, mojo_resource->filter);
 413   EXPECT_EQ(Size::From(size), mojo_resource->size);
 414   EXPECT_EQ(is_repeated, mojo_resource->is_repeated);
 415   EXPECT_EQ(is_software, mojo_resource->is_software);
 416
 417   cc::TransferableResource round_trip_resource =
 418       mojo_resource.To<cc::TransferableResource>();
 419   EXPECT_EQ(id, round_trip_resource.id);
 420   EXPECT_EQ(format, round_trip_resource.format);
 421   EXPECT_EQ(filter, round_trip_resource.filter);
 422   EXPECT_EQ(size, round_trip_resource.size);
 423   EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox);
 424   EXPECT_EQ(mailbox_holder.texture_target,
 425             round_trip_resource.mailbox_holder.texture_target);
 426   EXPECT_EQ(mailbox_holder.sync_point,
 427             round_trip_resource.mailbox_holder.sync_point);
 428   EXPECT_EQ(is_repeated, round_trip_resource.is_repeated);
 429   EXPECT_EQ(is_software, round_trip_resource.is_software);
 430 }
 431
 432 TEST(SurfaceLibTest, ReturnedResource) {
 433   uint32_t id = 5u;
 434   uint32_t sync_point = 24u;
 435   int count = 2;
 436   bool lost = false;
 437   cc::ReturnedResource resource;
 438   resource.id = id;
 439   resource.sync_point = sync_point;
 440   resource.count = count;
 441   resource.lost = lost;
 442
 443   ReturnedResourcePtr mojo_resource = ReturnedResource::From(resource);
 444   EXPECT_EQ(id, mojo_resource->id);
 445   EXPECT_EQ(sync_point, mojo_resource->sync_point);
 446   EXPECT_EQ(count, mojo_resource->count);
 447   EXPECT_EQ(lost, mojo_resource->lost);
 448
 449   cc::ReturnedResource round_trip_resource =
 450       mojo_resource.To<cc::ReturnedResource>();
 451   EXPECT_EQ(id, round_trip_resource.id);
 452   EXPECT_EQ(sync_point, round_trip_resource.sync_point);
 453   EXPECT_EQ(count, round_trip_resource.count);
 454   EXPECT_EQ(lost, round_trip_resource.lost);
 455 }
 456
 457 }  // namespace
 458 }  // namespace mojo