src/content/common/cc_messages_unittest.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 <string.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/command_line.h"
  12 #include "cc/output/compositor_frame.h"
  13 #include "content/public/common/content_switches.h"
  14 #include "ipc/ipc_message.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16 #include "third_party/khronos/GLES2/gl2ext.h"
  17 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  18
  19 using cc::CheckerboardDrawQuad;
  20 using cc::DelegatedFrameData;
  21 using cc::DebugBorderDrawQuad;
  22 using cc::DrawQuad;
  23 using cc::FilterOperation;
  24 using cc::FilterOperations;
  25 using cc::IOSurfaceDrawQuad;
  26 using cc::PictureDrawQuad;
  27 using cc::RenderPass;
  28 using cc::RenderPassDrawQuad;
  29 using cc::ResourceProvider;
  30 using cc::SharedQuadState;
  31 using cc::SolidColorDrawQuad;
  32 using cc::TextureDrawQuad;
  33 using cc::TileDrawQuad;
  34 using cc::TransferableResource;
  35 using cc::StreamVideoDrawQuad;
  36 using cc::VideoLayerImpl;
  37 using cc::YUVVideoDrawQuad;
  38 using gfx::Transform;
  39
  40 namespace content {
  41 namespace {
  42
  43 class CCMessagesTest : public testing::Test {
  44  protected:
  45   void Compare(const RenderPass* a, const RenderPass* b) {
  46     EXPECT_EQ(a->id, b->id);
  47     EXPECT_EQ(a->output_rect.ToString(), b->output_rect.ToString());
  48     EXPECT_EQ(a->damage_rect.ToString(), b->damage_rect.ToString());
  49     EXPECT_EQ(a->transform_to_root_target, b->transform_to_root_target);
  50     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
  51   }
  52
  53   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
  54     EXPECT_EQ(a->content_to_target_transform, b->content_to_target_transform);
  55     EXPECT_EQ(a->content_bounds, b->content_bounds);
  56     EXPECT_EQ(a->visible_content_rect, b->visible_content_rect);
  57     EXPECT_EQ(a->clip_rect, b->clip_rect);
  58     EXPECT_EQ(a->is_clipped, b->is_clipped);
  59     EXPECT_EQ(a->opacity, b->opacity);
  60   }
  61
  62   void Compare(const DrawQuad* a, const DrawQuad* b) {
  63     ASSERT_NE(DrawQuad::INVALID, a->material);
  64     ASSERT_EQ(a->material, b->material);
  65     EXPECT_EQ(a->rect.ToString(), b->rect.ToString());
  66     EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString());
  67     EXPECT_EQ(a->visible_rect.ToString(), b->visible_rect.ToString());
  68     EXPECT_EQ(a->needs_blending, b->needs_blending);
  69
  70     Compare(a->shared_quad_state, b->shared_quad_state);
  71
  72     switch (a->material) {
  73       case DrawQuad::CHECKERBOARD:
  74         Compare(CheckerboardDrawQuad::MaterialCast(a),
  75                 CheckerboardDrawQuad::MaterialCast(b));
  76         break;
  77       case DrawQuad::DEBUG_BORDER:
  78         Compare(DebugBorderDrawQuad::MaterialCast(a),
  79                 DebugBorderDrawQuad::MaterialCast(b));
  80         break;
  81       case DrawQuad::IO_SURFACE_CONTENT:
  82         Compare(IOSurfaceDrawQuad::MaterialCast(a),
  83                 IOSurfaceDrawQuad::MaterialCast(b));
  84         break;
  85       case DrawQuad::PICTURE_CONTENT:
  86         Compare(PictureDrawQuad::MaterialCast(a),
  87                 PictureDrawQuad::MaterialCast(b));
  88         break;
  89       case DrawQuad::RENDER_PASS:
  90         Compare(RenderPassDrawQuad::MaterialCast(a),
  91                 RenderPassDrawQuad::MaterialCast(b));
  92         break;
  93       case DrawQuad::TEXTURE_CONTENT:
  94         Compare(TextureDrawQuad::MaterialCast(a),
  95                 TextureDrawQuad::MaterialCast(b));
  96         break;
  97       case DrawQuad::TILED_CONTENT:
  98         Compare(TileDrawQuad::MaterialCast(a),
  99                 TileDrawQuad::MaterialCast(b));
 100         break;
 101       case DrawQuad::SOLID_COLOR:
 102         Compare(SolidColorDrawQuad::MaterialCast(a),
 103                 SolidColorDrawQuad::MaterialCast(b));
 104         break;
 105       case DrawQuad::STREAM_VIDEO_CONTENT:
 106         Compare(StreamVideoDrawQuad::MaterialCast(a),
 107                 StreamVideoDrawQuad::MaterialCast(b));
 108         break;
 109       case DrawQuad::YUV_VIDEO_CONTENT:
 110         Compare(YUVVideoDrawQuad::MaterialCast(a),
 111                 YUVVideoDrawQuad::MaterialCast(b));
 112         break;
 113       case DrawQuad::INVALID:
 114         break;
 115     }
 116   }
 117
 118   void Compare(const CheckerboardDrawQuad* a, const CheckerboardDrawQuad* b) {
 119     EXPECT_EQ(a->color, b->color);
 120   }
 121
 122   void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) {
 123     EXPECT_EQ(a->color, b->color);
 124     EXPECT_EQ(a->width, b->width);
 125   }
 126
 127   void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) {
 128     EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
 129     EXPECT_EQ(a->io_surface_resource_id, b->io_surface_resource_id);
 130     EXPECT_EQ(a->orientation, b->orientation);
 131   }
 132
 133   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
 134     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
 135     EXPECT_EQ(a->is_replica, b->is_replica);
 136     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
 137     EXPECT_EQ(a->contents_changed_since_last_frame,
 138               b->contents_changed_since_last_frame);
 139     EXPECT_EQ(a->mask_uv_rect.ToString(), b->mask_uv_rect.ToString());
 140     EXPECT_EQ(a->filters.size(), b->filters.size());
 141     for (size_t i = 0; i < a->filters.size(); ++i) {
 142       if (a->filters.at(i).type() != cc::FilterOperation::REFERENCE) {
 143         EXPECT_EQ(a->filters.at(i), b->filters.at(i));
 144       } else {
 145         EXPECT_EQ(b->filters.at(i).type(), cc::FilterOperation::REFERENCE);
 146         EXPECT_EQ(a->filters.at(i).image_filter()->countInputs(),
 147                   b->filters.at(i).image_filter()->countInputs());
 148       }
 149     }
 150     EXPECT_EQ(a->background_filters, b->background_filters);
 151   }
 152
 153   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
 154     EXPECT_EQ(a->color, b->color);
 155     EXPECT_EQ(a->force_anti_aliasing_off, b->force_anti_aliasing_off);
 156   }
 157
 158   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
 159     EXPECT_EQ(a->resource_id, b->resource_id);
 160     EXPECT_EQ(a->matrix, b->matrix);
 161   }
 162
 163   void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) {
 164     EXPECT_EQ(a->resource_id, b->resource_id);
 165     EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha);
 166     EXPECT_EQ(a->uv_top_left, b->uv_top_left);
 167     EXPECT_EQ(a->uv_bottom_right, b->uv_bottom_right);
 168     EXPECT_EQ(a->background_color, b->background_color);
 169     EXPECT_EQ(a->vertex_opacity[0], b->vertex_opacity[0]);
 170     EXPECT_EQ(a->vertex_opacity[1], b->vertex_opacity[1]);
 171     EXPECT_EQ(a->vertex_opacity[2], b->vertex_opacity[2]);
 172     EXPECT_EQ(a->vertex_opacity[3], b->vertex_opacity[3]);
 173     EXPECT_EQ(a->flipped, b->flipped);
 174   }
 175
 176   void Compare(const TileDrawQuad* a, const TileDrawQuad* b) {
 177     EXPECT_EQ(a->resource_id, b->resource_id);
 178     EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect);
 179     EXPECT_EQ(a->texture_size, b->texture_size);
 180     EXPECT_EQ(a->swizzle_contents, b->swizzle_contents);
 181   }
 182
 183   void Compare(const YUVVideoDrawQuad* a, const YUVVideoDrawQuad* b) {
 184     EXPECT_EQ(a->tex_scale, b->tex_scale);
 185     EXPECT_EQ(a->y_plane_resource_id, b->y_plane_resource_id);
 186     EXPECT_EQ(a->u_plane_resource_id, b->u_plane_resource_id);
 187     EXPECT_EQ(a->v_plane_resource_id, b->v_plane_resource_id);
 188     EXPECT_EQ(a->a_plane_resource_id, b->a_plane_resource_id);
 189   }
 190
 191   void Compare(const TransferableResource& a, const TransferableResource& b) {
 192     EXPECT_EQ(a.id, b.id);
 193     EXPECT_EQ(a.sync_point, b.sync_point);
 194     EXPECT_EQ(a.format, b.format);
 195     EXPECT_EQ(a.target, b.target);
 196     EXPECT_EQ(a.filter, b.filter);
 197     EXPECT_EQ(a.size.ToString(), b.size.ToString());
 198     for (size_t i = 0; i < arraysize(a.mailbox.name); ++i)
 199       EXPECT_EQ(a.mailbox.name[i], b.mailbox.name[i]);
 200   }
 201 };
 202
 203 TEST_F(CCMessagesTest, AllQuads) {
 204   CommandLine& command_line = *CommandLine::ForCurrentProcess();
 205   if (!command_line.HasSwitch(switches::kAllowFiltersOverIPC))
 206     command_line.AppendSwitch(switches::kAllowFiltersOverIPC);
 207
 208   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 209
 210   Transform arbitrary_matrix;
 211   arbitrary_matrix.Scale(3, 3);
 212   arbitrary_matrix.Translate(-5, 20);
 213   arbitrary_matrix.Rotate(15);
 214   gfx::Rect arbitrary_rect1(-5, 9, 3, 15);
 215   gfx::Rect arbitrary_rect1_inside_rect1(-4, 12, 2, 8);
 216   gfx::Rect arbitrary_rect2_inside_rect1(-5, 11, 1, 2);
 217   gfx::Rect arbitrary_rect2(40, 23, 11, 7);
 218   gfx::Rect arbitrary_rect1_inside_rect2(44, 23, 4, 2);
 219   gfx::Rect arbitrary_rect2_inside_rect2(41, 25, 3, 5);
 220   gfx::Rect arbitrary_rect3(7, -53, 22, 19);
 221   gfx::Rect arbitrary_rect1_inside_rect3(10, -40, 6, 3);
 222   gfx::Rect arbitrary_rect2_inside_rect3(12, -51, 5, 12);
 223   gfx::Size arbitrary_size1(15, 19);
 224   gfx::Size arbitrary_size2(3, 99);
 225   gfx::Size arbitrary_size3(75, 1281);
 226   gfx::RectF arbitrary_rectf1(4.2f, -922.1f, 15.6f, 29.5f);
 227   gfx::SizeF arbitrary_sizef1(15.2f, 104.6f);
 228   gfx::PointF arbitrary_pointf1(31.4f, 15.9f);
 229   gfx::PointF arbitrary_pointf2(26.5f, -35.8f);
 230   float arbitrary_float1 = 0.7f;
 231   float arbitrary_float2 = 0.3f;
 232   float arbitrary_float3 = 0.9f;
 233   float arbitrary_float_array[4] = {3.5f, 6.2f, 9.3f, 12.3f};
 234   bool arbitrary_bool1 = true;
 235   bool arbitrary_bool2 = false;
 236   bool arbitrary_bool3 = true;
 237   int arbitrary_int = 5;
 238   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
 239   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
 240       IOSurfaceDrawQuad::UNFLIPPED;
 241   RenderPass::Id arbitrary_id(10, 14);
 242   ResourceProvider::ResourceId arbitrary_resourceid1 = 55;
 243   ResourceProvider::ResourceId arbitrary_resourceid2 = 47;
 244   ResourceProvider::ResourceId arbitrary_resourceid3 = 23;
 245   ResourceProvider::ResourceId arbitrary_resourceid4 = 16;
 246   SkScalar arbitrary_sigma = SkFloatToScalar(2.0f);
 247
 248   FilterOperations arbitrary_filters1;
 249   arbitrary_filters1.Append(FilterOperation::CreateGrayscaleFilter(
 250       arbitrary_float1));
 251   skia::RefPtr<SkImageFilter> arbitrary_filter = skia::AdoptRef(
 252     new SkBlurImageFilter(arbitrary_sigma, arbitrary_sigma));
 253   arbitrary_filters1.Append(
 254       cc::FilterOperation::CreateReferenceFilter(arbitrary_filter));
 255
 256   FilterOperations arbitrary_filters2;
 257   arbitrary_filters2.Append(FilterOperation::CreateBrightnessFilter(
 258       arbitrary_float2));
 259
 260   scoped_ptr<SharedQuadState> shared_state1_in = SharedQuadState::Create();
 261   shared_state1_in->SetAll(arbitrary_matrix,
 262                            arbitrary_size1,
 263                            arbitrary_rect1,
 264                            arbitrary_rect2,
 265                            arbitrary_bool1,
 266                            arbitrary_float1);
 267   scoped_ptr<SharedQuadState> shared_state1_cmp = shared_state1_in->Copy();
 268
 269   scoped_ptr<CheckerboardDrawQuad> checkerboard_in =
 270       CheckerboardDrawQuad::Create();
 271   checkerboard_in->SetAll(shared_state1_in.get(),
 272                           arbitrary_rect1,
 273                           arbitrary_rect2_inside_rect1,
 274                           arbitrary_rect1_inside_rect1,
 275                           arbitrary_bool1,
 276                           arbitrary_color);
 277   scoped_ptr<DrawQuad> checkerboard_cmp = checkerboard_in->Copy(
 278       checkerboard_in->shared_quad_state);
 279
 280   scoped_ptr<DebugBorderDrawQuad> debugborder_in =
 281       DebugBorderDrawQuad::Create();
 282   debugborder_in->SetAll(shared_state1_in.get(),
 283                          arbitrary_rect3,
 284                          arbitrary_rect1_inside_rect3,
 285                          arbitrary_rect2_inside_rect3,
 286                          arbitrary_bool1,
 287                          arbitrary_color,
 288                          arbitrary_int);
 289   scoped_ptr<DrawQuad> debugborder_cmp = debugborder_in->Copy(
 290       debugborder_in->shared_quad_state);
 291
 292   scoped_ptr<IOSurfaceDrawQuad> iosurface_in =
 293       IOSurfaceDrawQuad::Create();
 294   iosurface_in->SetAll(shared_state1_in.get(),
 295                        arbitrary_rect2,
 296                        arbitrary_rect2_inside_rect2,
 297                        arbitrary_rect1_inside_rect2,
 298                        arbitrary_bool1,
 299                        arbitrary_size1,
 300                        arbitrary_resourceid3,
 301                        arbitrary_orientation);
 302   scoped_ptr<DrawQuad> iosurface_cmp = iosurface_in->Copy(
 303       iosurface_in->shared_quad_state);
 304
 305   scoped_ptr<RenderPassDrawQuad> renderpass_in =
 306       RenderPassDrawQuad::Create();
 307   renderpass_in->SetAll(shared_state1_in.get(),
 308                         arbitrary_rect1,
 309                         arbitrary_rect2_inside_rect1,
 310                         arbitrary_rect1_inside_rect1,
 311                         arbitrary_bool1,
 312                         arbitrary_id,
 313                         arbitrary_bool2,
 314                         arbitrary_resourceid2,
 315                         arbitrary_rect1,
 316                         arbitrary_rectf1,
 317                         arbitrary_filters1,
 318                         arbitrary_filters2);
 319   scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
 320       renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
 321
 322   scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create();
 323   shared_state2_in->SetAll(arbitrary_matrix,
 324                            arbitrary_size2,
 325                            arbitrary_rect2,
 326                            arbitrary_rect3,
 327                            arbitrary_bool1,
 328                            arbitrary_float2);
 329   scoped_ptr<SharedQuadState> shared_state2_cmp = shared_state2_in->Copy();
 330
 331   scoped_ptr<SharedQuadState> shared_state3_in = SharedQuadState::Create();
 332   shared_state3_in->SetAll(arbitrary_matrix,
 333                            arbitrary_size3,
 334                            arbitrary_rect3,
 335                            arbitrary_rect1,
 336                            arbitrary_bool1,
 337                            arbitrary_float3);
 338   scoped_ptr<SharedQuadState> shared_state3_cmp = shared_state3_in->Copy();
 339
 340   scoped_ptr<SolidColorDrawQuad> solidcolor_in =
 341       SolidColorDrawQuad::Create();
 342   solidcolor_in->SetAll(shared_state1_in.get(),
 343                         arbitrary_rect3,
 344                         arbitrary_rect1_inside_rect3,
 345                         arbitrary_rect2_inside_rect3,
 346                         arbitrary_bool1,
 347                         arbitrary_color,
 348                         arbitrary_bool2);
 349   scoped_ptr<DrawQuad> solidcolor_cmp = solidcolor_in->Copy(
 350       solidcolor_in->shared_quad_state);
 351
 352   scoped_ptr<StreamVideoDrawQuad> streamvideo_in =
 353       StreamVideoDrawQuad::Create();
 354   streamvideo_in->SetAll(shared_state1_in.get(),
 355                          arbitrary_rect2,
 356                          arbitrary_rect2_inside_rect2,
 357                          arbitrary_rect1_inside_rect2,
 358                          arbitrary_bool1,
 359                          arbitrary_resourceid2,
 360                          arbitrary_matrix);
 361   scoped_ptr<DrawQuad> streamvideo_cmp = streamvideo_in->Copy(
 362       streamvideo_in->shared_quad_state);
 363
 364   scoped_ptr<TextureDrawQuad> texture_in = TextureDrawQuad::Create();
 365   texture_in->SetAll(shared_state1_in.get(),
 366                      arbitrary_rect2,
 367                      arbitrary_rect2_inside_rect2,
 368                      arbitrary_rect1_inside_rect2,
 369                      arbitrary_bool1,
 370                      arbitrary_resourceid1,
 371                      arbitrary_bool2,
 372                      arbitrary_pointf1,
 373                      arbitrary_pointf2,
 374                      arbitrary_color,
 375                      arbitrary_float_array,
 376                      arbitrary_bool3);
 377   scoped_ptr<DrawQuad> texture_cmp = texture_in->Copy(
 378       texture_in->shared_quad_state);
 379
 380   scoped_ptr<TileDrawQuad> tile_in = TileDrawQuad::Create();
 381   tile_in->SetAll(shared_state1_in.get(),
 382                   arbitrary_rect2,
 383                   arbitrary_rect2_inside_rect2,
 384                   arbitrary_rect1_inside_rect2,
 385                   arbitrary_bool1,
 386                   arbitrary_resourceid3,
 387                   arbitrary_rectf1,
 388                   arbitrary_size1,
 389                   arbitrary_bool2);
 390   scoped_ptr<DrawQuad> tile_cmp = tile_in->Copy(
 391       tile_in->shared_quad_state);
 392
 393   scoped_ptr<YUVVideoDrawQuad> yuvvideo_in =
 394       YUVVideoDrawQuad::Create();
 395   yuvvideo_in->SetAll(shared_state1_in.get(),
 396                       arbitrary_rect1,
 397                       arbitrary_rect2_inside_rect1,
 398                       arbitrary_rect1_inside_rect1,
 399                       arbitrary_bool1,
 400                       arbitrary_sizef1,
 401                       arbitrary_resourceid1,
 402                       arbitrary_resourceid2,
 403                       arbitrary_resourceid3,
 404                       arbitrary_resourceid4);
 405   scoped_ptr<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy(
 406       yuvvideo_in->shared_quad_state);
 407
 408   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
 409   pass_in->SetAll(arbitrary_id,
 410                   arbitrary_rect1,
 411                   arbitrary_rectf1,
 412                   arbitrary_matrix,
 413                   arbitrary_bool1);
 414
 415   pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass());
 416   pass_in->quad_list.push_back(checkerboard_in.PassAs<DrawQuad>());
 417   pass_in->quad_list.push_back(debugborder_in.PassAs<DrawQuad>());
 418   pass_in->quad_list.push_back(iosurface_in.PassAs<DrawQuad>());
 419   pass_in->quad_list.push_back(renderpass_in.PassAs<DrawQuad>());
 420   pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass());
 421   pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass());
 422   pass_in->quad_list.push_back(solidcolor_in.PassAs<DrawQuad>());
 423   pass_in->quad_list.push_back(streamvideo_in.PassAs<DrawQuad>());
 424   pass_in->quad_list.push_back(texture_in.PassAs<DrawQuad>());
 425   pass_in->quad_list.push_back(tile_in.PassAs<DrawQuad>());
 426   pass_in->quad_list.push_back(yuvvideo_in.PassAs<DrawQuad>());
 427
 428   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
 429   pass_cmp->SetAll(arbitrary_id,
 430                    arbitrary_rect1,
 431                    arbitrary_rectf1,
 432                    arbitrary_matrix,
 433                    arbitrary_bool1);
 434
 435   pass_cmp->shared_quad_state_list.push_back(shared_state1_cmp.Pass());
 436   pass_cmp->quad_list.push_back(checkerboard_cmp.PassAs<DrawQuad>());
 437   pass_cmp->quad_list.push_back(debugborder_cmp.PassAs<DrawQuad>());
 438   pass_cmp->quad_list.push_back(iosurface_cmp.PassAs<DrawQuad>());
 439   pass_cmp->quad_list.push_back(renderpass_cmp.PassAs<DrawQuad>());
 440   pass_cmp->shared_quad_state_list.push_back(shared_state2_cmp.Pass());
 441   pass_cmp->shared_quad_state_list.push_back(shared_state3_cmp.Pass());
 442   pass_cmp->quad_list.push_back(solidcolor_cmp.PassAs<DrawQuad>());
 443   pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs<DrawQuad>());
 444   pass_cmp->quad_list.push_back(texture_cmp.PassAs<DrawQuad>());
 445   pass_cmp->quad_list.push_back(tile_cmp.PassAs<DrawQuad>());
 446   pass_cmp->quad_list.push_back(yuvvideo_cmp.PassAs<DrawQuad>());
 447
 448   // Make sure the in and cmp RenderPasses match.
 449   Compare(pass_cmp.get(), pass_in.get());
 450   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
 451   ASSERT_EQ(9u, pass_in->quad_list.size());
 452   for (size_t i = 0; i < 3; ++i) {
 453     Compare(pass_cmp->shared_quad_state_list[i],
 454             pass_in->shared_quad_state_list[i]);
 455   }
 456   for (size_t i = 0; i < pass_in->quad_list.size(); ++i)
 457     Compare(pass_cmp->quad_list[i], pass_in->quad_list[i]);
 458   for (size_t i = 1; i < pass_in->quad_list.size(); ++i) {
 459     bool same_shared_quad_state_cmp =
 460         pass_cmp->quad_list[i]->shared_quad_state ==
 461         pass_cmp->quad_list[i - 1]->shared_quad_state;
 462     bool same_shared_quad_state_in =
 463         pass_in->quad_list[i]->shared_quad_state ==
 464         pass_in->quad_list[i - 1]->shared_quad_state;
 465     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
 466   }
 467
 468   DelegatedFrameData frame_in;
 469   frame_in.render_pass_list.push_back(pass_in.Pass());
 470
 471   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 472
 473   DelegatedFrameData frame_out;
 474   PickleIterator iter(msg);
 475   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
 476       &iter, &frame_out));
 477
 478   // Make sure the out and cmp RenderPasses match.
 479   scoped_ptr<RenderPass> pass_out = frame_out.render_pass_list.take(
 480       frame_out.render_pass_list.begin());
 481   Compare(pass_cmp.get(), pass_out.get());
 482   ASSERT_EQ(3u, pass_out->shared_quad_state_list.size());
 483   ASSERT_EQ(9u, pass_out->quad_list.size());
 484   for (size_t i = 0; i < 3; ++i) {
 485     Compare(pass_cmp->shared_quad_state_list[i],
 486             pass_out->shared_quad_state_list[i]);
 487   }
 488   for (size_t i = 0; i < pass_out->quad_list.size(); ++i)
 489     Compare(pass_cmp->quad_list[i], pass_out->quad_list[i]);
 490   for (size_t i = 1; i < pass_out->quad_list.size(); ++i) {
 491     bool same_shared_quad_state_cmp =
 492         pass_cmp->quad_list[i]->shared_quad_state ==
 493         pass_cmp->quad_list[i - 1]->shared_quad_state;
 494     bool same_shared_quad_state_out =
 495         pass_out->quad_list[i]->shared_quad_state ==
 496         pass_out->quad_list[i - 1]->shared_quad_state;
 497     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
 498   }
 499 }
 500
 501 TEST_F(CCMessagesTest, Resources) {
 502   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 503   gfx::Size arbitrary_size(757, 1281);
 504   unsigned int arbitrary_uint1 = 71234838;
 505   unsigned int arbitrary_uint2 = 53589793;
 506
 507   GLbyte arbitrary_mailbox1[64] = {
 508     1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 509     1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 510     1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
 511     1, 2, 3, 4
 512   };
 513
 514   GLbyte arbitrary_mailbox2[64] = {
 515     0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0,
 516     0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0,
 517     0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0,
 518     0, 9, 8, 7
 519   };
 520
 521   TransferableResource arbitrary_resource1;
 522   arbitrary_resource1.id = 2178312;
 523   arbitrary_resource1.sync_point = arbitrary_uint1;
 524   arbitrary_resource1.format = cc::RGBA_8888;
 525   arbitrary_resource1.target = GL_TEXTURE_2D;
 526   arbitrary_resource1.filter = 53;
 527   arbitrary_resource1.size = gfx::Size(37189, 123123);
 528   arbitrary_resource1.mailbox.SetName(arbitrary_mailbox1);
 529
 530   TransferableResource arbitrary_resource2;
 531   arbitrary_resource2.id = 789132;
 532   arbitrary_resource2.sync_point = arbitrary_uint2;
 533   arbitrary_resource2.format = cc::RGBA_4444;
 534   arbitrary_resource2.target = GL_TEXTURE_EXTERNAL_OES;
 535   arbitrary_resource2.filter = 47;
 536   arbitrary_resource2.size = gfx::Size(89123, 23789);
 537   arbitrary_resource2.mailbox.SetName(arbitrary_mailbox2);
 538
 539   scoped_ptr<RenderPass> renderpass_in = RenderPass::Create();
 540   renderpass_in->SetNew(
 541       RenderPass::Id(1, 1), gfx::Rect(), gfx::Rect(), gfx::Transform());
 542
 543   DelegatedFrameData frame_in;
 544   frame_in.resource_list.push_back(arbitrary_resource1);
 545   frame_in.resource_list.push_back(arbitrary_resource2);
 546   frame_in.render_pass_list.push_back(renderpass_in.Pass());
 547
 548   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 549
 550   DelegatedFrameData frame_out;
 551   PickleIterator iter(msg);
 552   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
 553       &iter, &frame_out));
 554
 555   ASSERT_EQ(2u, frame_out.resource_list.size());
 556   Compare(arbitrary_resource1, frame_out.resource_list[0]);
 557   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 558 }
 559
 560 TEST_F(CCMessagesTest, LargestQuadType) {
 561   size_t largest = 0;
 562
 563   bool done = false;
 564   for (int i = 0; !done; ++i) {
 565     switch (static_cast<DrawQuad::Material>(i)) {
 566       case cc::DrawQuad::CHECKERBOARD:
 567         largest = std::max(largest, sizeof(cc::CheckerboardDrawQuad));
 568         break;
 569       case cc::DrawQuad::DEBUG_BORDER:
 570         largest = std::max(largest, sizeof(cc::DebugBorderDrawQuad));
 571         break;
 572       case cc::DrawQuad::IO_SURFACE_CONTENT:
 573         largest = std::max(largest, sizeof(cc::IOSurfaceDrawQuad));
 574         break;
 575       case cc::DrawQuad::PICTURE_CONTENT:
 576         largest = std::max(largest, sizeof(cc::PictureDrawQuad));
 577         break;
 578       case cc::DrawQuad::TEXTURE_CONTENT:
 579         largest = std::max(largest, sizeof(cc::TextureDrawQuad));
 580         break;
 581       case cc::DrawQuad::RENDER_PASS:
 582         largest = std::max(largest, sizeof(cc::RenderPassDrawQuad));
 583         break;
 584       case cc::DrawQuad::SOLID_COLOR:
 585         largest = std::max(largest, sizeof(cc::SolidColorDrawQuad));
 586         break;
 587       case cc::DrawQuad::TILED_CONTENT:
 588         largest = std::max(largest, sizeof(cc::TileDrawQuad));
 589         break;
 590       case cc::DrawQuad::STREAM_VIDEO_CONTENT:
 591         largest = std::max(largest, sizeof(cc::StreamVideoDrawQuad));
 592         break;
 593       case cc::DrawQuad::YUV_VIDEO_CONTENT:
 594         largest = std::max(largest, sizeof(cc::YUVVideoDrawQuad));
 595         break;
 596       case cc::DrawQuad::INVALID:
 597         break;
 598       default:
 599         done = true;
 600     }
 601   }
 602
 603   // Verify the largest DrawQuad type is RenderPassDrawQuad. If this ever
 604   // changes, then the ReserveSizeForRenderPassWrite() method needs to be
 605   // updated as well to use the new largest quad.
 606   EXPECT_EQ(sizeof(RenderPassDrawQuad), largest);
 607 }
 608
 609 }  // namespace
 610 }  // namespace content