| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 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 "content/common/cc_messages.h" | |
| 6 | |
| 7 #include <stddef.h> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/numerics/safe_conversions.h" | |
| 11 #include "cc/output/compositor_frame.h" | |
| 12 #include "cc/output/filter_operations.h" | |
| 13 #include "cc/quads/draw_quad.h" | |
| 14 #include "cc/quads/largest_draw_quad.h" | |
| 15 #include "cc/quads/render_pass_id.h" | |
| 16 #include "content/public/common/common_param_traits.h" | |
| 17 #include "third_party/skia/include/core/SkData.h" | |
| 18 #include "third_party/skia/include/core/SkFlattenableSerialization.h" | |
| 19 #include "third_party/skia/include/core/SkImageFilter.h" | |
| 20 #include "third_party/skia/include/core/SkRefCnt.h" | |
| 21 | |
| 22 namespace IPC { | |
| 23 | |
| 24 void ParamTraits<cc::FilterOperation>::GetSize(base::PickleSizer* s, | |
| 25 const param_type& p) { | |
| 26 GetParamSize(s, p.type()); | |
| 27 switch (p.type()) { | |
| 28 case cc::FilterOperation::GRAYSCALE: | |
| 29 case cc::FilterOperation::SEPIA: | |
| 30 case cc::FilterOperation::SATURATE: | |
| 31 case cc::FilterOperation::HUE_ROTATE: | |
| 32 case cc::FilterOperation::INVERT: | |
| 33 case cc::FilterOperation::BRIGHTNESS: | |
| 34 case cc::FilterOperation::SATURATING_BRIGHTNESS: | |
| 35 case cc::FilterOperation::CONTRAST: | |
| 36 case cc::FilterOperation::OPACITY: | |
| 37 case cc::FilterOperation::BLUR: | |
| 38 GetParamSize(s, p.amount()); | |
| 39 break; | |
| 40 case cc::FilterOperation::DROP_SHADOW: | |
| 41 GetParamSize(s, p.drop_shadow_offset()); | |
| 42 GetParamSize(s, p.amount()); | |
| 43 GetParamSize(s, p.drop_shadow_color()); | |
| 44 break; | |
| 45 case cc::FilterOperation::COLOR_MATRIX: | |
| 46 for (int i = 0; i < 20; ++i) | |
| 47 GetParamSize(s, p.matrix()[i]); | |
| 48 break; | |
| 49 case cc::FilterOperation::ZOOM: | |
| 50 GetParamSize(s, p.amount()); | |
| 51 GetParamSize(s, p.zoom_inset()); | |
| 52 break; | |
| 53 case cc::FilterOperation::REFERENCE: | |
| 54 GetParamSize(s, p.image_filter()); | |
| 55 break; | |
| 56 case cc::FilterOperation::ALPHA_THRESHOLD: | |
| 57 NOTREACHED(); | |
| 58 break; | |
| 59 } | |
| 60 } | |
| 61 | |
| 62 void ParamTraits<cc::FilterOperation>::Write(base::Pickle* m, | |
| 63 const param_type& p) { | |
| 64 WriteParam(m, p.type()); | |
| 65 switch (p.type()) { | |
| 66 case cc::FilterOperation::GRAYSCALE: | |
| 67 case cc::FilterOperation::SEPIA: | |
| 68 case cc::FilterOperation::SATURATE: | |
| 69 case cc::FilterOperation::HUE_ROTATE: | |
| 70 case cc::FilterOperation::INVERT: | |
| 71 case cc::FilterOperation::BRIGHTNESS: | |
| 72 case cc::FilterOperation::SATURATING_BRIGHTNESS: | |
| 73 case cc::FilterOperation::CONTRAST: | |
| 74 case cc::FilterOperation::OPACITY: | |
| 75 case cc::FilterOperation::BLUR: | |
| 76 WriteParam(m, p.amount()); | |
| 77 break; | |
| 78 case cc::FilterOperation::DROP_SHADOW: | |
| 79 WriteParam(m, p.drop_shadow_offset()); | |
| 80 WriteParam(m, p.amount()); | |
| 81 WriteParam(m, p.drop_shadow_color()); | |
| 82 break; | |
| 83 case cc::FilterOperation::COLOR_MATRIX: | |
| 84 for (int i = 0; i < 20; ++i) | |
| 85 WriteParam(m, p.matrix()[i]); | |
| 86 break; | |
| 87 case cc::FilterOperation::ZOOM: | |
| 88 WriteParam(m, p.amount()); | |
| 89 WriteParam(m, p.zoom_inset()); | |
| 90 break; | |
| 91 case cc::FilterOperation::REFERENCE: | |
| 92 WriteParam(m, p.image_filter()); | |
| 93 break; | |
| 94 case cc::FilterOperation::ALPHA_THRESHOLD: | |
| 95 NOTREACHED(); | |
| 96 break; | |
| 97 } | |
| 98 } | |
| 99 | |
| 100 bool ParamTraits<cc::FilterOperation>::Read(const base::Pickle* m, | |
| 101 base::PickleIterator* iter, | |
| 102 param_type* r) { | |
| 103 cc::FilterOperation::FilterType type; | |
| 104 float amount; | |
| 105 gfx::Point drop_shadow_offset; | |
| 106 SkColor drop_shadow_color; | |
| 107 SkScalar matrix[20]; | |
| 108 int zoom_inset; | |
| 109 | |
| 110 if (!ReadParam(m, iter, &type)) | |
| 111 return false; | |
| 112 r->set_type(type); | |
| 113 | |
| 114 bool success = false; | |
| 115 switch (type) { | |
| 116 case cc::FilterOperation::GRAYSCALE: | |
| 117 case cc::FilterOperation::SEPIA: | |
| 118 case cc::FilterOperation::SATURATE: | |
| 119 case cc::FilterOperation::HUE_ROTATE: | |
| 120 case cc::FilterOperation::INVERT: | |
| 121 case cc::FilterOperation::BRIGHTNESS: | |
| 122 case cc::FilterOperation::SATURATING_BRIGHTNESS: | |
| 123 case cc::FilterOperation::CONTRAST: | |
| 124 case cc::FilterOperation::OPACITY: | |
| 125 case cc::FilterOperation::BLUR: | |
| 126 if (ReadParam(m, iter, &amount)) { | |
| 127 r->set_amount(amount); | |
| 128 success = true; | |
| 129 } | |
| 130 break; | |
| 131 case cc::FilterOperation::DROP_SHADOW: | |
| 132 if (ReadParam(m, iter, &drop_shadow_offset) && | |
| 133 ReadParam(m, iter, &amount) && | |
| 134 ReadParam(m, iter, &drop_shadow_color)) { | |
| 135 r->set_drop_shadow_offset(drop_shadow_offset); | |
| 136 r->set_amount(amount); | |
| 137 r->set_drop_shadow_color(drop_shadow_color); | |
| 138 success = true; | |
| 139 } | |
| 140 break; | |
| 141 case cc::FilterOperation::COLOR_MATRIX: { | |
| 142 int i; | |
| 143 for (i = 0; i < 20; ++i) { | |
| 144 if (!ReadParam(m, iter, &matrix[i])) | |
| 145 break; | |
| 146 } | |
| 147 if (i == 20) { | |
| 148 r->set_matrix(matrix); | |
| 149 success = true; | |
| 150 } | |
| 151 break; | |
| 152 } | |
| 153 case cc::FilterOperation::ZOOM: | |
| 154 if (ReadParam(m, iter, &amount) && | |
| 155 ReadParam(m, iter, &zoom_inset) && | |
| 156 amount >= 0.f && | |
| 157 zoom_inset >= 0) { | |
| 158 r->set_amount(amount); | |
| 159 r->set_zoom_inset(zoom_inset); | |
| 160 success = true; | |
| 161 } | |
| 162 break; | |
| 163 case cc::FilterOperation::REFERENCE: { | |
| 164 sk_sp<SkImageFilter> filter; | |
| 165 if (!ReadParam(m, iter, &filter)) { | |
| 166 success = false; | |
| 167 break; | |
| 168 } | |
| 169 r->set_image_filter(std::move(filter)); | |
| 170 success = true; | |
| 171 break; | |
| 172 } | |
| 173 case cc::FilterOperation::ALPHA_THRESHOLD: | |
| 174 break; | |
| 175 } | |
| 176 return success; | |
| 177 } | |
| 178 | |
| 179 void ParamTraits<cc::FilterOperation>::Log( | |
| 180 const param_type& p, std::string* l) { | |
| 181 l->append("("); | |
| 182 LogParam(static_cast<unsigned>(p.type()), l); | |
| 183 l->append(", "); | |
| 184 | |
| 185 switch (p.type()) { | |
| 186 case cc::FilterOperation::GRAYSCALE: | |
| 187 case cc::FilterOperation::SEPIA: | |
| 188 case cc::FilterOperation::SATURATE: | |
| 189 case cc::FilterOperation::HUE_ROTATE: | |
| 190 case cc::FilterOperation::INVERT: | |
| 191 case cc::FilterOperation::BRIGHTNESS: | |
| 192 case cc::FilterOperation::SATURATING_BRIGHTNESS: | |
| 193 case cc::FilterOperation::CONTRAST: | |
| 194 case cc::FilterOperation::OPACITY: | |
| 195 case cc::FilterOperation::BLUR: | |
| 196 LogParam(p.amount(), l); | |
| 197 break; | |
| 198 case cc::FilterOperation::DROP_SHADOW: | |
| 199 LogParam(p.drop_shadow_offset(), l); | |
| 200 l->append(", "); | |
| 201 LogParam(p.amount(), l); | |
| 202 l->append(", "); | |
| 203 LogParam(p.drop_shadow_color(), l); | |
| 204 break; | |
| 205 case cc::FilterOperation::COLOR_MATRIX: | |
| 206 for (int i = 0; i < 20; ++i) { | |
| 207 if (i) | |
| 208 l->append(", "); | |
| 209 LogParam(p.matrix()[i], l); | |
| 210 } | |
| 211 break; | |
| 212 case cc::FilterOperation::ZOOM: | |
| 213 LogParam(p.amount(), l); | |
| 214 l->append(", "); | |
| 215 LogParam(p.zoom_inset(), l); | |
| 216 break; | |
| 217 case cc::FilterOperation::REFERENCE: | |
| 218 LogParam(p.image_filter(), l); | |
| 219 break; | |
| 220 case cc::FilterOperation::ALPHA_THRESHOLD: | |
| 221 NOTREACHED(); | |
| 222 break; | |
| 223 } | |
| 224 l->append(")"); | |
| 225 } | |
| 226 | |
| 227 void ParamTraits<cc::FilterOperations>::GetSize(base::PickleSizer* s, | |
| 228 const param_type& p) { | |
| 229 GetParamSize(s, base::checked_cast<uint32_t>(p.size())); | |
| 230 for (std::size_t i = 0; i < p.size(); ++i) { | |
| 231 GetParamSize(s, p.at(i)); | |
| 232 } | |
| 233 } | |
| 234 | |
| 235 void ParamTraits<cc::FilterOperations>::Write(base::Pickle* m, | |
| 236 const param_type& p) { | |
| 237 WriteParam(m, base::checked_cast<uint32_t>(p.size())); | |
| 238 for (std::size_t i = 0; i < p.size(); ++i) { | |
| 239 WriteParam(m, p.at(i)); | |
| 240 } | |
| 241 } | |
| 242 | |
| 243 bool ParamTraits<cc::FilterOperations>::Read(const base::Pickle* m, | |
| 244 base::PickleIterator* iter, | |
| 245 param_type* r) { | |
| 246 uint32_t count; | |
| 247 if (!ReadParam(m, iter, &count)) | |
| 248 return false; | |
| 249 | |
| 250 for (std::size_t i = 0; i < count; ++i) { | |
| 251 cc::FilterOperation op = cc::FilterOperation::CreateEmptyFilter(); | |
| 252 if (!ReadParam(m, iter, &op)) | |
| 253 return false; | |
| 254 r->Append(op); | |
| 255 } | |
| 256 return true; | |
| 257 } | |
| 258 | |
| 259 void ParamTraits<cc::FilterOperations>::Log( | |
| 260 const param_type& p, std::string* l) { | |
| 261 l->append("("); | |
| 262 for (std::size_t i = 0; i < p.size(); ++i) { | |
| 263 if (i) | |
| 264 l->append(", "); | |
| 265 LogParam(p.at(i), l); | |
| 266 } | |
| 267 l->append(")"); | |
| 268 } | |
| 269 | |
| 270 void ParamTraits<sk_sp<SkImageFilter>>::GetSize(base::PickleSizer* s, | |
| 271 const param_type& p) { | |
| 272 SkImageFilter* filter = p.get(); | |
| 273 if (filter) { | |
| 274 sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter)); | |
| 275 s->AddData(data->size()); | |
| 276 } else { | |
| 277 s->AddData(0); | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 void ParamTraits<sk_sp<SkImageFilter>>::Write(base::Pickle* m, | |
| 282 const param_type& p) { | |
| 283 SkImageFilter* filter = p.get(); | |
| 284 if (filter) { | |
| 285 sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter)); | |
| 286 m->WriteData(static_cast<const char*>(data->data()), data->size()); | |
| 287 } else { | |
| 288 m->WriteData(0, 0); | |
| 289 } | |
| 290 } | |
| 291 | |
| 292 bool ParamTraits<sk_sp<SkImageFilter>>::Read(const base::Pickle* m, | |
| 293 base::PickleIterator* iter, | |
| 294 param_type* r) { | |
| 295 const char* data = 0; | |
| 296 int length = 0; | |
| 297 if (!iter->ReadData(&data, &length)) | |
| 298 return false; | |
| 299 if (length > 0) { | |
| 300 SkFlattenable* flattenable = SkValidatingDeserializeFlattenable( | |
| 301 data, length, SkImageFilter::GetFlattenableType()); | |
| 302 *r = sk_sp<SkImageFilter>(static_cast<SkImageFilter*>(flattenable)); | |
| 303 } else { | |
| 304 r->reset(); | |
| 305 } | |
| 306 return true; | |
| 307 } | |
| 308 | |
| 309 void ParamTraits<sk_sp<SkImageFilter> >::Log( | |
| 310 const param_type& p, std::string* l) { | |
| 311 l->append("("); | |
| 312 LogParam(p.get() ? p->countInputs() : 0, l); | |
| 313 l->append(")"); | |
| 314 } | |
| 315 | |
| 316 void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) { | |
| 317 WriteParam(m, p.id); | |
| 318 WriteParam(m, p.output_rect); | |
| 319 WriteParam(m, p.damage_rect); | |
| 320 WriteParam(m, p.transform_to_root_target); | |
| 321 WriteParam(m, p.has_transparent_background); | |
| 322 WriteParam(m, base::checked_cast<uint32_t>(p.quad_list.size())); | |
| 323 | |
| 324 cc::SharedQuadStateList::ConstIterator shared_quad_state_iter = | |
| 325 p.shared_quad_state_list.begin(); | |
| 326 cc::SharedQuadStateList::ConstIterator last_shared_quad_state_iter = | |
| 327 p.shared_quad_state_list.end(); | |
| 328 for (const auto& quad : p.quad_list) { | |
| 329 DCHECK(quad->rect.Contains(quad->visible_rect)) | |
| 330 << quad->material << " rect: " << quad->rect.ToString() | |
| 331 << " visible_rect: " << quad->visible_rect.ToString(); | |
| 332 DCHECK(quad->opaque_rect.IsEmpty() || | |
| 333 quad->rect.Contains(quad->opaque_rect)) | |
| 334 << quad->material << " rect: " << quad->rect.ToString() | |
| 335 << " opaque_rect: " << quad->opaque_rect.ToString(); | |
| 336 | |
| 337 switch (quad->material) { | |
| 338 case cc::DrawQuad::DEBUG_BORDER: | |
| 339 WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(quad)); | |
| 340 break; | |
| 341 case cc::DrawQuad::IO_SURFACE_CONTENT: | |
| 342 WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(quad)); | |
| 343 break; | |
| 344 case cc::DrawQuad::PICTURE_CONTENT: | |
| 345 NOTREACHED(); | |
| 346 break; | |
| 347 case cc::DrawQuad::TEXTURE_CONTENT: | |
| 348 WriteParam(m, *cc::TextureDrawQuad::MaterialCast(quad)); | |
| 349 break; | |
| 350 case cc::DrawQuad::RENDER_PASS: | |
| 351 WriteParam(m, *cc::RenderPassDrawQuad::MaterialCast(quad)); | |
| 352 break; | |
| 353 case cc::DrawQuad::SOLID_COLOR: | |
| 354 WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(quad)); | |
| 355 break; | |
| 356 case cc::DrawQuad::SURFACE_CONTENT: | |
| 357 WriteParam(m, *cc::SurfaceDrawQuad::MaterialCast(quad)); | |
| 358 break; | |
| 359 case cc::DrawQuad::TILED_CONTENT: | |
| 360 WriteParam(m, *cc::TileDrawQuad::MaterialCast(quad)); | |
| 361 break; | |
| 362 case cc::DrawQuad::STREAM_VIDEO_CONTENT: | |
| 363 WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(quad)); | |
| 364 break; | |
| 365 case cc::DrawQuad::YUV_VIDEO_CONTENT: | |
| 366 WriteParam(m, *cc::YUVVideoDrawQuad::MaterialCast(quad)); | |
| 367 break; | |
| 368 case cc::DrawQuad::INVALID: | |
| 369 break; | |
| 370 } | |
| 371 | |
| 372 // Null shared quad states should not occur. | |
| 373 DCHECK(quad->shared_quad_state); | |
| 374 | |
| 375 // SharedQuadStates should appear in the order they are used by DrawQuads. | |
| 376 // Find the SharedQuadState for this DrawQuad. | |
| 377 while (shared_quad_state_iter != p.shared_quad_state_list.end() && | |
| 378 quad->shared_quad_state != *shared_quad_state_iter) | |
| 379 ++shared_quad_state_iter; | |
| 380 | |
| 381 DCHECK(shared_quad_state_iter != p.shared_quad_state_list.end()); | |
| 382 | |
| 383 if (shared_quad_state_iter != last_shared_quad_state_iter) { | |
| 384 WriteParam(m, true); | |
| 385 WriteParam(m, **shared_quad_state_iter); | |
| 386 last_shared_quad_state_iter = shared_quad_state_iter; | |
| 387 } else { | |
| 388 WriteParam(m, false); | |
| 389 } | |
| 390 } | |
| 391 } | |
| 392 | |
| 393 static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) { | |
| 394 size_t to_reserve = sizeof(cc::RenderPass); | |
| 395 | |
| 396 // Whether the quad points to a new shared quad state for each quad. | |
| 397 to_reserve += p.quad_list.size() * sizeof(bool); | |
| 398 | |
| 399 // Shared quad state is only written when a quad contains a shared quad state | |
| 400 // that has not been written. | |
| 401 to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState); | |
| 402 | |
| 403 // The largest quad type, verified by a unit test. | |
| 404 to_reserve += p.quad_list.size() * cc::LargestDrawQuadSize(); | |
| 405 return to_reserve; | |
| 406 } | |
| 407 | |
| 408 template <typename QuadType> | |
| 409 static cc::DrawQuad* ReadDrawQuad(const base::Pickle* m, | |
| 410 base::PickleIterator* iter, | |
| 411 cc::RenderPass* render_pass) { | |
| 412 QuadType* quad = render_pass->CreateAndAppendDrawQuad<QuadType>(); | |
| 413 if (!ReadParam(m, iter, quad)) | |
| 414 return NULL; | |
| 415 return quad; | |
| 416 } | |
| 417 | |
| 418 bool ParamTraits<cc::RenderPass>::Read(const base::Pickle* m, | |
| 419 base::PickleIterator* iter, | |
| 420 param_type* p) { | |
| 421 cc::RenderPassId id; | |
| 422 gfx::Rect output_rect; | |
| 423 gfx::Rect damage_rect; | |
| 424 gfx::Transform transform_to_root_target; | |
| 425 bool has_transparent_background; | |
| 426 uint32_t quad_list_size; | |
| 427 | |
| 428 if (!ReadParam(m, iter, &id) || !ReadParam(m, iter, &output_rect) || | |
| 429 !ReadParam(m, iter, &damage_rect) || | |
| 430 !ReadParam(m, iter, &transform_to_root_target) || | |
| 431 !ReadParam(m, iter, &has_transparent_background) || | |
| 432 !ReadParam(m, iter, &quad_list_size)) | |
| 433 return false; | |
| 434 | |
| 435 p->SetAll(id, | |
| 436 output_rect, | |
| 437 damage_rect, | |
| 438 transform_to_root_target, | |
| 439 has_transparent_background); | |
| 440 | |
| 441 for (uint32_t i = 0; i < quad_list_size; ++i) { | |
| 442 cc::DrawQuad::Material material; | |
| 443 base::PickleIterator temp_iter = *iter; | |
| 444 if (!ReadParam(m, &temp_iter, &material)) | |
| 445 return false; | |
| 446 | |
| 447 cc::DrawQuad* draw_quad = NULL; | |
| 448 switch (material) { | |
| 449 case cc::DrawQuad::DEBUG_BORDER: | |
| 450 draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter, p); | |
| 451 break; | |
| 452 case cc::DrawQuad::IO_SURFACE_CONTENT: | |
| 453 draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter, p); | |
| 454 break; | |
| 455 case cc::DrawQuad::PICTURE_CONTENT: | |
| 456 NOTREACHED(); | |
| 457 return false; | |
| 458 case cc::DrawQuad::SURFACE_CONTENT: | |
| 459 draw_quad = ReadDrawQuad<cc::SurfaceDrawQuad>(m, iter, p); | |
| 460 break; | |
| 461 case cc::DrawQuad::TEXTURE_CONTENT: | |
| 462 draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter, p); | |
| 463 break; | |
| 464 case cc::DrawQuad::RENDER_PASS: | |
| 465 draw_quad = ReadDrawQuad<cc::RenderPassDrawQuad>(m, iter, p); | |
| 466 break; | |
| 467 case cc::DrawQuad::SOLID_COLOR: | |
| 468 draw_quad = ReadDrawQuad<cc::SolidColorDrawQuad>(m, iter, p); | |
| 469 break; | |
| 470 case cc::DrawQuad::TILED_CONTENT: | |
| 471 draw_quad = ReadDrawQuad<cc::TileDrawQuad>(m, iter, p); | |
| 472 break; | |
| 473 case cc::DrawQuad::STREAM_VIDEO_CONTENT: | |
| 474 draw_quad = ReadDrawQuad<cc::StreamVideoDrawQuad>(m, iter, p); | |
| 475 break; | |
| 476 case cc::DrawQuad::YUV_VIDEO_CONTENT: | |
| 477 draw_quad = ReadDrawQuad<cc::YUVVideoDrawQuad>(m, iter, p); | |
| 478 break; | |
| 479 case cc::DrawQuad::INVALID: | |
| 480 break; | |
| 481 } | |
| 482 if (!draw_quad) | |
| 483 return false; | |
| 484 if (!draw_quad->rect.Contains(draw_quad->visible_rect)) { | |
| 485 LOG(ERROR) << "Quad with invalid visible rect " << draw_quad->material | |
| 486 << " rect: " << draw_quad->rect.ToString() | |
| 487 << " visible_rect: " << draw_quad->visible_rect.ToString(); | |
| 488 return false; | |
| 489 } | |
| 490 if (!draw_quad->opaque_rect.IsEmpty() && | |
| 491 !draw_quad->rect.Contains(draw_quad->opaque_rect)) { | |
| 492 LOG(ERROR) << "Quad with invalid opaque rect " << draw_quad->material | |
| 493 << " rect: " << draw_quad->rect.ToString() | |
| 494 << " opaque_rect: " << draw_quad->opaque_rect.ToString(); | |
| 495 return false; | |
| 496 } | |
| 497 | |
| 498 bool has_new_shared_quad_state; | |
| 499 if (!ReadParam(m, iter, &has_new_shared_quad_state)) | |
| 500 return false; | |
| 501 | |
| 502 // If the quad has a new shared quad state, read it in. | |
| 503 if (has_new_shared_quad_state) { | |
| 504 cc::SharedQuadState* state = p->CreateAndAppendSharedQuadState(); | |
| 505 if (!ReadParam(m, iter, state)) | |
| 506 return false; | |
| 507 } | |
| 508 | |
| 509 draw_quad->shared_quad_state = p->shared_quad_state_list.back(); | |
| 510 } | |
| 511 | |
| 512 return true; | |
| 513 } | |
| 514 | |
| 515 void ParamTraits<cc::RenderPass>::Log( | |
| 516 const param_type& p, std::string* l) { | |
| 517 l->append("RenderPass(("); | |
| 518 LogParam(p.id, l); | |
| 519 l->append("), "); | |
| 520 LogParam(p.output_rect, l); | |
| 521 l->append(", "); | |
| 522 LogParam(p.damage_rect, l); | |
| 523 l->append(", "); | |
| 524 LogParam(p.transform_to_root_target, l); | |
| 525 l->append(", "); | |
| 526 LogParam(p.has_transparent_background, l); | |
| 527 l->append(", "); | |
| 528 | |
| 529 l->append("["); | |
| 530 for (const auto& shared_quad_state : p.shared_quad_state_list) { | |
| 531 if (shared_quad_state != p.shared_quad_state_list.front()) | |
| 532 l->append(", "); | |
| 533 LogParam(*shared_quad_state, l); | |
| 534 } | |
| 535 l->append("], ["); | |
| 536 for (const auto& quad : p.quad_list) { | |
| 537 if (quad != p.quad_list.front()) | |
| 538 l->append(", "); | |
| 539 switch (quad->material) { | |
| 540 case cc::DrawQuad::DEBUG_BORDER: | |
| 541 LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l); | |
| 542 break; | |
| 543 case cc::DrawQuad::IO_SURFACE_CONTENT: | |
| 544 LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l); | |
| 545 break; | |
| 546 case cc::DrawQuad::PICTURE_CONTENT: | |
| 547 NOTREACHED(); | |
| 548 break; | |
| 549 case cc::DrawQuad::TEXTURE_CONTENT: | |
| 550 LogParam(*cc::TextureDrawQuad::MaterialCast(quad), l); | |
| 551 break; | |
| 552 case cc::DrawQuad::RENDER_PASS: | |
| 553 LogParam(*cc::RenderPassDrawQuad::MaterialCast(quad), l); | |
| 554 break; | |
| 555 case cc::DrawQuad::SOLID_COLOR: | |
| 556 LogParam(*cc::SolidColorDrawQuad::MaterialCast(quad), l); | |
| 557 break; | |
| 558 case cc::DrawQuad::SURFACE_CONTENT: | |
| 559 LogParam(*cc::SurfaceDrawQuad::MaterialCast(quad), l); | |
| 560 break; | |
| 561 case cc::DrawQuad::TILED_CONTENT: | |
| 562 LogParam(*cc::TileDrawQuad::MaterialCast(quad), l); | |
| 563 break; | |
| 564 case cc::DrawQuad::STREAM_VIDEO_CONTENT: | |
| 565 LogParam(*cc::StreamVideoDrawQuad::MaterialCast(quad), l); | |
| 566 break; | |
| 567 case cc::DrawQuad::YUV_VIDEO_CONTENT: | |
| 568 LogParam(*cc::YUVVideoDrawQuad::MaterialCast(quad), l); | |
| 569 break; | |
| 570 case cc::DrawQuad::INVALID: | |
| 571 break; | |
| 572 } | |
| 573 } | |
| 574 l->append("])"); | |
| 575 } | |
| 576 | |
| 577 namespace { | |
| 578 enum CompositorFrameType { | |
| 579 NO_FRAME, | |
| 580 DELEGATED_FRAME, | |
| 581 GL_FRAME, | |
| 582 }; | |
| 583 } | |
| 584 | |
| 585 void ParamTraits<cc::CompositorFrame>::Write(base::Pickle* m, | |
| 586 const param_type& p) { | |
| 587 WriteParam(m, p.metadata); | |
| 588 if (p.delegated_frame_data) { | |
| 589 DCHECK(!p.gl_frame_data); | |
| 590 WriteParam(m, static_cast<int>(DELEGATED_FRAME)); | |
| 591 WriteParam(m, *p.delegated_frame_data); | |
| 592 } else if (p.gl_frame_data) { | |
| 593 WriteParam(m, static_cast<int>(GL_FRAME)); | |
| 594 WriteParam(m, *p.gl_frame_data); | |
| 595 } else { | |
| 596 WriteParam(m, static_cast<int>(NO_FRAME)); | |
| 597 } | |
| 598 } | |
| 599 | |
| 600 bool ParamTraits<cc::CompositorFrame>::Read(const base::Pickle* m, | |
| 601 base::PickleIterator* iter, | |
| 602 param_type* p) { | |
| 603 if (!ReadParam(m, iter, &p->metadata)) | |
| 604 return false; | |
| 605 | |
| 606 int compositor_frame_type; | |
| 607 if (!ReadParam(m, iter, &compositor_frame_type)) | |
| 608 return false; | |
| 609 | |
| 610 switch (compositor_frame_type) { | |
| 611 case DELEGATED_FRAME: | |
| 612 p->delegated_frame_data.reset(new cc::DelegatedFrameData()); | |
| 613 if (!ReadParam(m, iter, p->delegated_frame_data.get())) | |
| 614 return false; | |
| 615 break; | |
| 616 case GL_FRAME: | |
| 617 p->gl_frame_data.reset(new cc::GLFrameData()); | |
| 618 if (!ReadParam(m, iter, p->gl_frame_data.get())) | |
| 619 return false; | |
| 620 break; | |
| 621 case NO_FRAME: | |
| 622 break; | |
| 623 default: | |
| 624 return false; | |
| 625 } | |
| 626 return true; | |
| 627 } | |
| 628 | |
| 629 void ParamTraits<cc::CompositorFrame>::Log(const param_type& p, | |
| 630 std::string* l) { | |
| 631 l->append("CompositorFrame("); | |
| 632 LogParam(p.metadata, l); | |
| 633 l->append(", "); | |
| 634 if (p.delegated_frame_data) | |
| 635 LogParam(*p.delegated_frame_data, l); | |
| 636 else if (p.gl_frame_data) | |
| 637 LogParam(*p.gl_frame_data, l); | |
| 638 l->append(")"); | |
| 639 } | |
| 640 | |
| 641 void ParamTraits<cc::CompositorFrameAck>::Write(base::Pickle* m, | |
| 642 const param_type& p) { | |
| 643 WriteParam(m, p.resources); | |
| 644 if (p.gl_frame_data) { | |
| 645 WriteParam(m, static_cast<int>(GL_FRAME)); | |
| 646 WriteParam(m, *p.gl_frame_data); | |
| 647 } else { | |
| 648 WriteParam(m, static_cast<int>(NO_FRAME)); | |
| 649 } | |
| 650 } | |
| 651 | |
| 652 bool ParamTraits<cc::CompositorFrameAck>::Read(const base::Pickle* m, | |
| 653 base::PickleIterator* iter, | |
| 654 param_type* p) { | |
| 655 if (!ReadParam(m, iter, &p->resources)) | |
| 656 return false; | |
| 657 | |
| 658 int compositor_frame_type; | |
| 659 if (!ReadParam(m, iter, &compositor_frame_type)) | |
| 660 return false; | |
| 661 | |
| 662 switch (compositor_frame_type) { | |
| 663 case NO_FRAME: | |
| 664 break; | |
| 665 case GL_FRAME: | |
| 666 p->gl_frame_data.reset(new cc::GLFrameData()); | |
| 667 if (!ReadParam(m, iter, p->gl_frame_data.get())) | |
| 668 return false; | |
| 669 break; | |
| 670 default: | |
| 671 return false; | |
| 672 } | |
| 673 return true; | |
| 674 } | |
| 675 | |
| 676 void ParamTraits<cc::CompositorFrameAck>::Log(const param_type& p, | |
| 677 std::string* l) { | |
| 678 l->append("CompositorFrameAck("); | |
| 679 LogParam(p.resources, l); | |
| 680 l->append(", "); | |
| 681 if (p.gl_frame_data) | |
| 682 LogParam(*p.gl_frame_data, l); | |
| 683 l->append(")"); | |
| 684 } | |
| 685 | |
| 686 void ParamTraits<cc::DelegatedFrameData>::Write(base::Pickle* m, | |
| 687 const param_type& p) { | |
| 688 DCHECK_NE(0u, p.render_pass_list.size()); | |
| 689 | |
| 690 size_t to_reserve = sizeof(p.device_scale_factor); | |
| 691 to_reserve += p.resource_list.size() * sizeof(cc::TransferableResource); | |
| 692 for (const auto& pass : p.render_pass_list) { | |
| 693 to_reserve += sizeof(size_t) * 2; | |
| 694 to_reserve += ReserveSizeForRenderPassWrite(*pass); | |
| 695 } | |
| 696 m->Reserve(to_reserve); | |
| 697 | |
| 698 WriteParam(m, p.device_scale_factor); | |
| 699 WriteParam(m, p.resource_list); | |
| 700 WriteParam(m, base::checked_cast<uint32_t>(p.render_pass_list.size())); | |
| 701 for (const auto& pass : p.render_pass_list) { | |
| 702 WriteParam(m, base::checked_cast<uint32_t>(pass->quad_list.size())); | |
| 703 WriteParam(m, base::checked_cast<uint32_t>( | |
| 704 pass->shared_quad_state_list.size())); | |
| 705 WriteParam(m, *pass); | |
| 706 } | |
| 707 } | |
| 708 | |
| 709 bool ParamTraits<cc::DelegatedFrameData>::Read(const base::Pickle* m, | |
| 710 base::PickleIterator* iter, | |
| 711 param_type* p) { | |
| 712 if (!ReadParam(m, iter, &p->device_scale_factor)) | |
| 713 return false; | |
| 714 | |
| 715 const static size_t kMaxRenderPasses = 10000; | |
| 716 const static size_t kMaxSharedQuadStateListSize = 100000; | |
| 717 const static size_t kMaxQuadListSize = 1000000; | |
| 718 | |
| 719 std::set<cc::RenderPassId> pass_set; | |
| 720 | |
| 721 uint32_t num_render_passes; | |
| 722 if (!ReadParam(m, iter, &p->resource_list) || | |
| 723 !ReadParam(m, iter, &num_render_passes) || | |
| 724 num_render_passes > kMaxRenderPasses || num_render_passes == 0) | |
| 725 return false; | |
| 726 for (uint32_t i = 0; i < num_render_passes; ++i) { | |
| 727 uint32_t quad_list_size; | |
| 728 uint32_t shared_quad_state_list_size; | |
| 729 if (!ReadParam(m, iter, &quad_list_size) || | |
| 730 !ReadParam(m, iter, &shared_quad_state_list_size) || | |
| 731 quad_list_size > kMaxQuadListSize || | |
| 732 shared_quad_state_list_size > kMaxSharedQuadStateListSize) | |
| 733 return false; | |
| 734 std::unique_ptr<cc::RenderPass> render_pass = | |
| 735 cc::RenderPass::Create(static_cast<size_t>(shared_quad_state_list_size), | |
| 736 static_cast<size_t>(quad_list_size)); | |
| 737 if (!ReadParam(m, iter, render_pass.get())) | |
| 738 return false; | |
| 739 // Validate that each RenderPassDrawQuad points at a valid RenderPass | |
| 740 // earlier in the frame. | |
| 741 for (const auto* quad : render_pass->quad_list) { | |
| 742 if (quad->material != cc::DrawQuad::RENDER_PASS) | |
| 743 continue; | |
| 744 const cc::RenderPassDrawQuad* rpdq = | |
| 745 cc::RenderPassDrawQuad::MaterialCast(quad); | |
| 746 if (!pass_set.count(rpdq->render_pass_id)) | |
| 747 return false; | |
| 748 } | |
| 749 pass_set.insert(render_pass->id); | |
| 750 p->render_pass_list.push_back(std::move(render_pass)); | |
| 751 } | |
| 752 return true; | |
| 753 } | |
| 754 | |
| 755 void ParamTraits<cc::DelegatedFrameData>::Log(const param_type& p, | |
| 756 std::string* l) { | |
| 757 l->append("DelegatedFrameData("); | |
| 758 LogParam(p.device_scale_factor, l); | |
| 759 LogParam(p.resource_list, l); | |
| 760 l->append(", ["); | |
| 761 for (size_t i = 0; i < p.render_pass_list.size(); ++i) { | |
| 762 if (i) | |
| 763 l->append(", "); | |
| 764 LogParam(*p.render_pass_list[i], l); | |
| 765 } | |
| 766 l->append("])"); | |
| 767 } | |
| 768 | |
| 769 void ParamTraits<cc::DrawQuad::Resources>::GetSize(base::PickleSizer* s, | |
| 770 const param_type& p) { | |
| 771 GetParamSize(s, p.count); | |
| 772 for (size_t i = 0; i < p.count; ++i) | |
| 773 GetParamSize(s, p.ids[i]); | |
| 774 } | |
| 775 | |
| 776 void ParamTraits<cc::DrawQuad::Resources>::Write(base::Pickle* m, | |
| 777 const param_type& p) { | |
| 778 DCHECK_LE(p.count, cc::DrawQuad::Resources::kMaxResourceIdCount); | |
| 779 WriteParam(m, p.count); | |
| 780 for (size_t i = 0; i < p.count; ++i) | |
| 781 WriteParam(m, p.ids[i]); | |
| 782 } | |
| 783 | |
| 784 bool ParamTraits<cc::DrawQuad::Resources>::Read(const base::Pickle* m, | |
| 785 base::PickleIterator* iter, | |
| 786 param_type* p) { | |
| 787 if (!ReadParam(m, iter, &p->count)) | |
| 788 return false; | |
| 789 if (p->count > cc::DrawQuad::Resources::kMaxResourceIdCount) | |
| 790 return false; | |
| 791 for (size_t i = 0; i < p->count; ++i) { | |
| 792 if (!ReadParam(m, iter, &p->ids[i])) | |
| 793 return false; | |
| 794 } | |
| 795 return true; | |
| 796 } | |
| 797 | |
| 798 void ParamTraits<cc::DrawQuad::Resources>::Log(const param_type& p, | |
| 799 std::string* l) { | |
| 800 l->append("DrawQuad::Resources("); | |
| 801 LogParam(p.count, l); | |
| 802 l->append(", ["); | |
| 803 if (p.count > cc::DrawQuad::Resources::kMaxResourceIdCount) { | |
| 804 l->append("])"); | |
| 805 return; | |
| 806 } | |
| 807 | |
| 808 for (size_t i = 0; i < p.count; ++i) { | |
| 809 LogParam(p.ids[i], l); | |
| 810 if (i < (p.count - 1)) | |
| 811 l->append(", "); | |
| 812 } | |
| 813 l->append("])"); | |
| 814 } | |
| 815 | |
| 816 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::GetSize( | |
| 817 base::PickleSizer* s, const param_type& p) { | |
| 818 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 819 GetParamSize(s, p.size_in_pixels[i]); | |
| 820 } | |
| 821 } | |
| 822 | |
| 823 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Write( | |
| 824 base::Pickle* m, | |
| 825 const param_type& p) { | |
| 826 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 827 WriteParam(m, p.size_in_pixels[i]); | |
| 828 } | |
| 829 } | |
| 830 | |
| 831 bool ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Read( | |
| 832 const base::Pickle* m, | |
| 833 base::PickleIterator* iter, | |
| 834 param_type* p) { | |
| 835 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 836 if (!ReadParam(m, iter, &p->size_in_pixels[i])) | |
| 837 return false; | |
| 838 } | |
| 839 return true; | |
| 840 } | |
| 841 | |
| 842 void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Log( | |
| 843 const param_type& p, | |
| 844 std::string* l) { | |
| 845 l->append("StreamVideoDrawQuad::OverlayResources(["); | |
| 846 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 847 LogParam(p.size_in_pixels[i], l); | |
| 848 if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1)) | |
| 849 l->append(", "); | |
| 850 } | |
| 851 l->append("])"); | |
| 852 } | |
| 853 | |
| 854 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::GetSize( | |
| 855 base::PickleSizer* s, const param_type& p) { | |
| 856 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 857 GetParamSize(s, p.size_in_pixels[i]); | |
| 858 } | |
| 859 } | |
| 860 | |
| 861 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Write( | |
| 862 base::Pickle* m, | |
| 863 const param_type& p) { | |
| 864 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 865 WriteParam(m, p.size_in_pixels[i]); | |
| 866 } | |
| 867 } | |
| 868 | |
| 869 bool ParamTraits<cc::TextureDrawQuad::OverlayResources>::Read( | |
| 870 const base::Pickle* m, | |
| 871 base::PickleIterator* iter, | |
| 872 param_type* p) { | |
| 873 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 874 if (!ReadParam(m, iter, &p->size_in_pixels[i])) | |
| 875 return false; | |
| 876 } | |
| 877 return true; | |
| 878 } | |
| 879 | |
| 880 void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Log( | |
| 881 const param_type& p, | |
| 882 std::string* l) { | |
| 883 l->append("TextureDrawQuad::OverlayResources(["); | |
| 884 for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) { | |
| 885 LogParam(p.size_in_pixels[i], l); | |
| 886 if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1)) | |
| 887 l->append(", "); | |
| 888 } | |
| 889 l->append("])"); | |
| 890 } | |
| 891 | |
| 892 } // namespace IPC | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1978053002:
Move cc ParamTraits to cc/ipc (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master