src/content/common/cc_messages_unittest.cc

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