cc: Remove redundant is_overlay arguments

content/common/cc_messages_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/cc_messages.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 113 matching lines @@
 
   void Compare(const DebugBorderDrawQuad* a, const DebugBorderDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
     EXPECT_EQ(a->width, b->width);
   }
 
   void Compare(const IOSurfaceDrawQuad* a, const IOSurfaceDrawQuad* b) {
     EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
     EXPECT_EQ(a->io_surface_resource_id(), b->io_surface_resource_id());
     EXPECT_EQ(a->orientation, b->orientation);
-    EXPECT_EQ(a->allow_overlay, b->allow_overlay);
   }
 
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
     EXPECT_EQ(a->render_pass_id, b->render_pass_id);
     EXPECT_EQ(a->mask_resource_id(), b->mask_resource_id());
     EXPECT_EQ(a->mask_uv_scale.ToString(), b->mask_uv_scale.ToString());
     EXPECT_EQ(a->mask_texture_size.ToString(), b->mask_texture_size.ToString());
     EXPECT_EQ(a->filters.size(), b->filters.size());
     for (size_t i = 0; i < a->filters.size(); ++i) {
       if (a->filters.at(i).type() != cc::FilterOperation::REFERENCE) {
         EXPECT_EQ(a->filters.at(i), b->filters.at(i));
       } else {
         EXPECT_EQ(b->filters.at(i).type(), cc::FilterOperation::REFERENCE);
         EXPECT_EQ(a->filters.at(i).image_filter()->countInputs(),
                   b->filters.at(i).image_filter()->countInputs());
       }
     }
     EXPECT_EQ(a->filters_scale, b->filters_scale);
     EXPECT_EQ(a->background_filters, b->background_filters);
   }
 
   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
     EXPECT_EQ(a->force_anti_aliasing_off, b->force_anti_aliasing_off);
   }
 
   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
     EXPECT_EQ(a->resource_id(), b->resource_id());
     EXPECT_EQ(a->resource_size_in_pixels(), b->resource_size_in_pixels());
-    EXPECT_EQ(a->allow_overlay(), b->allow_overlay());
     EXPECT_EQ(a->matrix, b->matrix);
   }
 
   void Compare(const SurfaceDrawQuad* a, const SurfaceDrawQuad* b) {
     EXPECT_EQ(a->surface_id, b->surface_id);
   }
 
   void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) {
     EXPECT_EQ(a->resource_id(), b->resource_id());
     EXPECT_EQ(a->resource_size_in_pixels(), b->resource_size_in_pixels());
-    EXPECT_EQ(a->allow_overlay(), b->allow_overlay());
     EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha);
     EXPECT_EQ(a->uv_top_left, b->uv_top_left);
     EXPECT_EQ(a->uv_bottom_right, b->uv_bottom_right);
     EXPECT_EQ(a->background_color, b->background_color);
     EXPECT_EQ(a->vertex_opacity[0], b->vertex_opacity[0]);
     EXPECT_EQ(a->vertex_opacity[1], b->vertex_opacity[1]);
     EXPECT_EQ(a->vertex_opacity[2], b->vertex_opacity[2]);
     EXPECT_EQ(a->vertex_opacity[3], b->vertex_opacity[3]);
     EXPECT_EQ(a->y_flipped, b->y_flipped);
     EXPECT_EQ(a->nearest_neighbor, b->nearest_neighbor);
@@ skipping 23 matching lines @@
     EXPECT_EQ(a.id, b.id);
     EXPECT_EQ(a.format, b.format);
     EXPECT_EQ(a.filter, b.filter);
     EXPECT_EQ(a.size.ToString(), b.size.ToString());
     for (size_t i = 0; i < arraysize(a.mailbox_holder.mailbox.name); ++i) {
       EXPECT_EQ(a.mailbox_holder.mailbox.name[i],
                 b.mailbox_holder.mailbox.name[i]);
     }
     EXPECT_EQ(a.mailbox_holder.texture_target, b.mailbox_holder.texture_target);
     EXPECT_EQ(a.mailbox_holder.sync_point, b.mailbox_holder.sync_point);
