1 // Copyright 2012 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/test/render_pass_test_utils.h"
6
7 #include <stdint.h>
8
9 #include <memory>
10 #include <unordered_map>
11 #include <utility>
12 #include <vector>
13
14 #include "base/bind.h"
15 #include "base/callback_helpers.h"
16 #include "components/viz/client/client_resource_provider.h"
17 #include "components/viz/common/quads/aggregated_render_pass_draw_quad.h"
18 #include "components/viz/common/quads/compositor_render_pass_draw_quad.h"
19 #include "components/viz/common/quads/debug_border_draw_quad.h"
20 #include "components/viz/common/quads/shared_quad_state.h"
21 #include "components/viz/common/quads/solid_color_draw_quad.h"
22 #include "components/viz/common/quads/stream_video_draw_quad.h"
23 #include "components/viz/common/quads/texture_draw_quad.h"
24 #include "components/viz/common/quads/tile_draw_quad.h"
25 #include "components/viz/common/quads/yuv_video_draw_quad.h"
26 #include "components/viz/common/resources/returned_resource.h"
27 #include "components/viz/common/resources/transferable_resource.h"
28 #include "components/viz/service/display/display_resource_provider.h"
29 #include "gpu/command_buffer/common/sync_token.h"
30 #include "third_party/skia/include/core/SkColor.h"
31 #include "third_party/skia/include/core/SkImageFilter.h"
32 #include "ui/gfx/geometry/rect.h"
33
34 namespace cc {
35
36 namespace {
37
CreateAndImportResource(viz::ClientResourceProvider * resource_provider,const gpu::SyncToken & sync_token,gfx::ColorSpace color_space=gfx::ColorSpace::CreateSRGB ())38 viz::ResourceId CreateAndImportResource(
39 viz::ClientResourceProvider* resource_provider,
40 const gpu::SyncToken& sync_token,
41 gfx::ColorSpace color_space = gfx::ColorSpace::CreateSRGB()) {
42 constexpr gfx::Size size(64, 64);
43 auto transfer_resource = viz::TransferableResource::MakeGL(
44 gpu::Mailbox::Generate(), GL_LINEAR, GL_TEXTURE_2D, sync_token, size,
45 false /* is_overlay_candidate */);
46 transfer_resource.color_space = std::move(color_space);
47 return resource_provider->ImportResource(
48 transfer_resource, viz::SingleReleaseCallback::Create(base::DoNothing()));
49 }
50
51 } // anonymous namespace
52
AddRenderPass(viz::CompositorRenderPassList * pass_list,viz::CompositorRenderPassId render_pass_id,const gfx::Rect & output_rect,const gfx::Transform & root_transform,const FilterOperations & filters)53 viz::CompositorRenderPass* AddRenderPass(
54 viz::CompositorRenderPassList* pass_list,
55 viz::CompositorRenderPassId render_pass_id,
56 const gfx::Rect& output_rect,
57 const gfx::Transform& root_transform,
58 const FilterOperations& filters) {
59 auto pass = viz::CompositorRenderPass::Create();
60 pass->SetNew(render_pass_id, output_rect, output_rect, root_transform);
61 pass->filters = filters;
62 viz::CompositorRenderPass* saved = pass.get();
63 pass_list->push_back(std::move(pass));
64 return saved;
65 }
66
AddRenderPass(viz::AggregatedRenderPassList * pass_list,viz::AggregatedRenderPassId render_pass_id,const gfx::Rect & output_rect,const gfx::Transform & root_transform,const FilterOperations & filters)67 viz::AggregatedRenderPass* AddRenderPass(
68 viz::AggregatedRenderPassList* pass_list,
69 viz::AggregatedRenderPassId render_pass_id,
70 const gfx::Rect& output_rect,
71 const gfx::Transform& root_transform,
72 const FilterOperations& filters) {
73 auto pass = std::make_unique<viz::AggregatedRenderPass>();
74 pass->SetNew(render_pass_id, output_rect, output_rect, root_transform);
75 pass->filters = filters;
76 auto* saved = pass.get();
77 pass_list->push_back(std::move(pass));
78 return saved;
79 }
80
AddRenderPassWithDamage(viz::CompositorRenderPassList * pass_list,viz::CompositorRenderPassId render_pass_id,const gfx::Rect & output_rect,const gfx::Rect & damage_rect,const gfx::Transform & root_transform,const FilterOperations & filters)81 viz::CompositorRenderPass* AddRenderPassWithDamage(
82 viz::CompositorRenderPassList* pass_list,
83 viz::CompositorRenderPassId render_pass_id,
84 const gfx::Rect& output_rect,
85 const gfx::Rect& damage_rect,
86 const gfx::Transform& root_transform,
87 const FilterOperations& filters) {
88 auto pass = viz::CompositorRenderPass::Create();
89 pass->SetNew(render_pass_id, output_rect, damage_rect, root_transform);
90 pass->filters = filters;
91 viz::CompositorRenderPass* saved = pass.get();
92 pass_list->push_back(std::move(pass));
93 return saved;
94 }
95
AddRenderPassWithDamage(viz::AggregatedRenderPassList * pass_list,viz::AggregatedRenderPassId render_pass_id,const gfx::Rect & output_rect,const gfx::Rect & damage_rect,const gfx::Transform & root_transform,const FilterOperations & filters)96 viz::AggregatedRenderPass* AddRenderPassWithDamage(
97 viz::AggregatedRenderPassList* pass_list,
98 viz::AggregatedRenderPassId render_pass_id,
99 const gfx::Rect& output_rect,
100 const gfx::Rect& damage_rect,
101 const gfx::Transform& root_transform,
102 const FilterOperations& filters) {
103 auto pass = std::make_unique<viz::AggregatedRenderPass>();
104 pass->SetNew(render_pass_id, output_rect, damage_rect, root_transform);
105 pass->filters = filters;
106 auto* saved = pass.get();
107 pass_list->push_back(std::move(pass));
108 return saved;
109 }
110
AddClippedQuad(viz::AggregatedRenderPass * pass,const gfx::Rect & rect,SkColor color)111 viz::SolidColorDrawQuad* AddClippedQuad(viz::AggregatedRenderPass* pass,
112 const gfx::Rect& rect,
113 SkColor color) {
114 viz::SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
115 shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
116 rect, true, false, 1, SkBlendMode::kSrcOver, 0);
117 auto* quad = pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
118 quad->SetNew(shared_state, rect, rect, color, false);
119 return quad;
120 }
121
AddTransformedQuad(viz::AggregatedRenderPass * pass,const gfx::Rect & rect,SkColor color,const gfx::Transform & transform)122 viz::SolidColorDrawQuad* AddTransformedQuad(viz::AggregatedRenderPass* pass,
123 const gfx::Rect& rect,
124 SkColor color,
125 const gfx::Transform& transform) {
126 viz::SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
127 shared_state->SetAll(transform, rect, rect, gfx::MaskFilterInfo(), rect,
128 false, false, 1,
129
130 SkBlendMode::kSrcOver, 0);
131 auto* quad = pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
132 quad->SetNew(shared_state, rect, rect, color, false);
133 return quad;
134 }
135
136 template <typename QuadType, typename RenderPassType>
137 QuadType* AddRenderPassQuadInternal(RenderPassType* to_pass,
138 RenderPassType* contributing_pass) {
139 gfx::Rect output_rect = contributing_pass->output_rect;
140 viz::SharedQuadState* shared_state =
141 to_pass->CreateAndAppendSharedQuadState();
142 shared_state->SetAll(gfx::Transform(), output_rect, output_rect,
143 gfx::MaskFilterInfo(), output_rect, false, false, 1,
144 SkBlendMode::kSrcOver, 0);
145 auto* quad = to_pass->template CreateAndAppendDrawQuad<QuadType>();
146 quad->SetNew(shared_state, output_rect, output_rect, contributing_pass->id, 0,
147 gfx::RectF(), gfx::Size(), gfx::Vector2dF(), gfx::PointF(),
148 gfx::RectF(), false, 1.0f);
149 return quad;
150 }
151
AddRenderPassQuad(viz::CompositorRenderPass * to_pass,viz::CompositorRenderPass * contributing_pass)152 viz::CompositorRenderPassDrawQuad* AddRenderPassQuad(
153 viz::CompositorRenderPass* to_pass,
154 viz::CompositorRenderPass* contributing_pass) {
155 return AddRenderPassQuadInternal<viz::CompositorRenderPassDrawQuad>(
156 to_pass, contributing_pass);
157 }
AddRenderPassQuad(viz::AggregatedRenderPass * to_pass,viz::AggregatedRenderPass * contributing_pass)158 viz::AggregatedRenderPassDrawQuad* AddRenderPassQuad(
159 viz::AggregatedRenderPass* to_pass,
160 viz::AggregatedRenderPass* contributing_pass) {
161 return AddRenderPassQuadInternal<viz::AggregatedRenderPassDrawQuad>(
162 to_pass, contributing_pass);
163 }
164
AddRenderPassQuad(viz::AggregatedRenderPass * to_pass,viz::AggregatedRenderPass * contributing_pass,viz::ResourceId mask_resource_id,gfx::Transform transform,SkBlendMode blend_mode)165 void AddRenderPassQuad(viz::AggregatedRenderPass* to_pass,
166 viz::AggregatedRenderPass* contributing_pass,
167 viz::ResourceId mask_resource_id,
168 gfx::Transform transform,
169 SkBlendMode blend_mode) {
170 gfx::Rect output_rect = contributing_pass->output_rect;
171 viz::SharedQuadState* shared_state =
172 to_pass->CreateAndAppendSharedQuadState();
173 shared_state->SetAll(transform, output_rect, output_rect,
174 gfx::MaskFilterInfo(), output_rect, false, false, 1,
175 blend_mode, 0);
176 auto* quad =
177 to_pass->CreateAndAppendDrawQuad<viz::AggregatedRenderPassDrawQuad>();
178 gfx::Size arbitrary_nonzero_size(1, 1);
179 quad->SetNew(shared_state, output_rect, output_rect, contributing_pass->id,
180 mask_resource_id, gfx::RectF(output_rect),
181 arbitrary_nonzero_size, gfx::Vector2dF(), gfx::PointF(),
182 gfx::RectF(), false, 1.0f);
183 }
184
AddOneOfEveryQuadType(viz::CompositorRenderPass * to_pass,viz::ClientResourceProvider * resource_provider,viz::CompositorRenderPassId child_pass_id)185 std::vector<viz::ResourceId> AddOneOfEveryQuadType(
186 viz::CompositorRenderPass* to_pass,
187 viz::ClientResourceProvider* resource_provider,
188 viz::CompositorRenderPassId child_pass_id) {
189 gfx::Rect rect(0, 0, 100, 100);
190 gfx::Rect visible_rect(0, 0, 100, 100);
191 bool needs_blending = true;
192 const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
193
194 static const gpu::SyncToken kSyncToken(
195 gpu::CommandBufferNamespace::GPU_IO,
196 gpu::CommandBufferId::FromUnsafeValue(0x123), 30);
197
198 viz::ResourceId resource1 =
199 CreateAndImportResource(resource_provider, kSyncToken);
200 viz::ResourceId resource2 =
201 CreateAndImportResource(resource_provider, kSyncToken);
202 viz::ResourceId resource3 =
203 CreateAndImportResource(resource_provider, kSyncToken);
204 viz::ResourceId resource4 =
205 CreateAndImportResource(resource_provider, kSyncToken);
206 viz::ResourceId resource5 =
207 CreateAndImportResource(resource_provider, kSyncToken);
208 viz::ResourceId resource6 =
209 CreateAndImportResource(resource_provider, kSyncToken);
210 viz::ResourceId resource8 =
211 CreateAndImportResource(resource_provider, kSyncToken);
212
213 viz::ResourceId plane_resources[4];
214 for (int i = 0; i < 4; ++i) {
215 plane_resources[i] = CreateAndImportResource(
216 resource_provider, kSyncToken, gfx::ColorSpace::CreateREC601());
217 }
218
219 viz::SharedQuadState* shared_state =
220 to_pass->CreateAndAppendSharedQuadState();
221 shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
222 rect, false, false, 1, SkBlendMode::kSrcOver, 0);
223
224 auto* debug_border_quad =
225 to_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
226 debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1);
227
228 if (child_pass_id) {
229 auto* render_pass_quad =
230 to_pass->CreateAndAppendDrawQuad<viz::CompositorRenderPassDrawQuad>();
231 render_pass_quad->SetNew(shared_state, rect, visible_rect, child_pass_id,
232 resource5, gfx::RectF(rect), gfx::Size(73, 26),
233 gfx::Vector2dF(), gfx::PointF(), gfx::RectF(),
234 false, 1.0f);
235 }
236
237 auto* solid_color_quad =
238 to_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
239 solid_color_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED,
240 false);
241
242 auto* stream_video_quad =
243 to_pass->CreateAndAppendDrawQuad<viz::StreamVideoDrawQuad>();
244 stream_video_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
245 resource6, gfx::Size(), gfx::PointF(),
246 gfx::PointF(1.f, 1.f));
247
248 auto* texture_quad = to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
249 texture_quad->SetNew(
250 shared_state, rect, visible_rect, needs_blending, resource1, false,
251 gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
252 vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
253
254 auto* external_resource_texture_quad =
255 to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
256 external_resource_texture_quad->SetNew(
257 shared_state, rect, visible_rect, needs_blending, resource8, false,
258 gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
259 vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
260
261 auto* scaled_tile_quad =
262 to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
263 scaled_tile_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
264 resource2, gfx::RectF(0, 0, 50, 50),
265 gfx::Size(50, 50), false, false, false);
266
267 viz::SharedQuadState* transformed_state =
268 to_pass->CreateAndAppendSharedQuadState();
269 *transformed_state = *shared_state;
270 gfx::Transform rotation;
271 rotation.Rotate(45);
272 transformed_state->quad_to_target_transform =
273 transformed_state->quad_to_target_transform * rotation;
274 auto* transformed_tile_quad =
275 to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
276 transformed_tile_quad->SetNew(
277 transformed_state, rect, visible_rect, needs_blending, resource3,
278 gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false);
279
280 viz::SharedQuadState* shared_state2 =
281 to_pass->CreateAndAppendSharedQuadState();
282 shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
283 rect, false, false, 1, SkBlendMode::kSrcOver, 0);
284
285 auto* tile_quad = to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
286 tile_quad->SetNew(shared_state2, rect, visible_rect, needs_blending,
287 resource4, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100),
288 false, false, false);
289
290 auto* yuv_quad = to_pass->CreateAndAppendDrawQuad<viz::YUVVideoDrawQuad>();
291 yuv_quad->SetNew(shared_state2, rect, visible_rect, needs_blending,
292 gfx::RectF(.0f, .0f, 100.0f, 100.0f),
293 gfx::RectF(.0f, .0f, 50.0f, 50.0f), gfx::Size(100, 100),
294 gfx::Size(50, 50), plane_resources[0], plane_resources[1],
295 plane_resources[2], plane_resources[3],
296 gfx::ColorSpace::CreateREC601(), 0.0, 1.0, 8);
297
298 return {resource1, resource2, resource3,
299 resource4, resource5, resource6,
300 resource8, plane_resources[0], plane_resources[1],
301 plane_resources[2], plane_resources[3]};
302 }
303
CollectResources(std::vector<viz::ReturnedResource> * array,const std::vector<viz::ReturnedResource> & returned)304 static void CollectResources(
305 std::vector<viz::ReturnedResource>* array,
306 const std::vector<viz::ReturnedResource>& returned) {}
307
AddOneOfEveryQuadTypeInDisplayResourceProvider(viz::AggregatedRenderPass * to_pass,viz::DisplayResourceProvider * resource_provider,viz::ClientResourceProvider * child_resource_provider,viz::ContextProvider * child_context_provider,viz::AggregatedRenderPassId child_pass_id,gpu::SyncToken * sync_token_for_mailbox_tebxture)308 void AddOneOfEveryQuadTypeInDisplayResourceProvider(
309 viz::AggregatedRenderPass* to_pass,
310 viz::DisplayResourceProvider* resource_provider,
311 viz::ClientResourceProvider* child_resource_provider,
312 viz::ContextProvider* child_context_provider,
313 viz::AggregatedRenderPassId child_pass_id,
314 gpu::SyncToken* sync_token_for_mailbox_tebxture) {
315 gfx::Rect rect(0, 0, 100, 100);
316 gfx::Rect visible_rect(0, 0, 100, 100);
317 bool needs_blending = true;
318 const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
319
320 static const gpu::SyncToken kDefaultSyncToken(
321 gpu::CommandBufferNamespace::GPU_IO,
322 gpu::CommandBufferId::FromUnsafeValue(0x111), 42);
323 static const gpu::SyncToken kSyncTokenForMailboxTextureQuad(
324 gpu::CommandBufferNamespace::GPU_IO,
325 gpu::CommandBufferId::FromUnsafeValue(0x123), 30);
326 *sync_token_for_mailbox_tebxture = kSyncTokenForMailboxTextureQuad;
327
328 viz::ResourceId resource1 =
329 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
330 viz::ResourceId resource2 =
331 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
332 viz::ResourceId resource3 =
333 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
334 viz::ResourceId resource4 =
335 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
336 viz::ResourceId resource5 =
337 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
338 viz::ResourceId resource6 =
339 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
340 viz::ResourceId resource7 =
341 CreateAndImportResource(child_resource_provider, kDefaultSyncToken);
342 viz::ResourceId resource8 = CreateAndImportResource(
343 child_resource_provider, kSyncTokenForMailboxTextureQuad);
344
345 // Transfer resource to the parent.
346 std::vector<viz::ResourceId> resource_ids_to_transfer;
347 resource_ids_to_transfer.push_back(resource1);
348 resource_ids_to_transfer.push_back(resource2);
349 resource_ids_to_transfer.push_back(resource3);
350 resource_ids_to_transfer.push_back(resource4);
351 resource_ids_to_transfer.push_back(resource5);
352 resource_ids_to_transfer.push_back(resource6);
353 resource_ids_to_transfer.push_back(resource7);
354 resource_ids_to_transfer.push_back(resource8);
355
356 viz::ResourceId plane_resources[4];
357 for (int i = 0; i < 4; ++i) {
358 plane_resources[i] =
359 CreateAndImportResource(child_resource_provider, kDefaultSyncToken,
360 gfx::ColorSpace::CreateREC601());
361 resource_ids_to_transfer.push_back(plane_resources[i]);
362 }
363
364 std::vector<viz::ReturnedResource> returned_to_child;
365 int child_id = resource_provider->CreateChild(
366 base::BindRepeating(&CollectResources, &returned_to_child));
367
368 // Transfer resource to the parent.
369 std::vector<viz::TransferableResource> list;
370 child_resource_provider->PrepareSendToParent(resource_ids_to_transfer, &list,
371 child_context_provider);
372 resource_provider->ReceiveFromChild(child_id, list);
373
374 // Delete them in the child so they won't be leaked, and will be released once
375 // returned from the parent. This assumes they won't need to be sent to the
376 // parent again.
377 for (viz::ResourceId id : resource_ids_to_transfer)
378 child_resource_provider->RemoveImportedResource(id);
379
380 // Before create DrawQuad in viz::DisplayResourceProvider's namespace, get the
381 // mapped resource id first.
382 std::unordered_map<viz::ResourceId, viz::ResourceId> resource_map =
383 resource_provider->GetChildToParentMap(child_id);
384 viz::ResourceId mapped_resource1 = resource_map[resource1];
385 viz::ResourceId mapped_resource2 = resource_map[resource2];
386 viz::ResourceId mapped_resource3 = resource_map[resource3];
387 viz::ResourceId mapped_resource4 = resource_map[resource4];
388 viz::ResourceId mapped_resource5 = resource_map[resource5];
389 viz::ResourceId mapped_resource6 = resource_map[resource6];
390 viz::ResourceId mapped_resource8 = resource_map[resource8];
391 viz::ResourceId mapped_plane_resources[4];
392 for (int i = 0; i < 4; ++i) {
393 mapped_plane_resources[i] = resource_map[plane_resources[i]];
394 }
395
396 viz::SharedQuadState* shared_state =
397 to_pass->CreateAndAppendSharedQuadState();
398 shared_state->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
399 rect, false, false, 1, SkBlendMode::kSrcOver, 0);
400
401 viz::DebugBorderDrawQuad* debug_border_quad =
402 to_pass->CreateAndAppendDrawQuad<viz::DebugBorderDrawQuad>();
403 debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1);
404 if (child_pass_id) {
405 auto* render_pass_quad =
406 to_pass->CreateAndAppendDrawQuad<viz::AggregatedRenderPassDrawQuad>();
407 render_pass_quad->SetNew(shared_state, rect, visible_rect, child_pass_id,
408 mapped_resource5, gfx::RectF(rect),
409 gfx::Size(73, 26), gfx::Vector2dF(), gfx::PointF(),
410 gfx::RectF(), false, 1.0f);
411 }
412
413 viz::SolidColorDrawQuad* solid_color_quad =
414 to_pass->CreateAndAppendDrawQuad<viz::SolidColorDrawQuad>();
415 solid_color_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED,
416 false);
417
418 viz::StreamVideoDrawQuad* stream_video_quad =
419 to_pass->CreateAndAppendDrawQuad<viz::StreamVideoDrawQuad>();
420 stream_video_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
421 mapped_resource6, gfx::Size(), gfx::PointF(),
422 gfx::PointF(1.f, 1.f));
423
424 viz::TextureDrawQuad* texture_quad =
425 to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
426 texture_quad->SetNew(
427 shared_state, rect, visible_rect, needs_blending, mapped_resource1, false,
428 gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
429 vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
430
431 viz::TextureDrawQuad* external_resource_texture_quad =
432 to_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
433 external_resource_texture_quad->SetNew(
434 shared_state, rect, visible_rect, needs_blending, mapped_resource8, false,
435 gfx::PointF(0.f, 0.f), gfx::PointF(1.f, 1.f), SK_ColorTRANSPARENT,
436 vertex_opacity, false, false, false, gfx::ProtectedVideoType::kClear);
437
438 viz::TileDrawQuad* scaled_tile_quad =
439 to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
440 scaled_tile_quad->SetNew(shared_state, rect, visible_rect, needs_blending,
441 mapped_resource2, gfx::RectF(0, 0, 50, 50),
442 gfx::Size(50, 50), false, false, false);
443
444 viz::SharedQuadState* transformed_state =
445 to_pass->CreateAndAppendSharedQuadState();
446 *transformed_state = *shared_state;
447 gfx::Transform rotation;
448 rotation.Rotate(45);
449 transformed_state->quad_to_target_transform =
450 transformed_state->quad_to_target_transform * rotation;
451 viz::TileDrawQuad* transformed_tile_quad =
452 to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
453 transformed_tile_quad->SetNew(
454 transformed_state, rect, visible_rect, needs_blending, mapped_resource3,
455 gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false);
456
457 viz::SharedQuadState* shared_state2 =
458 to_pass->CreateAndAppendSharedQuadState();
459 shared_state2->SetAll(gfx::Transform(), rect, rect, gfx::MaskFilterInfo(),
460 rect, false, false, 1, SkBlendMode::kSrcOver, 0);
461
462 viz::TileDrawQuad* tile_quad =
463 to_pass->CreateAndAppendDrawQuad<viz::TileDrawQuad>();
464 tile_quad->SetNew(shared_state2, rect, visible_rect, needs_blending,
465 mapped_resource4, gfx::RectF(0, 0, 100, 100),
466 gfx::Size(100, 100), false, false, false);
467
468 viz::YUVVideoDrawQuad* yuv_quad =
469 to_pass->CreateAndAppendDrawQuad<viz::YUVVideoDrawQuad>();
470 yuv_quad->SetNew(
471 shared_state2, rect, visible_rect, needs_blending,
472 gfx::RectF(.0f, .0f, 100.0f, 100.0f), gfx::RectF(.0f, .0f, 50.0f, 50.0f),
473 gfx::Size(100, 100), gfx::Size(50, 50), mapped_plane_resources[0],
474 mapped_plane_resources[1], mapped_plane_resources[2],
475 mapped_plane_resources[3], gfx::ColorSpace::CreateREC601(), 0.0, 1.0, 8);
476 }
477
478 } // namespace cc
479