Hook up plumbing for minification/magnification filters.

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"
+#include "testing/gtest_mac.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accelerated_widget_mac/ca_renderer_layer_tree.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/mac/io_surface.h"
 
 namespace gpu {
 
 class CALayerTreeTest : public testing::Test {
  protected:
   void SetUp() override {
@@ skipping 13 matching lines @@
   bool is_clipped = true;
   gfx::Rect clip_rect(2, 4, 8, 16);
   int sorting_context_id = 0;
   gfx::Transform transform;
   transform.Translate(10, 20);
   gfx::RectF contents_rect(0.0f, 0.25f, 0.5f, 0.75f);
   gfx::Rect rect(16, 32, 64, 128);
   unsigned background_color = SkColorSetARGB(0xFF, 0xFF, 0, 0);
   unsigned edge_aa_mask = GL_CA_LAYER_EDGE_LEFT_CHROMIUM;
   float opacity = 0.5f;
+  unsigned filter = GL_LINEAR;
   float scale_factor = 1.0f;
   bool result = false;
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
   CALayer* root_layer = nil;
   CALayer* clip_and_sorting_layer = nil;
   CALayer* transform_layer = nil;
   CALayer* content_layer = nil;
 
   // Validate the initial values.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
@@ skipping 19 matching lines @@
     EXPECT_EQ(transform.matrix().get(3, 1),
               [transform_layer sublayerTransform].m42);
 
     // Validate the content layer.
     EXPECT_EQ(static_cast<id>(io_surface.get()), [content_layer contents]);
     EXPECT_EQ(contents_rect, gfx::RectF([content_layer contentsRect]));
     EXPECT_EQ(rect.origin(), gfx::Point([content_layer position]));
     EXPECT_EQ(gfx::Rect(rect.size()), gfx::Rect([content_layer bounds]));
     EXPECT_EQ(kCALayerLeftEdge, [content_layer edgeAntialiasingMask]);
     EXPECT_EQ(opacity, [content_layer opacity]);
+    EXPECT_NSEQ(kCAFilterLinear, [content_layer minificationFilter]);
+    EXPECT_NSEQ(kCAFilterLinear, [content_layer magnificationFilter]);
     if ([content_layer respondsToSelector:(@selector(contentsScale))])
       EXPECT_EQ(scale_factor, [content_layer contentsScale]);
   }
 
   // Update just the clip rect and re-commit.
   {
     clip_rect = gfx::Rect(4, 8, 16, 32);
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 22 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 19 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 17 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 15 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         nullptr,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 17 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         nullptr,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 17 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         nullptr,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 17 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         nullptr,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     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_EQ(opacity, [content_layer opacity]);
   }
 
+  // Change the filter.
+  {
+    filter = GL_NEAREST;
+    std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
+        new ui::CARendererLayerTree);
+    result = new_ca_layer_tree->ScheduleCALayer(
+        is_clipped,
+        clip_rect,
+        sorting_context_id,
+        transform,
+        nullptr,
+        nullptr,
+        contents_rect,
+        rect,
+        background_color,
+        edge_aa_mask,
+        opacity,
+        filter);
+    EXPECT_TRUE(result);
+    new_ca_layer_tree->CommitScheduledCALayers(
+        superlayer_, std::move(ca_layer_tree), scale_factor);
+    std::swap(new_ca_layer_tree, ca_layer_tree);
+
+    // Validate the tree structure.
+    EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
+    EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
+    EXPECT_EQ(1u, [[root_layer sublayers] count]);
+    EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
+    EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
+    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 the clipping and IOSurface contents back.
   {
     is_clipped = true;
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_EQ(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     EXPECT_EQ(clip_and_sorting_layer, [[root_layer sublayers] objectAtIndex:0]);
@@ skipping 17 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     EXPECT_NE(root_layer, [[superlayer_ sublayers] objectAtIndex:0]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
@@ skipping 42 matching lines @@
 TEST_F(CALayerTreeTest, SplitSortingContextZero) {
   bool is_clipped = false;
   gfx::Rect clip_rect;
   int sorting_context_id = 0;
   gfx::RectF contents_rect(0, 0, 1, 1);
   gfx::Rect 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;
 
   // We'll use the IOSurface contents to identify the content layers.
   base::ScopedCFTypeRef<IOSurfaceRef> io_surfaces[5];
   for (size_t i = 0; i < 5; ++i) {
     io_surfaces[i].reset(gfx::CreateIOSurface(
         gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888));
   }
 
   // Have 5 transforms:
   // * 2 flat but different (1 sorting context layer, 2 transform layers)
@@ skipping 14 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transforms[i],
         io_surfaces[i],
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr, scale_factor);
 
   // Validate the root layer.
   EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
   CALayer* root_layer = [[superlayer_ sublayers] objectAtIndex:0];
 
   // Validate that we have 3 sorting context layers.
   EXPECT_EQ(3u, [[root_layer sublayers] count]);
@@ skipping 43 matching lines @@
   bool is_clipped = false;
   gfx::Rect clip_rect;
   int sorting_context_ids[3] = {3, -1, 0};
   gfx::RectF contents_rect(0, 0, 1, 1);
   gfx::Rect rect(0, 0, 256, 256);
   gfx::Transform transform;
   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;
 
   // We'll use the IOSurface contents to identify the content layers.
   base::ScopedCFTypeRef<IOSurfaceRef> io_surfaces[3];
   for (size_t i = 0; i < 3; ++i) {
     io_surfaces[i].reset(gfx::CreateIOSurface(
         gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888));
   }
 
   // Schedule and commit the layers.
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
       new ui::CARendererLayerTree);
   for (size_t i = 0; i < 3; ++i) {
     bool result = ca_layer_tree->ScheduleCALayer(
         is_clipped,
         clip_rect,
         sorting_context_ids[i],
         transform,
         io_surfaces[i],
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr, scale_factor);
 
   // Validate the root layer.
   EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
   CALayer* root_layer = [[superlayer_ sublayers] objectAtIndex:0];
 
   // Validate that we have 3 sorting context layers.
   EXPECT_EQ(3u, [[root_layer sublayers] count]);
@@ skipping 28 matching lines @@
 
 // Verify that sorting contexts must all have the same clipping properties.
 TEST_F(CALayerTreeTest, SortingContextMustHaveConsistentClip) {
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
   gfx::RectF contents_rect(0, 0, 1, 1);
   gfx::Rect rect(0, 0, 256, 256);
   gfx::Transform transform;
   unsigned background_color = SkColorSetARGB(0xFF, 0xFF, 0xFF, 0xFF);
   unsigned edge_aa_mask = 0;
   float opacity = 1.0f;
+  unsigned filter = GL_LINEAR;
 
   // Vary the clipping parameters within sorting contexts.
   bool is_clippeds[3] = { true, true, false};
   gfx::Rect clip_rects[3] = {
       gfx::Rect(0, 0, 16, 16),
       gfx::Rect(4, 8, 16, 32),
       gfx::Rect(0, 0, 16, 16)
   };
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
       new ui::CARendererLayerTree);
   // First send the various clip parameters to sorting context zero. This is
   // legitimate.
   for (size_t i = 0; i < 3; ++i) {
     int sorting_context_id = 0;
     bool result = ca_layer_tree->ScheduleCALayer(
         is_clippeds[i],
         clip_rects[i],
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
   }
   // Next send the various clip parameters to a non-zero sorting context. This
   // will fail when we try to change the clip within the sorting context.
   for (size_t i = 0; i < 3; ++i) {
     int sorting_context_id = 3;
     bool result = ca_layer_tree->ScheduleCALayer(
         is_clippeds[i],
         clip_rects[i],
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     if (i == 0)
       EXPECT_TRUE(result);
     else
       EXPECT_FALSE(result);
   }
   // Try once more with the original clip and verify it works.
   {
     int sorting_context_id = 3;
     bool result = ca_layer_tree->ScheduleCALayer(
         is_clippeds[0],
         clip_rects[0],
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
   }
 }
 
 // Test updating each layer's properties.
 TEST_F(CALayerTreeTest, AVLayer) {
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface(gfx::CreateIOSurface(
       gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR));
 
   bool is_clipped = true;
   gfx::Rect clip_rect(2, 4, 8, 16);
   int sorting_context_id = 0;
   gfx::Transform transform;
   gfx::RectF contents_rect(0.0f, 0.0f, 1.0f, 1.0f);
   gfx::Rect rect(16, 32, 64, 128);
   unsigned background_color = SkColorSetARGB(0xFF, 0xFF, 0, 0);
   unsigned edge_aa_mask = GL_CA_LAYER_EDGE_LEFT_CHROMIUM;
   float opacity = 0.5f;
   float scale_factor = 1.0f;
   bool result = false;
+  unsigned filter = GL_LINEAR;
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
   CALayer* root_layer = nil;
   CALayer* clip_and_sorting_layer = nil;
   CALayer* transform_layer = nil;
   CALayer* content_layer1 = nil;
   CALayer* content_layer2 = nil;
   CALayer* content_layer3 = nil;
 
   // Validate the initial values.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect, background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
@@ skipping 18 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
@@ skipping 22 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         cv_pixel_buffer,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
@@ skipping 21 matching lines @@
         is_clipped,
         clip_rect,
         sorting_context_id,
         transform,
         io_surface,
         nullptr,
         contents_rect,
         rect,
         background_color,
         edge_aa_mask,
-        opacity);
+        opacity,
+        filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
@@ skipping 20 matching lines @@
   gfx::Transform transform;
   transform.Translate(10, 20);
   transform.Scale(0.5, 2.0);
   gfx::RectF contents_rect(0.0f, 0.0f, 1.0f, 1.0f);
   gfx::Rect rect(16, 32, 64, 128);
   unsigned background_color = SkColorSetARGB(0, 0, 0, 0);
   unsigned edge_aa_mask = 0;
   float opacity = 1.0f;
   float scale_factor = 1.0f;
   bool result = false;
+  unsigned filter = GL_LINEAR;
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
 
   base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
   CVPixelBufferCreateWithIOSurface(nullptr, io_surface, nullptr,
                                    cv_pixel_buffer.InitializeInto());
 
   // Test a configuration with no background.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, io_surface,
         cv_pixel_buffer, contents_rect, rect, background_color, edge_aa_mask,
-        opacity);
+        opacity, filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     bool fullscreen_low_power_valid =
         new_ca_layer_tree->CommitFullscreenLowPowerLayer(
             fullscreen_low_power_layer_);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
@@ skipping 11 matching lines @@
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     EXPECT_TRUE(fullscreen_low_power_valid);
   }
 
   // Test a configuration with a black background.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, nullptr, nullptr,
-        contents_rect, rect, SK_ColorBLACK, edge_aa_mask, opacity);
+        contents_rect, rect, SK_ColorBLACK, edge_aa_mask, opacity, filter);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, io_surface,
         cv_pixel_buffer, contents_rect, rect, background_color, edge_aa_mask,
-        opacity);
+        opacity, filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     bool fullscreen_low_power_valid =
         new_ca_layer_tree->CommitFullscreenLowPowerLayer(
             fullscreen_low_power_layer_);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
@@ skipping 11 matching lines @@
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     EXPECT_TRUE(fullscreen_low_power_valid);
   }
 
   // Test a configuration with a white background. It will fail.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, nullptr, nullptr,
-        contents_rect, rect, SK_ColorWHITE, edge_aa_mask, opacity);
+        contents_rect, rect, SK_ColorWHITE, edge_aa_mask, opacity, filter);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, io_surface,
         cv_pixel_buffer, contents_rect, rect, background_color, edge_aa_mask,
