Move filters to RenderPassDrawQuad

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 25 matching lines @@
 class CCMessagesTest : public testing::Test {
  protected:
   void Compare(const RenderPass* a, const RenderPass* b) {
     EXPECT_EQ(a->id, b->id);
     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);
-    EXPECT_EQ(a->filters, b->filters);
-    EXPECT_EQ(a->filter, b->filter);
-    EXPECT_EQ(a->background_filters, b->background_filters);
   }
 
   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);
     EXPECT_EQ(a->clipped_rect_in_target, b->clipped_rect_in_target);
     EXPECT_EQ(a->clip_rect, b->clip_rect);
     EXPECT_EQ(a->is_clipped, b->is_clipped);
     EXPECT_EQ(a->opacity, b->opacity);
   }
@@ skipping 64 matching lines @@
     EXPECT_EQ(a->io_surface_texture_id, b->io_surface_texture_id);
     EXPECT_EQ(a->orientation, b->orientation);
   }
 
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
     EXPECT_EQ(a->is_replica, b->is_replica);
     EXPECT_EQ(a->mask_resource_id, b->mask_resource_id);
     EXPECT_EQ(a->contents_changed_since_last_frame,
               b->contents_changed_since_last_frame);
     EXPECT_EQ(a->mask_uv_rect.ToString(), b->mask_uv_rect.ToString());
+    EXPECT_EQ(a->filters, b->filters);
+    EXPECT_EQ(a->filter, b->filter);
+    EXPECT_EQ(a->background_filters, b->background_filters);
   }
 
   void Compare(const SolidColorDrawQuad* a, const SolidColorDrawQuad* b) {
     EXPECT_EQ(a->color, b->color);
   }
 
   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
     EXPECT_EQ(a->texture_id, b->texture_id);
     EXPECT_EQ(a->matrix, b->matrix);
   }
@@ skipping 140 matching lines @@
       RenderPassDrawQuad::Create();
   renderpass_in->SetAll(shared_state1_in.get(),
                         arbitrary_rect1,
                         arbitrary_rect2,
                         arbitrary_rect3,
                         arbitrary_bool1,
                         arbitrary_id,
                         arbitrary_bool2,
                         arbitrary_resourceid,
                         arbitrary_rect1,
-                        arbitrary_rectf1);
+                        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_rect2,
                            arbitrary_rect3,
                            arbitrary_rect1,
                            arbitrary_bool1,
                            arbitrary_float2);
@@ skipping 44 matching lines @@
                       arbitrary_plane3);
   scoped_ptr<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy(
       yuvvideo_in->shared_quad_state);
 
   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(arbitrary_id,
                   arbitrary_rect1,
                   arbitrary_rectf1,
                   arbitrary_matrix,
                   arbitrary_bool1,
-                  arbitrary_bool2,
-                  arbitrary_filters1,
-                  arbitrary_filter, // TODO(danakj): filter is not serialized.
-                  arbitrary_filters2);
+                  arbitrary_bool2);
 
   pass_in->shared_quad_state_list.append(shared_state1_in.Pass());
   pass_in->quad_list.append(checkerboard_in.PassAs<DrawQuad>());
   pass_in->quad_list.append(debugborder_in.PassAs<DrawQuad>());
   pass_in->quad_list.append(iosurface_in.PassAs<DrawQuad>());
   pass_in->quad_list.append(renderpass_in.PassAs<DrawQuad>());
   pass_in->shared_quad_state_list.append(shared_state2_in.Pass());
   pass_in->shared_quad_state_list.append(shared_state3_in.Pass());
   pass_in->quad_list.append(solidcolor_in.PassAs<DrawQuad>());
   pass_in->quad_list.append(streamvideo_in.PassAs<DrawQuad>());
   pass_in->quad_list.append(yuvvideo_in.PassAs<DrawQuad>());
 
   scoped_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(arbitrary_id,
                    arbitrary_rect1,
                    arbitrary_rectf1,
                    arbitrary_matrix,
                    arbitrary_bool1,
-                   arbitrary_bool2,
-                   arbitrary_filters1,
-                   arbitrary_filter, // TODO(danakj): filter is not serialized.
-                   arbitrary_filters2);
+                   arbitrary_bool2);
 
   pass_cmp->shared_quad_state_list.append(shared_state1_cmp.Pass());
   pass_cmp->quad_list.append(checkerboard_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.append(debugborder_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.append(iosurface_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.append(renderpass_cmp.PassAs<DrawQuad>());
   pass_cmp->shared_quad_state_list.append(shared_state2_cmp.Pass());
   pass_cmp->shared_quad_state_list.append(shared_state3_cmp.Pass());
   pass_cmp->quad_list.append(solidcolor_cmp.PassAs<DrawQuad>());
   pass_cmp->quad_list.append(streamvideo_cmp.PassAs<DrawQuad>());
@@ skipping 102 matching lines @@
   EXPECT_EQ(arbitrary_size.ToString(), frame_out.size.ToString());
   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