cc: Move filters from RenderPassDrawQuad to RenderPass

cc/ipc/cc_param_traits_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 <stddef.h>
 #include <string.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 36 matching lines @@
 
 static constexpr cc::FrameSinkId kArbitraryFrameSinkId(1, 1);
 
 class CCParamTraitsTest : 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->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->background_filters.size(), b->background_filters.size());
+    for (size_t i = 0; i < a->background_filters.size(); ++i) {
+      if (a->background_filters.at(i).type() !=
+          cc::FilterOperation::REFERENCE) {
+        EXPECT_EQ(a->background_filters.at(i), b->background_filters.at(i));
+      } else {
+        EXPECT_EQ(b->background_filters.at(i).type(),
+                  cc::FilterOperation::REFERENCE);
+        EXPECT_EQ(a->background_filters.at(i).image_filter()->countInputs(),
+                  b->background_filters.at(i).image_filter()->countInputs());
+      }
+    }
     EXPECT_EQ(a->has_transparent_background, b->has_transparent_background);
   }
 
   void Compare(const SharedQuadState* a, const SharedQuadState* b) {
     EXPECT_EQ(a->quad_to_target_transform, b->quad_to_target_transform);
     EXPECT_EQ(a->quad_layer_bounds, b->quad_layer_bounds);
     EXPECT_EQ(a->visible_quad_layer_rect, b->visible_quad_layer_rect);
     EXPECT_EQ(a->clip_rect, b->clip_rect);
     EXPECT_EQ(a->is_clipped, b->is_clipped);
     EXPECT_EQ(a->opacity, b->opacity);
@@ skipping 55 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 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->filters_origin, b->filters_origin);
-    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());
@@ skipping 121 matching lines @@
       FilterOperation::CreateGrayscaleFilter(arbitrary_float1));
   arbitrary_filters1.Append(cc::FilterOperation::CreateReferenceFilter(
       SkBlurImageFilter::Make(arbitrary_sigma, arbitrary_sigma, nullptr)));
 
   FilterOperations arbitrary_filters2;
   arbitrary_filters2.Append(
       FilterOperation::CreateBrightnessFilter(arbitrary_float2));
 
   std::unique_ptr<RenderPass> child_pass_in = RenderPass::Create();
   child_pass_in->SetAll(child_id, arbitrary_rect2, arbitrary_rect3,
-                        arbitrary_matrix2, arbitrary_bool2);
+                        arbitrary_matrix2, arbitrary_filters1,
+                        arbitrary_filters2, arbitrary_bool2);
 
   std::unique_ptr<RenderPass> child_pass_cmp = RenderPass::Create();
   child_pass_cmp->SetAll(child_id, arbitrary_rect2, arbitrary_rect3,
-                         arbitrary_matrix2, arbitrary_bool2);
+                         arbitrary_matrix2, arbitrary_filters1,
+                         arbitrary_filters2, arbitrary_bool2);
 
   std::unique_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(root_id, arbitrary_rect1, arbitrary_rect2, arbitrary_matrix1,
-                  arbitrary_bool1);
+                  arbitrary_filters2, arbitrary_filters1, arbitrary_bool1);
 
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(arbitrary_matrix1, arbitrary_size1, arbitrary_rect1,
                            arbitrary_rect2, arbitrary_bool1, arbitrary_float1,
                            arbitrary_blend_mode1, arbitrary_context_id1);
 
   std::unique_ptr<RenderPass> pass_cmp = RenderPass::Create();
   pass_cmp->SetAll(root_id, arbitrary_rect1, arbitrary_rect2, arbitrary_matrix1,
-                   arbitrary_bool1);
+                   arbitrary_filters2, arbitrary_filters1, arbitrary_bool1);
 
   SharedQuadState* shared_state1_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   *shared_state1_cmp = *shared_state1_in;
 
   DebugBorderDrawQuad* debugborder_in =
       pass_in->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debugborder_in->SetAll(shared_state1_in, arbitrary_rect3,
                          arbitrary_rect1_inside_rect3,
                          arbitrary_rect2_inside_rect3, arbitrary_bool1,
                          arbitrary_color, arbitrary_int);
   pass_cmp->CopyFromAndAppendDrawQuad(debugborder_in,
                                       debugborder_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 = *shared_state2_in;
 
   RenderPassDrawQuad* renderpass_in =
       pass_in->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   renderpass_in->SetAll(
       shared_state2_in, arbitrary_rect1, arbitrary_rect2_inside_rect1,
       arbitrary_rect1_inside_rect1, arbitrary_bool1, child_id,
       arbitrary_resourceid2, arbitrary_vector2df1, arbitrary_size1,
-      arbitrary_filters1, arbitrary_vector2df2, arbitrary_pointf2,
-      arbitrary_filters2);
+      arbitrary_vector2df2, arbitrary_pointf2);
   pass_cmp->CopyFromAndAppendRenderPassDrawQuad(
       renderpass_in, renderpass_in->shared_quad_state,
       renderpass_in->render_pass_id);
 
   SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state3_in->SetAll(arbitrary_matrix1, arbitrary_size3, arbitrary_rect3,
                            arbitrary_rect1, arbitrary_bool1, arbitrary_float3,
                            arbitrary_blend_mode3, arbitrary_context_id3);
   SharedQuadState* shared_state3_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
@@ skipping 127 matching lines @@
     bool same_shared_quad_state_out =
         pass_out->quad_list.ElementAt(i)->shared_quad_state ==
         pass_out->quad_list.ElementAt(i - 1)->shared_quad_state;
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
   }
 }
 
 TEST_F(CCParamTraitsTest, UnusedSharedQuadStates) {
   std::unique_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(RenderPassId(1, 1), gfx::Rect(100, 100), gfx::Rect(),
-                  gfx::Transform(), false);
+                  gfx::Transform(), FilterOperations(), FilterOperations(),
+                  false);
 
   // The first SharedQuadState is used.
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(gfx::Transform(), gfx::Size(1, 1), gfx::Rect(),
                            gfx::Rect(), false, 1.f, SkBlendMode::kSrcOver, 0);
 
   SolidColorDrawQuad* quad1 =
       pass_in->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad1->SetAll(shared_state1_in, gfx::Rect(10, 10), gfx::Rect(10, 10),
                 gfx::Rect(10, 10), false, SK_ColorRED, false);
@@ skipping 85 matching lines @@
   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_token = arbitrary_token2;
   arbitrary_resource2.is_overlay_candidate = false;
 
   std::unique_ptr<RenderPass> renderpass_in = RenderPass::Create();
   renderpass_in->SetNew(RenderPassId(1, 1), gfx::Rect(), gfx::Rect(),
-                        gfx::Transform());
+                        gfx::Transform(), FilterOperations(),
+                        FilterOperations());
 
   CompositorFrame 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(std::move(renderpass_in));
 
   IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
 
   CompositorFrame frame_out;
   base::PickleIterator iter(msg);
   EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::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