Implement filter effects in Core Animation using CAFilters.

ui/accelerated_widget_mac/ca_layer_tree_unittest_mac.mm

 // Copyright 2016 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 <AVFoundation/AVFoundation.h>
 #include <memory>
 
 #include "base/mac/sdk_forward_declarations.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 21 matching lines @@
   int sorting_context_id = 0;
   gfx::Transform transform;
   gfx::RectF contents_rect = gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f);
   gfx::Rect rect = gfx::Rect(0, 0, 256, 256);
   unsigned background_color = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
   unsigned edge_aa_mask = 0;
   float opacity = 1.0f;
   float scale_factor = 1.0f;
   unsigned filter = GL_LINEAR;
   scoped_refptr<gl::GLImageIOSurface> gl_image;
+  ui::CARendererLayerParams::FilterEffects filter_effects;
 };
 
 scoped_refptr<gl::GLImageIOSurface> CreateGLImage(const gfx::Size& size,
                                                   gfx::BufferFormat format,
                                                   bool video) {
   scoped_refptr<gl::GLImageIOSurface> gl_image(
       new gl::GLImageIOSurface(size, GL_RGBA));
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface(
       gfx::CreateIOSurface(size, format));
   if (video) {
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
     CVPixelBufferCreateWithIOSurface(nullptr, io_surface, nullptr,
                                      cv_pixel_buffer.InitializeInto());
     gl_image->InitializeWithCVPixelBuffer(cv_pixel_buffer,
                                           gfx::GenericSharedMemoryId(), format);
   } else {
     gl_image->Initialize(io_surface, gfx::GenericSharedMemoryId(), format);
   }
   return gl_image;
 }
 
 bool ScheduleCALayer(ui::CARendererLayerTree* tree,
                      CALayerProperties* properties) {
-  return tree->ScheduleCALayer(ui::CARendererLayerParams(
+  ui::CARendererLayerParams params = ui::CARendererLayerParams(
       properties->is_clipped, properties->clip_rect,
       properties->sorting_context_id, properties->transform,
       properties->gl_image.get(), properties->contents_rect, properties->rect,
       properties->background_color, properties->edge_aa_mask,
-      properties->opacity, properties->filter));
+      properties->opacity, properties->filter);
+  params.filter_effects = properties->filter_effects;
+  return tree->ScheduleCALayer(params);
 }
 
 void UpdateCALayerTree(std::unique_ptr<ui::CARendererLayerTree>& ca_layer_tree,
                        CALayerProperties* properties,
                        CALayer* superlayer) {
   std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
       new ui::CARendererLayerTree);
   bool result = ScheduleCALayer(new_ca_layer_tree.get(), properties);
   EXPECT_TRUE(result);
   new_ca_layer_tree->CommitScheduledCALayers(
@@ skipping 274 matching lines @@
     EXPECT_EQ(transform_layer,
               [[clip_and_sorting_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     EXPECT_EQ(content_layer, [[transform_layer sublayers] objectAtIndex:0]);
 
     // Validate the content layer.
     EXPECT_NSEQ(kCAFilterNearest, [content_layer minificationFilter]);
     EXPECT_NSEQ(kCAFilterNearest, [content_layer magnificationFilter]);
   }
 
+  // Add every filter effect.
+  {
+    using FilterEffectType = ui::CARendererLayerParams::FilterEffectType;
+    for (int i = static_cast<int>(FilterEffectType::MIN);
+         i <= static_cast<int>(FilterEffectType::MAX); i++) {
+      ui::CARendererLayerParams::FilterEffect filter_effect;
+      filter_effect.type = static_cast<FilterEffectType>(i);
+      filter_effect.amount = i * 0.05 + 0.1;
+      properties.filter_effects.push_back(filter_effect);
+    }
+    UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
+
+    // Validate the content layer.
+    EXPECT_EQ(9u, [[content_layer filters] count]);
+    EXPECT_GT([content_layer shadowRadius], 0.0);
+    EXPECT_LT([content_layer shadowRadius], 1.0);
+  }
+
+  // Remove every filter effect.
+  {
+    properties.filter_effects.clear();
+    UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
+
+    // Validate the content layer.
+    EXPECT_EQ(0u, [[content_layer filters] count]);
+    EXPECT_EQ(0.0, [content_layer shadowRadius]);
+  }
+
   // Add the clipping and IOSurface contents back.
   {
     properties.is_clipped = true;
     properties.gl_image =
         CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
@@ skipping 524 matching lines @@
     CALayer* content_layer = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer and fullscreen low power mode.
     EXPECT_TRUE([content_layer
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     EXPECT_FALSE(fullscreen_low_power_valid);
   }
 }
 
 }  // namespace gpu