cc: Move filters from RenderPassDrawQuad to RenderPass

cc/output/renderer_pixeltest.cc

 // Copyright 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 <stdint.h>
 #include <memory>
 
 #include "base/message_loop/message_loop.h"
 #include "cc/base/math_util.h"
@@ skipping 21 matching lines @@
 namespace cc {
 namespace {
 
 #if !defined(OS_ANDROID)
 std::unique_ptr<RenderPass> CreateTestRootRenderPass(RenderPassId id,
                                                      const gfx::Rect& rect) {
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   const gfx::Rect output_rect = rect;
   const gfx::Rect damage_rect = rect;
   const gfx::Transform transform_to_root_target;
-  pass->SetNew(id, output_rect, damage_rect, transform_to_root_target);
+  const FilterOperations filters;
+  const FilterOperations background_filters;
+  pass->SetNew(id, output_rect, damage_rect, transform_to_root_target, filters,
+               background_filters);
   return pass;
 }
 
 std::unique_ptr<RenderPass> CreateTestRenderPass(
     RenderPassId id,
     const gfx::Rect& rect,
-    const gfx::Transform& transform_to_root_target) {
+    const gfx::Transform& transform_to_root_target,
+    const FilterOperations& filters,
+    const FilterOperations& background_filters) {
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   const gfx::Rect output_rect = rect;
   const gfx::Rect damage_rect = rect;
-  pass->SetNew(id, output_rect, damage_rect, transform_to_root_target);
+  pass->SetNew(id, output_rect, damage_rect, transform_to_root_target, filters,
+               background_filters);
   return pass;
 }
 
 SharedQuadState* CreateTestSharedQuadState(
     gfx::Transform quad_to_target_transform,
     const gfx::Rect& rect,
     RenderPass* render_pass) {
   const gfx::Size layer_bounds = rect.size();
   const gfx::Rect visible_layer_rect = rect;
   const gfx::Rect clip_rect = rect;
@@ skipping 26 matching lines @@
   return shared_state;
 }
 
 void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state,
                                   const gfx::Rect& rect,
                                   RenderPassId pass_id,
                                   RenderPass* render_pass) {
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state, rect, rect, pass_id,
-               0,                    // mask_resource_id
-               gfx::Vector2dF(),     // mask_uv_scale
-               gfx::Size(),          // mask_texture_size
-               FilterOperations(),   // foreground filters
-               gfx::Vector2dF(),     // filters scale
-               gfx::PointF(),        // filter origin
-               FilterOperations());  // background filters
+               0,                 // mask_resource_id
+               gfx::Vector2dF(),  // mask_uv_scale
+               gfx::Size(),       // mask_texture_size
+               gfx::Vector2dF(),  // filters scale
+               gfx::PointF());    // filter origin
 }
 
 void CreateTestTwoColoredTextureDrawQuad(const gfx::Rect& rect,
                                          SkColor texel_color,
                                          SkColor texel_stripe_color,
                                          SkColor background_color,
                                          bool premultiplied_alpha,
                                          const SharedQuadState* shared_state,
                                          ResourceProvider* resource_provider,
                                          RenderPass* render_pass) {
@@ skipping 576 matching lines @@
       base::FilePath(FILE_PATH_LITERAL("green.png")),
       ExactPixelComparator(true)));
 }
 
 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) {
   gfx::Rect rect(this->device_viewport_size_);
   gfx::Rect small_rect(100, 100);
 
   RenderPassId child_id(2, 1);
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_id, small_rect, gfx::Transform());
+      CreateTestRenderPass(child_id, small_rect, gfx::Transform(),
+                           FilterOperations(), FilterOperations());
 
   SharedQuadState* child_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), small_rect, child_pass.get());
 
   SolidColorDrawQuad* color_quad =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false);
 
   RenderPassId root_id(1, 1);
