cc: Move filters from RenderPassDrawQuad to RenderPass

cc/test/render_pass_test_utils.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/test/render_pass_test_utils.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
 
 RenderPass* AddRenderPass(RenderPassList* pass_list,
                           RenderPassId id,
                           const gfx::Rect& output_rect,
-                          const gfx::Transform& root_transform) {
+                          const gfx::Transform& root_transform,
+                          const FilterOperations& filters) {
   std::unique_ptr<RenderPass> pass(RenderPass::Create());
-  pass->SetNew(id, output_rect, output_rect, root_transform);
+  pass->SetNew(id, output_rect, output_rect, root_transform, filters,
+               FilterOperations());
   RenderPass* saved = pass.get();
   pass_list->push_back(std::move(pass));
   return saved;
 }
 
 SolidColorDrawQuad* AddQuad(RenderPass* pass,
                             const gfx::Rect& rect,
                             SkColor color) {
   SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1,
@@ skipping 30 matching lines @@
 }
 
 void AddRenderPassQuad(RenderPass* to_pass, RenderPass* contributing_pass) {
   gfx::Rect output_rect = contributing_pass->output_rect;
   SharedQuadState* shared_state = to_pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), output_rect.size(), output_rect,
                        output_rect, false, 1, SkBlendMode::kSrcOver, 0);
   RenderPassDrawQuad* quad =
       to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state, output_rect, output_rect, contributing_pass->id, 0,
-               gfx::Vector2dF(), gfx::Size(), FilterOperations(),
-               gfx::Vector2dF(), gfx::PointF(), FilterOperations());
+               gfx::Vector2dF(), gfx::Size(), gfx::Vector2dF(), gfx::PointF());
 }
 
 void AddRenderPassQuad(RenderPass* to_pass,
                        RenderPass* contributing_pass,
                        ResourceId mask_resource_id,
-                       const FilterOperations& filters,
                        gfx::Transform transform,
                        SkBlendMode blend_mode) {
   gfx::Rect output_rect = contributing_pass->output_rect;
   SharedQuadState* shared_state = to_pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(transform,
                        output_rect.size(),
                        output_rect,
                        output_rect,
                        false,
                        1,
                        blend_mode,
                        0);
   RenderPassDrawQuad* quad =
       to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   gfx::Size arbitrary_nonzero_size(1, 1);
   quad->SetNew(shared_state, output_rect, output_rect, contributing_pass->id,
                mask_resource_id, gfx::Vector2dF(1.f, 1.f),
-               arbitrary_nonzero_size, filters, gfx::Vector2dF(), gfx::PointF(),
-               FilterOperations());
+               arbitrary_nonzero_size, gfx::Vector2dF(), gfx::PointF());
 }
 
 static void EmptyReleaseCallback(const gpu::SyncToken& sync_token,
                                  bool lost_resource,
                                  BlockingTaskRunner* main_thread_task_runner) {}
 
 void AddOneOfEveryQuadType(RenderPass* to_pass,
                            ResourceProvider* resource_provider,
                            RenderPassId child_pass,
                            gpu::SyncToken* sync_token_for_mailbox_tebxture) {
@@ skipping 51 matching lines @@
   shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1,
                        SkBlendMode::kSrcOver, 0);
 
   DebugBorderDrawQuad* debug_border_quad =
       to_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1);
 
   if (child_pass.layer_id) {
     RenderPassDrawQuad* render_pass_quad =
         to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
-    render_pass_quad->SetNew(
-        shared_state, rect, visible_rect, child_pass, resource5,
-        gfx::Vector2dF(1.f, 1.f), resource5_size, FilterOperations(),
-        gfx::Vector2dF(), gfx::PointF(), FilterOperations());
+    render_pass_quad->SetNew(shared_state, rect, visible_rect, child_pass,
+                             resource5, gfx::Vector2dF(1.f, 1.f),
+                             resource5_size, gfx::Vector2dF(), gfx::PointF());
   }
 
   SolidColorDrawQuad* solid_color_quad =
       to_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   solid_color_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED,
                            false);
 
   StreamVideoDrawQuad* stream_video_quad =
       to_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
   stream_video_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
@@ skipping 54 matching lines @@
       to_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
   yuv_quad->SetNew(shared_state2, rect, opaque_rect, visible_rect,
                    gfx::RectF(.0f, .0f, 100.0f, 100.0f),
                    gfx::RectF(.0f, .0f, 50.0f, 50.0f), gfx::Size(100, 100),
                    gfx::Size(50, 50), plane_resources[0], plane_resources[1],
                    plane_resources[2], plane_resources[3], color_space,
                    gfx::ColorSpace::CreateJpeg(), 0.0, 1.0, 8);
 }
 
 }  // namespace cc