cc: Moving anti-aliasing decision to parent compositor.

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 "cc/compositor_frame.h"
 #include "ipc/ipc_message.h"
@@ skipping 29 matching lines @@
     EXPECT_EQ(a->output_rect.ToString(), b->output_rect.ToString());
     EXPECT_EQ(a->damage_rect.ToString(), b->damage_rect.ToString());
     EXPECT_EQ(a->transform_to_root_target, b->transform_to_root_target);
     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
     EXPECT_EQ(a->has_occlusion_from_outside_target_surface,
               b->has_occlusion_from_outside_target_surface);
   }
 
   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
     EXPECT_EQ(a->content_to_target_transform, b->content_to_target_transform);
     EXPECT_EQ(a->visible_content_rect, b->visible_content_rect);

[danakj, 2013/02/26 22:11:21]

Thanks! Can you also compare the content_bounds in a and b here?

[ernstm, 2013/02/26 22:28:26]

Done.

     EXPECT_EQ(a->clip_rect, b->clip_rect);
     EXPECT_EQ(a->is_clipped, b->is_clipped);
     EXPECT_EQ(a->opacity, b->opacity);
   }
 
   void Compare(const DrawQuad* a, const DrawQuad* b) {
     ASSERT_NE(DrawQuad::INVALID, a->material);
     ASSERT_EQ(a->material, b->material);
     EXPECT_EQ(a->rect.ToString(), b->rect.ToString());
     EXPECT_EQ(a->opaque_rect.ToString(), b->opaque_rect.ToString());
@@ skipping 89 matching lines @@
     EXPECT_EQ(a->vertex_opacity[2], b->vertex_opacity[2]);
     EXPECT_EQ(a->vertex_opacity[3], b->vertex_opacity[3]);
     EXPECT_EQ(a->flipped, b->flipped);
   }
 
   void Compare(const TileDrawQuad* a, const TileDrawQuad* b) {
     EXPECT_EQ(a->resource_id, b->resource_id);
     EXPECT_EQ(a->tex_coord_rect, b->tex_coord_rect);
     EXPECT_EQ(a->texture_size, b->texture_size);
     EXPECT_EQ(a->swizzle_contents, b->swizzle_contents);
-    EXPECT_EQ(a->left_edge_aa, b->left_edge_aa);
-    EXPECT_EQ(a->top_edge_aa, b->top_edge_aa);
-    EXPECT_EQ(a->right_edge_aa, b->right_edge_aa);
-    EXPECT_EQ(a->bottom_edge_aa, b->bottom_edge_aa);
   }
 
   void Compare(const YUVVideoDrawQuad* a, const YUVVideoDrawQuad* b) {
     EXPECT_EQ(a->tex_scale, b->tex_scale);
     EXPECT_EQ(a->y_plane.resourceId, b->y_plane.resourceId);
     EXPECT_EQ(a->y_plane.size.ToString(), b->y_plane.size.ToString());
     EXPECT_EQ(a->y_plane.format, b->y_plane.format);
     EXPECT_EQ(a->u_plane.resourceId, b->u_plane.resourceId);
     EXPECT_EQ(a->u_plane.size.ToString(), b->u_plane.size.ToString());
     EXPECT_EQ(a->u_plane.format, b->u_plane.format);
@@ skipping 28 matching lines @@
   gfx::SizeF arbitrary_sizef1(15.2f, 104.6f);
   gfx::PointF arbitrary_pointf1(31.4f, 15.9f);
   gfx::PointF arbitrary_pointf2(26.5f, -35.8f);
   float arbitrary_float1 = 0.7f;
   float arbitrary_float2 = 0.3f;
   float arbitrary_float3 = 0.9f;
   float arbitrary_float_array[4] = {3.5f, 6.2f, 9.3f, 12.3f};
   bool arbitrary_bool1 = true;
   bool arbitrary_bool2 = false;
   bool arbitrary_bool3 = true;
-  bool arbitrary_bool4 = true;
-  bool arbitrary_bool5 = false;
-  bool arbitrary_bool6 = true;
   int arbitrary_int = 5;
   SkColor arbitrary_color = SkColorSetARGB(25, 36, 47, 58);
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
   RenderPass::Id arbitrary_id(10, 14);
   ResourceProvider::ResourceId arbitrary_resourceid = 55;
 
   VideoLayerImpl::FramePlane arbitrary_plane1;
   arbitrary_plane1.resourceId = arbitrary_resourceid;
   arbitrary_plane1.size = arbitrary_size1;
@@ skipping 15 matching lines @@
 
   WebFilterOperations arbitrary_filters2;
   arbitrary_filters2.append(WebFilterOperation::createBrightnessFilter(
       arbitrary_float2));
 
   // TODO(danakj): filter is not serialized.
   skia::RefPtr<SkImageFilter> arbitrary_filter;
 
   scoped_ptr<SharedQuadState> shared_state1_in = SharedQuadState::Create();
   shared_state1_in->SetAll(arbitrary_matrix,
+                           arbitrary_size1,
                            arbitrary_rect1,
                            arbitrary_rect2,
                            arbitrary_bool1,
                            arbitrary_float1);
   scoped_ptr<SharedQuadState> shared_state1_cmp = shared_state1_in->Copy();
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_in =
       CheckerboardDrawQuad::Create();
   checkerboard_in->SetAll(shared_state1_in.get(),
                           arbitrary_rect1,
@@ skipping 42 matching lines @@
                         arbitrary_rect1,
                         arbitrary_rectf1,
                         arbitrary_filters1,
                         arbitrary_filter, // TODO(piman): not serialized.
                         arbitrary_filters2);
   scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
       renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
 
   scoped_ptr<SharedQuadState> shared_state2_in = SharedQuadState::Create();
   shared_state2_in->SetAll(arbitrary_matrix,
+                           arbitrary_size2,
                            arbitrary_rect2,
                            arbitrary_rect3,
                            arbitrary_bool1,
                            arbitrary_float2);
   scoped_ptr<SharedQuadState> shared_state2_cmp = shared_state2_in->Copy();
 
   scoped_ptr<SharedQuadState> shared_state3_in = SharedQuadState::Create();
   shared_state3_in->SetAll(arbitrary_matrix,
+                           arbitrary_size3,
                            arbitrary_rect3,
                            arbitrary_rect1,
                            arbitrary_bool1,
                            arbitrary_float3);
   scoped_ptr<SharedQuadState> shared_state3_cmp = shared_state3_in->Copy();
 
   scoped_ptr<SolidColorDrawQuad> solidcolor_in =
       SolidColorDrawQuad::Create();
   solidcolor_in->SetAll(shared_state1_in.get(),
                         arbitrary_rect3,
@@ skipping 33 matching lines @@
 
   scoped_ptr<TileDrawQuad> tile_in = TileDrawQuad::Create();
   tile_in->SetAll(shared_state1_in.get(),
                   arbitrary_rect2,
                   arbitrary_rect3,
                   arbitrary_rect1,
                   arbitrary_bool1,
                   arbitrary_resourceid,
                   arbitrary_rectf1,
                   arbitrary_size1,
-                  arbitrary_bool2,
-                  arbitrary_bool3,
-                  arbitrary_bool4,
-                  arbitrary_bool5,
-                  arbitrary_bool6);
+                  arbitrary_bool2);
   scoped_ptr<DrawQuad> tile_cmp = tile_in->Copy(
       tile_in->shared_quad_state);
 
   scoped_ptr<YUVVideoDrawQuad> yuvvideo_in =
       YUVVideoDrawQuad::Create();
   yuvvideo_in->SetAll(shared_state1_in.get(),
                       arbitrary_rect1,
                       arbitrary_rect2,
                       arbitrary_rect3,
                       arbitrary_bool1,
@@ skipping 144 matching lines @@
 
   EXPECT_EQ(arbitrary_uint, frame_out.resource_list.sync_point);
 
   EXPECT_EQ(2u, frame_out.resource_list.resources.size());
   Compare(arbitrary_resource1, frame_out.resource_list.resources[0]);
   Compare(arbitrary_resource2, frame_out.resource_list.resources[1]);
 }
 
 }  // namespace
 }  // namespace content