-  std::unique_ptr<RenderPass> root_pass =
-      CreateTestRenderPass(root_id, rect, gfx::Transform());
+  std::unique_ptr<RenderPass> root_pass = CreateTestRenderPass(
+      root_id, rect, gfx::Transform(), FilterOperations(), FilterOperations());
 
   SharedQuadState* root_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, root_pass.get());
 
   CreateTestRenderPassDrawQuad(
       root_shared_state, small_rect, child_id, root_pass.get());
 
   RenderPass* child_pass_ptr = child_pass.get();
 
   RenderPassList pass_list;
@@ skipping 267 matching lines @@
   this->AppendBackgroundAndRunTest(
       FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f),
       FILE_PATH_LITERAL("intersecting_blue_green_squares.png"));
 }
 
 TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) {
   this->SetupQuadStateAndRenderPass();
   RenderPassId child_pass_id1(2, 2);
   RenderPassId child_pass_id2(2, 3);
   std::unique_ptr<RenderPass> child_pass1 =
-      CreateTestRenderPass(child_pass_id1, this->quad_rect_, gfx::Transform());
+      CreateTestRenderPass(child_pass_id1, this->quad_rect_, gfx::Transform(),
+                           FilterOperations(), FilterOperations());
   SharedQuadState* child1_quad_state = CreateTestSharedQuadState(
       gfx::Transform(), this->quad_rect_, child_pass1.get());
   std::unique_ptr<RenderPass> child_pass2 =
-      CreateTestRenderPass(child_pass_id2, this->quad_rect_, gfx::Transform());
+      CreateTestRenderPass(child_pass_id2, this->quad_rect_, gfx::Transform(),
+                           FilterOperations(), FilterOperations());
   SharedQuadState* child2_quad_state = CreateTestSharedQuadState(
       gfx::Transform(), this->quad_rect_, child_pass2.get());
 
   CreateTestTwoColoredTextureDrawQuad(
       this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 0)),
       GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)), SK_ColorTRANSPARENT,
       true, child1_quad_state, this->resource_provider_.get(),
       child_pass1.get());
   CreateTestTwoColoredTextureDrawQuad(
       this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)),
@@ skipping 456 matching lines @@
 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+  SkScalar matrix[20];
+  float amount = 0.5f;
+  matrix[0] = 0.213f + 0.787f * amount;
+  matrix[1] = 0.715f - 0.715f * amount;
+  matrix[2] = 1.f - (matrix[0] + matrix[1]);
+  matrix[3] = matrix[4] = 0;
+  matrix[5] = 0.213f - 0.213f * amount;
+  matrix[6] = 0.715f + 0.285f * amount;
+  matrix[7] = 1.f - (matrix[5] + matrix[6]);
+  matrix[8] = matrix[9] = 0;
+  matrix[10] = 0.213f - 0.213f * amount;
+  matrix[11] = 0.715f - 0.715f * amount;
+  matrix[12] = 1.f - (matrix[10] + matrix[11]);
+  matrix[13] = matrix[14] = 0;
+  matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
+  matrix[18] = 1;
+  FilterOperations filters;
+  filters.Append(
+      FilterOperation::CreateReferenceFilter(SkColorFilterImageFilter::Make(
+          SkColorFilter::MakeMatrixFilterRowMajor255(matrix), nullptr)));
+
+  std::unique_ptr<RenderPass> child_pass = CreateTestRenderPass(
+      child_pass_id, pass_rect, transform_to_root, filters, FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
@@ skipping 12 matching lines @@
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
-  SkScalar matrix[20];
-  float amount = 0.5f;
-  matrix[0] = 0.213f + 0.787f * amount;
-  matrix[1] = 0.715f - 0.715f * amount;
-  matrix[2] = 1.f - (matrix[0] + matrix[1]);
-  matrix[3] = matrix[4] = 0;
-  matrix[5] = 0.213f - 0.213f * amount;
-  matrix[6] = 0.715f + 0.285f * amount;
-  matrix[7] = 1.f - (matrix[5] + matrix[6]);
-  matrix[8] = matrix[9] = 0;
-  matrix[10] = 0.213f - 0.213f * amount;
-  matrix[11] = 0.715f - 0.715f * amount;
-  matrix[12] = 1.f - (matrix[10] + matrix[11]);
-  matrix[13] = matrix[14] = 0;
-  matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
-  matrix[18] = 1;
-  FilterOperations filters;
-  filters.Append(
-      FilterOperation::CreateReferenceFilter(SkColorFilterImageFilter::Make(
-          SkColorFilter::MakeMatrixFilterRowMajor255(matrix), nullptr)));
-
   RenderPassDrawQuad* render_pass_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect,
                            child_pass_id, 0, gfx::Vector2dF(), gfx::Size(),
-                           filters, gfx::Vector2dF(), gfx::PointF(),
-                           FilterOperations());
+                           gfx::Vector2dF(), gfx::PointF());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(child_pass));
   pass_list.push_back(std::move(root_pass));
 
   // This test has alpha=254 for the software renderer vs. alpha=255 for the gl
   // renderer so use a fuzzy comparator.
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")),
       FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
 }
 
 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateSaturateFilter(0.5f));
