cc: correctly fix edge-AA for filtered render surfaces.

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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
@@ skipping 297 matching lines @@
           value->AppendInteger(it.rect().y());
           value->AppendInteger(it.rect().width());
           value->AppendInteger(it.rect().height());
         }
         value->EndArray();
       }
       break;
   }
 }
 
-static int SpreadForStdDeviation(float std_deviation) {
-  // https://dvcs.w3.org/hg/FXTF/raw-file/tip/filters/index.html#feGaussianBlurElement
-  // provides this approximation for evaluating a gaussian blur by a triple box
-  // filter.
-  float d = floorf(std_deviation * 3.f * sqrt(8.f * atan(1.f)) / 4.f + 0.5f);
-  return static_cast<int>(ceilf(d * 3.f / 2.f));
+static SkVector MapStdDeviation(float std_deviation, const SkMatrix& matrix) {

[enne (OOO), 2016/05/13 21:31:13]

Can you explain this change to me?

[Stephen White, 2016/05/13 21:51:07]

Basically, this syncs this function up with the Skia implementation, 
so this function gives the same result as calling filterBounds() on 
the built SkImageFilter DAG would give.

(Since we don't use the triple-box-blur on the GPU path, the 
previous version was not accurate anyway. We use 3 * sigma in
Skia since it's a Gaussian blur and 99.7 percent of the samples 
fall within 3 sigmas of the mean. The function also applies the 
matrix, which in practice is always a scaling matrix.)

+  SkVector sigma = SkVector::Make(std_deviation, std_deviation);
+  matrix.mapVectors(&sigma, 1);
+  return sigma * SkIntToScalar(3);
 }
 
-gfx::Rect FilterOperation::MapRect(const gfx::Rect& rect) const {
+gfx::Rect FilterOperation::MapRect(const gfx::Rect& rect,
+                                   const SkMatrix& matrix) const {
   switch (type_) {
     case FilterOperation::BLUR: {
-      int spread = SpreadForStdDeviation(amount());
+      SkVector spread = MapStdDeviation(amount(), matrix);
       gfx::Rect result = rect;
-      result.Inset(-spread, -spread, -spread, -spread);
+      result.Inset(-spread.x(), -spread.y(), -spread.x(), -spread.y());
       return result;
     }
     case FilterOperation::DROP_SHADOW: {
-      int spread = SpreadForStdDeviation(amount());
+      SkVector spread = MapStdDeviation(amount(), matrix);
       gfx::Rect result = rect;
-      result.Inset(-spread, -spread, -spread, -spread);
+      result.Inset(-spread.x(), -spread.y(), -spread.x(), -spread.y());
       result += drop_shadow_offset().OffsetFromOrigin();
       result.Union(rect);
       return result;
     }
     case FilterOperation::REFERENCE: {
       if (!image_filter())
         return rect;
       SkIRect in_rect = gfx::RectToSkIRect(rect);
       SkIRect out_rect = image_filter()->filterBounds(
-          in_rect, SkMatrix::I(), SkImageFilter::kForward_MapDirection);
+          in_rect, matrix, SkImageFilter::kForward_MapDirection);
       return gfx::SkIRectToRect(out_rect);
     }
     default:
       return rect;
   }
 }
 
 }  // namespace cc