-        opacity);
+        opacity, filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     bool fullscreen_low_power_valid =
         new_ca_layer_tree->CommitFullscreenLowPowerLayer(
             fullscreen_low_power_layer_);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
@@ skipping 12 matching lines @@
     EXPECT_FALSE(fullscreen_low_power_valid);
   }
 
   // Test a configuration with a black foreground. It too will fail.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
         new ui::CARendererLayerTree);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, io_surface,
         cv_pixel_buffer, contents_rect, rect, background_color, edge_aa_mask,
-        opacity);
+        opacity, filter);
     result = new_ca_layer_tree->ScheduleCALayer(
         is_clipped, clip_rect, sorting_context_id, transform, nullptr, nullptr,
-        contents_rect, rect, SK_ColorBLACK, edge_aa_mask, opacity);
+        contents_rect, rect, SK_ColorBLACK, edge_aa_mask, opacity, filter);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), scale_factor);
     bool fullscreen_low_power_valid =
         new_ca_layer_tree->CommitFullscreenLowPowerLayer(
             fullscreen_low_power_layer_);
     std::swap(new_ca_layer_tree, ca_layer_tree);
 
     // Validate the tree structure.
     EXPECT_EQ(1u, [[superlayer_ sublayers] count]);
     CALayer* root_layer = [[superlayer_ sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[root_layer sublayers] count]);
     CALayer* clip_and_sorting_layer = [[root_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     CALayer* transform_layer =
         [[clip_and_sorting_layer sublayers] objectAtIndex:0];
     EXPECT_EQ(2u, [[transform_layer sublayers] count]);
     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