| 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 <stddef.h> | |
| 6 #include <stdint.h> | |
| 7 | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "cc/quads/debug_border_draw_quad.h" | |
| 11 #include "cc/quads/render_pass.h" | |
| 12 #include "cc/quads/solid_color_draw_quad.h" | |
| 13 #include "cc/quads/surface_draw_quad.h" | |
| 14 #include "cc/quads/texture_draw_quad.h" | |
| 15 #include "cc/resources/resource_provider.h" | |
| 16 #include "components/mus/public/cpp/surfaces/surfaces_type_converters.h" | |
| 17 #include "gpu/command_buffer/common/mailbox.h" | |
| 18 #include "gpu/command_buffer/common/mailbox_holder.h" | |
| 19 #include "gpu/command_buffer/common/sync_token.h" | |
| 20 #include "testing/gtest/include/gtest/gtest.h" | |
| 21 #include "third_party/skia/include/core/SkColor.h" | |
| 22 #include "third_party/skia/include/core/SkXfermode.h" | |
| 23 | |
| 24 using cc::mojom::CompositorFrame; | |
| 25 using cc::mojom::CompositorFramePtr; | |
| 26 using cc::mojom::DebugBorderQuadState; | |
| 27 using cc::mojom::DebugBorderQuadStatePtr; | |
| 28 using cc::mojom::DrawQuad; | |
| 29 using cc::mojom::DrawQuadPtr; | |
| 30 using cc::mojom::RenderPass; | |
| 31 using cc::mojom::RenderPassPtr; | |
| 32 using cc::mojom::RenderPassQuadState; | |
| 33 using cc::mojom::RenderPassQuadStatePtr; | |
| 34 using cc::mojom::SolidColorQuadState; | |
| 35 using cc::mojom::SolidColorQuadStatePtr; | |
| 36 using cc::mojom::SurfaceQuadState; | |
| 37 using cc::mojom::SurfaceQuadStatePtr; | |
| 38 using cc::mojom::TextureQuadState; | |
| 39 using cc::mojom::TextureQuadStatePtr; | |
| 40 using cc::mojom::TileQuadState; | |
| 41 using cc::mojom::TileQuadStatePtr; | |
| 42 using cc::mojom::YUVColorSpace; | |
| 43 using cc::mojom::YUVVideoQuadState; | |
| 44 using cc::mojom::YUVVideoQuadStatePtr; | |
| 45 | |
| 46 namespace mojo { | |
| 47 namespace { | |
| 48 | |
| 49 | |
| 50 class SurfaceLibQuadTest : public testing::Test { | |
| 51 public: | |
| 52 SurfaceLibQuadTest() | |
| 53 : rect(5, 7, 13, 19), | |
| 54 opaque_rect(rect), | |
| 55 visible_rect(9, 11, 5, 7), | |
| 56 needs_blending(false) { | |
| 57 pass = cc::RenderPass::Create(); | |
| 58 sqs = pass->CreateAndAppendSharedQuadState(); | |
| 59 } | |
| 60 | |
| 61 protected: | |
| 62 gfx::Rect rect; | |
| 63 gfx::Rect opaque_rect; | |
| 64 gfx::Rect visible_rect; | |
| 65 bool needs_blending; | |
| 66 std::unique_ptr<cc::RenderPass> pass; | |
| 67 cc::SharedQuadState* sqs; | |
| 68 }; | |
| 69 | |
| 70 TEST_F(SurfaceLibQuadTest, ColorQuad) { | |
| 71 cc::SolidColorDrawQuad* color_quad = | |
| 72 pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>(); | |
| 73 SkColor arbitrary_color = SK_ColorGREEN; | |
| 74 bool force_anti_aliasing_off = true; | |
| 75 color_quad->SetAll(sqs, | |
| 76 rect, | |
| 77 opaque_rect, | |
| 78 visible_rect, | |
| 79 needs_blending, | |
| 80 arbitrary_color, | |
| 81 force_anti_aliasing_off); | |
| 82 | |
| 83 DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*color_quad); | |
| 84 ASSERT_FALSE(mus_quad.is_null()); | |
| 85 EXPECT_EQ(cc::mojom::Material::SOLID_COLOR, mus_quad->material); | |
| 86 EXPECT_EQ(rect, mus_quad->rect); | |
| 87 EXPECT_EQ(opaque_rect, mus_quad->opaque_rect); | |
| 88 EXPECT_EQ(visible_rect, mus_quad->visible_rect); | |
| 89 EXPECT_EQ(needs_blending, mus_quad->needs_blending); | |
| 90 ASSERT_TRUE(mus_quad->solid_color_quad_state); | |
| 91 SolidColorQuadStatePtr& mus_color_state = mus_quad->solid_color_quad_state; | |
| 92 EXPECT_EQ(arbitrary_color, mus_color_state->color); | |
| 93 EXPECT_EQ(force_anti_aliasing_off, mus_color_state->force_anti_aliasing_off); | |
| 94 } | |
| 95 | |
| 96 TEST_F(SurfaceLibQuadTest, SurfaceQuad) { | |
| 97 cc::SurfaceDrawQuad* surface_quad = | |
| 98 pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>(); | |
| 99 cc::SurfaceId arbitrary_id(0, 5, 0); | |
| 100 surface_quad->SetAll( | |
| 101 sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id); | |
| 102 | |
| 103 DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*surface_quad); | |
| 104 ASSERT_FALSE(mus_quad.is_null()); | |
| 105 EXPECT_EQ(cc::mojom::Material::SURFACE_CONTENT, mus_quad->material); | |
| 106 ASSERT_TRUE(mus_quad->surface_quad_state); | |
| 107 SurfaceQuadStatePtr& mus_surface_state = mus_quad->surface_quad_state; | |
| 108 EXPECT_EQ(arbitrary_id, mus_surface_state->surface); | |
| 109 } | |
| 110 | |
| 111 TEST_F(SurfaceLibQuadTest, TextureQuad) { | |
| 112 cc::TextureDrawQuad* texture_quad = | |
| 113 pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>(); | |
| 114 unsigned resource_id = 9; | |
| 115 bool premultiplied_alpha = true; | |
| 116 gfx::PointF uv_top_left(1.7f, 2.1f); | |
| 117 gfx::PointF uv_bottom_right(-7.f, 16.3f); | |
| 118 SkColor background_color = SK_ColorYELLOW; | |
| 119 float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f}; | |
| 120 bool y_flipped = false; | |
| 121 bool nearest_neighbor = false; | |
| 122 bool secure_output_only = true; | |
| 123 texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending, | |
| 124 resource_id, gfx::Size(), premultiplied_alpha, | |
| 125 uv_top_left, uv_bottom_right, background_color, | |
| 126 vertex_opacity, y_flipped, nearest_neighbor, | |
| 127 secure_output_only); | |
| 128 | |
| 129 DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*texture_quad); | |
| 130 ASSERT_FALSE(mus_quad.is_null()); | |
| 131 EXPECT_EQ(cc::mojom::Material::TEXTURE_CONTENT, mus_quad->material); | |
| 132 ASSERT_TRUE(mus_quad->texture_quad_state); | |
| 133 TextureQuadStatePtr& mus_texture_state = mus_quad->texture_quad_state; | |
| 134 EXPECT_EQ(resource_id, mus_texture_state->resource_id); | |
| 135 EXPECT_EQ(premultiplied_alpha, mus_texture_state->premultiplied_alpha); | |
| 136 EXPECT_EQ(uv_top_left, mus_texture_state->uv_top_left); | |
| 137 EXPECT_EQ(uv_bottom_right, mus_texture_state->uv_bottom_right); | |
| 138 EXPECT_EQ(background_color, mus_texture_state->background_color); | |
| 139 for (size_t i = 0; i < 4; ++i) { | |
| 140 EXPECT_EQ(vertex_opacity[i], mus_texture_state->vertex_opacity[i]) << i; | |
| 141 } | |
| 142 EXPECT_EQ(y_flipped, mus_texture_state->y_flipped); | |
| 143 EXPECT_EQ(secure_output_only, mus_texture_state->secure_output_only); | |
| 144 } | |
| 145 | |
| 146 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) { | |
| 147 DrawQuadPtr mus_texture_quad = DrawQuad::New(); | |
| 148 mus_texture_quad->material = cc::mojom::Material::TEXTURE_CONTENT; | |
| 149 TextureQuadStatePtr mus_texture_state = TextureQuadState::New(); | |
| 150 mus_texture_quad->texture_quad_state = std::move(mus_texture_state); | |
| 151 RenderPassPtr mus_pass = RenderPass::New(); | |
| 152 mus_pass->id.layer_id = 1; | |
| 153 mus_pass->id.index = 1u; | |
| 154 mus_pass->quads.push_back(std::move(mus_texture_quad)); | |
| 155 mus_pass->shared_quad_states.AllocateAndConstruct<cc::SharedQuadState>(); | |
| 156 | |
| 157 std::unique_ptr<cc::RenderPass> pass = | |
| 158 mus_pass.To<std::unique_ptr<cc::RenderPass>>(); | |
| 159 | |
| 160 EXPECT_FALSE(pass); | |
| 161 } | |
| 162 | |
| 163 TEST(SurfaceLibTest, RenderPass) { | |
| 164 std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create(); | |
| 165 cc::RenderPassId pass_id(1, 6); | |
| 166 gfx::Rect output_rect(4, 9, 13, 71); | |
| 167 gfx::Rect damage_rect(9, 17, 41, 45); | |
| 168 gfx::Transform transform_to_root_target; | |
| 169 transform_to_root_target.Skew(0.0, 43.0); | |
| 170 bool has_transparent_background = false; | |
| 171 pass->SetAll(pass_id, | |
| 172 output_rect, | |
| 173 damage_rect, | |
| 174 transform_to_root_target, | |
| 175 has_transparent_background); | |
| 176 | |
| 177 gfx::Transform quad_to_target_transform; | |
| 178 quad_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f); | |
| 179 gfx::Size quad_layer_bounds(57, 39); | |
| 180 gfx::Rect visible_quad_layer_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 cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState(); | |
| 187 sqs->SetAll(quad_to_target_transform, quad_layer_bounds, | |
| 188 visible_quad_layer_rect, clip_rect, is_clipped, opacity, | |
| 189 blend_mode, sorting_context_id); | |
| 190 | |
| 191 gfx::Rect rect(5, 7, 13, 19); | |
| 192 gfx::Rect opaque_rect(rect); | |
| 193 gfx::Rect visible_rect(9, 11, 5, 7); | |
| 194 bool needs_blending = false; | |
| 195 | |
| 196 cc::SolidColorDrawQuad* color_quad = | |
| 197 pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>(); | |
| 198 SkColor arbitrary_color = SK_ColorGREEN; | |
| 199 bool force_anti_aliasing_off = true; | |
| 200 color_quad->SetAll(pass->shared_quad_state_list.back(), | |
| 201 rect, | |
| 202 opaque_rect, | |
| 203 visible_rect, | |
| 204 needs_blending, | |
| 205 arbitrary_color, | |
| 206 force_anti_aliasing_off); | |
| 207 | |
| 208 cc::SurfaceDrawQuad* surface_quad = | |
| 209 pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>(); | |
| 210 cc::SurfaceId arbitrary_id(0, 5, 0); | |
| 211 surface_quad->SetAll( | |
| 212 sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id); | |
| 213 | |
| 214 cc::TextureDrawQuad* texture_quad = | |
| 215 pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>(); | |
| 216 unsigned resource_id = 9; | |
| 217 bool premultiplied_alpha = true; | |
| 218 gfx::PointF uv_top_left(1.7f, 2.1f); | |
| 219 gfx::PointF uv_bottom_right(-7.f, 16.3f); | |
| 220 SkColor background_color = SK_ColorYELLOW; | |
| 221 float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f}; | |
| 222 bool y_flipped = false; | |
| 223 bool nearest_neighbor = false; | |
| 224 bool secure_output_only = false; | |
| 225 texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending, | |
| 226 resource_id, gfx::Size(), premultiplied_alpha, | |
| 227 uv_top_left, uv_bottom_right, background_color, | |
| 228 vertex_opacity, y_flipped, nearest_neighbor, | |
| 229 secure_output_only); | |
| 230 | |
| 231 RenderPassPtr mus_pass = RenderPass::From(*pass); | |
| 232 ASSERT_FALSE(mus_pass.is_null()); | |
| 233 EXPECT_EQ(6u, mus_pass->id.index); | |
| 234 EXPECT_EQ(output_rect, mus_pass->output_rect); | |
| 235 EXPECT_EQ(damage_rect, mus_pass->damage_rect); | |
| 236 EXPECT_EQ(transform_to_root_target, mus_pass->transform_to_root_target); | |
| 237 EXPECT_EQ(has_transparent_background, mus_pass->has_transparent_background); | |
| 238 ASSERT_EQ(1u, mus_pass->shared_quad_states.size()); | |
| 239 ASSERT_EQ(3u, mus_pass->quads.size()); | |
| 240 EXPECT_EQ(0u, mus_pass->quads[0]->shared_quad_state_index); | |
| 241 | |
| 242 std::unique_ptr<cc::RenderPass> round_trip_pass = | |
| 243 mus_pass.To<std::unique_ptr<cc::RenderPass>>(); | |
| 244 EXPECT_EQ(pass_id, round_trip_pass->id); | |
| 245 EXPECT_EQ(output_rect, round_trip_pass->output_rect); | |
| 246 EXPECT_EQ(damage_rect, round_trip_pass->damage_rect); | |
| 247 EXPECT_EQ(transform_to_root_target, | |
| 248 round_trip_pass->transform_to_root_target); | |
| 249 EXPECT_EQ(has_transparent_background, | |
| 250 round_trip_pass->has_transparent_background); | |
| 251 ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size()); | |
| 252 ASSERT_EQ(3u, round_trip_pass->quad_list.size()); | |
| 253 EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(), | |
| 254 round_trip_pass->quad_list.front()->shared_quad_state); | |
| 255 | |
| 256 cc::SharedQuadState* round_trip_sqs = | |
| 257 round_trip_pass->shared_quad_state_list.front(); | |
| 258 EXPECT_EQ(quad_to_target_transform, round_trip_sqs->quad_to_target_transform); | |
| 259 EXPECT_EQ(quad_layer_bounds, round_trip_sqs->quad_layer_bounds); | |
| 260 EXPECT_EQ(visible_quad_layer_rect, round_trip_sqs->visible_quad_layer_rect); | |
| 261 EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect); | |
| 262 EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped); | |
| 263 EXPECT_EQ(opacity, round_trip_sqs->opacity); | |
| 264 EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id); | |
| 265 | |
| 266 cc::DrawQuad* round_trip_quad = round_trip_pass->quad_list.front(); | |
| 267 // First is solid color quad. | |
| 268 ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material); | |
| 269 EXPECT_EQ(rect, round_trip_quad->rect); | |
| 270 EXPECT_EQ(opaque_rect, round_trip_quad->opaque_rect); | |
| 271 EXPECT_EQ(visible_rect, round_trip_quad->visible_rect); | |
| 272 EXPECT_EQ(needs_blending, round_trip_quad->needs_blending); | |
| 273 const cc::SolidColorDrawQuad* round_trip_color_quad = | |
| 274 cc::SolidColorDrawQuad::MaterialCast(round_trip_quad); | |
| 275 EXPECT_EQ(arbitrary_color, round_trip_color_quad->color); | |
| 276 EXPECT_EQ(force_anti_aliasing_off, | |
| 277 round_trip_color_quad->force_anti_aliasing_off); | |
| 278 | |
| 279 round_trip_quad = round_trip_pass->quad_list.ElementAt(1); | |
| 280 // Second is surface quad. | |
| 281 ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material); | |
| 282 const cc::SurfaceDrawQuad* round_trip_surface_quad = | |
| 283 cc::SurfaceDrawQuad::MaterialCast(round_trip_quad); | |
| 284 EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id); | |
| 285 | |
| 286 round_trip_quad = round_trip_pass->quad_list.ElementAt(2); | |
| 287 // Third is texture quad. | |
| 288 ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material); | |
| 289 const cc::TextureDrawQuad* round_trip_texture_quad = | |
| 290 cc::TextureDrawQuad::MaterialCast(round_trip_quad); | |
| 291 EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id()); | |
| 292 EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha); | |
| 293 EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left); | |
| 294 EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right); | |
| 295 EXPECT_EQ(background_color, round_trip_texture_quad->background_color); | |
| 296 for (size_t i = 0; i < 4; ++i) { | |
| 297 EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i]) | |
| 298 << i; | |
| 299 } | |
| 300 EXPECT_EQ(y_flipped, round_trip_texture_quad->y_flipped); | |
| 301 EXPECT_EQ(secure_output_only, round_trip_texture_quad->secure_output_only); | |
| 302 } | |
| 303 | |
| 304 TEST_F(SurfaceLibQuadTest, DebugBorderQuad) { | |
| 305 cc::DebugBorderDrawQuad* debug_border_quad = | |
| 306 pass->CreateAndAppendDrawQuad<cc::DebugBorderDrawQuad>(); | |
| 307 const SkColor arbitrary_color = SK_ColorGREEN; | |
| 308 const int width = 3; | |
| 309 debug_border_quad->SetAll(sqs, | |
| 310 rect, | |
| 311 opaque_rect, | |
| 312 visible_rect, | |
| 313 needs_blending, | |
| 314 arbitrary_color, | |
| 315 width); | |
| 316 | |
| 317 DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*debug_border_quad); | |
| 318 ASSERT_FALSE(mus_quad.is_null()); | |
| 319 EXPECT_EQ(cc::mojom::Material::DEBUG_BORDER, mus_quad->material); | |
| 320 EXPECT_EQ(rect, mus_quad->rect); | |
| 321 EXPECT_EQ(opaque_rect, mus_quad->opaque_rect); | |
| 322 EXPECT_EQ(visible_rect, mus_quad->visible_rect); | |
| 323 EXPECT_EQ(needs_blending, mus_quad->needs_blending); | |
| 324 ASSERT_TRUE(mus_quad->debug_border_quad_state); | |
| 325 DebugBorderQuadStatePtr& mus_debug_border_state = | |
| 326 mus_quad->debug_border_quad_state; | |
| 327 EXPECT_EQ(arbitrary_color, mus_debug_border_state->color); | |
| 328 EXPECT_EQ(width, mus_debug_border_state->width); | |
| 329 } | |
| 330 | |
| 331 } // namespace | |
| 332 } // namespace mojo | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2088603002:
Implement RenderPass StructTraits (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master