+
+  std::unique_ptr<RenderPass> child_pass = CreateTestRenderPass(
+      child_pass_id, pass_rect, transform_to_root, filters, FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
@@ skipping 12 matching lines @@
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
-  FilterOperations filters;
-  filters.Append(FilterOperation::CreateSaturateFilter(0.5f));
-
   RenderPassDrawQuad* render_pass_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect,
                            child_pass_id, 0, gfx::Vector2dF(), gfx::Size(),
-                           filters, gfx::Vector2dF(), gfx::PointF(),
-                           FilterOperations());
+                           gfx::Vector2dF(), gfx::PointF());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(child_pass));
   pass_list.push_back(std::move(root_pass));
 
   // This test blends slightly differently with the software renderer vs. the gl
   // renderer so use a fuzzy comparator.
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")),
       FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
 }
 
 TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+  FilterOperations filters;
+  filters.Append(FilterOperation::CreateGrayscaleFilter(1.f));
+  filters.Append(FilterOperation::CreateBrightnessFilter(0.5f));
+
+  std::unique_ptr<RenderPass> child_pass = CreateTestRenderPass(
+      child_pass_id, pass_rect, transform_to_root, filters, FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
@@ skipping 12 matching lines @@
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
-  FilterOperations filters;
-  filters.Append(FilterOperation::CreateGrayscaleFilter(1.f));
-  filters.Append(FilterOperation::CreateBrightnessFilter(0.5f));
-
   RenderPassDrawQuad* render_pass_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect,
                            child_pass_id, 0, gfx::Vector2dF(), gfx::Size(),
-                           filters, gfx::Vector2dF(), gfx::PointF(),
-                           FilterOperations());
+                           gfx::Vector2dF(), gfx::PointF());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(child_pass));
   pass_list.push_back(std::move(root_pass));
 
   // This test blends slightly differently with the software renderer vs. the gl
   // renderer so use a fuzzy comparator.
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")),
       FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
 }
 
 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+  SkScalar matrix[20];
