Scale the ALPHA_THRESHOLD filter's region based on the device scale factor.

cc/output/filter_operations_unittest.cc

 // Copyright 2013 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/filter_operations.h"
 #include "skia/ext/refptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/point.h"
 
@@ skipping 122 matching lines @@
   SAVE_RESTORE_OFFSET_AMOUNT_COLOR(
       DropShadow, DROP_SHADOW, gfx::Point(3, 4), 0.4f, 0xffffff00);
 
   SkScalar matrix[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
                          17, 18, 19, 20};
   SAVE_RESTORE_MATRIX(ColorMatrix, COLOR_MATRIX, matrix);
 
   SAVE_RESTORE_AMOUNT_INSET(Zoom, ZOOM, 0.5f, 32);
 }
 
+TEST(FilterOperationsTest, SaveAndRestoreAlphaThreshold) {
+  SkRegion region(SkIRect::MakeLTRB(20, 10, 300, 200));
+  float dsf = 2.f;
+  float inner = 0.6f;
+  float outer = 0.3f;
+
+  FilterOperation op =
+      FilterOperation::CreateAlphaThresholdFilter(region, dsf, inner, outer);
+  EXPECT_EQ(FilterOperation::ALPHA_THRESHOLD, op.type());
+  EXPECT_EQ(region, op.region());
+  EXPECT_EQ(dsf, op.device_scale_factor());
+  EXPECT_EQ(inner, op.amount());
+  EXPECT_EQ(outer, op.outer_threshold());
+
+  FilterOperation op2 = FilterOperation::CreateEmptyFilter();
+  op2.set_type(FilterOperation::ALPHA_THRESHOLD);
+
+  EXPECT_NE(region, op2.region());
+  EXPECT_NE(dsf, op2.device_scale_factor());
+  EXPECT_NE(inner, op2.amount());
+  EXPECT_NE(outer, op2.outer_threshold());
+
+  op2.set_region(region);
+  op2.set_device_scale_factor(dsf);
+  op2.set_amount(inner);
+  op2.set_outer_threshold(outer);
+
+  EXPECT_EQ(FilterOperation::ALPHA_THRESHOLD, op2.type());
+  EXPECT_EQ(region, op2.region());
+  EXPECT_EQ(dsf, op2.device_scale_factor());
+  EXPECT_EQ(inner, op2.amount());
+  EXPECT_EQ(outer, op2.outer_threshold());
+}
+
 TEST(FilterOperationsTest, BlendGrayscaleFilters) {
   FilterOperation from = FilterOperation::CreateGrayscaleFilter(0.25f);
   FilterOperation to = FilterOperation::CreateGrayscaleFilter(0.75f);
 
   FilterOperation blended = FilterOperation::Blend(&from, &to, -0.75);
   FilterOperation expected = FilterOperation::CreateGrayscaleFilter(0.f);
   EXPECT_EQ(expected, blended);
 
   blended = FilterOperation::Blend(&from, &to, 0.75);
   expected = FilterOperation::CreateGrayscaleFilter(0.625f);
@@ skipping 383 matching lines @@
   EXPECT_EQ(filter, blended);
   blended = FilterOperation::Blend(&filter, NULL, 0.75);
   EXPECT_EQ(null_filter, blended);
 
   blended = FilterOperation::Blend(NULL, &filter, 0.25);
   EXPECT_EQ(null_filter, blended);
   blended = FilterOperation::Blend(NULL, &filter, 0.75);
   EXPECT_EQ(filter, blended);
 }
 
+TEST(FilterOperationsTest, BlendAlphaThresholdFilters) {
+  SkRegion start_region(SkIRect::MakeLTRB(15, 5, 200, 100));
+  SkRegion end_region(SkIRect::MakeLTRB(20, 10, 300, 200));
+  float start_dsf = 1.f;
+  float end_dsf = 2.f;
+
+  FilterOperation from = FilterOperation::CreateAlphaThresholdFilter(
+      start_region, start_dsf, 0.25f, 0.25f);
+  FilterOperation to = FilterOperation::CreateAlphaThresholdFilter(
+      end_region, end_dsf, 0.75f, 0.75f);
+
+  FilterOperation blended = FilterOperation::Blend(&from, &to, -0.75);
+  FilterOperation expected = FilterOperation::CreateAlphaThresholdFilter(
+      start_region, start_dsf, 0.f, 0.f);
+  EXPECT_EQ(expected, blended);
+
+  blended = FilterOperation::Blend(&from, &to, 0.25);
+  expected = FilterOperation::CreateAlphaThresholdFilter(
+      start_region, start_dsf, 0.375f, 0.375f);
+  EXPECT_EQ(expected, blended);
+
+  blended = FilterOperation::Blend(&from, &to, 0.75);
+  expected = FilterOperation::CreateAlphaThresholdFilter(
+      end_region, end_dsf, 0.625f, 0.625f);
+  EXPECT_EQ(expected, blended);
+
+  blended = FilterOperation::Blend(&from, &to, 1.8);
+  expected = FilterOperation::CreateAlphaThresholdFilter(
+      end_region, end_dsf, 1.f, 1.f);
+  EXPECT_EQ(expected, blended);
+}
+
 // Tests blending non-empty sequences that have the same length and matching
 // operations.
 TEST(FilterOperationsTest, BlendMatchingSequences) {
   FilterOperations from;
   FilterOperations to;
 
   from.Append(FilterOperation::CreateBlurFilter(0.f));
   to.Append(FilterOperation::CreateBlurFilter(2.f));
 
   from.Append(FilterOperation::CreateSaturateFilter(4.f));
@@ skipping 138 matching lines @@
   blended = to.Blend(from, -0.75);
   EXPECT_EQ(to, blended);
   blended = to.Blend(from, 0.75);
   EXPECT_EQ(to, blended);
   blended = to.Blend(from, 1.5);
   EXPECT_EQ(to, blended);
 }
 
 }  // namespace
 }  // namespace cc