cc: Move filters from RenderPassDrawQuad to RenderPass

cc/output/gl_renderer_unittest.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 "cc/output/gl_renderer.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <vector>
@@ skipping 475 matching lines @@
 namespace {
 
 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {
   gfx::Size viewport_size(1, 1);
   EXPECT_FALSE(renderer_->stencil_enabled());
 
   output_surface_->set_has_external_stencil_test(true);
 
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
 
   DrawFrame(renderer_.get(), viewport_size);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
@@ skipping 178 matching lines @@
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
 
   // On DEBUG builds, render passes with opaque background clear to blue to
   // easily see regions that were not drawn on the screen.
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_EXT)))
       .Times(1);
 #ifdef NDEBUG
   EXPECT_CALL(*context, clear(_)).Times(0);
 #else
@@ skipping 23 matching lines @@
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = true;
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);
   EXPECT_CALL(*context, clear(_)).Times(1);
   DrawFrame(&renderer, viewport_size);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, OffscreenOutputSurface) {
@@ skipping 15 matching lines @@
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(1, 1);
   AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                gfx::Transform());
+                gfx::Transform(), FilterOperations());
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))
       .Times(1);
   EXPECT_CALL(*context, clear(_)).Times(AnyNumber());
   DrawFrame(&renderer, viewport_size);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
@@ skipping 39 matching lines @@
 
   RendererSettings settings;
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   renderer.SetVisible(true);
 
   // During initialization we are allowed to set any texture parameters.
   EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
 
-  RenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1,
-                                        gfx::Rect(100, 100), gfx::Transform());
+  RenderPass* root_pass =
+      AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(100, 100),
+                    gfx::Transform(), FilterOperations());
   gpu::SyncToken mailbox_sync_token;
   AddOneOfEveryQuadType(root_pass, resource_provider.get(), 0,
                         &mailbox_sync_token);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
 
   // Set up expected texture filter state transitions that match the quads
   // created in AppendOneOfEveryQuadType().
   Mock::VerifyAndClearExpectations(context);
   {
@@ skipping 63 matching lines @@
   settings.should_clear_root_render_pass = false;
 
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(10, 10);
 
   int child_pass_id = 2;
-  RenderPass* child_pass =
-      AddRenderPass(&render_passes_in_draw_order_, child_pass_id,
-                    gfx::Rect(viewport_size), gfx::Transform());
+  RenderPass* child_pass = AddRenderPass(
+      &render_passes_in_draw_order_, child_pass_id, gfx::Rect(viewport_size),
+      gfx::Transform(), FilterOperations());
   AddQuad(child_pass, gfx::Rect(viewport_size), SK_ColorBLUE);
 
   int root_pass_id = 1;
-  RenderPass* root_pass =
-      AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                    gfx::Rect(viewport_size), gfx::Transform());
+  RenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
+                                        root_pass_id, gfx::Rect(viewport_size),
+                                        gfx::Transform(), FilterOperations());
   AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
 
   AddRenderPassQuad(root_pass, child_pass);
 
 #ifdef NDEBUG
   GLint clear_bits = GL_COLOR_BUFFER_BIT;
 #else
   GLint clear_bits = GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
 #endif
 
@@ skipping 61 matching lines @@
   renderer.Initialize();
   EXPECT_FALSE(renderer.use_partial_swap());
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(1, 1);
 
   gfx::Rect grand_child_rect(25, 25);
   int grand_child_pass_id = 3;
   RenderPass* grand_child_pass =
       AddRenderPass(&render_passes_in_draw_order_, grand_child_pass_id,
-                    grand_child_rect, gfx::Transform());
+                    grand_child_rect, gfx::Transform(), FilterOperations());
   AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
   gfx::Rect child_rect(50, 50);
   int child_pass_id = 2;
   RenderPass* child_pass =
       AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
   int root_pass_id = 1;
