ui/accelerated_widget_mac/ca_renderer_layer_tree.h - chromium/src - Git at Google

 // Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_
 #define UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_

 #include <CoreVideo/CoreVideo.h>
 #include <IOSurface/IOSurfaceRef.h>
 #include <QuartzCore/QuartzCore.h>

 #include <list>
 #include <memory>

 #include "base/apple/scoped_cftyperef.h"
 #include "base/containers/flat_map.h"
 #include "base/feature_list.h"
 #include "base/memory/raw_ptr.h"
 #include "base/memory/scoped_refptr.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accelerated_widget_mac/accelerated_widget_mac_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/rrect_f.h"
 #include "ui/gfx/geometry/transform.h"
 #include "ui/gfx/hdr_metadata.h"
 #include "ui/gfx/mac/io_surface.h"
 #include "ui/gfx/video_types.h"

 @class AVSampleBufferDisplayLayer;

 namespace ui {

 ACCELERATED_WIDGET_MAC_EXPORT BASE_DECLARE_FEATURE(
     kFullscreenLowPowerBackdropMac);
 ACCELERATED_WIDGET_MAC_EXPORT BASE_DECLARE_FEATURE(kCALayerTreeOptimization);

 struct CARendererLayerParams;

 enum class CALayerType {
   // A CALayer with contents set to an IOSurface by setContents.
   kDefault,
   // An AVSampleBufferDisplayLayer.
   kVideo,
   // A CAMetalLayer that copies half-float or 10-bit IOSurfaces.
   kHDRCopier,
 };

 // The CARendererLayerTree will construct a hierarchy of CALayers from a linear
 // list provided by the CoreAnimation renderer using the algorithm and structure
 // referenced described in
 // https://docs.google.com/document/d/1DtSN9zzvCF44_FQPM7ie01UxGHagQ66zfF5L9HnigQY/edit?usp=sharing
 class ACCELERATED_WIDGET_MAC_EXPORT CARendererLayerTree {
  public:
   CARendererLayerTree(bool allow_av_sample_buffer_display_layer,
                       bool allow_solid_color_layers);

   CARendererLayerTree(const CARendererLayerTree&) = delete;
   CARendererLayerTree& operator=(const CARendererLayerTree&) = delete;

   // This will remove all CALayers from this tree from their superlayer.
   ~CARendererLayerTree();

   // Append the description of a new CALayer to the tree. This will not
   // create any new CALayers until CommitScheduledCALayers is called. This
   // cannot be called anymore after CommitScheduledCALayers has been called.
   bool ScheduleCALayer(const CARendererLayerParams& params);

   // Set the MTLDevice to use for any CAMetalLayers.
   void SetMetalDevice(id<MTLDevice> metal_device) {
     metal_device_ = metal_device;
   }

   // Create a CALayer tree for the scheduled layers, and set |superlayer| to
   // have only this tree as its sublayers. If |old_tree| is non-null, then try
   // to re-use the CALayers of |old_tree| as much as possible. |old_tree| will
   // be destroyed at the end of the function, and any CALayers in it which were
   // not re-used by |this| will be removed from the CALayer hierarchy.
   void CommitScheduledCALayers(CALayer* superlayer,
                                std::unique_ptr<CARendererLayerTree> old_tree,
                                const gfx::Size& pixel_size,
                                float scale_factor);

   // Returns the contents used for a given solid color.
   id ContentsForSolidColorForTesting(SkColor4f color);

   // If there exists only a single content layer, return the IOSurface of that
   // layer.
   IOSurfaceRef GetContentIOSurface() const;

  private:
   class SolidColorContents;
   class RootLayer;
   class ClipAndSortingLayer;
   class TransformLayer;
   class ContentLayer;
   friend class ContentLayer;

   using CALayerMap = base::flat_map<IOSurfaceRef, base::WeakPtr<ContentLayer>>;

   void MatchLayersToOldTreeDefault(CARendererLayerTree* old_tree);
   void MatchLayersToOldTree(CARendererLayerTree* old_tree);

   class RootLayer {
    public:
     RootLayer(CARendererLayerTree* tree);

     RootLayer(RootLayer&&) = delete;
     RootLayer(const RootLayer&) = delete;
     RootLayer& operator=(const RootLayer&) = delete;

     // This will remove |ca_layer| from its superlayer, if |ca_layer| is
     // non-nil.
     ~RootLayer();

     // Append a new content layer, without modifying the actual CALayer
     // structure.
     bool AddContentLayer(const CARendererLayerParams& params);

     // Downgrade all downgradeable AVSampleBufferDisplayLayers to be normal
     // CALayers.
     // https://crbug.com/923427, https://crbug.com/1143477
     void DowngradeAVLayersToCALayers();

     // Allocate CALayers for this layer and its children, and set their
     // properties appropriately. Re-use the CALayers from |old_layer| if
     // possible. If re-using a CALayer from |old_layer|, reset its |ca_layer|
     // to nil, so that its destructor will not remove an active CALayer.
     void CommitToCA(CALayer* superlayer, const gfx::Size& pixel_size);

     void CALayerFallBack();

     // Return true if the CALayer tree is just a video layer on a black or
     // transparent background, false otherwise.
     bool WantsFullscreenLowPowerBackdrop() const;

     // Tree that owns `this`.
     const raw_ptr<CARendererLayerTree> tree_;

     std::list<ClipAndSortingLayer> clip_and_sorting_layers_;
     CALayer* __strong ca_layer_;

     // Weak pointer to the layer in the old CARendererLayerTree that will be
     // reused by this layer, and the weak factory used to make that pointer.
     base::WeakPtr<RootLayer> old_layer_;
     base::WeakPtrFactory<RootLayer> weak_factory_for_new_layer_{this};
   };
   class ClipAndSortingLayer {
    public:
     ClipAndSortingLayer(RootLayer* root_layer,
                         bool is_clipped,
                         gfx::Rect clip_rect,
                         gfx::RRectF rounded_corner_bounds,
                         unsigned sorting_context_id,
                         bool is_singleton_sorting_context);

     ClipAndSortingLayer(ClipAndSortingLayer&& layer) = delete;
     ClipAndSortingLayer(const ClipAndSortingLayer&) = delete;
     ClipAndSortingLayer& operator=(const ClipAndSortingLayer&) = delete;

     // See the behavior of RootLayer for the effects of these functions on the
     // |ca_layer| member and |old_layer| argument.
     ~ClipAndSortingLayer();
     void AddContentLayer(const CARendererLayerParams& params);

     void CommitToCA(CALayer* last_committed_clip_ca_layer);
     void CALayerFallBack();

     CARendererLayerTree* tree() { return parent_layer_->tree_; }

     // Parent layer that owns `this`, and child layers that `this` owns.
     const raw_ptr<RootLayer> parent_layer_;
     std::list<TransformLayer> transform_layers_;

     bool is_clipped_ = false;
     gfx::Rect clip_rect_;
     gfx::RRectF rounded_corner_bounds_;
     unsigned sorting_context_id_ = 0;
     bool is_singleton_sorting_context_ = false;
     CALayer* __strong clipping_ca_layer_;
     CALayer* __strong rounded_corner_ca_layer_;

     // The status when used as an old layer.
     bool ca_layer_used_ = false;

     // Weak pointer to the layer in the old CARendererLayerTree that will be
     // reused by this layer, and the weak factory used to make that pointer.
     base::WeakPtr<ClipAndSortingLayer> old_layer_;
     base::WeakPtrFactory<ClipAndSortingLayer> weak_factory_for_new_layer_{this};
   };
   class TransformLayer {
    public:
     TransformLayer(ClipAndSortingLayer* parent_layer,
                    const gfx::Transform& transform);

     TransformLayer(TransformLayer&& layer) = delete;
     TransformLayer(const TransformLayer&) = delete;
     TransformLayer& operator=(const TransformLayer&) = delete;

     // See the behavior of RootLayer for the effects of these functions on the
     // |ca_layer| member and |old_layer| argument.
     ~TransformLayer();
     void AddContentLayer(const CARendererLayerParams& params);
     void CommitToCA(CALayer* last_committed_transform_ca_layer);

     void CALayerFallBack();

     CARendererLayerTree* tree() { return parent_layer_->tree(); }

     // Parent layer that owns `this`, and child layers that `this` owns.
     const raw_ptr<ClipAndSortingLayer> parent_layer_;
     std::list<ContentLayer> content_layers_;

     gfx::Transform transform_;
     CALayer* __strong ca_layer_;

     // The ca layer status when used as an old layer.
     bool ca_layer_used_ = false;

     // Weak pointer to the layer in the old CARendererLayerTree that will be
     // reused by this layer, and the weak factory used to make that pointer.
     base::WeakPtr<TransformLayer> old_layer_;
     base::WeakPtrFactory<TransformLayer> weak_factory_for_new_layer_{this};
   };
   class ContentLayer {
    public:
     ContentLayer(TransformLayer* parent_layer,
                  base::apple::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                  base::apple::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
                  const gfx::RectF& contents_rect,
                  const gfx::Rect& rect,
                  SkColor4f background_color,
                  const gfx::ColorSpace& color_space,
                  unsigned edge_aa_mask,
                  float opacity,
                  bool nearest_neighbor_filter,
                  const gfx::HDRMetadata& hdr_metadata,
                  gfx::ProtectedVideoType protected_video_type,
                  bool is_render_pass_draw_quad);

     ContentLayer(ContentLayer&& layer) = delete;
     ContentLayer(const ContentLayer&) = delete;
     ContentLayer& operator=(const ContentLayer&) = delete;

     // See the behavior of RootLayer for the effects of these functions.
     ~ContentLayer();
     void CommitToCA(CALayer* last_committed_ca_layer);

     CARendererLayerTree* tree() { return parent_layer_->tree(); }
     void UpdateMapAndMatchOldLayers(CALayerMap& old_ca_layer_map,
                                     int& layer_order,
                                     int& last_old_layer_order);

     // Parent layer that owns `this`.
     const raw_ptr<TransformLayer> parent_layer_;

     // Ensure that the IOSurface be marked as in-use as soon as it is received.
     // When they are committed to the window server, that will also increment
     // their use count.
     const gfx::ScopedInUseIOSurface io_surface_;
     const base::apple::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer_;
     scoped_refptr<SolidColorContents> solid_color_contents_;
     gfx::RectF contents_rect_;
     gfx::RectF rect_;
     SkColor4f background_color_ = SkColors::kTransparent;
     // The color space of |io_surface|. Used for HDR tonemapping.
     gfx::ColorSpace io_surface_color_space_;
     // Note that the CoreAnimation edge antialiasing mask is not the same as
     // the edge antialiasing mask passed to the constructor.
     CAEdgeAntialiasingMask ca_edge_aa_mask_ = 0;
     float opacity_ = 1;
     NSString* const ca_filter_ = nil;

     CALayerType type_ = CALayerType::kDefault;

     // If |type| is CALayerType::kVideo and |video_type_can_downgrade| then
     // |type| can be downgraded to kDefault. This can be set to false for
     // HDR video (that cannot be displayed by a regular CALayer) or for
     // protected content (see https://crbug.com/1026703).
     bool video_type_can_downgrade_ = true;

     gfx::HDRMetadata hdr_metadata_;

     gfx::ProtectedVideoType protected_video_type_ =
         gfx::ProtectedVideoType::kClear;

     CALayer* __strong ca_layer_;

     // If this layer's contents can be represented as an
     // AVSampleBufferDisplayLayer, then |ca_layer| will point to |av_layer|.
     AVSampleBufferDisplayLayer* __strong av_layer_;

     // Layer used to colorize content when it updates, if borders are
     // enabled.
     CALayer* __strong update_indicator_layer_;

     // Indicate the content layer order in the whole layer tree.
     int layer_order_ = 0;

     // The status when used as an old layer.
     bool ca_layer_used_ = false;

     bool is_render_pass_draw_quad_ = false;

     // Weak pointer to the layer in the old CARendererLayerTree that will be
     // reused by this layer, and the weak factory used to make that pointer.
     base::WeakPtr<ContentLayer> old_layer_;
     base::WeakPtrFactory<ContentLayer> weak_factory_for_new_layer_{this};
   };

   RootLayer root_layer_{this};
   float scale_factor_ = 1;
   bool has_committed_ = false;
   const bool allow_av_sample_buffer_display_layer_ = true;
   const bool allow_solid_color_layers_ = true;
   id<MTLDevice> __strong metal_device_ = nil;

   // Used for uma.
   int changed_io_surfaces_during_commit_ = 0;
   int unchanged_io_surfaces_during_commit_ = 0;
   int total_updated_io_surface_size_during_commit_ = 0;

   // Enable CALayerTree optimization that will try to reuse the CALayer with a
   // matched CALayer from the old CALayerTree in the previous frame.
   const bool ca_layer_tree_optimization_;

   // Map of content IOSurface.
   CALayerMap ca_layer_map_;
 };

 }  // namespace ui

 #endif  // UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_
	// Copyright 2016 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_
	#define UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_

	#include <CoreVideo/CoreVideo.h>
	#include <IOSurface/IOSurfaceRef.h>
	#include <QuartzCore/QuartzCore.h>

	#include <list>
	#include <memory>

	#include "base/apple/scoped_cftyperef.h"
	#include "base/containers/flat_map.h"
	#include "base/feature_list.h"
	#include "base/memory/raw_ptr.h"
	#include "base/memory/scoped_refptr.h"
	#include "third_party/abseil-cpp/absl/types/optional.h"
	#include "third_party/skia/include/core/SkColor.h"
	#include "ui/accelerated_widget_mac/accelerated_widget_mac_export.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/rect_f.h"
	#include "ui/gfx/geometry/rrect_f.h"
	#include "ui/gfx/geometry/transform.h"
	#include "ui/gfx/hdr_metadata.h"
	#include "ui/gfx/mac/io_surface.h"
	#include "ui/gfx/video_types.h"

	@class AVSampleBufferDisplayLayer;

	namespace ui {

	ACCELERATED_WIDGET_MAC_EXPORT BASE_DECLARE_FEATURE(
	kFullscreenLowPowerBackdropMac);
	ACCELERATED_WIDGET_MAC_EXPORT BASE_DECLARE_FEATURE(kCALayerTreeOptimization);

	struct CARendererLayerParams;

	enum class CALayerType {
	// A CALayer with contents set to an IOSurface by setContents.
	kDefault,
	// An AVSampleBufferDisplayLayer.
	kVideo,
	// A CAMetalLayer that copies half-float or 10-bit IOSurfaces.
	kHDRCopier,
	};

	// The CARendererLayerTree will construct a hierarchy of CALayers from a linear
	// list provided by the CoreAnimation renderer using the algorithm and structure
	// referenced described in
	// https://docs.google.com/document/d/1DtSN9zzvCF44_FQPM7ie01UxGHagQ66zfF5L9HnigQY/edit?usp=sharing
	class ACCELERATED_WIDGET_MAC_EXPORT CARendererLayerTree {
	public:
	CARendererLayerTree(bool allow_av_sample_buffer_display_layer,
	bool allow_solid_color_layers);

	CARendererLayerTree(const CARendererLayerTree&) = delete;
	CARendererLayerTree& operator=(const CARendererLayerTree&) = delete;

	// This will remove all CALayers from this tree from their superlayer.
	~CARendererLayerTree();

	// Append the description of a new CALayer to the tree. This will not
	// create any new CALayers until CommitScheduledCALayers is called. This
	// cannot be called anymore after CommitScheduledCALayers has been called.
	bool ScheduleCALayer(const CARendererLayerParams& params);

	// Set the MTLDevice to use for any CAMetalLayers.
	void SetMetalDevice(id<MTLDevice> metal_device) {
	metal_device_ = metal_device;
	}

	// Create a CALayer tree for the scheduled layers, and set \|superlayer\| to
	// have only this tree as its sublayers. If \|old_tree\| is non-null, then try
	// to re-use the CALayers of \|old_tree\| as much as possible. \|old_tree\| will
	// be destroyed at the end of the function, and any CALayers in it which were
	// not re-used by \|this\| will be removed from the CALayer hierarchy.
	void CommitScheduledCALayers(CALayer* superlayer,
	std::unique_ptr<CARendererLayerTree> old_tree,
	const gfx::Size& pixel_size,
	float scale_factor);

	// Returns the contents used for a given solid color.
	id ContentsForSolidColorForTesting(SkColor4f color);

	// If there exists only a single content layer, return the IOSurface of that
	// layer.
	IOSurfaceRef GetContentIOSurface() const;

	private:
	class SolidColorContents;
	class RootLayer;
	class ClipAndSortingLayer;
	class TransformLayer;
	class ContentLayer;
	friend class ContentLayer;

	using CALayerMap = base::flat_map<IOSurfaceRef, base::WeakPtr<ContentLayer>>;

	void MatchLayersToOldTreeDefault(CARendererLayerTree* old_tree);
	void MatchLayersToOldTree(CARendererLayerTree* old_tree);

	class RootLayer {
	public:
	RootLayer(CARendererLayerTree* tree);

	RootLayer(RootLayer&&) = delete;
	RootLayer(const RootLayer&) = delete;
	RootLayer& operator=(const RootLayer&) = delete;

	// This will remove \|ca_layer\| from its superlayer, if \|ca_layer\| is
	// non-nil.
	~RootLayer();

	// Append a new content layer, without modifying the actual CALayer
	// structure.
	bool AddContentLayer(const CARendererLayerParams& params);

	// Downgrade all downgradeable AVSampleBufferDisplayLayers to be normal
	// CALayers.
	// https://crbug.com/923427, https://crbug.com/1143477
	void DowngradeAVLayersToCALayers();

	// Allocate CALayers for this layer and its children, and set their
	// properties appropriately. Re-use the CALayers from \|old_layer\| if
	// possible. If re-using a CALayer from \|old_layer\|, reset its \|ca_layer\|
	// to nil, so that its destructor will not remove an active CALayer.
	void CommitToCA(CALayer* superlayer, const gfx::Size& pixel_size);

	void CALayerFallBack();

	// Return true if the CALayer tree is just a video layer on a black or
	// transparent background, false otherwise.
	bool WantsFullscreenLowPowerBackdrop() const;

	// Tree that owns `this`.
	const raw_ptr<CARendererLayerTree> tree_;

	std::list<ClipAndSortingLayer> clip_and_sorting_layers_;
	CALayer* __strong ca_layer_;

	// Weak pointer to the layer in the old CARendererLayerTree that will be
	// reused by this layer, and the weak factory used to make that pointer.
	base::WeakPtr<RootLayer> old_layer_;
	base::WeakPtrFactory<RootLayer> weak_factory_for_new_layer_{this};
	};
	class ClipAndSortingLayer {
	public:
	ClipAndSortingLayer(RootLayer* root_layer,
	bool is_clipped,
	gfx::Rect clip_rect,
	gfx::RRectF rounded_corner_bounds,
	unsigned sorting_context_id,
	bool is_singleton_sorting_context);

	ClipAndSortingLayer(ClipAndSortingLayer&& layer) = delete;
	ClipAndSortingLayer(const ClipAndSortingLayer&) = delete;
	ClipAndSortingLayer& operator=(const ClipAndSortingLayer&) = delete;

	// See the behavior of RootLayer for the effects of these functions on the
	// \|ca_layer\| member and \|old_layer\| argument.
	~ClipAndSortingLayer();
	void AddContentLayer(const CARendererLayerParams& params);

	void CommitToCA(CALayer* last_committed_clip_ca_layer);
	void CALayerFallBack();

	CARendererLayerTree* tree() { return parent_layer_->tree_; }

	// Parent layer that owns `this`, and child layers that `this` owns.
	const raw_ptr<RootLayer> parent_layer_;
	std::list<TransformLayer> transform_layers_;

	bool is_clipped_ = false;
	gfx::Rect clip_rect_;
	gfx::RRectF rounded_corner_bounds_;
	unsigned sorting_context_id_ = 0;
	bool is_singleton_sorting_context_ = false;
	CALayer* __strong clipping_ca_layer_;
	CALayer* __strong rounded_corner_ca_layer_;

	// The status when used as an old layer.
	bool ca_layer_used_ = false;

	// Weak pointer to the layer in the old CARendererLayerTree that will be
	// reused by this layer, and the weak factory used to make that pointer.
	base::WeakPtr<ClipAndSortingLayer> old_layer_;
	base::WeakPtrFactory<ClipAndSortingLayer> weak_factory_for_new_layer_{this};
	};
	class TransformLayer {
	public:
	TransformLayer(ClipAndSortingLayer* parent_layer,
	const gfx::Transform& transform);

	TransformLayer(TransformLayer&& layer) = delete;
	TransformLayer(const TransformLayer&) = delete;
	TransformLayer& operator=(const TransformLayer&) = delete;

	// See the behavior of RootLayer for the effects of these functions on the
	// \|ca_layer\| member and \|old_layer\| argument.
	~TransformLayer();
	void AddContentLayer(const CARendererLayerParams& params);
	void CommitToCA(CALayer* last_committed_transform_ca_layer);

	void CALayerFallBack();

	CARendererLayerTree* tree() { return parent_layer_->tree(); }

	// Parent layer that owns `this`, and child layers that `this` owns.
	const raw_ptr<ClipAndSortingLayer> parent_layer_;
	std::list<ContentLayer> content_layers_;

	gfx::Transform transform_;
	CALayer* __strong ca_layer_;

	// The ca layer status when used as an old layer.
	bool ca_layer_used_ = false;

	// Weak pointer to the layer in the old CARendererLayerTree that will be
	// reused by this layer, and the weak factory used to make that pointer.
	base::WeakPtr<TransformLayer> old_layer_;
	base::WeakPtrFactory<TransformLayer> weak_factory_for_new_layer_{this};
	};
	class ContentLayer {
	public:
	ContentLayer(TransformLayer* parent_layer,
	base::apple::ScopedCFTypeRef<IOSurfaceRef> io_surface,
	base::apple::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
	const gfx::RectF& contents_rect,
	const gfx::Rect& rect,
	SkColor4f background_color,
	const gfx::ColorSpace& color_space,
	unsigned edge_aa_mask,
	float opacity,
	bool nearest_neighbor_filter,
	const gfx::HDRMetadata& hdr_metadata,
	gfx::ProtectedVideoType protected_video_type,
	bool is_render_pass_draw_quad);

	ContentLayer(ContentLayer&& layer) = delete;
	ContentLayer(const ContentLayer&) = delete;
	ContentLayer& operator=(const ContentLayer&) = delete;

	// See the behavior of RootLayer for the effects of these functions.
	~ContentLayer();
	void CommitToCA(CALayer* last_committed_ca_layer);

	CARendererLayerTree* tree() { return parent_layer_->tree(); }
	void UpdateMapAndMatchOldLayers(CALayerMap& old_ca_layer_map,
	int& layer_order,
	int& last_old_layer_order);

	// Parent layer that owns `this`.
	const raw_ptr<TransformLayer> parent_layer_;

	// Ensure that the IOSurface be marked as in-use as soon as it is received.
	// When they are committed to the window server, that will also increment
	// their use count.
	const gfx::ScopedInUseIOSurface io_surface_;
	const base::apple::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer_;
	scoped_refptr<SolidColorContents> solid_color_contents_;
	gfx::RectF contents_rect_;
	gfx::RectF rect_;
	SkColor4f background_color_ = SkColors::kTransparent;
	// The color space of \|io_surface\|. Used for HDR tonemapping.
	gfx::ColorSpace io_surface_color_space_;
	// Note that the CoreAnimation edge antialiasing mask is not the same as
	// the edge antialiasing mask passed to the constructor.
	CAEdgeAntialiasingMask ca_edge_aa_mask_ = 0;
	float opacity_ = 1;
	NSString* const ca_filter_ = nil;

	CALayerType type_ = CALayerType::kDefault;

	// If \|type\| is CALayerType::kVideo and \|video_type_can_downgrade\| then
	// \|type\| can be downgraded to kDefault. This can be set to false for
	// HDR video (that cannot be displayed by a regular CALayer) or for
	// protected content (see https://crbug.com/1026703).
	bool video_type_can_downgrade_ = true;

	gfx::HDRMetadata hdr_metadata_;

	gfx::ProtectedVideoType protected_video_type_ =
	gfx::ProtectedVideoType::kClear;

	CALayer* __strong ca_layer_;

	// If this layer's contents can be represented as an
	// AVSampleBufferDisplayLayer, then \|ca_layer\| will point to \|av_layer\|.
	AVSampleBufferDisplayLayer* __strong av_layer_;

	// Layer used to colorize content when it updates, if borders are
	// enabled.
	CALayer* __strong update_indicator_layer_;

	// Indicate the content layer order in the whole layer tree.
	int layer_order_ = 0;

	// The status when used as an old layer.
	bool ca_layer_used_ = false;

	bool is_render_pass_draw_quad_ = false;

	// Weak pointer to the layer in the old CARendererLayerTree that will be
	// reused by this layer, and the weak factory used to make that pointer.
	base::WeakPtr<ContentLayer> old_layer_;
	base::WeakPtrFactory<ContentLayer> weak_factory_for_new_layer_{this};
	};

	RootLayer root_layer_{this};
	float scale_factor_ = 1;
	bool has_committed_ = false;
	const bool allow_av_sample_buffer_display_layer_ = true;
	const bool allow_solid_color_layers_ = true;
	id<MTLDevice> __strong metal_device_ = nil;

	// Used for uma.
	int changed_io_surfaces_during_commit_ = 0;
	int unchanged_io_surfaces_during_commit_ = 0;
	int total_updated_io_surface_size_during_commit_ = 0;

	// Enable CALayerTree optimization that will try to reuse the CALayer with a
	// matched CALayer from the old CALayerTree in the previous frame.
	const bool ca_layer_tree_optimization_;

	// Map of content IOSurface.
	CALayerMap ca_layer_map_;
	};

	} // namespace ui

	#endif // UI_ACCELERATED_WIDGET_MAC_CA_RENDERER_LAYER_TREE_H_