| OLD | NEW |
|---|
| (Empty) |
| 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/converters/geometry/geometry_type_converters.h" | |
| 12 #include "mojo/converters/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<cc::DrawQuad>(*color_quad); | |
| 73 ASSERT_FALSE(mojo_quad.is_null()); | |
| 74 EXPECT_EQ(Material::SOLID_COLOR, mojo_quad->material); | |
| 75 EXPECT_TRUE(Rect::From(rect)->Equals(*mojo_quad->rect)); | |
| 76 EXPECT_TRUE(Rect::From(opaque_rect)->Equals(*mojo_quad->opaque_rect)); | |
| 77 EXPECT_TRUE(Rect::From(visible_rect)->Equals(*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_TRUE(Color::From(arbitrary_color)->Equals(*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<cc::DrawQuad>(*surface_quad); | |
| 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_TRUE( | |
| 98 SurfaceId::From(arbitrary_id)->Equals(*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 bool nearest_neighbor = false; | |
| 112 texture_quad->SetAll(sqs, | |
| 113 rect, | |
| 114 opaque_rect, | |
| 115 visible_rect, | |
| 116 needs_blending, | |
| 117 resource_id, | |
| 118 premultiplied_alpha, | |
| 119 uv_top_left, | |
| 120 uv_bottom_right, | |
| 121 background_color, | |
| 122 vertex_opacity, | |
| 123 flipped, | |
| 124 nearest_neighbor); | |
| 125 | |
| 126 QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*texture_quad); | |
| 127 ASSERT_FALSE(mojo_quad.is_null()); | |
| 128 EXPECT_EQ(Material::TEXTURE_CONTENT, mojo_quad->material); | |
| 129 ASSERT_TRUE(mojo_quad->texture_quad_state); | |
| 130 TextureQuadStatePtr& mojo_texture_state = mojo_quad->texture_quad_state; | |
| 131 EXPECT_EQ(resource_id, mojo_texture_state->resource_id); | |
| 132 EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha); | |
| 133 EXPECT_TRUE( | |
| 134 PointF::From(uv_top_left)->Equals(*mojo_texture_state->uv_top_left)); | |
| 135 EXPECT_TRUE(PointF::From(uv_bottom_right) | |
| 136 ->Equals(*mojo_texture_state->uv_bottom_right)); | |
| 137 EXPECT_TRUE(Color::From(background_color) | |
| 138 ->Equals(*mojo_texture_state->background_color)); | |
| 139 for (size_t i = 0; i < 4; ++i) { | |
| 140 EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i; | |
| 141 } | |
| 142 EXPECT_EQ(flipped, mojo_texture_state->flipped); | |
| 143 } | |
| 144 | |
| 145 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) { | |
| 146 QuadPtr mojo_texture_quad = Quad::New(); | |
| 147 mojo_texture_quad->material = Material::TEXTURE_CONTENT; | |
| 148 TextureQuadStatePtr mojo_texture_state = TextureQuadState::New(); | |
| 149 mojo_texture_state->background_color = Color::New(); | |
| 150 mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass(); | |
| 151 PassPtr mojo_pass = Pass::New(); | |
| 152 mojo_pass->quads.push_back(mojo_texture_quad.Pass()); | |
| 153 SharedQuadStatePtr mojo_sqs = SharedQuadState::New(); | |
| 154 mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass()); | |
| 155 | |
| 156 scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >(); | |
| 157 | |
| 158 EXPECT_FALSE(pass); | |
| 159 } | |
| 160 | |
| 161 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) { | |
| 162 QuadPtr mojo_texture_quad = Quad::New(); | |
| 163 mojo_texture_quad->material = Material::TEXTURE_CONTENT; | |
| 164 TextureQuadStatePtr mojo_texture_state = TextureQuadState::New(); | |
| 165 mojo_texture_state->vertex_opacity = mojo::Array<float>::New(4); | |
| 166 mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass(); | |
| 167 PassPtr mojo_pass = Pass::New(); | |
| 168 mojo_pass->quads.push_back(mojo_texture_quad.Pass()); | |
| 169 SharedQuadStatePtr mojo_sqs = SharedQuadState::New(); | |
| 170 mojo_pass->shared_quad_states.push_back(mojo_sqs.Pass()); | |
| 171 | |
| 172 scoped_ptr<cc::RenderPass> pass = mojo_pass.To<scoped_ptr<cc::RenderPass> >(); | |
| 173 EXPECT_FALSE(pass); | |
| 174 } | |
| 175 | |
| 176 TEST(SurfaceLibTest, SharedQuadState) { | |
| 177 gfx::Transform content_to_target_transform; | |
| 178 content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f); | |
| 179 gfx::Size content_bounds(57, 39); | |
| 180 gfx::Rect visible_content_rect(3, 7, 28, 42); | |
| 181 gfx::Rect clip_rect(9, 12, 21, 31); | |
| 182 bool is_clipped = true; | |
| 183 float opacity = 0.65f; | |
| 184 int sorting_context_id = 13; | |
| 185 ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode; | |
| 186 scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create(); | |
| 187 cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState(); | |
| 188 sqs->SetAll(content_to_target_transform, | |
| 189 content_bounds, | |
| 190 visible_content_rect, | |
| 191 clip_rect, | |
| 192 is_clipped, | |
| 193 opacity, | |
| 194 blend_mode, | |
| 195 sorting_context_id); | |
| 196 | |
| 197 SharedQuadStatePtr mojo_sqs = SharedQuadState::From(*sqs); | |
| 198 ASSERT_FALSE(mojo_sqs.is_null()); | |
| 199 EXPECT_TRUE(Transform::From(content_to_target_transform) | |
| 200 ->Equals(*mojo_sqs->content_to_target_transform)); | |
| 201 EXPECT_TRUE(Size::From(content_bounds)->Equals(*mojo_sqs->content_bounds)); | |
| 202 EXPECT_TRUE(Rect::From(visible_content_rect) | |
| 203 ->Equals(*mojo_sqs->visible_content_rect)); | |
| 204 EXPECT_TRUE(Rect::From(clip_rect)->Equals(*mojo_sqs->clip_rect)); | |
| 205 EXPECT_EQ(is_clipped, mojo_sqs->is_clipped); | |
| 206 EXPECT_EQ(opacity, mojo_sqs->opacity); | |
| 207 EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id); | |
| 208 } | |
| 209 | |
| 210 TEST(SurfaceLibTest, RenderPass) { | |
| 211 scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create(); | |
| 212 cc::RenderPassId pass_id(1, 6); | |
| 213 gfx::Rect output_rect(4, 9, 13, 71); | |
| 214 gfx::Rect damage_rect(9, 17, 41, 45); | |
| 215 gfx::Transform transform_to_root_target; | |
| 216 transform_to_root_target.SkewY(43.0); | |
| 217 bool has_transparent_background = false; | |
| 218 pass->SetAll(pass_id, | |
| 219 output_rect, | |
| 220 damage_rect, | |
| 221 transform_to_root_target, | |
| 222 has_transparent_background); | |
| 223 | |
| 224 gfx::Transform content_to_target_transform; | |
| 225 content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f); | |
| 226 gfx::Size content_bounds(57, 39); | |
| 227 gfx::Rect visible_content_rect(3, 7, 28, 42); | |
| 228 gfx::Rect clip_rect(9, 12, 21, 31); | |
| 229 bool is_clipped = true; | |
| 230 float opacity = 0.65f; | |
| 231 int sorting_context_id = 13; | |
| 232 ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode; | |
| 233 cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState(); | |
| 234 sqs->SetAll(content_to_target_transform, | |
| 235 content_bounds, | |
| 236 visible_content_rect, | |
| 237 clip_rect, | |
| 238 is_clipped, | |
| 239 opacity, | |
| 240 blend_mode, | |
| 241 sorting_context_id); | |
| 242 | |
| 243 gfx::Rect rect(5, 7, 13, 19); | |
| 244 gfx::Rect opaque_rect(rect); | |
| 245 gfx::Rect visible_rect(9, 11, 5, 7); | |
| 246 bool needs_blending = false; | |
| 247 | |
| 248 cc::SolidColorDrawQuad* color_quad = | |
| 249 pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>(); | |
| 250 SkColor arbitrary_color = SK_ColorGREEN; | |
| 251 bool force_anti_aliasing_off = true; | |
| 252 color_quad->SetAll(pass->shared_quad_state_list.back(), | |
| 253 rect, | |
| 254 opaque_rect, | |
| 255 visible_rect, | |
| 256 needs_blending, | |
| 257 arbitrary_color, | |
| 258 force_anti_aliasing_off); | |
| 259 | |
| 260 cc::SurfaceDrawQuad* surface_quad = | |
| 261 pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>(); | |
| 262 cc::SurfaceId arbitrary_id(5); | |
| 263 surface_quad->SetAll( | |
| 264 sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id); | |
| 265 | |
| 266 cc::TextureDrawQuad* texture_quad = | |
| 267 pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>(); | |
| 268 unsigned resource_id = 9; | |
| 269 bool premultiplied_alpha = true; | |
| 270 gfx::PointF uv_top_left(1.7f, 2.1f); | |
| 271 gfx::PointF uv_bottom_right(-7.f, 16.3f); | |
| 272 SkColor background_color = SK_ColorYELLOW; | |
| 273 float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f}; | |
| 274 bool flipped = false; | |
| 275 bool nearest_neighbor = false; | |
| 276 texture_quad->SetAll(sqs, | |
| 277 rect, | |
| 278 opaque_rect, | |
| 279 visible_rect, | |
| 280 needs_blending, | |
| 281 resource_id, | |
| 282 premultiplied_alpha, | |
| 283 uv_top_left, | |
| 284 uv_bottom_right, | |
| 285 background_color, | |
| 286 vertex_opacity, | |
| 287 flipped, | |
| 288 nearest_neighbor); | |
| 289 | |
| 290 PassPtr mojo_pass = Pass::From(*pass); | |
| 291 ASSERT_FALSE(mojo_pass.is_null()); | |
| 292 EXPECT_EQ(6, mojo_pass->id); | |
| 293 EXPECT_TRUE(Rect::From(output_rect)->Equals(*mojo_pass->output_rect)); | |
| 294 EXPECT_TRUE(Rect::From(damage_rect)->Equals(*mojo_pass->damage_rect)); | |
| 295 EXPECT_TRUE(Transform::From(transform_to_root_target) | |
| 296 ->Equals(*mojo_pass->transform_to_root_target)); | |
| 297 EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background); | |
| 298 ASSERT_EQ(1u, mojo_pass->shared_quad_states.size()); | |
| 299 ASSERT_EQ(3u, mojo_pass->quads.size()); | |
| 300 EXPECT_EQ(0u, mojo_pass->quads[0]->shared_quad_state_index); | |
| 301 | |
| 302 scoped_ptr<cc::RenderPass> round_trip_pass = | |
| 303 mojo_pass.To<scoped_ptr<cc::RenderPass> >(); | |
| 304 EXPECT_EQ(pass_id, round_trip_pass->id); | |
| 305 EXPECT_EQ(output_rect, round_trip_pass->output_rect); | |
| 306 EXPECT_EQ(damage_rect, round_trip_pass->damage_rect); | |
| 307 EXPECT_EQ(transform_to_root_target, | |
| 308 round_trip_pass->transform_to_root_target); | |
| 309 EXPECT_EQ(has_transparent_background, | |
| 310 round_trip_pass->has_transparent_background); | |
| 311 ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size()); | |
| 312 ASSERT_EQ(3u, round_trip_pass->quad_list.size()); | |
| 313 EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(), | |
| 314 round_trip_pass->quad_list.front()->shared_quad_state); | |
| 315 | |
| 316 cc::SharedQuadState* round_trip_sqs = | |
| 317 round_trip_pass->shared_quad_state_list.front(); | |
| 318 EXPECT_EQ(content_to_target_transform, | |
| 319 round_trip_sqs->content_to_target_transform); | |
| 320 EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds); | |
| 321 EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect); | |
| 322 EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect); | |
| 323 EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped); | |
| 324 EXPECT_EQ(opacity, round_trip_sqs->opacity); | |
| 325 EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id); | |
| 326 | |
| 327 cc::DrawQuad* round_trip_quad = round_trip_pass->quad_list.front(); | |
| 328 // First is solid color quad. | |
| 329 ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material); | |
| 330 EXPECT_EQ(rect, round_trip_quad->rect); | |
| 331 EXPECT_EQ(opaque_rect, round_trip_quad->opaque_rect); | |
| 332 EXPECT_EQ(visible_rect, round_trip_quad->visible_rect); | |
| 333 EXPECT_EQ(needs_blending, round_trip_quad->needs_blending); | |
| 334 const cc::SolidColorDrawQuad* round_trip_color_quad = | |
| 335 cc::SolidColorDrawQuad::MaterialCast(round_trip_quad); | |
| 336 EXPECT_EQ(arbitrary_color, round_trip_color_quad->color); | |
| 337 EXPECT_EQ(force_anti_aliasing_off, | |
| 338 round_trip_color_quad->force_anti_aliasing_off); | |
| 339 | |
| 340 round_trip_quad = round_trip_pass->quad_list.ElementAt(1); | |
| 341 // Second is surface quad. | |
| 342 ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material); | |
| 343 const cc::SurfaceDrawQuad* round_trip_surface_quad = | |
| 344 cc::SurfaceDrawQuad::MaterialCast(round_trip_quad); | |
| 345 EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id); | |
| 346 | |
| 347 round_trip_quad = round_trip_pass->quad_list.ElementAt(2); | |
| 348 // Third is texture quad. | |
| 349 ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material); | |
| 350 const cc::TextureDrawQuad* round_trip_texture_quad = | |
| 351 cc::TextureDrawQuad::MaterialCast(round_trip_quad); | |
| 352 EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id); | |
| 353 EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha); | |
| 354 EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left); | |
| 355 EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right); | |
| 356 EXPECT_EQ(background_color, round_trip_texture_quad->background_color); | |
| 357 for (size_t i = 0; i < 4; ++i) { | |
| 358 EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i]) | |
| 359 << i; | |
| 360 } | |
| 361 EXPECT_EQ(flipped, round_trip_texture_quad->flipped); | |
| 362 } | |
| 363 | |
| 364 TEST(SurfaceLibTest, Mailbox) { | |
| 365 gpu::Mailbox mailbox; | |
| 366 mailbox.Generate(); | |
| 367 | |
| 368 MailboxPtr mojo_mailbox = Mailbox::From(mailbox); | |
| 369 EXPECT_EQ(0, memcmp(mailbox.name, &mojo_mailbox->name.storage()[0], 64)); | |
| 370 | |
| 371 gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>(); | |
| 372 EXPECT_EQ(mailbox, round_trip_mailbox); | |
| 373 } | |
| 374 | |
| 375 TEST(SurfaceLibTest, MailboxEmptyName) { | |
| 376 MailboxPtr mojo_mailbox = Mailbox::New(); | |
| 377 | |
| 378 gpu::Mailbox converted_mailbox = mojo_mailbox.To<gpu::Mailbox>(); | |
| 379 EXPECT_TRUE(converted_mailbox.IsZero()); | |
| 380 } | |
| 381 | |
| 382 TEST(SurfaceLibTest, MailboxHolder) { | |
| 383 gpu::Mailbox mailbox; | |
| 384 mailbox.Generate(); | |
| 385 uint32_t texture_target = GL_TEXTURE_2D; | |
| 386 uint32_t sync_point = 7u; | |
| 387 gpu::MailboxHolder holder(mailbox, texture_target, sync_point); | |
| 388 | |
| 389 MailboxHolderPtr mojo_holder = MailboxHolder::From(holder); | |
| 390 EXPECT_EQ(texture_target, mojo_holder->texture_target); | |
| 391 EXPECT_EQ(sync_point, mojo_holder->sync_point); | |
| 392 | |
| 393 gpu::MailboxHolder round_trip_holder = mojo_holder.To<gpu::MailboxHolder>(); | |
| 394 EXPECT_EQ(mailbox, round_trip_holder.mailbox); | |
| 395 EXPECT_EQ(texture_target, round_trip_holder.texture_target); | |
| 396 EXPECT_EQ(sync_point, round_trip_holder.sync_point); | |
| 397 } | |
| 398 | |
| 399 TEST(SurfaceLibTest, TransferableResource) { | |
| 400 uint32_t id = 7u; | |
| 401 cc::ResourceFormat format = cc::BGRA_8888; | |
| 402 uint32_t filter = 123u; | |
| 403 gfx::Size size(17, 18); | |
| 404 gpu::MailboxHolder mailbox_holder; | |
| 405 bool is_repeated = false; | |
| 406 ; | |
| 407 bool is_software = false; | |
| 408 cc::TransferableResource resource; | |
| 409 resource.id = id; | |
| 410 resource.format = format; | |
| 411 resource.filter = filter; | |
| 412 resource.size = size; | |
| 413 resource.mailbox_holder = mailbox_holder; | |
| 414 resource.is_repeated = is_repeated; | |
| 415 resource.is_software = is_software; | |
| 416 | |
| 417 TransferableResourcePtr mojo_resource = TransferableResource::From(resource); | |
| 418 EXPECT_EQ(id, mojo_resource->id); | |
| 419 EXPECT_EQ(static_cast<ResourceFormat>(format), | |
| 420 mojo_resource->format); | |
| 421 EXPECT_EQ(filter, mojo_resource->filter); | |
| 422 EXPECT_TRUE(Size::From(size)->Equals(*mojo_resource->size)); | |
| 423 EXPECT_EQ(is_repeated, mojo_resource->is_repeated); | |
| 424 EXPECT_EQ(is_software, mojo_resource->is_software); | |
| 425 | |
| 426 cc::TransferableResource round_trip_resource = | |
| 427 mojo_resource.To<cc::TransferableResource>(); | |
| 428 EXPECT_EQ(id, round_trip_resource.id); | |
| 429 EXPECT_EQ(format, round_trip_resource.format); | |
| 430 EXPECT_EQ(filter, round_trip_resource.filter); | |
| 431 EXPECT_EQ(size, round_trip_resource.size); | |
| 432 EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox); | |
| 433 EXPECT_EQ(mailbox_holder.texture_target, | |
| 434 round_trip_resource.mailbox_holder.texture_target); | |
| 435 EXPECT_EQ(mailbox_holder.sync_point, | |
| 436 round_trip_resource.mailbox_holder.sync_point); | |
| 437 EXPECT_EQ(is_repeated, round_trip_resource.is_repeated); | |
| 438 EXPECT_EQ(is_software, round_trip_resource.is_software); | |
| 439 } | |
| 440 | |
| 441 TEST(SurfaceLibTest, ReturnedResource) { | |
| 442 uint32_t id = 5u; | |
| 443 uint32_t sync_point = 24u; | |
| 444 int count = 2; | |
| 445 bool lost = false; | |
| 446 cc::ReturnedResource resource; | |
| 447 resource.id = id; | |
| 448 resource.sync_point = sync_point; | |
| 449 resource.count = count; | |
| 450 resource.lost = lost; | |
| 451 | |
| 452 ReturnedResourcePtr mojo_resource = ReturnedResource::From(resource); | |
| 453 EXPECT_EQ(id, mojo_resource->id); | |
| 454 EXPECT_EQ(sync_point, mojo_resource->sync_point); | |
| 455 EXPECT_EQ(count, mojo_resource->count); | |
| 456 EXPECT_EQ(lost, mojo_resource->lost); | |
| 457 | |
| 458 cc::ReturnedResource round_trip_resource = | |
| 459 mojo_resource.To<cc::ReturnedResource>(); | |
| 460 EXPECT_EQ(id, round_trip_resource.id); | |
| 461 EXPECT_EQ(sync_point, round_trip_resource.sync_point); | |
| 462 EXPECT_EQ(count, round_trip_resource.count); | |
| 463 EXPECT_EQ(lost, round_trip_resource.lost); | |
| 464 } | |
| 465 | |
| 466 } // namespace | |
| 467 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1534693002:
Delete the Surfaces service. (Closed)
Base URL: git@github.com:domokit/mojo.git@cl-2d