Fix CSS reference filters with negative transformed children.

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"
@@ skipping 83 matching lines @@
   shared_state->SetAll(gfx::Transform(),
                        output_rect.size(),
                        output_rect,
                        output_rect,
                        false,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        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(),
-               FilterOperations());
+  quad->SetNew(shared_state, output_rect, output_rect, contributing_pass->id, 0,
+               gfx::Vector2dF(), gfx::Size(), FilterOperations(),
+               gfx::Vector2dF(), gfx::PointF(), FilterOperations());
 }
 
 void AddRenderPassQuad(RenderPass* to_pass,
                        RenderPass* contributing_pass,
                        ResourceId mask_resource_id,
                        const FilterOperations& filters,
                        gfx::Transform transform,
                        SkXfermode::Mode 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(),
+  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());
 }
 
 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,
@@ skipping 52 matching lines @@
   shared_state->SetAll(gfx::Transform(), rect.size(), rect, rect, false, 1,
                        SkXfermode::kSrcOver_Mode, 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(), FilterOperations());
+    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());
 
     RenderPassDrawQuad* render_pass_replica_quad =
         to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     render_pass_replica_quad->SetNew(
         shared_state, rect, visible_rect, child_pass, resource5,
         gfx::Vector2dF(1.f, 1.f), resource5_size, FilterOperations(),
-        gfx::Vector2dF(), FilterOperations());
+        gfx::Vector2dF(), gfx::PointF(), FilterOperations());
   }
 
   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