Fix CSS reference filters with negative transformed children.

cc/output/overlay_unittest.cc

 // Copyright 2014 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 <utility>
 
 #include "base/memory/ptr_util.h"
 #include "cc/base/region.h"
@@ skipping 1749 matching lines @@
   RenderPassId render_pass_id_;
   FilterOperations filters_;
   FilterOperations background_filters_;
   CALayerOverlayList ca_layer_list_;
   OverlayCandidateList overlay_list_;
 };
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadNoFilters) {
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 1), background_filters_);
+                filters_, gfx::Vector2dF(1, 1), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
 
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadAllValidFilters) {
   filters_.Append(FilterOperation::CreateGrayscaleFilter(0.1f));
   filters_.Append(FilterOperation::CreateSepiaFilter(0.2f));
   filters_.Append(FilterOperation::CreateSaturateFilter(0.3f));
   filters_.Append(FilterOperation::CreateHueRotateFilter(0.4f));
   filters_.Append(FilterOperation::CreateInvertFilter(0.5f));
   filters_.Append(FilterOperation::CreateBrightnessFilter(0.6f));
   filters_.Append(FilterOperation::CreateContrastFilter(0.7f));
   filters_.Append(FilterOperation::CreateOpacityFilter(0.8f));
   filters_.Append(FilterOperation::CreateBlurFilter(0.9f));
   filters_.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(10, 20),
                                                           1.0f, SK_ColorGREEN));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 1), background_filters_);
+                filters_, gfx::Vector2dF(1, 1), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
 
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadOpacityFilterScale) {
   filters_.Append(FilterOperation::CreateOpacityFilter(0.8f));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 2), background_filters_);
+                filters_, gfx::Vector2dF(1, 2), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadBlurFilterScale) {
   filters_.Append(FilterOperation::CreateBlurFilter(0.8f));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 2), background_filters_);
+                filters_, gfx::Vector2dF(1, 2), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadDropShadowFilterScale) {
   filters_.Append(FilterOperation::CreateDropShadowFilter(gfx::Point(10, 20),
                                                           1.0f, SK_ColorGREEN));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 2), background_filters_);
+                filters_, gfx::Vector2dF(1, 2), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadBackgroundFilter) {
   background_filters_.Append(FilterOperation::CreateGrayscaleFilter(0.1f));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 1), background_filters_);
+                filters_, gfx::Vector2dF(1, 1), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(0U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadMask) {
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 2, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 1), background_filters_);
+                filters_, gfx::Vector2dF(1, 1), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(1U, ca_layer_list_.size());
 }
 
 TEST_F(CALayerOverlayRPDQTest, RenderPassDrawQuadUnsupportedFilter) {
   filters_.Append(FilterOperation::CreateZoomFilter(0.9f, 1));
   quad_->SetNew(pass_->shared_quad_state_list.back(), kOverlayRect,
                 kOverlayRect, render_pass_id_, 0, gfx::Vector2dF(), gfx::Size(),
-                filters_, gfx::Vector2dF(1, 1), background_filters_);
+                filters_, gfx::Vector2dF(1, 1), gfx::PointF(),
+                background_filters_);
   ProcessForOverlays();
   EXPECT_EQ(0U, ca_layer_list_.size());
 }
 
 }  // namespace
 }  // namespace cc