-    EXPECT_EQ(a.allow_overlay, b.allow_overlay);
+    EXPECT_EQ(a.is_overlay_candidate, b.is_overlay_candidate);
   }
 };
 
 TEST_F(CCMessagesTest, AllQuads) {
   IPC::Message msg(1, 2, IPC::Message::PRIORITY_NORMAL);
 
   Transform arbitrary_matrix1;
   arbitrary_matrix1.Scale(3, 3);
   arbitrary_matrix1.Translate(-5, 20);
   arbitrary_matrix1.Rotate(15);
@@ skipping 32 matching lines @@
   int arbitrary_context_id1 = 12;
   int arbitrary_context_id2 = 57;
   int arbitrary_context_id3 = -503;
   int arbitrary_int = 5;
   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
   SkXfermode::Mode arbitrary_blend_mode1 = SkXfermode::kScreen_Mode;
   SkXfermode::Mode arbitrary_blend_mode2 = SkXfermode::kLighten_Mode;
   SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
-  bool arbitrary_allow_overlay = true;
   ResourceId arbitrary_resourceid1 = 55;
   ResourceId arbitrary_resourceid2 = 47;
   ResourceId arbitrary_resourceid3 = 23;
   ResourceId arbitrary_resourceid4 = 16;
   SkScalar arbitrary_sigma = SkFloatToScalar(2.0f);
   YUVVideoDrawQuad::ColorSpace arbitrary_color_space =
       YUVVideoDrawQuad::REC_601;
 
   RenderPassId child_id(30, 5);
   RenderPassId root_id(10, 14);
@@ skipping 49 matching lines @@
 
   IOSurfaceDrawQuad* iosurface_in =
       pass_in->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   iosurface_in->SetAll(shared_state1_in,
                        arbitrary_rect2,
                        arbitrary_rect2_inside_rect2,
                        arbitrary_rect1_inside_rect2,
                        arbitrary_bool1,
                        arbitrary_size1,
                        arbitrary_resourceid3,
-                       arbitrary_orientation,
-                       arbitrary_allow_overlay);
+                       arbitrary_orientation);
   pass_cmp->CopyFromAndAppendDrawQuad(iosurface_in,
                                       iosurface_in->shared_quad_state);
 
   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state2_in->SetAll(arbitrary_matrix2, arbitrary_size2, arbitrary_rect2,
                            arbitrary_rect3, arbitrary_bool1, arbitrary_float2,
                            arbitrary_blend_mode2, arbitrary_context_id2);
   SharedQuadState* shared_state2_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   shared_state2_cmp->CopyFrom(shared_state2_in);
