Use new Skia Blur Filter.

Skia Blur image filter has a new mode to clamp pixels outside image to
image edge. This can resolve the bleeding black issue at the bounds of
texture.

BUG=622128
TEST=manual tested with lock screen and new app launcher.

Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Id13383910327882d61bd908bff51d2c3fdc36bb9
Reviewed-on: https://chromium-review.googlesource.com/559935
Commit-Queue: Tao Wu <wutao@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Stephen White <senorblanco@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Reviewed-by: Vladimir Levin <vmpstr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487960}

cc/base/filter_operation.cc

@@ -22,6 +22,8 @@ bool FilterOperation::operator==(const FilterOperation& other) const {
     return false;
   if (type_ == COLOR_MATRIX)
     return !memcmp(matrix_, other.matrix_, sizeof(matrix_));
+  if (type_ == BLUR)
+    return amount_ == other.amount_ && blur_tile_mode_ == other.blur_tile_mode_;
   if (type_ == DROP_SHADOW) {
     return amount_ == other.amount_ &&
            drop_shadow_offset_ == other.drop_shadow_offset_ &&
@@ -52,6 +54,20 @@ FilterOperation::FilterOperation(FilterType type, float amount)
   memset(matrix_, 0, sizeof(matrix_));
 }
 
+FilterOperation::FilterOperation(FilterType type,
+                                 float amount,
+                                 SkBlurImageFilter::TileMode tile_mode)
+    : type_(type),
+      amount_(amount),
+      outer_threshold_(0),
+      drop_shadow_offset_(0, 0),
+      drop_shadow_color_(0),
+      zoom_inset_(0),
+      blur_tile_mode_(tile_mode) {
+  DCHECK_EQ(type_, BLUR);
+  memset(matrix_, 0, sizeof(matrix_));
+}
+
 FilterOperation::FilterOperation(FilterType type,
                                  const gfx::Point& offset,
                                  float stdDeviation,
@@ -124,7 +140,8 @@ FilterOperation::FilterOperation(const FilterOperation& other)
       drop_shadow_color_(other.drop_shadow_color_),
       image_filter_(other.image_filter_),
       zoom_inset_(other.zoom_inset_),
-      region_(other.region_) {
+      region_(other.region_),
+      blur_tile_mode_(other.blur_tile_mode_) {
   memcpy(matrix_, other.matrix_, sizeof(matrix_));
 }
 
@@ -231,7 +248,9 @@ FilterOperation FilterOperation::Blend(const FilterOperation* from,
       gfx::Tween::FloatValueBetween(progress, from_op.amount(), to_op.amount()),
       to_op.type()));
 
-  if (to_op.type() == FilterOperation::DROP_SHADOW) {
+  if (to_op.type() == FilterOperation::BLUR) {
+    blended_filter.set_blur_tile_mode(to_op.blur_tile_mode());
+  } else if (to_op.type() == FilterOperation::DROP_SHADOW) {
     gfx::Point blended_offset(gfx::Tween::LinearIntValueBetween(
                                   progress, from_op.drop_shadow_offset().x(),
                                   to_op.drop_shadow_offset().x()),

cc/base/filter_operation.h

@@ -13,6 +13,7 @@
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkScalar.h"
+#include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace base {
@@ -97,6 +98,11 @@ class CC_BASE_EXPORT FilterOperation {
     return region_;
   }
 
+  SkBlurImageFilter::TileMode blur_tile_mode() const {
+    DCHECK_EQ(type_, BLUR);
+    return blur_tile_mode_;
+  }
+
   static FilterOperation CreateGrayscaleFilter(float amount) {
     return FilterOperation(GRAYSCALE, amount);
   }
@@ -129,8 +135,11 @@ class CC_BASE_EXPORT FilterOperation {
     return FilterOperation(OPACITY, amount);
   }
 
-  static FilterOperation CreateBlurFilter(float amount) {
-    return FilterOperation(BLUR, amount);
+  static FilterOperation CreateBlurFilter(
+      float amount,
+      SkBlurImageFilter::TileMode tile_mode =
+          SkBlurImageFilter::kClampToBlack_TileMode) {
+    return FilterOperation(BLUR, amount, tile_mode);
   }
 
   static FilterOperation CreateDropShadowFilter(const gfx::Point& offset,
@@ -218,6 +227,11 @@ class CC_BASE_EXPORT FilterOperation {
     region_ = region;
   }
 
+  void set_blur_tile_mode(SkBlurImageFilter::TileMode tile_mode) {
+    DCHECK_EQ(type_, BLUR);
+    blur_tile_mode_ = tile_mode;
+  }
+
   // Given two filters of the same type, returns a filter operation created by
   // linearly interpolating a |progress| fraction from |from| to |to|. If either
   // |from| or |to| (but not both) is null, it is treated as a no-op filter of
@@ -241,6 +255,10 @@ class CC_BASE_EXPORT FilterOperation {
  private:
   FilterOperation(FilterType type, float amount);
 
+  FilterOperation(FilterType type,
+                  float amount,
+                  SkBlurImageFilter::TileMode tile_mode);
+
   FilterOperation(FilterType type,
                   const gfx::Point& offset,
                   float stdDeviation,
@@ -266,6 +284,7 @@ class CC_BASE_EXPORT FilterOperation {
   SkScalar matrix_[20];
   int zoom_inset_;
   SkRegion region_;
+  SkBlurImageFilter::TileMode blur_tile_mode_;
 };
 
 }  // namespace cc

cc/base/render_surface_filters.cc

@@ -12,7 +12,6 @@
 #include "cc/base/filter_operations.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/effects/SkAlphaThresholdFilter.h"
-#include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "third_party/skia/include/effects/SkComposeImageFilter.h"
@@ -195,7 +194,8 @@ sk_sp<SkImageFilter> RenderSurfaceFilters::BuildImageFilter(
         break;
       case FilterOperation::BLUR:
         image_filter = SkBlurImageFilter::Make(op.amount(), op.amount(),
-                                               std::move(image_filter));
+                                               std::move(image_filter), nullptr,
+                                               op.blur_tile_mode());
         break;
       case FilterOperation::DROP_SHADOW:
         image_filter = SkDropShadowImageFilter::Make(

cc/ipc/filter_operation.mojom

@@ -5,6 +5,7 @@
 module cc.mojom;
 
 import "skia/public/interfaces/image_filter.mojom";
+import "skia/public/interfaces/blur_image_filter_tile_mode.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 
 enum FilterType {
@@ -35,6 +36,7 @@ struct FilterOperation {
   skia.mojom.ImageFilter image_filter;
   array<float, 20>? matrix;
   int32 zoom_inset;
+  skia.mojom.BlurTileMode blur_tile_mode;
   // Note: SkRegion is currently not needed for serialization.
 };
 

cc/ipc/filter_operation_struct_traits.h

@@ -7,6 +7,7 @@
 
 #include "cc/base/filter_operation.h"
 #include "cc/ipc/filter_operation.mojom-shared.h"
+#include "skia/public/interfaces/blur_image_filter_tile_mode_struct_traits.h"
 #include "skia/public/interfaces/image_filter_struct_traits.h"
 
 namespace mojo {
@@ -141,6 +142,14 @@ struct StructTraits<cc::mojom::FilterOperationDataView, cc::FilterOperation> {
     return operation.zoom_inset();
   }
 
+  static skia::mojom::BlurTileMode blur_tile_mode(
+      const cc::FilterOperation& operation) {
+    if (operation.type() != cc::FilterOperation::BLUR)
+      return skia::mojom::BlurTileMode::CLAMP_TO_BLACK;
+    return EnumTraits<skia::mojom::BlurTileMode, SkBlurImageFilter::TileMode>::
+        ToMojom(operation.blur_tile_mode());
+  }
+
   static bool Read(cc::mojom::FilterOperationDataView data,
                    cc::FilterOperation* out) {
     out->set_type(MojoFilterTypeToCC(data.type()));
@@ -154,8 +163,14 @@ struct StructTraits<cc::mojom::FilterOperationDataView, cc::FilterOperation> {
       case cc::FilterOperation::SATURATING_BRIGHTNESS:
       case cc::FilterOperation::CONTRAST:
       case cc::FilterOperation::OPACITY:
+        out->set_amount(data.amount());
+        return true;
       case cc::FilterOperation::BLUR:
         out->set_amount(data.amount());
+        SkBlurImageFilter::TileMode tile_mode;
+        if (!data.ReadBlurTileMode(&tile_mode))
+          return false;
+        out->set_blur_tile_mode(tile_mode);
         return true;
       case cc::FilterOperation::DROP_SHADOW: {
         out->set_amount(data.amount());

cc/trees/layer_tree_host_pixeltest_filters.cc

@@ -36,7 +36,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlur) {
   background->AddChild(blur);
 
   FilterOperations filters;
-  filters.Append(FilterOperation::CreateBlurFilter(2.f));
+  filters.Append(FilterOperation::CreateBlurFilter(
+      2.f, SkBlurImageFilter::kClamp_TileMode));
   blur->SetBackgroundFilters(filters);
 
 #if defined(OS_WIN)
@@ -77,12 +78,13 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOutsets) {
   background->AddChild(blur);
 
   FilterOperations filters;
-  filters.Append(FilterOperation::CreateBlurFilter(5.f));
+  filters.Append(FilterOperation::CreateBlurFilter(
+      5.f, SkBlurImageFilter::kClamp_TileMode));
   blur->SetBackgroundFilters(filters);
 
 #if defined(OS_WIN)
-  // Windows has 5.6075% pixels by at most 2: crbug.com/259922
-  float percentage_pixels_large_error = 5.7f;
+  // Windows has 5.9325% pixels by at most 2: crbug.com/259922
+  float percentage_pixels_large_error = 6.0f;
   float percentage_pixels_small_error = 0.0f;
   float average_error_allowed_in_bad_pixels = 2.f;
   int large_error_allowed = 2;
@@ -138,7 +140,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) {
   blur->SetTransform(blur_transform);
 
   FilterOperations filters;
-  filters.Append(FilterOperation::CreateBlurFilter(2.f));
+  filters.Append(FilterOperation::CreateBlurFilter(
+      2.f, SkBlurImageFilter::kClamp_TileMode));
   blur->SetBackgroundFilters(filters);
 
 #if defined(OS_WIN)
@@ -478,7 +481,8 @@ class ImageBackgroundFilter : public LayerTreeHostFiltersPixelTest {
 
     // Add a blur filter to the blue layer.
     FilterOperations filters;
-    filters.Append(FilterOperation::CreateBlurFilter(5.0f));
+    filters.Append(FilterOperation::CreateBlurFilter(
+        5.0f, SkBlurImageFilter::kClamp_TileMode));
     filter->SetBackgroundFilters(filters);
 
     // Allow some fuzziness so that this doesn't fail when Skia makes minor
@@ -935,7 +939,8 @@ class BlurFilterWithClip : public LayerTreeHostFiltersPixelTest {
     filter_layer->AddChild(child4);
 
     FilterOperations filters;
-    filters.Append(FilterOperation::CreateBlurFilter(2.f));
+    filters.Append(FilterOperation::CreateBlurFilter(
+        2.f, SkBlurImageFilter::kClamp_TileMode));
     filter_layer->SetFilters(filters);
 
     // Force the allocation a larger textures.

skia/public/interfaces/BUILD.gn

@@ -7,6 +7,7 @@ import("//mojo/public/tools/bindings/mojom.gni")
 mojom("interfaces") {
   sources = [
     "bitmap.mojom",
+    "blur_image_filter_tile_mode.mojom",
     "image_filter.mojom",
   ]
 }

skia/public/interfaces/OWNERS

@@ -3,3 +3,6 @@ per-file *_struct_traits*.*=file://ipc/SECURITY_OWNERS
 
 per-file *.mojom=set noparent
 per-file *.mojom=file://ipc/SECURITY_OWNERS
+
+per-file *.typemap=set noparent
+per-file *.typemap=file://ipc/SECURITY_OWNERS

skia/public/interfaces/blur_image_filter_tile_mode.mojom

+// Copyright 2017 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.
+
+module skia.mojom;
+
+// Mirror of SkBlurImageFilter::TileMode.
+enum BlurTileMode {
+  CLAMP,
+  REPEAT,
+  CLAMP_TO_BLACK,
+  BLUR_TILE_MODE_LAST = CLAMP_TO_BLACK
+};

skia/public/interfaces/blur_image_filter_tile_mode.typemap

+# Copyright 2017 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.
+
+mojom = "//skia/public/interfaces/blur_image_filter_tile_mode.mojom"
+public_headers = [ "//third_party/skia/include/effects/SkBlurImageFilter.h" ]
+traits_headers =
+    [ "//skia/public/interfaces/blur_image_filter_tile_mode_struct_traits.h" ]
+type_mappings = [ "skia.mojom.BlurTileMode=SkBlurImageFilter::TileMode" ]

skia/public/interfaces/blur_image_filter_tile_mode_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef SKIA_PUBLIC_INTERFACES_BLUR_IMAGE_FILTER_TILE_MODE_STRUCT_TRAITS_H_
+#define SKIA_PUBLIC_INTERFACES_BLUR_IMAGE_FILTER_TILE_MODE_STRUCT_TRAITS_H_
+
+#include "skia/public/interfaces/blur_image_filter_tile_mode.mojom-shared.h"
+#include "third_party/skia/include/effects/SkBlurImageFilter.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<skia::mojom::BlurTileMode, SkBlurImageFilter::TileMode> {
+  static skia::mojom::BlurTileMode ToMojom(
+      SkBlurImageFilter::TileMode tile_mode) {
+    switch (tile_mode) {
+      case SkBlurImageFilter::kClamp_TileMode:
+        return skia::mojom::BlurTileMode::CLAMP;
+      case SkBlurImageFilter::kRepeat_TileMode:
+        return skia::mojom::BlurTileMode::REPEAT;
+      case SkBlurImageFilter::kClampToBlack_TileMode:
+        return skia::mojom::BlurTileMode::CLAMP_TO_BLACK;
+    }
+    NOTREACHED();
+    return skia::mojom::BlurTileMode::CLAMP_TO_BLACK;
+  }
+
+  static bool FromMojom(skia::mojom::BlurTileMode input,
+                        SkBlurImageFilter::TileMode* out) {
+    switch (input) {
+      case skia::mojom::BlurTileMode::CLAMP:
+        *out = SkBlurImageFilter::kClamp_TileMode;
+        return true;
+      case skia::mojom::BlurTileMode::REPEAT:
+        *out = SkBlurImageFilter::kRepeat_TileMode;
+        return true;
+      case skia::mojom::BlurTileMode::CLAMP_TO_BLACK:
+        *out = SkBlurImageFilter::kClampToBlack_TileMode;
+        return true;
+    }
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // SKIA_PUBLIC_INTERFACES_BLUR_IMAGE_FILTER_TILE_MODE_STRUCT_TRAITS_H_

skia/public/interfaces/test/struct_traits_unittest.cc

@@ -9,6 +9,7 @@
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkString.h"
+#include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkDropShadowImageFilter.h"
 #include "ui/gfx/skia_util.h"
@@ -34,6 +35,12 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
     std::move(callback).Run(b);
   }
 
+  void EchoBlurImageFilterTileMode(
+      SkBlurImageFilter::TileMode t,
+      EchoBlurImageFilterTileModeCallback callback) override {
+    std::move(callback).Run(t);
+  }
+
   void EchoImageFilter(const sk_sp<SkImageFilter>& i,
                        EchoImageFilterCallback callback) override {
     std::move(callback).Run(i);
@@ -126,4 +133,12 @@ TEST_F(StructTraitsTest, DropShadowImageFilter) {
   EXPECT_EQ(input_str, output_str);
 }
 
+TEST_F(StructTraitsTest, BlurImageFilterTileMode) {
+  SkBlurImageFilter::TileMode input(SkBlurImageFilter::kClamp_TileMode);
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  SkBlurImageFilter::TileMode output;
+  proxy->EchoBlurImageFilterTileMode(input, &output);
+  EXPECT_EQ(input, output);
+}
+
 }  // namespace skia

skia/public/interfaces/test/traits_test_service.mojom

@@ -5,6 +5,7 @@
 module skia.mojom;
 
 import "skia/public/interfaces/bitmap.mojom";
+import "skia/public/interfaces/blur_image_filter_tile_mode.mojom";
 import "skia/public/interfaces/image_filter.mojom";
 
 // All functions on this interface echo their arguments to test StructTraits
@@ -13,6 +14,9 @@ interface TraitsTestService {
   [Sync]
   EchoBitmap(Bitmap b) => (Bitmap pass);
 
+  [Sync]
+  EchoBlurImageFilterTileMode(BlurTileMode t) => (BlurTileMode pass);
+
   [Sync]
   EchoImageFilter(ImageFilter i) => (ImageFilter pass);
 };

skia/public/interfaces/typemaps.gni

@@ -3,6 +3,7 @@
 # found in the LICENSE file.
 
 typemaps = [
+  "//skia/public/interfaces/blur_image_filter_tile_mode.typemap",
   "//skia/public/interfaces/image_filter.typemap",
   "//skia/public/interfaces/skbitmap.typemap",
 ]

ui/compositor/layer.cc

@@ -92,7 +92,7 @@ Layer::Layer()
       visible_(true),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(false),
-      background_blur_radius_(0),
+      background_blur_sigma_(0.0f),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
@@ -118,7 +118,7 @@ Layer::Layer(LayerType type)
       visible_(true),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(false),
-      background_blur_radius_(0),
+      background_blur_sigma_(0.0f),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
@@ -165,7 +165,7 @@ std::unique_ptr<Layer> Layer::Clone() const {
   auto clone = base::MakeUnique<Layer>(type_);
 
   // Background filters.
-  clone->SetBackgroundBlur(background_blur_radius_);
+  clone->SetBackgroundBlur(background_blur_sigma_);
   clone->SetBackgroundZoom(zoom_, zoom_inset_);
 
   // Filters.
@@ -395,8 +395,8 @@ float Layer::GetTargetTemperature() const {
   return layer_temperature();
 }
 
-void Layer::SetBackgroundBlur(int blur_radius) {
-  background_blur_radius_ = blur_radius;
+void Layer::SetBackgroundBlur(float blur_sigma) {
+  background_blur_sigma_ = blur_sigma;
 
   SetLayerBackgroundFilters();
 }
@@ -512,9 +512,9 @@ void Layer::SetLayerBackgroundFilters() {
   if (zoom_ != 1)
     filters.Append(cc::FilterOperation::CreateZoomFilter(zoom_, zoom_inset_));
 
-  if (background_blur_radius_) {
+  if (background_blur_sigma_) {
     filters.Append(cc::FilterOperation::CreateBlurFilter(
-        background_blur_radius_));
+        background_blur_sigma_, SkBlurImageFilter::kClamp_TileMode));
   }
 
   cc_layer_->SetBackgroundFilters(filters);

ui/compositor/layer.h

@@ -193,10 +193,10 @@ class COMPOSITOR_EXPORT Layer
   // temperature otherwise.
   float GetTargetTemperature() const;
 
-  // Blur pixels by this amount in anything below the layer and visible through
-  // the layer.
-  int background_blur() const { return background_blur_radius_; }
-  void SetBackgroundBlur(int blur_radius);
+  // Blur pixels by 3 * this amount in anything below the layer and visible
+  // through the layer.
+  float background_blur() const { return background_blur_sigma_; }
+  void SetBackgroundBlur(float blur_sigma);
 
   // Saturate all pixels of this layer by this amount.
   // This effect will get "combined" with the inverted,
@@ -503,7 +503,7 @@ class COMPOSITOR_EXPORT Layer
   // to paint the content.
   cc::Region paint_region_;
 
-  int background_blur_radius_;
+  float background_blur_sigma_;
 
   // Several variables which will change the visible representation of
   // the layer.