+  float amount = 0.5f;
+  matrix[0] = 0.213f + 0.787f * amount;
+  matrix[1] = 0.715f - 0.715f * amount;
+  matrix[2] = 1.f - (matrix[0] + matrix[1]);
+  matrix[3] = 0;
+  matrix[4] = 20.f;
+  matrix[5] = 0.213f - 0.213f * amount;
+  matrix[6] = 0.715f + 0.285f * amount;
+  matrix[7] = 1.f - (matrix[5] + matrix[6]);
+  matrix[8] = 0;
+  matrix[9] = 200.f;
+  matrix[10] = 0.213f - 0.213f * amount;
+  matrix[11] = 0.715f - 0.715f * amount;
+  matrix[12] = 1.f - (matrix[10] + matrix[11]);
+  matrix[13] = 0;
+  matrix[14] = 1.5f;
+  matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
+  matrix[18] = 1;
+  FilterOperations filters;
+  filters.Append(
+      FilterOperation::CreateReferenceFilter(SkColorFilterImageFilter::Make(
+          SkColorFilter::MakeMatrixFilterRowMajor255(matrix), nullptr)));
+
+  std::unique_ptr<RenderPass> child_pass = CreateTestRenderPass(
+      child_pass_id, pass_rect, transform_to_root, filters, FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
   shared_state->opacity = 0.5f;
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
@@ skipping 12 matching lines @@
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   SolidColorDrawQuad* white =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(
       blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
 
   SharedQuadState* pass_shared_state =
       CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
 
-  SkScalar matrix[20];
-  float amount = 0.5f;
-  matrix[0] = 0.213f + 0.787f * amount;
-  matrix[1] = 0.715f - 0.715f * amount;
-  matrix[2] = 1.f - (matrix[0] + matrix[1]);
-  matrix[3] = 0;
-  matrix[4] = 20.f;
-  matrix[5] = 0.213f - 0.213f * amount;
-  matrix[6] = 0.715f + 0.285f * amount;
-  matrix[7] = 1.f - (matrix[5] + matrix[6]);
-  matrix[8] = 0;
-  matrix[9] = 200.f;
-  matrix[10] = 0.213f - 0.213f * amount;
-  matrix[11] = 0.715f - 0.715f * amount;
-  matrix[12] = 1.f - (matrix[10] + matrix[11]);
-  matrix[13] = 0;
-  matrix[14] = 1.5f;
-  matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
-  matrix[18] = 1;
-  FilterOperations filters;
-  filters.Append(
-      FilterOperation::CreateReferenceFilter(SkColorFilterImageFilter::Make(
-          SkColorFilter::MakeMatrixFilterRowMajor255(matrix), nullptr)));
-
   RenderPassDrawQuad* render_pass_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect,
                            child_pass_id, 0, gfx::Vector2dF(), gfx::Size(),
-                           filters, gfx::Vector2dF(), gfx::PointF(),
-                           FilterOperations());
+                           gfx::Vector2dF(), gfx::PointF());
 
   RenderPassList pass_list;
 
   pass_list.push_back(std::move(child_pass));
   pass_list.push_back(std::move(root_pass));
 
   // This test has alpha=254 for the software renderer vs. alpha=255 for the gl
   // renderer so use a fuzzy comparator.
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")),
       FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
 }
 
 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
@@ skipping 28 matching lines @@
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
@@ skipping 44 matching lines @@
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
   SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState(
       gfx::Transform(), viewport_rect, root_pass.get());
 
   RenderPassId child_pass_id(2, 2);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
   SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState(
       gfx::Transform(), viewport_rect, child_pass.get());
 
   // The child render pass is just a green box.
   static const SkColor kCSSGreen = 0xff008000;
   SolidColorDrawQuad* green =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   green->SetNew(
       child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false);
 
@@ skipping 36 matching lines @@
   EXPECT_NE(sub_rect.bottom(), child_pass->output_rect.bottom());
 
   // Set up a mask on the RenderPassDrawQuad.
   RenderPassDrawQuad* mask_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   mask_quad->SetNew(root_pass_shared_state, sub_rect, sub_rect, child_pass_id,
                     mask_resource_id,
                     gfx::Vector2dF(2.f / mask_rect.width(),
                                    2.f / mask_rect.height()),  // mask_uv_scale
                     gfx::Size(mask_rect.size()),  // mask_texture_size
-                    FilterOperations(),           // foreground filters
                     gfx::Vector2dF(),             // filters scale
-                    gfx::PointF(),                // filter origin
-                    FilterOperations());          // background filters
+                    gfx::PointF());               // filter origin
 
   // White background behind the masked render pass.
   SolidColorDrawQuad* white =
       root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(root_pass_shared_state,
                 viewport_rect,
                 viewport_rect,
                 SK_ColorWHITE,
                 false);
 