-  RenderPass* root_pass =
-      AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                    gfx::Rect(viewport_size), gfx::Transform());
+  RenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
+                                        root_pass_id, gfx::Rect(viewport_size),
+                                        gfx::Transform(), FilterOperations());
   AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
 
   AddRenderPassQuad(root_pass, child_pass);
   AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   DrawFrame(&renderer, viewport_size);
 }
 
 class DiscardCheckingGLES2Interface : public TestGLES2Interface {
@@ skipping 41 matching lines @@
                           resource_provider.get());
   renderer.Initialize();
   EXPECT_TRUE(renderer.use_partial_swap());
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(100, 100);
 
   {
     // Partial frame, should not discard.
     int root_pass_id = 1;
-    RenderPass* root_pass =
-        AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                      gfx::Rect(viewport_size), gfx::Transform());
+    RenderPass* root_pass = AddRenderPass(
+        &render_passes_in_draw_order_, root_pass_id, gfx::Rect(viewport_size),
+        gfx::Transform(), FilterOperations());
     AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
     root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     DrawFrame(&renderer, viewport_size);
     EXPECT_EQ(0, gl->discarded());
     gl->reset_discarded();
   }
   {
     // Full frame, should discard.
     int root_pass_id = 1;
-    RenderPass* root_pass =
-        AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                      gfx::Rect(viewport_size), gfx::Transform());
+    RenderPass* root_pass = AddRenderPass(
+        &render_passes_in_draw_order_, root_pass_id, gfx::Rect(viewport_size),
+        gfx::Transform(), FilterOperations());
     AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     DrawFrame(&renderer, viewport_size);
     EXPECT_EQ(1, gl->discarded());
     gl->reset_discarded();
   }
   {
     // Full frame, external scissor is set, should not discard.
     output_surface->set_has_external_stencil_test(true);
     int root_pass_id = 1;
-    RenderPass* root_pass =
-        AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                      gfx::Rect(viewport_size), gfx::Transform());
+    RenderPass* root_pass = AddRenderPass(
+        &render_passes_in_draw_order_, root_pass_id, gfx::Rect(viewport_size),
+        gfx::Transform(), FilterOperations());
     AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
     root_pass->has_transparent_background = false;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     DrawFrame(&renderer, viewport_size);
     EXPECT_EQ(0, gl->discarded());
     gl->reset_discarded();
     output_surface->set_has_external_stencil_test(false);
   }
@@ skipping 26 matching lines @@
   FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.Initialize();
   EXPECT_FALSE(renderer.use_partial_swap());
   renderer.SetVisible(true);
 
   gfx::Size viewport_size(100, 100);
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   int root_pass_id = 1;
-  RenderPass* root_pass =
-      AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                    gfx::Rect(viewport_size), gfx::Transform());
+  RenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
+                                        root_pass_id, gfx::Rect(viewport_size),
+                                        gfx::Transform(), FilterOperations());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
 
   unsigned fbo;
   gpu::gles2::GLES2Interface* gl =
       output_surface->context_provider()->ContextGL();
   gl->GenFramebuffers(1, &fbo);
   output_surface->set_framebuffer(fbo, GL_RGB);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   DrawFrame(&renderer, viewport_size);
@@ skipping 41 matching lines @@
 
   gfx::Transform transform_causing_aa;
   transform_causing_aa.Rotate(20.0);
 
   for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
     BlendMode blend_mode = static_cast<BlendMode>(i);
     SkBlendMode xfer_mode = BlendModeToSkXfermode(blend_mode);
     settings_.force_blending_with_shaders = (blend_mode != BLEND_MODE_NONE);
     // RenderPassProgram
     render_passes_in_draw_order_.clear();
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               gfx::Transform());
+    child_pass =
+        AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
+                      gfx::Transform(), FilterOperations());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
-                      FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               transform_causing_aa);
+    child_pass = AddRenderPass(&render_passes_in_draw_order_, child_pass_id,
+                               child_rect, transform_causing_aa, filters);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
-    AddRenderPassQuad(
-        root_pass, child_pass, 0, filters, gfx::Transform(), xfer_mode);
+    AddRenderPassQuad(root_pass, child_pass, 0, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgram
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               gfx::Transform());
+    child_pass =
+        AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
+                      gfx::Transform(), FilterOperations());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
-                      FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassMaskProgram(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
                               blend_mode);
 
     // RenderPassMaskColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               gfx::Transform());
