Revert of Implement filter effects in Core Animation using CAFilters.

ui/accelerated_widget_mac/ca_renderer_layer_tree.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 "ui/accelerated_widget_mac/ca_renderer_layer_tree.h"
 
 #include <AVFoundation/AVFoundation.h>
 #include <CoreMedia/CoreMedia.h>
 #include <CoreVideo/CoreVideo.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/geometry/dip_util.h"
+#include "ui/gl/ca_renderer_layer_params.h"
 #include "ui/gl/gl_image_io_surface.h"
 
 #if !defined(MAC_OS_X_VERSION_10_8) || \
     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8
 extern NSString* const AVLayerVideoGravityResize;
 extern "C" void NSAccessibilityPostNotificationWithUserInfo(
     id object,
     NSString* notification,
     NSDictionary* user_info);
 extern "C" OSStatus CMSampleBufferCreateForImageBuffer(
     CFAllocatorRef,
     CVImageBufferRef,
     Boolean dataReady,
     CMSampleBufferMakeDataReadyCallback,
     void*,
     CMVideoFormatDescriptionRef,
     const CMSampleTimingInfo*,
     CMSampleBufferRef*);
 extern "C" CFArrayRef CMSampleBufferGetSampleAttachmentsArray(CMSampleBufferRef,
                                                               Boolean);
 extern "C" OSStatus CMVideoFormatDescriptionCreateForImageBuffer(
     CFAllocatorRef,
     CVImageBufferRef,
     CMVideoFormatDescriptionRef*);
 extern "C" CMTime CMTimeMake(int64_t, int32_t);
 extern CFStringRef const kCMSampleAttachmentKey_DisplayImmediately;
 extern const CMTime kCMTimeInvalid;
 #endif  // MAC_OS_X_VERSION_10_8
 
-// CAFilter and CAColorMatrix are QuartzCore SPI.
-@interface CAFilter : NSObject<NSCopying, NSMutableCopying, NSCoding>
-@end
-
-@interface CAFilter (QuartzCoreSPI)
-+ (CAFilter*)filterWithType:(NSString*)type;
-@end
-
-// TODO(erikchen): Test out the named filter kCAFilterColorInvert.
-// https://crbug.com/581526.
-extern NSString* const kCAFilterColorMatrix;
-extern NSString* const kCAFilterColorMonochrome;
-extern NSString* const kCAFilterColorHueRotate;
-extern NSString* const kCAFilterColorSaturate;
-extern NSString* const kCAFilterGaussianBlur;
-
-struct CAColorMatrix {
-  float m11, m12, m13, m14, m15;
-  float m21, m22, m23, m24, m25;
-  float m31, m32, m33, m34, m35;
-  float m41, m42, m43, m44, m45;
-};
-typedef struct CAColorMatrix CAColorMatrix;
-
-@interface NSValue (QuartzCoreSPI)
-+ (NSValue*)valueWithCAColorMatrix:(CAColorMatrix)t;
-@end
-
 namespace ui {
 
 namespace {
 
-float Blend(float from, float to, float progress) {
-  return from + (to - from) * progress;
-}
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-double DegreeToRadians(double degree)  { return degree * M_PI / 180.0; }
-
-// These values were obtained from https://www.w3.org/TR/filter-effects/.
-static const double kSepiaFullConstants[3][3] = {
-  { 0.393, 0.769, 0.189 },
-  { 0.349, 0.686, 0.168 },
-  { 0.272, 0.534, 0.131 }
-};
-
-static const double kSepiaNoneConstants[3][3] = {
-  { 1, 0, 0 },
-  { 0, 1, 0 },
-  { 0, 0, 1 }
-};
-
 // This will enqueue |io_surface| to be drawn by |av_layer|. This will
 // retain |cv_pixel_buffer| until it is no longer being displayed.
 bool AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(
     AVSampleBufferDisplayLayer* av_layer,
     CVPixelBufferRef cv_pixel_buffer) {
   OSStatus os_status = noErr;
 
   base::ScopedCFTypeRef<CMVideoFormatDescriptionRef> video_info;
   os_status = CMVideoFormatDescriptionCreateForImageBuffer(
       nullptr, cv_pixel_buffer, video_info.InitializeInto());
@@ skipping 57 matching lines @@
       nullptr, io_surface, nullptr, cv_pixel_buffer.InitializeInto());
   if (cv_return != kCVReturnSuccess) {
     LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
     return false;
   }
 
   return AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
                                                         cv_pixel_buffer);
 }
 