@@ skipping 14 matching lines @@
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
   SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState(
       gfx::Transform(), viewport_rect, root_pass.get());
 
   RenderPassId child_pass_id(2, 2);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
   SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState(
       gfx::Transform(), viewport_rect, child_pass.get());
 
   // The child render pass is just a green box.
   static const SkColor kCSSGreen = 0xff008000;
   SolidColorDrawQuad* green =
       child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   green->SetNew(child_pass_shared_state, viewport_rect, viewport_rect,
                 kCSSGreen, false);
 
@@ skipping 36 matching lines @@
   EXPECT_NE(sub_rect.bottom(), child_pass->output_rect.bottom());
 
   // Set up a mask on the RenderPassDrawQuad.
   RenderPassDrawQuad* mask_quad =
       root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   mask_quad->SetNew(root_pass_shared_state, sub_rect, sub_rect, child_pass_id,
                     mask_resource_id,
                     gfx::Vector2dF(2.f / mask_rect.width(),
                                    2.f / mask_rect.height()),  // mask_uv_scale
                     gfx::Size(mask_rect.size()),  // mask_texture_size
-                    FilterOperations(),           // foreground filters
                     gfx::Vector2dF(),             // filters scale
-                    gfx::PointF(),                // filter origin
-                    FilterOperations());          // background filters
+                    gfx::PointF());               // filter origin
 
   // White background behind the masked render pass.
   SolidColorDrawQuad* white =
       root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   white->SetNew(root_pass_shared_state, viewport_rect, viewport_rect,
                 SK_ColorWHITE, false);
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(child_pass));
   pass_list.push_back(std::move(root_pass));
@@ skipping 13 matching lines @@
     RenderPassId root_id(1, 1);
     std::unique_ptr<RenderPass> root_pass =
         CreateTestRootRenderPass(root_id, device_viewport_rect);
     root_pass->has_transparent_background = false;
 
     gfx::Transform identity_quad_to_target_transform;
 
     RenderPassId filter_pass_id(2, 1);
     gfx::Transform transform_to_root;
     std::unique_ptr<RenderPass> filter_pass = CreateTestRenderPass(
-        filter_pass_id, filter_pass_layer_rect_, transform_to_root);
+        filter_pass_id, filter_pass_layer_rect_, transform_to_root,
+        FilterOperations(), this->background_filters_);
 
     // A non-visible quad in the filtering render pass.
     {
       SharedQuadState* shared_state =
           CreateTestSharedQuadState(identity_quad_to_target_transform,
                                     filter_pass_layer_rect_, filter_pass.get());
       SolidColorDrawQuad* color_quad =
           filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(shared_state, filter_pass_layer_rect_,
                          filter_pass_layer_rect_, SK_ColorTRANSPARENT, false);
     }
 
     {
       SharedQuadState* shared_state =
           CreateTestSharedQuadState(filter_pass_to_target_transform_,
                                     filter_pass_layer_rect_, filter_pass.get());
       RenderPassDrawQuad* filter_pass_quad =
           root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
       filter_pass_quad->SetNew(shared_state, filter_pass_layer_rect_,
                                filter_pass_layer_rect_, filter_pass_id,
                                0,                           // mask_resource_id
                                gfx::Vector2dF(),            // mask_uv_scale
                                gfx::Size(),                 // mask_texture_size
-                               FilterOperations(),          // filters
                                gfx::Vector2dF(1.0f, 1.0f),  // filters_scale
-                               gfx::PointF(),               // filters_origin
-                               this->background_filters_);
+                               gfx::PointF());              // filters_origin
     }
 
     const int kColumnWidth = device_viewport_rect.width() / 3;
 
     gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20);
     for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) {
       SharedQuadState* shared_state = CreateTestSharedQuadState(
           identity_quad_to_target_transform, left_rect, root_pass.get());
       SolidColorDrawQuad* color_quad =
           root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ skipping 158 matching lines @@
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
   root_pass->has_transparent_background = false;
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height());
   SolidColorDrawQuad* blue =