+    child_pass = AddRenderPass(&render_passes_in_draw_order_, child_pass_id,
+                               child_rect, gfx::Transform(), filters);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
-    AddRenderPassQuad(
-        root_pass, child_pass, mask, filters, gfx::Transform(), xfer_mode);
+    AddRenderPassQuad(root_pass, child_pass, mask, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassMaskColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM,
                                          SAMPLER_TYPE_2D, blend_mode);
 
     // RenderPassProgramAA
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               transform_causing_aa);
+    child_pass =
+        AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
+                      transform_causing_aa, FilterOperations());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
-                      FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               transform_causing_aa);
+    child_pass = AddRenderPass(&render_passes_in_draw_order_, child_pass_id,
+                               child_rect, transform_causing_aa, filters);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
-    AddRenderPassQuad(
-        root_pass, child_pass, 0, filters, transform_causing_aa, xfer_mode);
+    AddRenderPassQuad(root_pass, child_pass, 0, transform_causing_aa,
+                      xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgramAA
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               transform_causing_aa);
+    child_pass =
+        AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
+                      transform_causing_aa, FilterOperations());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), gfx::Transform());
+                              gfx::Rect(viewport_size), gfx::Transform(),
+                              FilterOperations());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
-                      FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassMaskProgramAA(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
                                 blend_mode);
 
     // RenderPassMaskColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
-    child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                               child_pass_id,
-                               child_rect,
-                               transform_causing_aa);
+    child_pass = AddRenderPass(&render_passes_in_draw_order_, child_pass_id,
+                               child_rect, transform_causing_aa, filters);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                              gfx::Rect(viewport_size), transform_causing_aa);
+                              gfx::Rect(viewport_size), transform_causing_aa,
+                              FilterOperations());
 
-    AddRenderPassQuad(
-        root_pass, child_pass, mask, filters, transform_causing_aa, xfer_mode);
+    AddRenderPassQuad(root_pass, child_pass, mask, transform_causing_aa,
+                      xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     DrawFrame(renderer_.get(), viewport_size);
     TestRenderPassMaskColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM,
                                            SAMPLER_TYPE_2D, blend_mode);
   }
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
@@ skipping 12 matching lines @@
   transform_preventing_aa.RotateAboutYAxis(-20.0);
   transform_preventing_aa.Scale(30.0, 1.0);
 
   // Verify that the test transform and test rect actually do cause the clipped
   // flag to trigger. Otherwise we are not testing the intended scenario.
   bool clipped = false;
   MathUtil::MapQuad(transform_preventing_aa, gfx::QuadF(gfx::RectF(child_rect)),
                     &clipped);
   ASSERT_TRUE(clipped);
 
-  child_pass = AddRenderPass(&render_passes_in_draw_order_,
-                             child_pass_id,
-                             child_rect,
-                             transform_preventing_aa);
+  child_pass =
+      AddRenderPass(&render_passes_in_draw_order_, child_pass_id, child_rect,
+                    transform_preventing_aa, FilterOperations());
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                            gfx::Rect(viewport_size), gfx::Transform());
+                            gfx::Rect(viewport_size), gfx::Transform(),
+                            FilterOperations());
 
-  AddRenderPassQuad(root_pass, child_pass, 0, FilterOperations(),
-                    transform_preventing_aa, SkBlendMode::kSrcOver);
+  AddRenderPassQuad(root_pass, child_pass, 0, transform_preventing_aa,
+                    SkBlendMode::kSrcOver);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   DrawFrame(renderer_.get(), viewport_size);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
   TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, BLEND_MODE_NONE);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Size viewport_size(1, 1);
   int root_pass_id = 1;
   RenderPass* root_pass;
 
   gfx::Transform pixel_aligned_transform_causing_aa;
   pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);
   pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                            gfx::Rect(viewport_size), gfx::Transform());