-// If the filter effect can be represented as a named filter, return it.
-// Otherwise, return nil.
-CAFilter* NamedFilterForType(CARendererLayerParams::FilterEffectType type,
-                             float amount) {
-  CAFilter* filter = nil;
-  switch (type) {
-    case CARendererLayerParams::FilterEffectType::GRAYSCALE:
-      filter = [CAFilter filterWithType:kCAFilterColorMonochrome];
-      [filter setValue:@(amount) forKey:@"inputAmount"];
-      break;
-    case CARendererLayerParams::FilterEffectType::SATURATE:
-      filter = [CAFilter filterWithType:kCAFilterColorSaturate];
-      [filter setValue:@(amount) forKey:@"inputAmount"];
-      break;
-    case CARendererLayerParams::FilterEffectType::HUE_ROTATE:
-      filter = [CAFilter filterWithType:kCAFilterColorHueRotate];
-      [filter setValue:@(DegreeToRadians(amount)) forKey:@"inputAngle"];
-      break;
-    case CARendererLayerParams::FilterEffectType::BLUR:
-      filter = [CAFilter filterWithType:kCAFilterGaussianBlur];
-      [filter setValue:@(amount) forKey:@"inputRadius"];
-      break;
-    default:
-      break;
-  }
-  return filter;
-}
-
-// If the filter effect has a corresponding color matrix, return it. Otherwise,
-// return nil.
-NSValue* ColorMatrixForType(CARendererLayerParams::FilterEffectType type,
-                            float amount) {
-  switch (type) {
-    case CARendererLayerParams::FilterEffectType::SEPIA:
-    {
-      float t = std::min(std::max(0.0f, amount), 1.0f);
-      CAColorMatrix colorMatrix = {
-        Blend(kSepiaNoneConstants[0][0], kSepiaFullConstants[0][0], t),
-        Blend(kSepiaNoneConstants[0][1], kSepiaFullConstants[0][1], t),
-        Blend(kSepiaNoneConstants[0][2], kSepiaFullConstants[0][2], t),
-        0, 0,
-
-        Blend(kSepiaNoneConstants[1][0], kSepiaFullConstants[1][0], t),
-        Blend(kSepiaNoneConstants[1][1], kSepiaFullConstants[1][1], t),
-        Blend(kSepiaNoneConstants[1][2], kSepiaFullConstants[1][2], t),
-        0, 0,
-
-        Blend(kSepiaNoneConstants[2][0], kSepiaFullConstants[2][0], t),
-        Blend(kSepiaNoneConstants[2][1], kSepiaFullConstants[2][1], t),
-        Blend(kSepiaNoneConstants[2][2], kSepiaFullConstants[2][2], t),
-        0, 0, 0, 0, 0, 1, 0
-      };
-      return [NSValue valueWithCAColorMatrix:colorMatrix];
-    }
-    case CARendererLayerParams::FilterEffectType::INVERT:
-    {
-      float multiplier = 1 - amount * 2;
-      CAColorMatrix colorMatrix = {
-        multiplier, 0, 0, 0, amount,
-        0, multiplier, 0, 0, amount,
-        0, 0, multiplier, 0, amount,
-        0, 0, 0, 1, 0
-      };
-      return [NSValue valueWithCAColorMatrix:colorMatrix];
-    }
-    case CARendererLayerParams::FilterEffectType::BRIGHTNESS:
-    {
-      CAColorMatrix colorMatrix = {
-        amount, 0, 0, 0, 0,
-        0, amount, 0, 0, 0,
-        0, 0, amount, 0, 0,
-        0, 0, 0, 1, 0
-      };
-      return [NSValue valueWithCAColorMatrix:colorMatrix];
-    }
-    case CARendererLayerParams::FilterEffectType::CONTRAST:
-    {
-      float intercept = -0.5 * amount + 0.5;
-      CAColorMatrix colorMatrix = {
-        amount, 0, 0, 0, intercept,
-        0, amount, 0, 0, intercept,
-        0, 0, amount, 0, intercept,
-        0, 0, 0, 1, 0
-      };
-      return [NSValue valueWithCAColorMatrix:colorMatrix];
-    }
-    case CARendererLayerParams::FilterEffectType::OPACITY:
-    {
-      CAColorMatrix colorMatrix = {
-        1, 0, 0, 0, 0,
-        0, 1, 0, 0, 0,
-        0, 0, 1, 0, 0,
-        0, 0, 0, amount, 0
-      };
-      return [NSValue valueWithCAColorMatrix:colorMatrix];
-    }
-    default:
-      return nil;
-  }
-}
-
-// Updates the CALayer to accurately represent the given |filter_effects|.
-void UpdateFiltersOnCALayer(
-    const CARendererLayerParams::FilterEffects& filter_effects,
-    CALayer* layer) {
-  if (filter_effects.empty()) {
-    // It's possible that this enables shadow properties, even if there were
-    // none before. That's an implementation detail of Core Animation.
-    [layer setShadowOffset:CGSizeZero];
-    [layer setShadowColor:nil];
-    [layer setShadowRadius:0];
-    [layer setShadowOpacity:0];
-    layer.filters = @[];
-    return;
-  }
-
-  NSMutableArray* filters = [NSMutableArray array];
-  for (const CARendererLayerParams::FilterEffect& filter_effect :
-       filter_effects) {
-    CAFilter* filter =
-        NamedFilterForType(filter_effect.type, filter_effect.amount);
-    if (filter) {
-      [filters addObject:filter];
-      continue;
-    }
-
-    NSValue* color_matrix =
-        ColorMatrixForType(filter_effect.type, filter_effect.amount);
-    if (color_matrix) {
-      CAFilter* filter = [CAFilter filterWithType:kCAFilterColorMatrix];
-      [filter setValue:color_matrix forKey:@"inputColorMatrix"];
-      [filters addObject:filter];
-      continue;
-    }
-
-    DCHECK_EQ(CARendererLayerParams::FilterEffectType::DROP_SHADOW,
-              filter_effect.type);
-    [layer setShadowOffset:CGSizeMake(filter_effect.drop_shadow_offset.x(),
-                                      filter_effect.drop_shadow_offset.y())];
-
-    CGFloat rgba_color_components[4] = {
-        SkColorGetR(filter_effect.drop_shadow_color) / 255.,
-        SkColorGetG(filter_effect.drop_shadow_color) / 255.,
-        SkColorGetB(filter_effect.drop_shadow_color) / 255.,
-        SkColorGetA(filter_effect.drop_shadow_color) / 255.,
-    };
-    base::ScopedCFTypeRef<CGColorRef> srgb_color(CGColorCreate(
-        CGColorSpaceCreateWithName(kCGColorSpaceSRGB), rgba_color_components));
-    [layer setShadowColor:srgb_color.get()];
-    [layer setShadowRadius:filter_effect.amount];
-    [layer setShadowOpacity:1];
-  }
-  layer.filters = filters;
-}
-
 }  // namespace
 
 CARendererLayerTree::CARendererLayerTree() {}
 CARendererLayerTree::~CARendererLayerTree() {}
 
 bool CARendererLayerTree::ScheduleCALayer(const CARendererLayerParams& params) {
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DLOG.
   if (has_committed_) {
     LOG(ERROR) << "ScheduleCALayer called after CommitScheduledCALayers.";
@@ skipping 127 matching lines @@
 }
 
 CARendererLayerTree::ContentLayer::ContentLayer(
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity,
-    unsigned filter,
-    const CARendererLayerParams::FilterEffects& filter_effects)
+    unsigned filter)
     : io_surface(io_surface),
       cv_pixel_buffer(cv_pixel_buffer),
       contents_rect(contents_rect),
       rect(rect),
       background_color(background_color),
       ca_edge_aa_mask(0),
       opacity(opacity),
-      ca_filter(filter == GL_LINEAR ? kCAFilterLinear : kCAFilterNearest),
-      filter_effects(filter_effects) {
+      ca_filter(filter == GL_LINEAR ? kCAFilterLinear : kCAFilterNearest) {
   DCHECK(filter == GL_LINEAR || filter == GL_NEAREST);
 
   // Because the root layer has setGeometryFlipped:YES, there is some ambiguity
   // about what exactly top and bottom mean. This ambiguity is resolved in
   // different ways for solid color CALayers and for CALayers that have content
   // (surprise!). For CALayers with IOSurface content, the top edge in the AA
   // mask refers to what appears as the bottom edge on-screen. For CALayers
   // without content (solid color layers), the top edge in the AA mask is the
   // top edge on-screen.
   // https://crbug.com/567946
@@ skipping 26 matching lines @@
     : io_surface(layer.io_surface),
       cv_pixel_buffer(layer.cv_pixel_buffer),
       contents_rect(layer.contents_rect),
       rect(layer.rect),
       background_color(layer.background_color),
       ca_edge_aa_mask(layer.ca_edge_aa_mask),
       opacity(layer.opacity),
       ca_filter(layer.ca_filter),
       ca_layer(std::move(layer.ca_layer)),
       av_layer(std::move(layer.av_layer)),
-      use_av_layer(layer.use_av_layer),
-      filter_effects(layer.filter_effects) {
+      use_av_layer(layer.use_av_layer) {
   DCHECK(!layer.ca_layer);
   DCHECK(!layer.av_layer);
 }
 
 CARendererLayerTree::ContentLayer::~ContentLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
 bool CARendererLayerTree::RootLayer::AddContentLayer(
     const CARendererLayerParams& params) {
@@ skipping 57 matching lines @@
     gl::GLImageIOSurface* io_surface_image =
         gl::GLImageIOSurface::FromGLImage(params.image);
     DCHECK(io_surface_image);
     io_surface = io_surface_image->io_surface();
     cv_pixel_buffer = io_surface_image->cv_pixel_buffer();
   }
 
   content_layers.push_back(
       ContentLayer(io_surface, cv_pixel_buffer, params.contents_rect,
                    params.rect, params.background_color, params.edge_aa_mask,
-                   params.opacity, params.filter, params.filter_effects));
+                   params.opacity, params.filter));
 }
 
 void CARendererLayerTree::RootLayer::CommitToCA(CALayer* superlayer,
                                                 RootLayer* old_layer,
                                                 float scale_factor) {
   if (old_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
   } else {
     ca_layer.reset([[CALayer alloc] init]);
@@ skipping 107 matching lines @@
 void CARendererLayerTree::ContentLayer::CommitToCA(CALayer* superlayer,
                                                    ContentLayer* old_layer,
                                                    float scale_factor) {
   bool update_contents = true;
   bool update_contents_rect = true;
   bool update_rect = true;
   bool update_background_color = true;
   bool update_ca_edge_aa_mask = true;
   bool update_opacity = true;
   bool update_ca_filter = true;
-  bool update_filter_effects =
-      (old_layer && !old_layer->filter_effects.empty()) ||
-      !filter_effects.empty();
   if (old_layer && old_layer->use_av_layer == use_av_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
     std::swap(av_layer, old_layer->av_layer);
     update_contents = old_layer->io_surface != io_surface ||
                       old_layer->cv_pixel_buffer != cv_pixel_buffer;
     update_contents_rect = old_layer->contents_rect != contents_rect;
     update_rect = old_layer->rect != rect;
     update_background_color = old_layer->background_color != background_color;
     update_ca_edge_aa_mask = old_layer->ca_edge_aa_mask != ca_edge_aa_mask;
     update_opacity = old_layer->opacity != opacity;
     update_ca_filter = old_layer->ca_filter != ca_filter;
-    update_filter_effects = old_layer->filter_effects != filter_effects;
   } else {
     if (use_av_layer) {
       av_layer.reset([[AVSampleBufferDisplayLayer alloc] init]);
       ca_layer.reset([av_layer retain]);
       [av_layer setVideoGravity:AVLayerVideoGravityResize];
     } else {
       ca_layer.reset([[CALayer alloc] init]);
     }
     [ca_layer setAnchorPoint:CGPointZero];
     [superlayer addSublayer:ca_layer];
   }
   DCHECK_EQ([ca_layer superlayer], superlayer);
   bool update_anything = update_contents || update_contents_rect ||
                          update_rect || update_background_color ||
                          update_ca_edge_aa_mask || update_opacity ||
-                         update_ca_filter || update_filter_effects;
+                         update_ca_filter;
   if (use_av_layer) {
     if (update_contents) {
       if (cv_pixel_buffer) {
         AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
                                                        cv_pixel_buffer);
       } else {
         AVSampleBufferDisplayLayerEnqueueIOSurface(av_layer, io_surface);
       }
     }
   } else {
@@ skipping 23 matching lines @@
     [ca_layer setBackgroundColor:srgb_background_color];
   }
   if (update_ca_edge_aa_mask)
     [ca_layer setEdgeAntialiasingMask:ca_edge_aa_mask];
   if (update_opacity)
     [ca_layer setOpacity:opacity];
   if (update_ca_filter) {
     [ca_layer setMagnificationFilter:ca_filter];
     [ca_layer setMinificationFilter:ca_filter];
   }
-  if (update_filter_effects) {
-    UpdateFiltersOnCALayer(filter_effects, ca_layer.get());
-  }
 
   static bool show_borders = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kShowMacOverlayBorders);
   if (show_borders) {
     base::ScopedCFTypeRef<CGColorRef> color;
     if (update_anything) {
       if (use_av_layer) {
         // Yellow represents an AV layer that changed this frame.
         color.reset(CGColorCreateGenericRGB(1, 1, 0, 1));
       } else {
         // Pink represents a CALayer that changed this frame.
         color.reset(CGColorCreateGenericRGB(1, 0, 1, 1));
       }
     } else {
       // Grey represents a CALayer that has not changed.
       color.reset(CGColorCreateGenericRGB(0.5, 0.5, 0.5, 1));
     }
     [ca_layer setBorderWidth:1];
     [ca_layer setBorderColor:color];
   }
 }
 
 }  // namespace ui