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