@@ skipping 55 matching lines @@
       FuzzyPixelOffByOneComparator(true)));
 }
 
 // This test tests that anti-aliasing works for axis aligned quads.
 // Anti-aliasing is only supported in the gl renderer.
 TEST_F(GLRendererPixelTest, AxisAligned) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, rect, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, rect, transform_to_root, FilterOperations(), FilterOperations());
 
   gfx::Transform red_quad_to_target_transform;
   red_quad_to_target_transform.Translate(50, 50);
   red_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),
                                      0.5f + 1.0f / (rect.height() * 2.0f));
   SharedQuadState* red_shared_state =
       CreateTestSharedQuadState(red_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
@@ skipping 25 matching lines @@
       ExactPixelComparator(true)));
 }
 
 // This test tests that forcing anti-aliasing off works as expected.
 // Anti-aliasing is only supported in the gl renderer.
 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, rect, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, rect, transform_to_root, FilterOperations(), FilterOperations());
 
   gfx::Transform hole_quad_to_target_transform;
   hole_quad_to_target_transform.Translate(50, 50);
   hole_quad_to_target_transform.Scale(0.5f + 1.0f / (rect.width() * 2.0f),
                                       0.5f + 1.0f / (rect.height() * 2.0f));
   SharedQuadState* hole_shared_state = CreateTestSharedQuadState(
       hole_quad_to_target_transform, rect, pass.get());
 
   SolidColorDrawQuad* hole =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ skipping 56 matching lines @@
 }
 
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadIdentityScale) {
   gfx::Rect viewport(this->device_viewport_size_);
   // TODO(enne): the renderer should figure this out on its own.
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   // One clipped blue quad in the lower right corner.  Outside the clip
   // is red, which should not appear.
   gfx::Rect blue_rect(gfx::Size(100, 100));
   gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50));
 
   std::unique_ptr<FakeRecordingSource> blue_recording =
       FakeRecordingSource::CreateFilledRecordingSource(blue_rect.size());
   SkPaint red_paint;
   red_paint.setColor(SK_ColorRED);
@@ skipping 54 matching lines @@
 }
 
 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity.
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadOpacity) {
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   // One viewport-filling 0.5-opacity green quad.
   std::unique_ptr<FakeRecordingSource> green_recording =
       FakeRecordingSource::CreateFilledRecordingSource(viewport.size());
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
   green_recording->add_draw_rect_with_paint(viewport, green_paint);
   green_recording->Rerecord();
   scoped_refptr<FakeRasterSource> green_raster_source =
       FakeRasterSource::CreateFromRecordingSource(green_recording.get(), false);
@@ skipping 60 matching lines @@
   // cheap in hardware.
   if (!IsSoftwareRenderer<TypeParam>())
     return;
 
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(2, 2);
   ASSERT_NE(surface, nullptr);
   SkCanvas* canvas = surface->getCanvas();
   canvas->drawPoint(0, 0, SK_ColorGREEN);
   canvas->drawPoint(0, 1, SK_ColorBLUE);
   canvas->drawPoint(1, 0, SK_ColorBLUE);
   canvas->drawPoint(1, 1, SK_ColorGREEN);
 
   std::unique_ptr<FakeRecordingSource> recording =
@@ skipping 27 matching lines @@
 }
 
 // This disables filtering by setting |nearest_neighbor| on the PictureDrawQuad.
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNearestNeighbor) {
   gfx::Rect viewport(this->device_viewport_size_);
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = true;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(2, 2);
   ASSERT_NE(surface, nullptr);
   SkCanvas* canvas = surface->getCanvas();
   canvas->drawPoint(0, 0, SK_ColorGREEN);
   canvas->drawPoint(0, 1, SK_ColorBLUE);
   canvas->drawPoint(1, 0, SK_ColorBLUE);
   canvas->drawPoint(1, 1, SK_ColorGREEN);
 
   std::unique_ptr<FakeRecordingSource> recording =
@@ skipping 47 matching lines @@
       gfx::ColorSpace());
 
   {
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   TileDrawQuad* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource,
                gfx::RectF(gfx::Rect(tile_size)), tile_size, swizzle_contents,
                nearest_neighbor);
 
