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

cc/output/filter_operation.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 <algorithm>
 
 #include "base/values.h"
 #include "cc/base/math_util.h"
 #include "cc/output/filter_operation.h"
 #include "third_party/skia/include/core/SkMath.h"
 #include "ui/gfx/animation/tween.h"
 
 namespace cc {
 
 bool FilterOperation::operator==(const FilterOperation& other) const {
   if (type_ != other.type_)
     return false;
   if (type_ == COLOR_MATRIX)
     return !memcmp(matrix_, other.matrix_, sizeof(matrix_));
   if (type_ == DROP_SHADOW) {
     return amount_ == other.amount_ &&
            drop_shadow_offset_ == other.drop_shadow_offset_ &&
            drop_shadow_color_ == other.drop_shadow_color_;
   }
   if (type_ == REFERENCE)
     return image_filter_.get() == other.image_filter_.get();
   if (type_ == ALPHA_THRESHOLD) {
     return region_ == other.region_ &&
-        amount_ == other.amount_ &&
-        outer_threshold_ == other.outer_threshold_;
+           device_scale_factor_ == other.device_scale_factor_ &&
+           amount_ == other.amount_ &&
+           outer_threshold_ == other.outer_threshold_;
   }
   return amount_ == other.amount_;
 }
 
 FilterOperation::FilterOperation(FilterType type, float amount)
     : type_(type),
       amount_(amount),
       outer_threshold_(0),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
-      zoom_inset_(0) {
+      zoom_inset_(0),
+      device_scale_factor_(1.f) {
   DCHECK_NE(type_, DROP_SHADOW);
   DCHECK_NE(type_, COLOR_MATRIX);
   DCHECK_NE(type_, REFERENCE);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(FilterType type,
                                  const gfx::Point& offset,
                                  float stdDeviation,
                                  SkColor color)
     : type_(type),
       amount_(stdDeviation),
       outer_threshold_(0),
       drop_shadow_offset_(offset),
       drop_shadow_color_(color),
-      zoom_inset_(0) {
+      zoom_inset_(0),
+      device_scale_factor_(1.f) {
   DCHECK_EQ(type_, DROP_SHADOW);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(FilterType type, SkScalar matrix[20])
     : type_(type),
       amount_(0),
       outer_threshold_(0),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
-      zoom_inset_(0) {
+      zoom_inset_(0),
+      device_scale_factor_(1.f) {
   DCHECK_EQ(type_, COLOR_MATRIX);
   memcpy(matrix_, matrix, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(FilterType type, float amount, int inset)
     : type_(type),
       amount_(amount),
       outer_threshold_(0),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
-      zoom_inset_(inset) {
+      zoom_inset_(inset),
+      device_scale_factor_(1.f) {
   DCHECK_EQ(type_, ZOOM);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(
     FilterType type,
     const skia::RefPtr<SkImageFilter>& image_filter)
     : type_(type),
       amount_(0),
       outer_threshold_(0),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
       image_filter_(image_filter),
-      zoom_inset_(0) {
+      zoom_inset_(0),
+      device_scale_factor_(1.f) {
   DCHECK_EQ(type_, REFERENCE);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(FilterType type,
                                  const SkRegion& region,
+                                 float device_scale_factor,
                                  float inner_threshold,
                                  float outer_threshold)
     : type_(type),
       amount_(inner_threshold),

[danakj, 2014/06/17 21:35:28]

how about putting the scale factor into amount_ and move inner_threshold to
another variable instead, as this makes it match with outer_threshold. 

[garykac, 2014/07/10 23:02:23]

No longer necessary.

       outer_threshold_(outer_threshold),
       drop_shadow_offset_(0, 0),
       drop_shadow_color_(0),
       zoom_inset_(0),
-      region_(region) {
+      region_(region),
+      device_scale_factor_(device_scale_factor) {
   DCHECK_EQ(type_, ALPHA_THRESHOLD);
   memset(matrix_, 0, sizeof(matrix_));
 }
 
 FilterOperation::FilterOperation(const FilterOperation& other)
     : type_(other.type_),
       amount_(other.amount_),
       outer_threshold_(other.outer_threshold_),
       drop_shadow_offset_(other.drop_shadow_offset_),
       drop_shadow_color_(other.drop_shadow_color_),
       image_filter_(other.image_filter_),
       zoom_inset_(other.zoom_inset_),
-      region_(other.region_) {
+      region_(other.region_),
+      device_scale_factor_(other.device_scale_factor_) {
   memcpy(matrix_, other.matrix_, sizeof(matrix_));
 }
 
 FilterOperation::~FilterOperation() {
 }
 
 static FilterOperation CreateNoOpFilter(FilterOperation::FilterType type) {
   switch (type) {
     case FilterOperation::GRAYSCALE:
       return FilterOperation::CreateGrayscaleFilter(0.f);
@@ skipping 23 matching lines @@
       return FilterOperation::CreateColorMatrixFilter(matrix);
     }
     case FilterOperation::ZOOM:
       return FilterOperation::CreateZoomFilter(1.f, 0);
     case FilterOperation::SATURATING_BRIGHTNESS:
       return FilterOperation::CreateSaturatingBrightnessFilter(0.f);
     case FilterOperation::REFERENCE:
       return FilterOperation::CreateReferenceFilter(
           skia::RefPtr<SkImageFilter>());
     case FilterOperation::ALPHA_THRESHOLD:
-      return FilterOperation::CreateAlphaThresholdFilter(SkRegion(), 1.f, 0.f);
+      return FilterOperation::CreateAlphaThresholdFilter(
+          SkRegion(), 1.f, 1.f, 0.f);
   }
   NOTREACHED();
   return FilterOperation::CreateEmptyFilter();
 }
 
 static float ClampAmountForFilterType(float amount,
                                       FilterOperation::FilterType type) {
   switch (type) {
     case FilterOperation::GRAYSCALE:
     case FilterOperation::SEPIA:
@@ skipping 66 matching lines @@
     blended_filter.set_zoom_inset(
         std::max(gfx::Tween::LinearIntValueBetween(
                      from_op.zoom_inset(), to_op.zoom_inset(), progress),
                  0));
   } else if (to_op.type() == FilterOperation::ALPHA_THRESHOLD) {
     blended_filter.set_outer_threshold(ClampAmountForFilterType(
             gfx::Tween::FloatValueBetween(progress,
                                           from_op.outer_threshold(),
                                           to_op.outer_threshold()),
             to_op.type()));
-    blended_filter.set_region(to_op.region());
+    const FilterOperation& copy_op = progress > 0.5 ? to_op : from_op;
+    blended_filter.set_region(copy_op.region());
+    blended_filter.set_device_scale_factor(copy_op.device_scale_factor());
   }
 
   return blended_filter;
 }
 
 scoped_ptr<base::Value> FilterOperation::AsValue() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetInteger("type", type_);
   switch (type_) {
     case FilterOperation::GRAYSCALE:
@@ skipping 40 matching lines @@
         value->SetDouble("inner_threshold", amount_);
         value->SetDouble("outer_threshold", outer_threshold_);
         scoped_ptr<base::ListValue> region_value(new base::ListValue());
         for (SkRegion::Iterator it(region_); !it.done(); it.next()) {
           region_value->AppendInteger(it.rect().x());
           region_value->AppendInteger(it.rect().y());
           region_value->AppendInteger(it.rect().width());
           region_value->AppendInteger(it.rect().height());
         }
         value->Set("region", region_value.release());
+        value->SetDouble("device_scale_factor", device_scale_factor_);
       }
       break;
   }
   return value.PassAs<base::Value>();
 }
 
 }  // namespace cc