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