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