Mac video: Add blacklist entry for AVSampleBufferDisplayLayer

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 56 matching lines @@
       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));
 }
 
 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);
+      new ui::CARendererLayerTree(true));
   bool result = ScheduleCALayer(new_ca_layer_tree.get(), properties);
   EXPECT_TRUE(result);
   new_ca_layer_tree->CommitScheduledCALayers(
+      superlayer, std::move(ca_layer_tree), properties->scale_factor);
+  std::swap(new_ca_layer_tree, ca_layer_tree);
+}
+
+void UpdateCALayerTreeWithAVDisabled(
+    std::unique_ptr<ui::CARendererLayerTree>& ca_layer_tree,
+    CALayerProperties* properties,
+    CALayer* superlayer) {
+  std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
+      new ui::CARendererLayerTree(false));
+  bool result = ScheduleCALayer(new_ca_layer_tree.get(), properties);
+  EXPECT_TRUE(result);
+  new_ca_layer_tree->CommitScheduledCALayers(
       superlayer, std::move(ca_layer_tree), properties->scale_factor);
   std::swap(new_ca_layer_tree, ca_layer_tree);
 }
 
 }  // namespace
 
 class CALayerTreeTest : public testing::Test {
  protected:
   void SetUp() override {
     superlayer_.reset([[CALayer alloc] init]);
@@ skipping 20 matching lines @@
 
   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);
+        new ui::CARendererLayerTree(true));
 
     UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
 
     // 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];
     EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
     transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
@@ skipping 333 matching lines @@
   // * 2 flat and the same (new sorting context layer, 1 transform layer)
   gfx::Transform transforms[5];
   transforms[0].Translate(10, 10);
   transforms[1].RotateAboutZAxis(45.0f);
   transforms[2].RotateAboutYAxis(45.0f);
   transforms[3].Translate(10, 10);
   transforms[4].Translate(10, 10);
 
   // Schedule and commit the layers.
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
-      new ui::CARendererLayerTree);
+      new ui::CARendererLayerTree(true));
   for (size_t i = 0; i < 5; ++i) {
     properties.gl_image = gl_images[i];
     properties.transform = transforms[i];
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr,
                                          properties.scale_factor);
 
   // Validate the root layer.
@@ skipping 62 matching lines @@
   scoped_refptr<gl::GLImageIOSurface> gl_images[3];
   for (size_t i = 0; i < 3; ++i) {
     gl_images[i] =
         CreateGLImage(gfx::Size(256, 256), gfx::BufferFormat::BGRA_8888, false);
   }
 
   int sorting_context_ids[3] = {3, -1, 0};
 
   // Schedule and commit the layers.
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree(
-      new ui::CARendererLayerTree);
+      new ui::CARendererLayerTree(true));
   for (size_t i = 0; i < 3; ++i) {
     properties.sorting_context_id = sorting_context_ids[i];
     properties.gl_image = gl_images[i];
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
   ca_layer_tree->CommitScheduledCALayers(superlayer_, nullptr,
                                          properties.scale_factor);
 
   // Validate the root layer.
@@ skipping 43 matching lines @@
 
   // 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);
+      new ui::CARendererLayerTree(true));
   // First send the various clip parameters to sorting context zero. This is
   // legitimate.
   for (size_t i = 0; i < 3; ++i) {
     properties.is_clipped = is_clippeds[i];
     properties.clip_rect = clip_rects[i];
 
     bool result = ScheduleCALayer(ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
   }
 
@@ skipping 122 matching lines @@
     EXPECT_EQ(1u, [[transform_layer sublayers] count]);
     content_layer4 = [[transform_layer sublayers] objectAtIndex:0];
 
     // Validate the content layer.
     EXPECT_FALSE([content_layer4
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     EXPECT_NE(content_layer4, content_layer3);
   }
 }
 
+// Ensure that blacklisting AVSampleBufferDisplayLayer works.
+TEST_F(CALayerTreeTest, AVLayerBlacklist) {
+  CALayerProperties properties;
+  properties.gl_image = CreateGLImage(
+      gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, 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_layer1 = nil;
+  CALayer* content_layer2 = nil;
+
+  {
+    UpdateCALayerTree(ca_layer_tree, &properties, superlayer_);
+
+    // 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];
+    EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
+    transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
+    EXPECT_EQ(1u, [[transform_layer sublayers] count]);
+    content_layer1 = [[transform_layer sublayers] objectAtIndex:0];
+
+    // Validate the content layer.
+    EXPECT_TRUE([content_layer1
+        isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
+  }
+
+  {
+    UpdateCALayerTreeWithAVDisabled(ca_layer_tree, &properties, superlayer_);
+
+    // 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];
+    EXPECT_EQ(1u, [[clip_and_sorting_layer sublayers] count]);
+    transform_layer = [[clip_and_sorting_layer sublayers] objectAtIndex:0];
+    EXPECT_EQ(1u, [[transform_layer sublayers] count]);
+    content_layer2 = [[transform_layer sublayers] objectAtIndex:0];
+
+    // Validate the content layer.
+    EXPECT_FALSE([content_layer2
+        isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
+    EXPECT_NE(content_layer1, content_layer2);
+  }
+}
+
 // Test fullscreen low power detection.
 TEST_F(CALayerTreeTest, FullscreenLowPower) {
   CALayerProperties properties;
   properties.gl_image = CreateGLImage(
       gfx::Size(256, 256), gfx::BufferFormat::YUV_420_BIPLANAR, true);
   properties.is_clipped = false;
 
   CALayerProperties properties_black;
   properties_black.is_clipped = false;
   properties_black.background_color = SK_ColorBLACK;
   CALayerProperties properties_white;
   properties_white.is_clipped = false;
   properties_white.background_color = SK_ColorWHITE;
 
   std::unique_ptr<ui::CARendererLayerTree> ca_layer_tree;
 
   // Test a configuration with no background.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
-        new ui::CARendererLayerTree);
+        new ui::CARendererLayerTree(true));
     bool result = ScheduleCALayer(new_ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), properties.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(1u, [[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_TRUE(fullscreen_low_power_valid);
   }
 
   // Test a configuration with a black background.
   {
     std::unique_ptr<ui::CARendererLayerTree> new_ca_layer_tree(
-        new ui::CARendererLayerTree);
+        new ui::CARendererLayerTree(true));
     bool result = ScheduleCALayer(new_ca_layer_tree.get(), &properties_black);
     EXPECT_TRUE(result);
     result = ScheduleCALayer(new_ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), properties.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);
@@ skipping 11 matching lines @@
 
     // Validate the content layer and fullscreen low power mode.
     EXPECT_TRUE([content_layer
         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);
+        new ui::CARendererLayerTree(true));
     bool result = ScheduleCALayer(new_ca_layer_tree.get(), &properties_white);
     EXPECT_TRUE(result);
     result = ScheduleCALayer(new_ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), properties.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);
@@ skipping 11 matching lines @@
 
     // Validate the content layer and fullscreen low power mode.
     EXPECT_TRUE([content_layer
         isKindOfClass:NSClassFromString(@"AVSampleBufferDisplayLayer")]);
     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);
+        new ui::CARendererLayerTree(true));
     bool result = ScheduleCALayer(new_ca_layer_tree.get(), &properties);
     EXPECT_TRUE(result);
     result = ScheduleCALayer(new_ca_layer_tree.get(), &properties_black);
     EXPECT_TRUE(result);
     new_ca_layer_tree->CommitScheduledCALayers(
         superlayer_, std::move(ca_layer_tree), properties.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);
@@ skipping 10 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