+                            gfx::Rect(viewport_size), gfx::Transform(),
+                            FilterOperations());
   AddTransformedQuad(root_pass, gfx::Rect(viewport_size), SK_ColorYELLOW,
                      pixel_aligned_transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   DrawFrame(renderer_.get(), viewport_size);
 
   TestSolidColorProgramAA();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
@@ skipping 65 matching lines @@
     renderer_->SetVisible(true);
     Mock::VerifyAndClearExpectations(output_surface_.get());
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(std::vector<ui::LatencyInfo>()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Size& viewport_size,
                  bool transparent) {
     int render_pass_id = 1;
-    RenderPass* render_pass =
-        AddRenderPass(&render_passes_in_draw_order_, render_pass_id,
-                      gfx::Rect(viewport_size), gfx::Transform());
+    RenderPass* render_pass = AddRenderPass(
+        &render_passes_in_draw_order_, render_pass_id, gfx::Rect(viewport_size),
+        gfx::Transform(), FilterOperations());
     AddQuad(render_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
     render_pass->has_transparent_background = transparent;
 
     EXPECT_CALL(*output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(*output_surface_,
                 Reshape(viewport_size, device_scale_factor, _, transparent))
         .Times(1);
 
     EXPECT_CALL(*output_surface_, BindFramebuffer()).Times(1);
@@ skipping 96 matching lines @@
       new TestOverlayProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
   std::unique_ptr<TestOverlayProcessor::Validator> validator(
       new TestOverlayProcessor::Validator);
   output_surface->SetOverlayCandidateValidator(validator.get());
 
   gfx::Size viewport_size(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
   root_pass->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&IgnoreCopyResult)));
 
   TextureMailbox mailbox =
       TextureMailbox(gpu::Mailbox::Generate(), gpu::SyncToken(), GL_TEXTURE_2D,
                      gfx::Size(256, 256), true, false);
   std::unique_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
   ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
@@ skipping 16 matching lines @@
   // added a fake strategy, so checking for Attempt calls checks if there was
   // any attempt to overlay, which there shouldn't be. We can't use the quad
   // list because the render pass is cleaned up by DrawFrame.
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   EXPECT_CALL(*validator, AllowCALayerOverlays()).Times(0);
   DrawFrame(&renderer, viewport_size);
   Mock::VerifyAndClearExpectations(processor->strategy_);
   Mock::VerifyAndClearExpectations(validator.get());
 
   // Without a copy request Attempt() should be called once.
-  root_pass = AddRenderPass(&render_passes_in_draw_order_, 1,
-                            gfx::Rect(viewport_size), gfx::Transform());
+  root_pass =
+      AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
 
   overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(
       root_pass->CreateAndAppendSharedQuadState(), gfx::Rect(viewport_size),
       gfx::Rect(viewport_size), gfx::Rect(viewport_size), resource_id,
       premultiplied_alpha, gfx::PointF(0, 0), gfx::PointF(1, 1),
       SK_ColorTRANSPARENT, vertex_opacity, flipped, nearest_neighbor, false);
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
       .WillOnce(::testing::Return(false));
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(1);
   DrawFrame(&renderer, viewport_size);
 
   // If the CALayerOverlay path is taken, then the ordinary overlay path should
   // not be called.
-  root_pass = AddRenderPass(&render_passes_in_draw_order_, 1,
-                            gfx::Rect(viewport_size), gfx::Transform());
+  root_pass =
+      AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
 
   overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(
       root_pass->CreateAndAppendSharedQuadState(), gfx::Rect(viewport_size),
       gfx::Rect(viewport_size), gfx::Rect(viewport_size), resource_id,
       premultiplied_alpha, gfx::PointF(0, 0), gfx::PointF(1, 1),
       SK_ColorTRANSPARENT, vertex_opacity, flipped, nearest_neighbor, false);
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
@@ skipping 78 matching lines @@
   renderer.SetVisible(true);
 
   SingleOverlayOnTopProcessor* processor =
       new SingleOverlayOnTopProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
 
   gfx::Size viewport_size(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 1, gfx::Rect(viewport_size),
-                    gfx::Transform());
+                    gfx::Transform(), FilterOperations());
   root_pass->has_transparent_background = false;
 
   gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                             gpu::CommandBufferId::FromUnsafeValue(0x123), 29);
   TextureMailbox mailbox =
       TextureMailbox(gpu::Mailbox::Generate(), sync_token, GL_TEXTURE_2D,
                      gfx::Size(256, 256), true, false);
   std::unique_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
   ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
@@ skipping 63 matching lines @@
     FakeRendererGL renderer(&settings, output_surface.get(),
                             resource_provider.get());
     renderer.Initialize();
     EXPECT_EQ(partial_swap, renderer.use_partial_swap());
     renderer.SetVisible(true);
 
     gfx::Size viewport_size(100, 100);
 
     {
       int root_pass_id = 1;
-      RenderPass* root_pass =
-          AddRenderPass(&render_passes_in_draw_order_, root_pass_id,
-                        gfx::Rect(viewport_size), gfx::Transform());
+      RenderPass* root_pass = AddRenderPass(
+          &render_passes_in_draw_order_, root_pass_id, gfx::Rect(viewport_size),
+          gfx::Transform(), FilterOperations());
       AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
 
       testing::Sequence seq;
       // A bunch of initialization that happens.
       EXPECT_CALL(*gl, Disable(GL_DEPTH_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_CULL_FACE)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_STENCIL_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Enable(GL_BLEND)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_SCISSOR_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Scissor(0, 0, 0, 0)).InSequence(seq);
@@ skipping 70 matching lines @@
   renderer_->SetVisible(true);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 }
 
 }  // namespace
 }  // namespace cc