Mac video: Add blacklist entry for AVSampleBufferDisplayLayer

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 111 matching lines @@
     LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
     return false;
   }
 
   return AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
                                                         cv_pixel_buffer);
 }
 
 }  // namespace
 
-CARendererLayerTree::CARendererLayerTree() {}
+CARendererLayerTree::CARendererLayerTree(
+    bool allow_av_sample_buffer_display_layer)
+    : allow_av_sample_buffer_display_layer_(
+          allow_av_sample_buffer_display_layer) {}
 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.";
     return false;
   }
-  return root_layer_.AddContentLayer(params);
+  return root_layer_.AddContentLayer(this, params);
 }
 
 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 107 matching lines @@
       content_layers(std::move(layer.content_layers)),
       ca_layer(layer.ca_layer) {
   layer.ca_layer.reset();
 }
 
 CARendererLayerTree::TransformLayer::~TransformLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
 CARendererLayerTree::ContentLayer::ContentLayer(
+    CARendererLayerTree* tree,
     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)
     : io_surface(io_surface),
       cv_pixel_buffer(cv_pixel_buffer),
@@ skipping 24 matching lines @@
       ca_edge_aa_mask |= kCALayerTopEdge;
   } else {
     if (edge_aa_mask & GL_CA_LAYER_EDGE_TOP_CHROMIUM)
       ca_edge_aa_mask |= kCALayerTopEdge;
     if (edge_aa_mask & GL_CA_LAYER_EDGE_BOTTOM_CHROMIUM)
       ca_edge_aa_mask |= kCALayerBottomEdge;
   }
 
   // Only allow 4:2:0 frames which fill the layer's contents to be promoted to
   // AV layers.
-  if (IOSurfaceGetPixelFormat(io_surface) ==
+  if (tree->allow_av_sample_buffer_display_layer_ &&
+      IOSurfaceGetPixelFormat(io_surface) ==
           kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange &&
       contents_rect == gfx::RectF(0, 0, 1, 1)) {
     use_av_layer = true;
   }
 }
 
 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(
+    CARendererLayerTree* tree,
     const CARendererLayerParams& params) {
   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 =
       !params.sorting_context_id && !params.transform.IsFlat();
 
@@ skipping 16 matching lines @@
         current_layer.clip_rect == params.clip_rect &&
         current_layer.sorting_context_id == params.sorting_context_id) {
       needs_new_clip_and_sorting_layer = false;
     }
   }
   if (needs_new_clip_and_sorting_layer) {
     clip_and_sorting_layers.push_back(ClipAndSortingLayer(
         params.is_clipped, params.clip_rect, params.sorting_context_id,
         is_singleton_sorting_context));
   }
-  clip_and_sorting_layers.back().AddContentLayer(params);
+  clip_and_sorting_layers.back().AddContentLayer(tree, params);
   return true;
 }
 
 void CARendererLayerTree::ClipAndSortingLayer::AddContentLayer(
+    CARendererLayerTree* tree,
     const CARendererLayerParams& params) {
   bool needs_new_transform_layer = true;
   if (!transform_layers.empty()) {
     const TransformLayer& current_layer = transform_layers.back();
     if (current_layer.transform == params.transform)
       needs_new_transform_layer = false;
   }
   if (needs_new_transform_layer)
     transform_layers.push_back(TransformLayer(params.transform));
-  transform_layers.back().AddContentLayer(params);
+  transform_layers.back().AddContentLayer(tree, params);
 }
 
 void CARendererLayerTree::TransformLayer::AddContentLayer(
+    CARendererLayerTree* tree,
     const CARendererLayerParams& params) {
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
   base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
   if (params.image) {
     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,
+      ContentLayer(tree, io_surface, cv_pixel_buffer, params.contents_rect,
                    params.rect, params.background_color, params.edge_aa_mask,
                    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);
@@ skipping 206 matching lines @@
     } 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