@@ skipping 28 matching lines @@
                         arbitrary_color,
                         arbitrary_bool2);
   pass_cmp->CopyFromAndAppendDrawQuad(solidcolor_in,
                                       solidcolor_in->shared_quad_state);
 
   StreamVideoDrawQuad* streamvideo_in =
       pass_in->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
   streamvideo_in->SetAll(
       shared_state3_in, arbitrary_rect2, arbitrary_rect2_inside_rect2,
       arbitrary_rect1_inside_rect2, arbitrary_bool1, arbitrary_resourceid2,
-      arbitrary_size1, arbitrary_bool2, arbitrary_matrix1);
+      arbitrary_size1, arbitrary_matrix1);
   pass_cmp->CopyFromAndAppendDrawQuad(streamvideo_in,
                                       streamvideo_in->shared_quad_state);
 
   cc::SurfaceId arbitrary_surface_id(3);
   SurfaceDrawQuad* surface_in =
       pass_in->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   surface_in->SetAll(shared_state3_in,
                      arbitrary_rect2,
                      arbitrary_rect2_inside_rect2,
                      arbitrary_rect1_inside_rect2,
                      arbitrary_bool1,
                      arbitrary_surface_id);
   pass_cmp->CopyFromAndAppendDrawQuad(surface_in,
                                       surface_in->shared_quad_state);
   pass_in->referenced_surfaces.push_back(arbitrary_surface_id);
   pass_cmp->referenced_surfaces.push_back(arbitrary_surface_id);
 
   TextureDrawQuad* texture_in =
       pass_in->CreateAndAppendDrawQuad<TextureDrawQuad>();
   texture_in->SetAll(shared_state3_in, arbitrary_rect2,
                      arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2,
                      arbitrary_bool1, arbitrary_resourceid1, arbitrary_size1,
-                     arbitrary_bool2, arbitrary_bool3, arbitrary_pointf1,
+                     arbitrary_bool2, arbitrary_pointf1,
                      arbitrary_pointf2, arbitrary_color, arbitrary_float_array,
                      arbitrary_bool4, arbitrary_bool5);
   pass_cmp->CopyFromAndAppendDrawQuad(texture_in,
                                       texture_in->shared_quad_state);
 
   TileDrawQuad* tile_in = pass_in->CreateAndAppendDrawQuad<TileDrawQuad>();
   tile_in->SetAll(shared_state3_in,
                   arbitrary_rect2,
                   arbitrary_rect2_inside_rect2,
                   arbitrary_rect1_inside_rect2,
@@ skipping 212 matching lines @@
       6, 5, 4, 3, 2, 1, 9, 7, 5, 3, 1, 2, 4, 6, 8, 0, 0, 9, 8, 7};
 
   TransferableResource arbitrary_resource1;
   arbitrary_resource1.id = 2178312;
   arbitrary_resource1.format = cc::RGBA_8888;
   arbitrary_resource1.filter = 53;
   arbitrary_resource1.size = gfx::Size(37189, 123123);
   arbitrary_resource1.mailbox_holder.mailbox.SetName(arbitrary_mailbox1);
   arbitrary_resource1.mailbox_holder.texture_target = GL_TEXTURE_2D;
   arbitrary_resource1.mailbox_holder.sync_point = arbitrary_uint1;
-  arbitrary_resource1.allow_overlay = true;
+  arbitrary_resource1.is_overlay_candidate = true;
 
   TransferableResource arbitrary_resource2;
   arbitrary_resource2.id = 789132;
   arbitrary_resource2.format = cc::RGBA_4444;
   arbitrary_resource2.filter = 47;
   arbitrary_resource2.size = gfx::Size(89123, 23789);
   arbitrary_resource2.mailbox_holder.mailbox.SetName(arbitrary_mailbox2);
   arbitrary_resource2.mailbox_holder.texture_target = GL_TEXTURE_EXTERNAL_OES;
   arbitrary_resource2.mailbox_holder.sync_point = arbitrary_uint2;
-  arbitrary_resource2.allow_overlay = false;
+  arbitrary_resource2.is_overlay_candidate = false;
 
   scoped_ptr<RenderPass> renderpass_in = RenderPass::Create();
   renderpass_in->SetNew(
       RenderPassId(1, 1), gfx::Rect(), gfx::Rect(), gfx::Transform());
 
   DelegatedFrameData frame_in;
   frame_in.resource_list.push_back(arbitrary_resource1);
   frame_in.resource_list.push_back(arbitrary_resource2);
   frame_in.render_pass_list.push_back(renderpass_in.Pass());
 
   IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 
   DelegatedFrameData frame_out;
   base::PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
       &iter, &frame_out));
 
   ASSERT_EQ(2u, frame_out.resource_list.size());
   Compare(arbitrary_resource1, frame_out.resource_list[0]);
   Compare(arbitrary_resource2, frame_out.resource_list[1]);
 }
 
 }  // namespace
 }  // namespace content