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 "cc/output/compositor_frame.h"
  12 #include "content/public/common/common_param_traits.h"
  13 #include "ipc/ipc_message.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/khronos/GLES2/gl2ext.h"
  16 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
  17
  18 #if defined(OS_POSIX)
  19 #include "base/file_descriptor_posix.h"
  20 #endif
  21
  22 using cc::CheckerboardDrawQuad;
  23 using cc::DelegatedFrameData;
  24 using cc::DebugBorderDrawQuad;
  25 using cc::DrawQuad;
  26 using cc::FilterOperation;
  27 using cc::FilterOperations;
  28 using cc::IOSurfaceDrawQuad;
  29 using cc::PictureDrawQuad;
  30 using cc::RenderPass;
  31 using cc::RenderPassId;
  32 using cc::RenderPassDrawQuad;
  33 using cc::ResourceProvider;
  34 using cc::SharedQuadState;
  35 using cc::SoftwareFrameData;
  36 using cc::SolidColorDrawQuad;
  37 using cc::SurfaceDrawQuad;
  38 using cc::TextureDrawQuad;
  39 using cc::TileDrawQuad;
  40 using cc::TransferableResource;
  41 using cc::StreamVideoDrawQuad;
  42 using cc::YUVVideoDrawQuad;
  43 using gfx::Transform;
  44
  45 namespace content {
  46 namespace {
  47
  48 class CCMessagesTest : public testing::Test {
  49  protected:
  50   void Compare(const RenderPass* a, const RenderPass* b) {
  51     EXPECT_EQ(a->id, b->id);
  52     EXPECT_EQ(a->output_rect.ToString(), b->output_rect.ToString());
  53     EXPECT_EQ(a->damage_rect.ToString(), b->damage_rect.ToString());
  54     EXPECT_EQ(a->transform_to_root_target, b->transform_to_root_target);
  55     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
  56   }
  57
  58   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
  59     EXPECT_EQ(a->content_to_target_transform, b->content_to_target_transform);
  60     EXPECT_EQ(a->content_bounds, b->content_bounds);
  61     EXPECT_EQ(a->visible_content_rect, b->visible_content_rect);
  62     EXPECT_EQ(a->clip_rect, b->clip_rect);
  63     EXPECT_EQ(a->is_clipped, b->is_clipped);
  64     EXPECT_EQ(a->opacity, b->opacity);
  65     EXPECT_EQ(a->blend_mode, b->blend_mode);
  66     EXPECT_EQ(a->sorting_context_id, b->sorting_context_id);
  67   }
  68
  69   void Compare(const DrawQuad* a, const DrawQuad* b) {
  70     ASSERT_NE(DrawQuad::INVALID, a->material);
  71     ASSERT_EQ(a->material, b->material);
  72     EXPECT_EQ(a->rect.ToString(), b->rect.ToString());
  73     EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString());
  74     EXPECT_EQ(a->visible_rect.ToString(), b->visible_rect.ToString());
  75     EXPECT_EQ(a->needs_blending, b->needs_blending);
  76
  77     Compare(a->shared_quad_state, b->shared_quad_state);
  78
  79     switch (a->material) {
  80       case DrawQuad::CHECKERBOARD:
  81         Compare(CheckerboardDrawQuad::MaterialCast(a),
  82                 CheckerboardDrawQuad::MaterialCast(b));
  83         break;
  84       case DrawQuad::DEBUG_BORDER:
  85         Compare(DebugBorderDrawQuad::MaterialCast(a),
  86                 DebugBorderDrawQuad::MaterialCast(b));
  87         break;
  88       case DrawQuad::IO_SURFACE_CONTENT:
  89         Compare(IOSurfaceDrawQuad::MaterialCast(a),
  90                 IOSurfaceDrawQuad::MaterialCast(b));
  91         break;
  92       case DrawQuad::PICTURE_CONTENT:
  93         Compare(PictureDrawQuad::MaterialCast(a),
  94                 PictureDrawQuad::MaterialCast(b));
  95         break;
  96       case DrawQuad::RENDER_PASS:
  97         Compare(RenderPassDrawQuad::MaterialCast(a),
  98                 RenderPassDrawQuad::MaterialCast(b));
  99         break;
 100       case DrawQuad::TEXTURE_CONTENT:
 101         Compare(TextureDrawQuad::MaterialCast(a),
 102                 TextureDrawQuad::MaterialCast(b));
 103         break;
 104       case DrawQuad::TILED_CONTENT:
 105         Compare(TileDrawQuad::MaterialCast(a),
 106                 TileDrawQuad::MaterialCast(b));
 107         break;
 108       case DrawQuad::SOLID_COLOR:
 109         Compare(SolidColorDrawQuad::MaterialCast(a),
 110                 SolidColorDrawQuad::MaterialCast(b));
 111         break;
 112       case DrawQuad::STREAM_VIDEO_CONTENT:
 113         Compare(StreamVideoDrawQuad::MaterialCast(a),
 114                 StreamVideoDrawQuad::MaterialCast(b));
 115         break;
 116       case DrawQuad::SURFACE_CONTENT:
 117         Compare(SurfaceDrawQuad::MaterialCast(a),
 118                 SurfaceDrawQuad::MaterialCast(b));
 119         break;
 120       case DrawQuad::YUV_VIDEO_CONTENT:
 121         Compare(YUVVideoDrawQuad::MaterialCast(a),
 122                 YUVVideoDrawQuad::MaterialCast(b));
 123         break;
 124       case DrawQuad::INVALID:
 125         break;
 126     }
 127   }
 128
 129   void Compare(const CheckerboardDrawQuad* a, const CheckerboardDrawQuad* b) {
 130     EXPECT_EQ(a->color, b->color);
 131     EXPECT_EQ(a->scale, b->scale);
 132   }
 133
 134   void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) {
 135     EXPECT_EQ(a->color, b->color);
 136     EXPECT_EQ(a->width, b->width);
 137   }
 138
 139   void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) {
 140     EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
 141     EXPECT_EQ(a->io_surface_resource_id, b->io_surface_resource_id);
 142     EXPECT_EQ(a->orientation, b->orientation);
 143   }
 144
 145   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
 146     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
 147     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
 148     EXPECT_EQ(a->mask_uv_scale.ToString(), b->mask_uv_scale.ToString());
 149     EXPECT_EQ(a->mask_texture_size.ToString(), b->mask_texture_size.ToString());
 150     EXPECT_EQ(a->filters.size(), b->filters.size());
 151     for (size_t i = 0; i < a->filters.size(); ++i) {
 152       if (a->filters.at(i).type() != cc::FilterOperation::REFERENCE) {
 153         EXPECT_EQ(a->filters.at(i), b->filters.at(i));
 154       } else {
 155         EXPECT_EQ(b->filters.at(i).type(), cc::FilterOperation::REFERENCE);
 156         EXPECT_EQ(a->filters.at(i).image_filter()->countInputs(),
 157                   b->filters.at(i).image_filter()->countInputs());
 158       }
 159     }
 160     EXPECT_EQ(a->filters_scale, b->filters_scale);
 161     EXPECT_EQ(a->background_filters, b->background_filters);
 162   }
 163
 164   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
 165     EXPECT_EQ(a->color, b->color);
 166     EXPECT_EQ(a->force_anti_aliasing_off, b->force_anti_aliasing_off);
 167   }
 168
 169   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
 170     EXPECT_EQ(a->resource_id, b->resource_id);
 171     EXPECT_EQ(a->matrix, b->matrix);
 172   }
 173
 174   void Compare(const SurfaceDrawQuad* a, const SurfaceDrawQuad* b) {
 175     EXPECT_EQ(a->surface_id, b->surface_id);
 176   }
 177
 178   void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) {
 179     EXPECT_EQ(a->resource_id, b->resource_id);
 180     EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha);
 181     EXPECT_EQ(a->uv_top_left, b->uv_top_left);
 182     EXPECT_EQ(a->uv_bottom_right, b->uv_bottom_right);
 183     EXPECT_EQ(a->background_color, b->background_color);
 184     EXPECT_EQ(a->vertex_opacity[0], b->vertex_opacity[0]);
 185     EXPECT_EQ(a->vertex_opacity[1], b->vertex_opacity[1]);
 186     EXPECT_EQ(a->vertex_opacity[2], b->vertex_opacity[2]);
 187     EXPECT_EQ(a->vertex_opacity[3], b->vertex_opacity[3]);
 188     EXPECT_EQ(a->flipped, b->flipped);
 189     EXPECT_EQ(a->nearest_neighbor, b->nearest_neighbor);
 190   }
 191
 192   void Compare(const TileDrawQuad* a, const TileDrawQuad* b) {
 193     EXPECT_EQ(a->resource_id, b->resource_id);
 194     EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect);
 195     EXPECT_EQ(a->texture_size, b->texture_size);
 196     EXPECT_EQ(a->swizzle_contents, b->swizzle_contents);
 197     EXPECT_EQ(a->nearest_neighbor, b->nearest_neighbor);
 198   }
 199
 200   void Compare(const YUVVideoDrawQuad* a, const YUVVideoDrawQuad* b) {
 201     EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect);
 202     EXPECT_EQ(a->ya_tex_size, b->ya_tex_size);
 203     EXPECT_EQ(a->uv_tex_size, b->uv_tex_size);
 204     EXPECT_EQ(a->y_plane_resource_id, b->y_plane_resource_id);
 205     EXPECT_EQ(a->u_plane_resource_id, b->u_plane_resource_id);
 206     EXPECT_EQ(a->v_plane_resource_id, b->v_plane_resource_id);
 207     EXPECT_EQ(a->a_plane_resource_id, b->a_plane_resource_id);
 208     EXPECT_EQ(a->color_space, b->color_space);
 209   }
 210
 211   void Compare(const TransferableResource& a, const TransferableResource& b) {
 212     EXPECT_EQ(a.id, b.id);
 213     EXPECT_EQ(a.format, b.format);
 214     EXPECT_EQ(a.filter, b.filter);
 215     EXPECT_EQ(a.size.ToString(), b.size.ToString());
 216     for (size_t i = 0; i < arraysize(a.mailbox_holder.mailbox.name); ++i) {
 217       EXPECT_EQ(a.mailbox_holder.mailbox.name[i],
 218                 b.mailbox_holder.mailbox.name[i]);
 219     }
 220     EXPECT_EQ(a.mailbox_holder.texture_target, b.mailbox_holder.texture_target);
 221     EXPECT_EQ(a.mailbox_holder.sync_point, b.mailbox_holder.sync_point);
 222     EXPECT_EQ(a.allow_overlay, b.allow_overlay);
 223   }
 224 };
 225
 226 TEST_F(CCMessagesTest, AllQuads) {
 227   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 228
 229   Transform arbitrary_matrix;
 230   arbitrary_matrix.Scale(3, 3);
 231   arbitrary_matrix.Translate(-5, 20);
 232   arbitrary_matrix.Rotate(15);
 233   gfx::Rect arbitrary_rect1(-5, 9, 3, 15);
 234   gfx::Rect arbitrary_rect1_inside_rect1(-4, 12, 2, 8);
 235   gfx::Rect arbitrary_rect2_inside_rect1(-5, 11, 1, 2);
 236   gfx::Rect arbitrary_rect2(40, 23, 11, 7);
 237   gfx::Rect arbitrary_rect1_inside_rect2(44, 23, 4, 2);
 238   gfx::Rect arbitrary_rect2_inside_rect2(41, 25, 3, 5);
 239   gfx::Rect arbitrary_rect3(7, -53, 22, 19);
 240   gfx::Rect arbitrary_rect1_inside_rect3(10, -40, 6, 3);
 241   gfx::Rect arbitrary_rect2_inside_rect3(12, -51, 5, 12);
 242   gfx::Size arbitrary_size1(15, 19);
 243   gfx::Size arbitrary_size2(3, 99);
 244   gfx::Size arbitrary_size3(75, 1281);
 245   gfx::RectF arbitrary_rectf1(4.2f, -922.1f, 15.6f, 29.5f);
 246   gfx::SizeF arbitrary_sizef1(15.2f, 104.6f);
 247   gfx::PointF arbitrary_pointf1(31.4f, 15.9f);
 248   gfx::PointF arbitrary_pointf2(26.5f, -35.8f);
 249   gfx::Vector2dF arbitrary_vector2df1(16.2f, -85.1f);
 250   gfx::Vector2dF arbitrary_vector2df2(-8.3f, 0.47f);
 251   float arbitrary_float1 = 0.7f;
 252   float arbitrary_float2 = 0.3f;
 253   float arbitrary_float3 = 0.9f;
 254   float arbitrary_float_array[4] = {3.5f, 6.2f, 9.3f, 12.3f};
 255   bool arbitrary_bool1 = true;
 256   bool arbitrary_bool2 = false;
 257   bool arbitrary_bool3 = true;
 258   bool arbitrary_bool4 = true;
 259   int arbitrary_context_id1 = 12;
 260   int arbitrary_context_id2 = 57;
 261   int arbitrary_context_id3 = -503;
 262   int arbitrary_int = 5;
 263   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
 264   SkXfermode::Mode arbitrary_blend_mode1 = SkXfermode::kScreen_Mode;
 265   SkXfermode::Mode arbitrary_blend_mode2 = SkXfermode::kLighten_Mode;
 266   SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
 267   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
 268       IOSurfaceDrawQuad::UNFLIPPED;
 269   RenderPassId arbitrary_id(10, 14);
 270   ResourceProvider::ResourceId arbitrary_resourceid1 = 55;
 271   ResourceProvider::ResourceId arbitrary_resourceid2 = 47;
 272   ResourceProvider::ResourceId arbitrary_resourceid3 = 23;
 273   ResourceProvider::ResourceId arbitrary_resourceid4 = 16;
 274   SkScalar arbitrary_sigma = SkFloatToScalar(2.0f);
 275   YUVVideoDrawQuad::ColorSpace arbitrary_color_space =
 276       YUVVideoDrawQuad::REC_601;
 277
 278   FilterOperations arbitrary_filters1;
 279   arbitrary_filters1.Append(FilterOperation::CreateGrayscaleFilter(
 280       arbitrary_float1));
 281   skia::RefPtr<SkImageFilter> arbitrary_filter = skia::AdoptRef(
 282       SkBlurImageFilter::Create(arbitrary_sigma, arbitrary_sigma));
 283   arbitrary_filters1.Append(
 284       cc::FilterOperation::CreateReferenceFilter(arbitrary_filter));
 285
 286   FilterOperations arbitrary_filters2;
 287   arbitrary_filters2.Append(FilterOperation::CreateBrightnessFilter(
 288       arbitrary_float2));
 289
 290   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
 291   pass_in->SetAll(arbitrary_id,
 292                   arbitrary_rect1,
 293                   arbitrary_rect2,
 294                   arbitrary_matrix,
 295                   arbitrary_bool1);
 296
 297   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
 298   shared_state1_in->SetAll(arbitrary_matrix,
 299                            arbitrary_size1,
 300                            arbitrary_rect1,
 301                            arbitrary_rect2,
 302                            arbitrary_bool1,
 303                            arbitrary_float1,
 304                            arbitrary_blend_mode1,
 305                            arbitrary_context_id1);
 306
 307   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
 308   pass_cmp->SetAll(arbitrary_id,
 309                    arbitrary_rect1,
 310                    arbitrary_rect2,
 311                    arbitrary_matrix,
 312                    arbitrary_bool1);
 313
 314   SharedQuadState* shared_state1_cmp =
 315       pass_cmp->CreateAndAppendSharedQuadState();
 316   shared_state1_cmp->CopyFrom(shared_state1_in);
 317
 318   CheckerboardDrawQuad* checkerboard_in =
 319       pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
 320   checkerboard_in->SetAll(shared_state1_in, arbitrary_rect1,
 321                           arbitrary_rect2_inside_rect1,
 322                           arbitrary_rect1_inside_rect1, arbitrary_bool1,
 323                           arbitrary_color, arbitrary_float1);
 324   pass_cmp->CopyFromAndAppendDrawQuad(checkerboard_in,
 325                                       checkerboard_in->shared_quad_state);
 326
 327   DebugBorderDrawQuad* debugborder_in =
 328       pass_in->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
 329   debugborder_in->SetAll(shared_state1_in,
 330                          arbitrary_rect3,
 331                          arbitrary_rect1_inside_rect3,
 332                          arbitrary_rect2_inside_rect3,
 333                          arbitrary_bool1,
 334                          arbitrary_color,
 335                          arbitrary_int);
 336   pass_cmp->CopyFromAndAppendDrawQuad(debugborder_in,
 337                                       debugborder_in->shared_quad_state);
 338
 339   IOSurfaceDrawQuad* iosurface_in =
 340       pass_in->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
 341   iosurface_in->SetAll(shared_state1_in,
 342                        arbitrary_rect2,
 343                        arbitrary_rect2_inside_rect2,
 344                        arbitrary_rect1_inside_rect2,
 345                        arbitrary_bool1,
 346                        arbitrary_size1,
 347                        arbitrary_resourceid3,
 348                        arbitrary_orientation);
 349   pass_cmp->CopyFromAndAppendDrawQuad(iosurface_in,
 350                                       iosurface_in->shared_quad_state);
 351
 352   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
 353   shared_state2_in->SetAll(arbitrary_matrix,
 354                            arbitrary_size2,
 355                            arbitrary_rect2,
 356                            arbitrary_rect3,
 357                            arbitrary_bool1,
 358                            arbitrary_float2,
 359                            arbitrary_blend_mode2,
 360                            arbitrary_context_id2);
 361   SharedQuadState* shared_state2_cmp =
 362       pass_cmp->CreateAndAppendSharedQuadState();
 363   shared_state2_cmp->CopyFrom(shared_state2_in);
 364
 365   RenderPassDrawQuad* renderpass_in =
 366       pass_in->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
 367   renderpass_in->SetAll(shared_state2_in,
 368                         arbitrary_rect1,
 369                         arbitrary_rect2_inside_rect1,
 370                         arbitrary_rect1_inside_rect1,
 371                         arbitrary_bool1,
 372                         arbitrary_id,
 373                         arbitrary_resourceid2,
 374                         arbitrary_vector2df1,
 375                         arbitrary_size1,
 376                         arbitrary_filters1,
 377                         arbitrary_vector2df2,
 378                         arbitrary_filters2);
 379   pass_cmp->CopyFromAndAppendRenderPassDrawQuad(
 380       renderpass_in,
 381       renderpass_in->shared_quad_state,
 382       renderpass_in->render_pass_id);
 383
 384   SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState();
 385   shared_state3_in->SetAll(arbitrary_matrix,
 386                            arbitrary_size3,
 387                            arbitrary_rect3,
 388                            arbitrary_rect1,
 389                            arbitrary_bool1,
 390                            arbitrary_float3,
 391                            arbitrary_blend_mode3,
 392                            arbitrary_context_id3);
 393   SharedQuadState* shared_state3_cmp =
 394       pass_cmp->CreateAndAppendSharedQuadState();
 395   shared_state3_cmp->CopyFrom(shared_state3_in);
 396
 397   SolidColorDrawQuad* solidcolor_in =
 398       pass_in->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 399   solidcolor_in->SetAll(shared_state3_in,
 400                         arbitrary_rect3,
 401                         arbitrary_rect1_inside_rect3,
 402                         arbitrary_rect2_inside_rect3,
 403                         arbitrary_bool1,
 404                         arbitrary_color,
 405                         arbitrary_bool2);
 406   pass_cmp->CopyFromAndAppendDrawQuad(solidcolor_in,
 407                                       solidcolor_in->shared_quad_state);
 408
 409   StreamVideoDrawQuad* streamvideo_in =
 410       pass_in->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
 411   streamvideo_in->SetAll(shared_state3_in,
 412                          arbitrary_rect2,
 413                          arbitrary_rect2_inside_rect2,
 414                          arbitrary_rect1_inside_rect2,
 415                          arbitrary_bool1,
 416                          arbitrary_resourceid2,
 417                          arbitrary_matrix);
 418   pass_cmp->CopyFromAndAppendDrawQuad(streamvideo_in,
 419                                       streamvideo_in->shared_quad_state);
 420
 421   cc::SurfaceId arbitrary_surface_id(3);
 422   SurfaceDrawQuad* surface_in =
 423       pass_in->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
 424   surface_in->SetAll(shared_state3_in,
 425                      arbitrary_rect2,
 426                      arbitrary_rect2_inside_rect2,
 427                      arbitrary_rect1_inside_rect2,
 428                      arbitrary_bool1,
 429                      arbitrary_surface_id);
 430   pass_cmp->CopyFromAndAppendDrawQuad(surface_in,
 431                                       surface_in->shared_quad_state);
 432
 433   TextureDrawQuad* texture_in =
 434       pass_in->CreateAndAppendDrawQuad<TextureDrawQuad>();
 435   texture_in->SetAll(shared_state3_in,
 436                      arbitrary_rect2,
 437                      arbitrary_rect2_inside_rect2,
 438                      arbitrary_rect1_inside_rect2,
 439                      arbitrary_bool1,
 440                      arbitrary_resourceid1,
 441                      arbitrary_bool2,
 442                      arbitrary_pointf1,
 443                      arbitrary_pointf2,
 444                      arbitrary_color,
 445                      arbitrary_float_array,
 446                      arbitrary_bool3,
 447                      arbitrary_bool4);
 448   pass_cmp->CopyFromAndAppendDrawQuad(texture_in,
 449                                       texture_in->shared_quad_state);
 450
 451   TileDrawQuad* tile_in = pass_in->CreateAndAppendDrawQuad<TileDrawQuad>();
 452   tile_in->SetAll(shared_state3_in,
 453                   arbitrary_rect2,
 454                   arbitrary_rect2_inside_rect2,
 455                   arbitrary_rect1_inside_rect2,
 456                   arbitrary_bool1,
 457                   arbitrary_resourceid3,
 458                   arbitrary_rectf1,
 459                   arbitrary_size1,
 460                   arbitrary_bool2,
 461                   arbitrary_bool3);
 462   pass_cmp->CopyFromAndAppendDrawQuad(tile_in, tile_in->shared_quad_state);
 463
 464   YUVVideoDrawQuad* yuvvideo_in =
 465       pass_in->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
 466   yuvvideo_in->SetAll(shared_state3_in,
 467                       arbitrary_rect1,
 468                       arbitrary_rect2_inside_rect1,
 469                       arbitrary_rect1_inside_rect1,
 470                       arbitrary_bool1,
 471                       arbitrary_rectf1,
 472                       arbitrary_size1,
 473                       arbitrary_size2,
 474                       arbitrary_resourceid1,
 475                       arbitrary_resourceid2,
 476                       arbitrary_resourceid3,
 477                       arbitrary_resourceid4,
 478                       arbitrary_color_space);
 479   pass_cmp->CopyFromAndAppendDrawQuad(yuvvideo_in,
 480                                       yuvvideo_in->shared_quad_state);
 481
 482   // Make sure the in and cmp RenderPasses match.
 483   Compare(pass_cmp.get(), pass_in.get());
 484   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
 485   ASSERT_EQ(10u, pass_in->quad_list.size());
 486   for (cc::SharedQuadStateList::ConstIterator
 487            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
 488            in_iterator = pass_in->shared_quad_state_list.begin();
 489        in_iterator != pass_in->shared_quad_state_list.end();
 490        ++cmp_iterator, ++in_iterator) {
 491     Compare(*cmp_iterator, *in_iterator);
 492   }
 493   for (auto in_iter = pass_in->quad_list.cbegin(),
 494             cmp_iter = pass_cmp->quad_list.cbegin();
 495        in_iter != pass_in->quad_list.cend();
 496        ++in_iter, ++cmp_iter)
 497     Compare(*cmp_iter, *in_iter);
 498
 499   for (size_t i = 1; i < pass_in->quad_list.size(); ++i) {
 500     bool same_shared_quad_state_cmp =
 501         pass_cmp->quad_list.ElementAt(i)->shared_quad_state ==
 502         pass_cmp->quad_list.ElementAt(i - 1)->shared_quad_state;
 503     bool same_shared_quad_state_in =
 504         pass_in->quad_list.ElementAt(i)->shared_quad_state ==
 505         pass_in->quad_list.ElementAt(i - 1)->shared_quad_state;
 506     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
 507   }
 508
 509   DelegatedFrameData frame_in;
 510   frame_in.render_pass_list.push_back(pass_in.Pass());
 511
 512   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 513
 514   DelegatedFrameData frame_out;
 515   PickleIterator iter(msg);
 516   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
 517       &iter, &frame_out));
 518
 519   // Make sure the out and cmp RenderPasses match.
 520   scoped_ptr<RenderPass> pass_out = frame_out.render_pass_list.take(
 521       frame_out.render_pass_list.begin());
 522   Compare(pass_cmp.get(), pass_out.get());
 523   ASSERT_EQ(3u, pass_out->shared_quad_state_list.size());
 524   ASSERT_EQ(10u, pass_out->quad_list.size());
 525   for (cc::SharedQuadStateList::ConstIterator
 526            cmp_iterator = pass_cmp->shared_quad_state_list.begin(),
 527            out_iterator = pass_out->shared_quad_state_list.begin();
 528        out_iterator != pass_out->shared_quad_state_list.end();
 529        ++cmp_iterator, ++out_iterator) {
 530     Compare(*cmp_iterator, *out_iterator);
 531   }
 532   for (auto out_iter = pass_out->quad_list.cbegin(),
 533             cmp_iter = pass_cmp->quad_list.cbegin();
 534        out_iter != pass_out->quad_list.cend();
 535        ++out_iter, ++cmp_iter)
 536     Compare(*cmp_iter, *out_iter);
 537
 538   for (size_t i = 1; i < pass_out->quad_list.size(); ++i) {
 539     bool same_shared_quad_state_cmp =
 540         pass_cmp->quad_list.ElementAt(i)->shared_quad_state ==
 541         pass_cmp->quad_list.ElementAt(i - 1)->shared_quad_state;
 542     bool same_shared_quad_state_out =
 543         pass_out->quad_list.ElementAt(i)->shared_quad_state ==
 544         pass_out->quad_list.ElementAt(i - 1)->shared_quad_state;
 545     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
 546   }
 547 }
 548
 549 TEST_F(CCMessagesTest, UnusedSharedQuadStates) {
 550   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
 551   pass_in->SetAll(RenderPassId(1, 1),
 552                   gfx::Rect(100, 100),
 553                   gfx::Rect(),
 554                   gfx::Transform(),
 555                   false);
 556
 557   // The first SharedQuadState is used.
 558   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
 559   shared_state1_in->SetAll(gfx::Transform(),
 560                            gfx::Size(1, 1),
 561                            gfx::Rect(),
 562                            gfx::Rect(),
 563                            false,
 564                            1.f,
 565                            SkXfermode::kSrcOver_Mode,
 566                            0);
 567
 568   CheckerboardDrawQuad* quad1 =
 569       pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
 570   quad1->SetAll(shared_state1_in, gfx::Rect(10, 10), gfx::Rect(10, 10),
 571                 gfx::Rect(10, 10), false, SK_ColorRED, 1.f);
 572
 573   // The second and third SharedQuadStates are not used.
 574   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
 575   shared_state2_in->SetAll(gfx::Transform(),
 576                            gfx::Size(2, 2),
 577                            gfx::Rect(),
 578                            gfx::Rect(),
 579                            false,
 580                            1.f,
 581                            SkXfermode::kSrcOver_Mode,
 582                            0);
 583
 584   SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState();
 585   shared_state3_in->SetAll(gfx::Transform(),
 586                            gfx::Size(3, 3),
 587                            gfx::Rect(),
 588                            gfx::Rect(),
 589                            false,
 590                            1.f,
 591                            SkXfermode::kSrcOver_Mode,
 592                            0);
 593
 594   // The fourth SharedQuadState is used.
 595   SharedQuadState* shared_state4_in = pass_in->CreateAndAppendSharedQuadState();
 596   shared_state4_in->SetAll(gfx::Transform(),
 597                            gfx::Size(4, 4),
 598                            gfx::Rect(),
 599                            gfx::Rect(),
 600                            false,
 601                            1.f,
 602                            SkXfermode::kSrcOver_Mode,
 603                            0);
 604
 605   CheckerboardDrawQuad* quad2 =
 606       pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
 607   quad2->SetAll(shared_state4_in, gfx::Rect(10, 10), gfx::Rect(10, 10),
 608                 gfx::Rect(10, 10), false, SK_ColorRED, 1.f);
 609
 610   // The fifth is not used again.
 611   SharedQuadState* shared_state5_in = pass_in->CreateAndAppendSharedQuadState();
 612   shared_state5_in->SetAll(gfx::Transform(),
 613                            gfx::Size(5, 5),
 614                            gfx::Rect(),
 615                            gfx::Rect(),
 616                            false,
 617                            1.f,
 618                            SkXfermode::kSrcOver_Mode,
 619                            0);
 620
 621   // 5 SharedQuadStates go in.
 622   ASSERT_EQ(5u, pass_in->shared_quad_state_list.size());
 623   ASSERT_EQ(2u, pass_in->quad_list.size());
 624
 625   DelegatedFrameData frame_in;
 626   frame_in.render_pass_list.push_back(pass_in.Pass());
 627
 628   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 629   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 630
 631   DelegatedFrameData frame_out;
 632   PickleIterator iter(msg);
 633   EXPECT_TRUE(
 634       IPC::ParamTraits<DelegatedFrameData>::Read(&msg, &iter, &frame_out));
 635
 636   scoped_ptr<RenderPass> pass_out =
 637       frame_out.render_pass_list.take(frame_out.render_pass_list.begin());
 638
 639   // 2 SharedQuadStates come out. The first and fourth SharedQuadStates were
 640   // used by quads, and so serialized. Others were not.
 641   ASSERT_EQ(2u, pass_out->shared_quad_state_list.size());
 642   ASSERT_EQ(2u, pass_out->quad_list.size());
 643
 644   EXPECT_EQ(
 645       gfx::Size(1, 1).ToString(),
 646       pass_out->shared_quad_state_list.ElementAt(0)->content_bounds.ToString());
 647   EXPECT_EQ(
 648       gfx::Size(4, 4).ToString(),
 649       pass_out->shared_quad_state_list.ElementAt(1)->content_bounds.ToString());
 650 }
 651
 652 TEST_F(CCMessagesTest, Resources) {
 653   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 654   gfx::Size arbitrary_size(757, 1281);
 655   unsigned int arbitrary_uint1 = 71234838;
 656   unsigned int arbitrary_uint2 = 53589793;
 657
 658   GLbyte arbitrary_mailbox1[GL_MAILBOX_SIZE_CHROMIUM] = {
 659       1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2,
 660       3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4,
 661       5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4};
 662
 663   GLbyte arbitrary_mailbox2[GL_MAILBOX_SIZE_CHROMIUM] = {
 664       0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0, 0, 9,
 665       8, 7, 6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0, 0, 9, 8, 7,
 666       6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0, 0, 9, 8, 7};
 667
 668   TransferableResource arbitrary_resource1;
 669   arbitrary_resource1.id = 2178312;
 670   arbitrary_resource1.format = cc::RGBA_8888;
 671   arbitrary_resource1.filter = 53;
 672   arbitrary_resource1.size = gfx::Size(37189, 123123);
 673   arbitrary_resource1.mailbox_holder.mailbox.SetName(arbitrary_mailbox1);
 674   arbitrary_resource1.mailbox_holder.texture_target = GL_TEXTURE_2D;
 675   arbitrary_resource1.mailbox_holder.sync_point = arbitrary_uint1;
 676   arbitrary_resource1.allow_overlay = true;
 677
 678   TransferableResource arbitrary_resource2;
 679   arbitrary_resource2.id = 789132;
 680   arbitrary_resource2.format = cc::RGBA_4444;
 681   arbitrary_resource2.filter = 47;
 682   arbitrary_resource2.size = gfx::Size(89123, 23789);
 683   arbitrary_resource2.mailbox_holder.mailbox.SetName(arbitrary_mailbox2);
 684   arbitrary_resource2.mailbox_holder.texture_target = GL_TEXTURE_EXTERNAL_OES;
 685   arbitrary_resource2.mailbox_holder.sync_point = arbitrary_uint2;
 686   arbitrary_resource2.allow_overlay = false;
 687
 688   scoped_ptr<RenderPass> renderpass_in = RenderPass::Create();
 689   renderpass_in->SetNew(
 690       RenderPassId(1, 1), gfx::Rect(), gfx::Rect(), gfx::Transform());
 691
 692   DelegatedFrameData frame_in;
 693   frame_in.resource_list.push_back(arbitrary_resource1);
 694   frame_in.resource_list.push_back(arbitrary_resource2);
 695   frame_in.render_pass_list.push_back(renderpass_in.Pass());
 696
 697   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 698
 699   DelegatedFrameData frame_out;
 700   PickleIterator iter(msg);
 701   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
 702       &iter, &frame_out));
 703
 704   ASSERT_EQ(2u, frame_out.resource_list.size());
 705   Compare(arbitrary_resource1, frame_out.resource_list[0]);
 706   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 707 }
 708
 709 TEST_F(CCMessagesTest, SoftwareFrameData) {
 710   cc::SoftwareFrameData frame_in;
 711   frame_in.id = 3;
 712   frame_in.size = gfx::Size(40, 20);
 713   frame_in.damage_rect = gfx::Rect(5, 18, 31, 44);
 714   frame_in.bitmap_id = cc::SharedBitmap::GenerateId();
 715
 716   // Write the frame.
 717   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 718   IPC::ParamTraits<cc::SoftwareFrameData>::Write(&msg, frame_in);
 719
 720   // Read the frame.
 721   cc::SoftwareFrameData frame_out;
 722   PickleIterator iter(msg);
 723   EXPECT_TRUE(
 724       IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
 725   EXPECT_EQ(frame_in.id, frame_out.id);
 726   EXPECT_EQ(frame_in.size.ToString(), frame_out.size.ToString());
 727   EXPECT_EQ(frame_in.damage_rect.ToString(), frame_out.damage_rect.ToString());
 728   EXPECT_EQ(frame_in.bitmap_id, frame_out.bitmap_id);
 729 }
 730
 731 TEST_F(CCMessagesTest, SoftwareFrameDataMaxInt) {
 732   SoftwareFrameData frame_in;
 733   frame_in.id = 3;
 734   frame_in.size = gfx::Size(40, 20);
 735   frame_in.damage_rect = gfx::Rect(5, 18, 31, 44);
 736   frame_in.bitmap_id = cc::SharedBitmap::GenerateId();
 737
 738   // Write the SoftwareFrameData by hand, make sure it works.
 739   {
 740     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 741     IPC::WriteParam(&msg, frame_in.id);
 742     IPC::WriteParam(&msg, frame_in.size);
 743     IPC::WriteParam(&msg, frame_in.damage_rect);
 744     IPC::WriteParam(&msg, frame_in.bitmap_id);
 745     SoftwareFrameData frame_out;
 746     PickleIterator iter(msg);
 747     EXPECT_TRUE(
 748         IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
 749   }
 750
 751   // The size of the frame may overflow when multiplied together.
 752   int max = std::numeric_limits<int>::max();
 753   frame_in.size = gfx::Size(max, max);
 754
 755   // If size_t is larger than int, then int*int*4 can always fit in size_t.
 756   bool expect_read = sizeof(size_t) >= sizeof(int) * 2;
 757
 758   // Write the SoftwareFrameData with the MaxInt size, if it causes overflow it
 759   // should fail.
 760   {
 761     IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 762     IPC::WriteParam(&msg, frame_in.id);
 763     IPC::WriteParam(&msg, frame_in.size);
 764     IPC::WriteParam(&msg, frame_in.damage_rect);
 765     IPC::WriteParam(&msg, frame_in.bitmap_id);
 766     SoftwareFrameData frame_out;
 767     PickleIterator iter(msg);
 768     EXPECT_EQ(
 769         expect_read,
 770         IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
 771   }
 772 }
 773
 774 }  // namespace
 775 }  // namespace content