@@ skipping 29 matching lines @@
       gfx::ColorSpace());
 
   {
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource, false,
                gfx::PointF(0, 0), gfx::PointF(1, 1), SK_ColorBLACK,
                vertex_opacity, false, nearest_neighbor, false);
@@ skipping 30 matching lines @@
       gfx::ColorSpace());
 
   {
     SkAutoLockPixels lock(bitmap);
     this->resource_provider_->CopyToResource(
         resource, static_cast<uint8_t*>(bitmap.getPixels()), tile_size);
   }
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource, false,
                gfx::PointF(0, 0), gfx::PointF(1, 1), SK_ColorBLACK,
                vertex_opacity, false, nearest_neighbor, false);
@@ skipping 10 matching lines @@
 }
 
 TYPED_TEST(SoftwareRendererPixelTest, PictureDrawQuadNonIdentityScale) {
   gfx::Rect viewport(this->device_viewport_size_);
   // TODO(enne): the renderer should figure this out on its own.
   ResourceFormat texture_format = RGBA_8888;
   bool nearest_neighbor = false;
 
   RenderPassId id(1, 1);
   gfx::Transform transform_to_root;
-  std::unique_ptr<RenderPass> pass =
-      CreateTestRenderPass(id, viewport, transform_to_root);
+  std::unique_ptr<RenderPass> pass = CreateTestRenderPass(
+      id, viewport, transform_to_root, FilterOperations(), FilterOperations());
 
   // As scaling up the blue checkerboards will cause sampling on the GPU,
   // a few extra "cleanup rects" need to be added to clobber the blending
   // to make the output image more clean.  This will also test subrects
   // of the layer.
   gfx::Transform green_quad_to_target_transform;
   gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100));
   gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20));
 
   std::unique_ptr<FakeRecordingSource> green_recording =
@@ skipping 127 matching lines @@
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
@@ skipping 27 matching lines @@
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   gfx::Rect blue_rect(0,
                       0,
                       this->device_viewport_size_.width(),
                       this->device_viewport_size_.height() / 2);
   SolidColorDrawQuad* blue =
@@ skipping 27 matching lines @@
   gfx::Rect viewport_rect(this->device_viewport_size_);
 
   RenderPassId root_pass_id(1, 1);
   std::unique_ptr<RenderPass> root_pass =
       CreateTestRootRenderPass(root_pass_id, viewport_rect);
 
   RenderPassId child_pass_id(2, 2);
   gfx::Rect pass_rect(this->device_viewport_size_);
   gfx::Transform transform_to_root;
   std::unique_ptr<RenderPass> child_pass =
-      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
+      CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root,
+                           FilterOperations(), FilterOperations());
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state = CreateTestSharedQuadState(
       quad_to_target_transform, viewport_rect, child_pass.get());
 
   // Draw a green quad full-size with a blue quad in the lower-right corner.
   gfx::Rect blue_rect(this->device_viewport_size_.width() * 3 / 4,
                       this->device_viewport_size_.height() * 3 / 4,
                       this->device_viewport_size_.width() * 3 / 4,
                       this->device_viewport_size_.height() * 3 / 4);
@@ skipping 107 matching lines @@
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc