Hook up plumbing for minification/magnification filters.

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>
@@ skipping 123 matching lines @@
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     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) {
+    float opacity,
+    unsigned filter) {
   // 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.";
     return false;
   }
   return root_layer_.AddContentLayer(is_clipped, clip_rect, sorting_context_id,
                                      transform, io_surface, cv_pixel_buffer,
                                      contents_rect, rect, background_color,
-                                     edge_aa_mask, opacity);
+                                     edge_aa_mask, opacity, filter);
 }
 
 void CARendererLayerTree::CommitScheduledCALayers(
     CALayer* superlayer,
     std::unique_ptr<CARendererLayerTree> old_tree,
     float scale_factor) {
   TRACE_EVENT0("gpu", "CARendererLayerTree::CommitScheduledCALayers");
   RootLayer* old_root_layer = nullptr;
   if (old_tree) {
     DCHECK(old_tree->has_committed_);
@@ skipping 113 matching lines @@
   [ca_layer removeFromSuperlayer];
 }
 
 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)
+    float opacity,
+    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) {
+      opacity(opacity),
+      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
   if (edge_aa_mask & GL_CA_LAYER_EDGE_LEFT_CHROMIUM)
     ca_edge_aa_mask |= kCALayerLeftEdge;
@@ skipping 25 matching lines @@
 }
 
 CARendererLayerTree::ContentLayer::ContentLayer(ContentLayer&& layer)
     : 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) {
   DCHECK(!layer.ca_layer);
   DCHECK(!layer.av_layer);
 }
 
 CARendererLayerTree::ContentLayer::~ContentLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
 bool CARendererLayerTree::RootLayer::AddContentLayer(
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     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) {
+    float opacity,
+    unsigned filter) {
   bool needs_new_clip_and_sorting_layer = true;
 
   // In sorting_context_id 0, all quads are listed in back-to-front order.
   // This is accomplished by having the CALayers be siblings of each other.
   // If a quad has a 3D transform, it is necessary to put it in its own sorting
   // context, so that it will not intersect with quads before and after it.
   bool is_singleton_sorting_context =
       !sorting_context_id && !transform.IsFlat();
 
   if (!clip_and_sorting_layers.empty()) {
@@ skipping 17 matching lines @@
       needs_new_clip_and_sorting_layer = false;
     }
   }
   if (needs_new_clip_and_sorting_layer) {
     clip_and_sorting_layers.push_back(
         ClipAndSortingLayer(is_clipped, clip_rect, sorting_context_id,
                             is_singleton_sorting_context));
   }
   clip_and_sorting_layers.back().AddContentLayer(
       transform, io_surface, cv_pixel_buffer, contents_rect, rect,
-      background_color, edge_aa_mask, opacity);
+      background_color, edge_aa_mask, opacity, filter);
   return true;
 }
 
 void CARendererLayerTree::ClipAndSortingLayer::AddContentLayer(
     const gfx::Transform& transform,
     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) {
+    float opacity,
+    unsigned filter) {
   bool needs_new_transform_layer = true;
   if (!transform_layers.empty()) {
     const TransformLayer& current_layer = transform_layers.back();
     if (current_layer.transform == transform)
       needs_new_transform_layer = false;
   }
   if (needs_new_transform_layer)
     transform_layers.push_back(TransformLayer(transform));
   transform_layers.back().AddContentLayer(io_surface, cv_pixel_buffer,
                                           contents_rect, rect, background_color,
-                                          edge_aa_mask, opacity);
+                                          edge_aa_mask, opacity, filter);
 }
 
 void CARendererLayerTree::TransformLayer::AddContentLayer(
     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) {
+    float opacity,
+    unsigned filter) {
   content_layers.push_back(ContentLayer(io_surface, cv_pixel_buffer,
                                         contents_rect, rect, background_color,
-                                        edge_aa_mask, opacity));
+                                        edge_aa_mask, opacity, 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 106 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;
   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;
   } 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_edge_aa_mask || update_opacity ||
+                         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 19 matching lines @@
         SkColorGetA(background_color) / 255.,
     };
     base::ScopedCFTypeRef<CGColorRef> srgb_background_color(CGColorCreate(
         CGColorSpaceCreateWithName(kCGColorSpaceSRGB), rgba_color_components));
     [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];
+  }
 
   static bool show_borders = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kShowMacOverlayBorders);
   if (show_borders) {
     base::ScopedCFTypeRef<CGColorRef> color;
     if (update_anything) {
       if (use_av_layer) {
         // Green represents an AV layer that changed this frame.
         color.reset(CGColorCreateGenericRGB(0, 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, 0, 0, 0.1));
     }
     [ca_layer setBorderWidth:1];
     [ca_layer setBorderColor:color];
   }
 }
 
 }  // namespace ui