src/content/common/cc_messages.cc

   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 "base/command_line.h"
   8 #include "cc/output/compositor_frame.h"
   9 #include "cc/output/filter_operations.h"
  10 #include "content/public/common/common_param_traits.h"
  11 #include "content/public/common/content_switches.h"
  12 #include "third_party/skia/include/core/SkData.h"
  13 #include "third_party/skia/include/core/SkFlattenableSerialization.h"
  14 #include "ui/gfx/transform.h"
  15
  16 namespace IPC {
  17
  18 void ParamTraits<cc::FilterOperation>::Write(
  19     Message* m, const param_type& p) {
  20   WriteParam(m, p.type());
  21   switch (p.type()) {
  22     case cc::FilterOperation::GRAYSCALE:
  23     case cc::FilterOperation::SEPIA:
  24     case cc::FilterOperation::SATURATE:
  25     case cc::FilterOperation::HUE_ROTATE:
  26     case cc::FilterOperation::INVERT:
  27     case cc::FilterOperation::BRIGHTNESS:
  28     case cc::FilterOperation::SATURATING_BRIGHTNESS:
  29     case cc::FilterOperation::CONTRAST:
  30     case cc::FilterOperation::OPACITY:
  31     case cc::FilterOperation::BLUR:
  32       WriteParam(m, p.amount());
  33       break;
  34     case cc::FilterOperation::DROP_SHADOW:
  35       WriteParam(m, p.drop_shadow_offset());
  36       WriteParam(m, p.amount());
  37       WriteParam(m, p.drop_shadow_color());
  38       break;
  39     case cc::FilterOperation::COLOR_MATRIX:
  40       for (int i = 0; i < 20; ++i)
  41         WriteParam(m, p.matrix()[i]);
  42       break;
  43     case cc::FilterOperation::ZOOM:
  44       WriteParam(m, p.amount());
  45       WriteParam(m, p.zoom_inset());
  46       break;
  47     case cc::FilterOperation::REFERENCE:
  48       WriteParam(m, p.image_filter());
  49       break;
  50   }
  51 }
  52
  53 bool ParamTraits<cc::FilterOperation>::Read(
  54     const Message* m, PickleIterator* iter, param_type* r) {
  55   cc::FilterOperation::FilterType type;
  56   float amount;
  57   gfx::Point drop_shadow_offset;
  58   SkColor drop_shadow_color;
  59   SkScalar matrix[20];
  60   int zoom_inset;
  61
  62   if (!ReadParam(m, iter, &type))
  63     return false;
  64   r->set_type(type);
  65
  66   bool success = false;
  67   switch (type) {
  68     case cc::FilterOperation::GRAYSCALE:
  69     case cc::FilterOperation::SEPIA:
  70     case cc::FilterOperation::SATURATE:
  71     case cc::FilterOperation::HUE_ROTATE:
  72     case cc::FilterOperation::INVERT:
  73     case cc::FilterOperation::BRIGHTNESS:
  74     case cc::FilterOperation::SATURATING_BRIGHTNESS:
  75     case cc::FilterOperation::CONTRAST:
  76     case cc::FilterOperation::OPACITY:
  77     case cc::FilterOperation::BLUR:
  78       if (ReadParam(m, iter, &amount)) {
  79         r->set_amount(amount);
  80         success = true;
  81       }
  82       break;
  83     case cc::FilterOperation::DROP_SHADOW:
  84       if (ReadParam(m, iter, &drop_shadow_offset) &&
  85           ReadParam(m, iter, &amount) &&
  86           ReadParam(m, iter, &drop_shadow_color)) {
  87         r->set_drop_shadow_offset(drop_shadow_offset);
  88         r->set_amount(amount);
  89         r->set_drop_shadow_color(drop_shadow_color);
  90         success = true;
  91       }
  92       break;
  93     case cc::FilterOperation::COLOR_MATRIX: {
  94       int i;
  95       for (i = 0; i < 20; ++i) {
  96         if (!ReadParam(m, iter, &matrix[i]))
  97           break;
  98       }
  99       if (i == 20) {
 100         r->set_matrix(matrix);
 101         success = true;
 102       }
 103       break;
 104     }
 105     case cc::FilterOperation::ZOOM:
 106       if (ReadParam(m, iter, &amount) &&
 107           ReadParam(m, iter, &zoom_inset) &&
 108           amount >= 0.f &&
 109           zoom_inset >= 0) {
 110         r->set_amount(amount);
 111         r->set_zoom_inset(zoom_inset);
 112         success = true;
 113       }
 114       break;
 115     case cc::FilterOperation::REFERENCE: {
 116       skia::RefPtr<SkImageFilter> filter;
 117       if (!ReadParam(m, iter, &filter)) {
 118         success = false;
 119         break;
 120       }
 121       r->set_image_filter(filter);
 122       success = true;
 123       break;
 124     }
 125   }
 126   return success;
 127 }
 128
 129 void ParamTraits<cc::FilterOperation>::Log(
 130     const param_type& p, std::string* l) {
 131   l->append("(");
 132   LogParam(static_cast<unsigned>(p.type()), l);
 133   l->append(", ");
 134
 135   switch (p.type()) {
 136     case cc::FilterOperation::GRAYSCALE:
 137     case cc::FilterOperation::SEPIA:
 138     case cc::FilterOperation::SATURATE:
 139     case cc::FilterOperation::HUE_ROTATE:
 140     case cc::FilterOperation::INVERT:
 141     case cc::FilterOperation::BRIGHTNESS:
 142     case cc::FilterOperation::SATURATING_BRIGHTNESS:
 143     case cc::FilterOperation::CONTRAST:
 144     case cc::FilterOperation::OPACITY:
 145     case cc::FilterOperation::BLUR:
 146       LogParam(p.amount(), l);
 147       break;
 148     case cc::FilterOperation::DROP_SHADOW:
 149       LogParam(p.drop_shadow_offset(), l);
 150       l->append(", ");
 151       LogParam(p.amount(), l);
 152       l->append(", ");
 153       LogParam(p.drop_shadow_color(), l);
 154       break;
 155     case cc::FilterOperation::COLOR_MATRIX:
 156       for (int i = 0; i < 20; ++i) {
 157         if (i)
 158           l->append(", ");
 159         LogParam(p.matrix()[i], l);
 160       }
 161       break;
 162     case cc::FilterOperation::ZOOM:
 163       LogParam(p.amount(), l);
 164       l->append(", ");
 165       LogParam(p.zoom_inset(), l);
 166       break;
 167     case cc::FilterOperation::REFERENCE:
 168       LogParam(p.image_filter(), l);
 169       break;
 170   }
 171   l->append(")");
 172 }
 173
 174 void ParamTraits<cc::FilterOperations>::Write(
 175     Message* m, const param_type& p) {
 176   WriteParam(m, p.size());
 177   for (std::size_t i = 0; i < p.size(); ++i) {
 178     WriteParam(m, p.at(i));
 179   }
 180 }
 181
 182 bool ParamTraits<cc::FilterOperations>::Read(
 183     const Message* m, PickleIterator* iter, param_type* r) {
 184   size_t count;
 185   if (!ReadParam(m, iter, &count))
 186     return false;
 187
 188   for (std::size_t i = 0; i < count; ++i) {
 189     cc::FilterOperation op = cc::FilterOperation::CreateEmptyFilter();
 190     if (!ReadParam(m, iter, &op))
 191       return false;
 192     r->Append(op);
 193   }
 194   return true;
 195 }
 196
 197 void ParamTraits<cc::FilterOperations>::Log(
 198     const param_type& p, std::string* l) {
 199   l->append("(");
 200   for (std::size_t i = 0; i < p.size(); ++i) {
 201     if (i)
 202       l->append(", ");
 203     LogParam(p.at(i), l);
 204   }
 205   l->append(")");
 206 }
 207
 208 void ParamTraits<skia::RefPtr<SkImageFilter> >::Write(
 209     Message* m, const param_type& p) {
 210   SkImageFilter* filter = p.get();
 211   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 212   if (filter && !command_line.HasSwitch(switches::kDisableFiltersOverIPC)) {
 213     skia::RefPtr<SkData> data =
 214         skia::AdoptRef(SkValidatingSerializeFlattenable(filter));
 215     m->WriteData(static_cast<const char*>(data->data()), data->size());
 216   } else {
 217     m->WriteData(0, 0);
 218   }
 219 }
 220
 221 bool ParamTraits<skia::RefPtr<SkImageFilter> >::Read(
 222     const Message* m, PickleIterator* iter, param_type* r) {
 223   const char* data = 0;
 224   int length = 0;
 225   if (!m->ReadData(iter, &data, &length))
 226     return false;
 227   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 228   if ((length > 0) &&
 229       !command_line.HasSwitch(switches::kDisableFiltersOverIPC)) {
 230     SkFlattenable* flattenable = SkValidatingDeserializeFlattenable(
 231         data, length, SkImageFilter::GetFlattenableType());
 232     *r = skia::AdoptRef(static_cast<SkImageFilter*>(flattenable));
 233   } else {
 234     r->clear();
 235   }
 236   return true;
 237 }
 238
 239 void ParamTraits<skia::RefPtr<SkImageFilter> >::Log(
 240     const param_type& p, std::string* l) {
 241   l->append("(");
 242   LogParam(p.get() ? p->countInputs() : 0, l);
 243   l->append(")");
 244 }
 245
 246 void ParamTraits<gfx::Transform>::Write(
 247     Message* m, const param_type& p) {
 248 #ifdef SK_MSCALAR_IS_FLOAT
 249   float column_major_data[16];
 250   p.matrix().asColMajorf(column_major_data);
 251 #else
 252   double column_major_data[16];
 253   p.matrix().asColMajord(column_major_data);
 254 #endif
 255   m->WriteBytes(&column_major_data, sizeof(SkMScalar) * 16);
 256 }
 257
 258 bool ParamTraits<gfx::Transform>::Read(
 259     const Message* m, PickleIterator* iter, param_type* r) {
 260   const char* column_major_data;
 261   if (!m->ReadBytes(iter, &column_major_data, sizeof(SkMScalar) * 16))
 262     return false;
 263   r->matrix().setColMajor(
 264       reinterpret_cast<const SkMScalar*>(column_major_data));
 265   return true;
 266 }
 267
 268 void ParamTraits<gfx::Transform>::Log(
 269     const param_type& p, std::string* l) {
 270 #ifdef SK_MSCALAR_IS_FLOAT
 271   float row_major_data[16];
 272   p.matrix().asRowMajorf(row_major_data);
 273 #else
 274   double row_major_data[16];
 275   p.matrix().asRowMajord(row_major_data);
 276 #endif
 277   l->append("(");
 278   for (int i = 0; i < 16; ++i) {
 279     if (i > 0)
 280       l->append(", ");
 281     LogParam(row_major_data[i], l);
 282   }
 283   l->append(") ");
 284 }
 285
 286 void ParamTraits<cc::RenderPass>::Write(
 287     Message* m, const param_type& p) {
 288   WriteParam(m, p.id);
 289   WriteParam(m, p.output_rect);
 290   WriteParam(m, p.damage_rect);
 291   WriteParam(m, p.transform_to_root_target);
 292   WriteParam(m, p.has_transparent_background);
 293   WriteParam(m, p.shared_quad_state_list.size());
 294   WriteParam(m, p.quad_list.size());
 295
 296   size_t shared_quad_state_index = 0;
 297   size_t last_shared_quad_state_index = kuint32max;
 298   for (size_t i = 0; i < p.quad_list.size(); ++i) {
 299     const cc::DrawQuad* quad = p.quad_list[i];
 300     DCHECK(quad->rect.Contains(quad->visible_rect))
 301         << quad->material << " rect: " << quad->rect.ToString()
 302         << " visible_rect: " << quad->visible_rect.ToString();
 303     DCHECK(quad->opaque_rect.IsEmpty() ||
 304            quad->rect.Contains(quad->opaque_rect))
 305         << quad->material << " rect: " << quad->rect.ToString()
 306         << " opaque_rect: " << quad->opaque_rect.ToString();
 307
 308     switch (quad->material) {
 309       case cc::DrawQuad::CHECKERBOARD:
 310         WriteParam(m, *cc::CheckerboardDrawQuad::MaterialCast(quad));
 311         break;
 312       case cc::DrawQuad::DEBUG_BORDER:
 313         WriteParam(m, *cc::DebugBorderDrawQuad::MaterialCast(quad));
 314         break;
 315       case cc::DrawQuad::IO_SURFACE_CONTENT:
 316         WriteParam(m, *cc::IOSurfaceDrawQuad::MaterialCast(quad));
 317         break;
 318       case cc::DrawQuad::PICTURE_CONTENT:
 319         NOTREACHED();
 320         break;
 321       case cc::DrawQuad::TEXTURE_CONTENT:
 322         WriteParam(m, *cc::TextureDrawQuad::MaterialCast(quad));
 323         break;
 324       case cc::DrawQuad::RENDER_PASS:
 325         WriteParam(m, *cc::RenderPassDrawQuad::MaterialCast(quad));
 326         break;
 327       case cc::DrawQuad::SOLID_COLOR:
 328         WriteParam(m, *cc::SolidColorDrawQuad::MaterialCast(quad));
 329         break;
 330       case cc::DrawQuad::SURFACE_CONTENT:
 331         WriteParam(m, *cc::SurfaceDrawQuad::MaterialCast(quad));
 332         break;
 333       case cc::DrawQuad::TILED_CONTENT:
 334         WriteParam(m, *cc::TileDrawQuad::MaterialCast(quad));
 335         break;
 336       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
 337         WriteParam(m, *cc::StreamVideoDrawQuad::MaterialCast(quad));
 338         break;
 339       case cc::DrawQuad::YUV_VIDEO_CONTENT:
 340         WriteParam(m, *cc::YUVVideoDrawQuad::MaterialCast(quad));
 341         break;
 342       case cc::DrawQuad::INVALID:
 343         break;
 344     }
 345
 346     const cc::ScopedPtrVector<cc::SharedQuadState>& sqs_list =
 347         p.shared_quad_state_list;
 348
 349     // This is an invalid index.
 350     size_t bad_index = sqs_list.size();
 351
 352     // Null shared quad states should not occur.
 353     DCHECK(quad->shared_quad_state);
 354     if (!quad->shared_quad_state) {
 355       WriteParam(m, bad_index);
 356       continue;
 357     }
 358
 359     // SharedQuadStates should appear in the order they are used by DrawQuads.
 360     // Find the SharedQuadState for this DrawQuad.
 361     while (shared_quad_state_index < sqs_list.size() &&
 362            quad->shared_quad_state != sqs_list[shared_quad_state_index])
 363       ++shared_quad_state_index;
 364
 365     DCHECK_LT(shared_quad_state_index, sqs_list.size());
 366     if (shared_quad_state_index >= sqs_list.size()) {
 367       WriteParam(m, bad_index);
 368       continue;
 369     }
 370
 371     WriteParam(m, shared_quad_state_index);
 372     if (shared_quad_state_index != last_shared_quad_state_index) {
 373       WriteParam(m, *sqs_list[shared_quad_state_index]);
 374       last_shared_quad_state_index = shared_quad_state_index;
 375     }
 376   }
 377 }
 378
 379 static size_t ReserveSizeForRenderPassWrite(const cc::RenderPass& p) {
 380   size_t to_reserve = sizeof(cc::RenderPass);
 381
 382   to_reserve += p.shared_quad_state_list.size() * sizeof(cc::SharedQuadState);
 383
 384   // The shared_quad_state_index for each quad.
 385   to_reserve += p.quad_list.size() * sizeof(size_t);
 386
 387   // The largest quad type, verified by a unit test.
 388   to_reserve += p.quad_list.size() * sizeof(cc::RenderPassDrawQuad);
 389   return to_reserve;
 390 }
 391
 392 template<typename QuadType>
 393 static scoped_ptr<cc::DrawQuad> ReadDrawQuad(const Message* m,
 394                                              PickleIterator* iter) {
 395   scoped_ptr<QuadType> quad = QuadType::Create();
 396   if (!ReadParam(m, iter, quad.get()))
 397     return scoped_ptr<QuadType>().template PassAs<cc::DrawQuad>();
 398   return quad.template PassAs<cc::DrawQuad>();
 399 }
 400
 401 bool ParamTraits<cc::RenderPass>::Read(
 402     const Message* m, PickleIterator* iter, param_type* p) {
 403   cc::RenderPass::Id id(-1, -1);
 404   gfx::Rect output_rect;
 405   gfx::RectF damage_rect;
 406   gfx::Transform transform_to_root_target;
 407   bool has_transparent_background;
 408   size_t shared_quad_state_list_size;
 409   size_t quad_list_size;
 410
 411   if (!ReadParam(m, iter, &id) ||
 412       !ReadParam(m, iter, &output_rect) ||
 413       !ReadParam(m, iter, &damage_rect) ||
 414       !ReadParam(m, iter, &transform_to_root_target) ||
 415       !ReadParam(m, iter, &has_transparent_background) ||
 416       !ReadParam(m, iter, &shared_quad_state_list_size) ||
 417       !ReadParam(m, iter, &quad_list_size))
 418     return false;
 419
 420   p->SetAll(id,
 421             output_rect,
 422             damage_rect,
 423             transform_to_root_target,
 424             has_transparent_background);
 425
 426   size_t last_shared_quad_state_index = kuint32max;
 427   for (size_t i = 0; i < quad_list_size; ++i) {
 428     cc::DrawQuad::Material material;
 429     PickleIterator temp_iter = *iter;
 430     if (!ReadParam(m, &temp_iter, &material))
 431       return false;
 432
 433     scoped_ptr<cc::DrawQuad> draw_quad;
 434     switch (material) {
 435       case cc::DrawQuad::CHECKERBOARD:
 436         draw_quad = ReadDrawQuad<cc::CheckerboardDrawQuad>(m, iter);
 437         break;
 438       case cc::DrawQuad::DEBUG_BORDER:
 439         draw_quad = ReadDrawQuad<cc::DebugBorderDrawQuad>(m, iter);
 440         break;
 441       case cc::DrawQuad::IO_SURFACE_CONTENT:
 442         draw_quad = ReadDrawQuad<cc::IOSurfaceDrawQuad>(m, iter);
 443         break;
 444       case cc::DrawQuad::PICTURE_CONTENT:
 445         NOTREACHED();
 446         return false;
 447       case cc::DrawQuad::SURFACE_CONTENT:
 448         draw_quad = ReadDrawQuad<cc::SurfaceDrawQuad>(m, iter);
 449         break;
 450       case cc::DrawQuad::TEXTURE_CONTENT:
 451         draw_quad = ReadDrawQuad<cc::TextureDrawQuad>(m, iter);
 452         break;
 453       case cc::DrawQuad::RENDER_PASS:
 454         draw_quad = ReadDrawQuad<cc::RenderPassDrawQuad>(m, iter);
 455         break;
 456       case cc::DrawQuad::SOLID_COLOR:
 457         draw_quad = ReadDrawQuad<cc::SolidColorDrawQuad>(m, iter);
 458         break;
 459       case cc::DrawQuad::TILED_CONTENT:
 460         draw_quad = ReadDrawQuad<cc::TileDrawQuad>(m, iter);
 461         break;
 462       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
 463         draw_quad = ReadDrawQuad<cc::StreamVideoDrawQuad>(m, iter);
 464         break;
 465       case cc::DrawQuad::YUV_VIDEO_CONTENT:
 466         draw_quad = ReadDrawQuad<cc::YUVVideoDrawQuad>(m, iter);
 467         break;
 468       case cc::DrawQuad::INVALID:
 469         break;
 470     }
 471     if (!draw_quad)
 472       return false;
 473     if (!draw_quad->rect.Contains(draw_quad->visible_rect)) {
 474       LOG(ERROR) << "Quad with invalid visible rect " << draw_quad->material
 475                  << " rect: " << draw_quad->rect.ToString()
 476                  << " visible_rect: " << draw_quad->visible_rect.ToString();
 477       return false;
 478     }
 479     if (!draw_quad->opaque_rect.IsEmpty() &&
 480         !draw_quad->rect.Contains(draw_quad->opaque_rect)) {
 481       LOG(ERROR) << "Quad with invalid opaque rect " << draw_quad->material
 482                  << " rect: " << draw_quad->rect.ToString()
 483                  << " opaque_rect: " << draw_quad->opaque_rect.ToString();
 484       return false;
 485     }
 486
 487     size_t shared_quad_state_index;
 488     if (!ReadParam(m, iter, &shared_quad_state_index))
 489       return false;
 490     if (shared_quad_state_index >= shared_quad_state_list_size)
 491       return false;
 492     // SharedQuadState indexes should be in ascending order.
 493     if (last_shared_quad_state_index != kuint32max &&
 494         shared_quad_state_index < last_shared_quad_state_index)
 495       return false;
 496
 497     // If the quad has a new shared quad state, read it in.
 498     if (last_shared_quad_state_index != shared_quad_state_index) {
 499       scoped_ptr<cc::SharedQuadState> state(cc::SharedQuadState::Create());
 500       if (!ReadParam(m, iter, state.get()))
 501         return false;
 502       p->shared_quad_state_list.push_back(state.Pass());
 503       last_shared_quad_state_index = shared_quad_state_index;
 504     }
 505
 506     draw_quad->shared_quad_state = p->shared_quad_state_list.back();
 507     p->quad_list.push_back(draw_quad.Pass());
 508   }
 509
 510   return true;
 511 }
 512
 513 void ParamTraits<cc::RenderPass>::Log(
 514     const param_type& p, std::string* l) {
 515   l->append("RenderPass((");
 516   LogParam(p.id, l);
 517   l->append("), ");
 518   LogParam(p.output_rect, l);
 519   l->append(", ");
 520   LogParam(p.damage_rect, l);
 521   l->append(", ");
 522   LogParam(p.transform_to_root_target, l);
 523   l->append(", ");
 524   LogParam(p.has_transparent_background, l);
 525   l->append(", ");
 526
 527   l->append("[");
 528   for (size_t i = 0; i < p.shared_quad_state_list.size(); ++i) {
 529     if (i)
 530       l->append(", ");
 531     LogParam(*p.shared_quad_state_list[i], l);
 532   }
 533   l->append("], [");
 534   for (size_t i = 0; i < p.quad_list.size(); ++i) {
 535     if (i)
 536       l->append(", ");
 537     const cc::DrawQuad* quad = p.quad_list[i];
 538     switch (quad->material) {
 539       case cc::DrawQuad::CHECKERBOARD:
 540         LogParam(*cc::CheckerboardDrawQuad::MaterialCast(quad), l);
 541         break;
 542       case cc::DrawQuad::DEBUG_BORDER:
 543         LogParam(*cc::DebugBorderDrawQuad::MaterialCast(quad), l);
 544         break;
 545       case cc::DrawQuad::IO_SURFACE_CONTENT:
 546         LogParam(*cc::IOSurfaceDrawQuad::MaterialCast(quad), l);
 547         break;
 548       case cc::DrawQuad::PICTURE_CONTENT:
 549         NOTREACHED();
 550         break;
 551       case cc::DrawQuad::TEXTURE_CONTENT:
 552         LogParam(*cc::TextureDrawQuad::MaterialCast(quad), l);
 553         break;
 554       case cc::DrawQuad::RENDER_PASS:
 555         LogParam(*cc::RenderPassDrawQuad::MaterialCast(quad), l);
 556         break;
 557       case cc::DrawQuad::SOLID_COLOR:
 558         LogParam(*cc::SolidColorDrawQuad::MaterialCast(quad), l);
 559         break;
 560       case cc::DrawQuad::SURFACE_CONTENT:
 561         LogParam(*cc::SurfaceDrawQuad::MaterialCast(quad), l);
 562         break;
 563       case cc::DrawQuad::TILED_CONTENT:
 564         LogParam(*cc::TileDrawQuad::MaterialCast(quad), l);
 565         break;
 566       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
 567         LogParam(*cc::StreamVideoDrawQuad::MaterialCast(quad), l);
 568         break;
 569       case cc::DrawQuad::YUV_VIDEO_CONTENT:
 570         LogParam(*cc::YUVVideoDrawQuad::MaterialCast(quad), l);
 571         break;
 572       case cc::DrawQuad::INVALID:
 573         break;
 574     }
 575   }
 576   l->append("])");
 577 }
 578
 579 namespace {
 580   enum CompositorFrameType {
 581     NO_FRAME,
 582     DELEGATED_FRAME,
 583     GL_FRAME,
 584     SOFTWARE_FRAME,
 585   };
 586 }
 587
 588 void ParamTraits<cc::CompositorFrame>::Write(Message* m,
 589                                              const param_type& p) {
 590   WriteParam(m, p.metadata);
 591   if (p.delegated_frame_data) {
 592     DCHECK(!p.gl_frame_data);
 593     DCHECK(!p.software_frame_data);
 594     WriteParam(m, static_cast<int>(DELEGATED_FRAME));
 595     WriteParam(m, *p.delegated_frame_data);
 596   } else if (p.gl_frame_data) {
 597     DCHECK(!p.software_frame_data);
 598     WriteParam(m, static_cast<int>(GL_FRAME));
 599     WriteParam(m, *p.gl_frame_data);
 600   } else if (p.software_frame_data) {
 601     WriteParam(m, static_cast<int>(SOFTWARE_FRAME));
 602     WriteParam(m, *p.software_frame_data);
 603   } else {
 604     WriteParam(m, static_cast<int>(NO_FRAME));
 605   }
 606 }
 607
 608 bool ParamTraits<cc::CompositorFrame>::Read(const Message* m,
 609                                             PickleIterator* iter,
 610                                             param_type* p) {
 611   if (!ReadParam(m, iter, &p->metadata))
 612     return false;
 613
 614   int compositor_frame_type;
 615   if (!ReadParam(m, iter, &compositor_frame_type))
 616     return false;
 617
 618   switch (compositor_frame_type) {
 619     case DELEGATED_FRAME:
 620       p->delegated_frame_data.reset(new cc::DelegatedFrameData());
 621       if (!ReadParam(m, iter, p->delegated_frame_data.get()))
 622         return false;
 623       break;
 624     case GL_FRAME:
 625       p->gl_frame_data.reset(new cc::GLFrameData());
 626       if (!ReadParam(m, iter, p->gl_frame_data.get()))
 627         return false;
 628       break;
 629     case SOFTWARE_FRAME:
 630       p->software_frame_data.reset(new cc::SoftwareFrameData());
 631       if (!ReadParam(m, iter, p->software_frame_data.get()))
 632         return false;
 633       break;
 634     case NO_FRAME:
 635       break;
 636     default:
 637       return false;
 638   }
 639   return true;
 640 }
 641
 642 void ParamTraits<cc::CompositorFrame>::Log(const param_type& p,
 643                                            std::string* l) {
 644   l->append("CompositorFrame(");
 645   LogParam(p.metadata, l);
 646   l->append(", ");
 647   if (p.delegated_frame_data)
 648     LogParam(*p.delegated_frame_data, l);
 649   else if (p.gl_frame_data)
 650     LogParam(*p.gl_frame_data, l);
 651   else if (p.software_frame_data)
 652     LogParam(*p.software_frame_data, l);
 653   l->append(")");
 654 }
 655
 656 void ParamTraits<cc::CompositorFrameAck>::Write(Message* m,
 657                                                 const param_type& p) {
 658   WriteParam(m, p.resources);
 659   WriteParam(m, p.last_software_frame_id);
 660   if (p.gl_frame_data) {
 661     WriteParam(m, static_cast<int>(GL_FRAME));
 662     WriteParam(m, *p.gl_frame_data);
 663   } else {
 664     WriteParam(m, static_cast<int>(NO_FRAME));
 665   }
 666 }
 667
 668 bool ParamTraits<cc::CompositorFrameAck>::Read(const Message* m,
 669                                                PickleIterator* iter,
 670                                                param_type* p) {
 671   if (!ReadParam(m, iter, &p->resources))
 672     return false;
 673
 674   if (!ReadParam(m, iter, &p->last_software_frame_id))
 675     return false;
 676
 677   int compositor_frame_type;
 678   if (!ReadParam(m, iter, &compositor_frame_type))
 679     return false;
 680
 681   switch (compositor_frame_type) {
 682     case NO_FRAME:
 683       break;
 684     case GL_FRAME:
 685       p->gl_frame_data.reset(new cc::GLFrameData());
 686       if (!ReadParam(m, iter, p->gl_frame_data.get()))
 687         return false;
 688       break;
 689     default:
 690       return false;
 691   }
 692   return true;
 693 }
 694
 695 void ParamTraits<cc::CompositorFrameAck>::Log(const param_type& p,
 696                                               std::string* l) {
 697   l->append("CompositorFrameAck(");
 698   LogParam(p.resources, l);
 699   l->append(", ");
 700   LogParam(p.last_software_frame_id, l);
 701   l->append(", ");
 702   if (p.gl_frame_data)
 703     LogParam(*p.gl_frame_data, l);
 704   l->append(")");
 705 }
 706
 707 void ParamTraits<cc::DelegatedFrameData>::Write(Message* m,
 708                                                 const param_type& p) {
 709   DCHECK_NE(0u, p.render_pass_list.size());
 710
 711   size_t to_reserve = p.resource_list.size() * sizeof(cc::TransferableResource);
 712   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
 713     const cc::RenderPass* pass = p.render_pass_list[i];
 714     to_reserve += ReserveSizeForRenderPassWrite(*pass);
 715   }
 716   m->Reserve(to_reserve);
 717
 718   WriteParam(m, p.resource_list);
 719   WriteParam(m, p.render_pass_list.size());
 720   for (size_t i = 0; i < p.render_pass_list.size(); ++i)
 721     WriteParam(m, *p.render_pass_list[i]);
 722 }
 723
 724 bool ParamTraits<cc::DelegatedFrameData>::Read(const Message* m,
 725                                                PickleIterator* iter,
 726                                                param_type* p) {
 727   const static size_t kMaxRenderPasses = 10000;
 728
 729   size_t num_render_passes;
 730   if (!ReadParam(m, iter, &p->resource_list) ||
 731       !ReadParam(m, iter, &num_render_passes) ||
 732       num_render_passes > kMaxRenderPasses || num_render_passes == 0)
 733     return false;
 734   for (size_t i = 0; i < num_render_passes; ++i) {
 735     scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
 736     if (!ReadParam(m, iter, render_pass.get()))
 737       return false;
 738     p->render_pass_list.push_back(render_pass.Pass());
 739   }
 740   return true;
 741 }
 742
 743 void ParamTraits<cc::DelegatedFrameData>::Log(const param_type& p,
 744                                               std::string* l) {
 745   l->append("DelegatedFrameData(");
 746   LogParam(p.resource_list, l);
 747   l->append(", [");
 748   for (size_t i = 0; i < p.render_pass_list.size(); ++i) {
 749     if (i)
 750       l->append(", ");
 751     LogParam(*p.render_pass_list[i], l);
 752   }
 753   l->append("])");
 754 }
 755
 756 }  // namespace IPC