content/common/gpu/ca_layer_tree_mac.h

// 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.

#ifndef CONTENT_COMMON_GPU_CA_LAYER_TREE_MAC_H_
#define CONTENT_COMMON_GPU_CA_LAYER_TREE_MAC_H_

#include <IOSurface/IOSurface.h>
#include <QuartzCore/QuartzCore.h>
#include <deque>
#include <vector>

#include "base/mac/scoped_cftyperef.h"
#include "base/mac/scoped_nsobject.h"
#include "base/memory/scoped_ptr.h"
#include "content/common/content_export.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/transform.h"

namespace content {

// The CALayerTree will construct a hierarchy of CALayers from a linear list,
// using the algorithm and structure referenced described in
// https://docs.google.com/document/d/1DtSN9zzvCF44_FQPM7ie01UxGHagQ66zfF5L9HnigQY/edit?usp=sharing
class CONTENT_EXPORT CALayerTree {
 public:
  CALayerTree();

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

  // 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(bool is_clipped,
                       const gfx::Rect& clip_rect,
                       unsigned sorting_context_id,
                       const gfx::Transform& transform,
                       base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                       const gfx::RectF& contents_rect,
                       const gfx::Rect& rect,
                       unsigned background_color,
                       unsigned edge_aa_mask,
                       float opacity);

  // 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,
                               scoped_ptr<CALayerTree> old_tree,
                               float scale_factor);

 private:
  struct RootLayer;
  struct ClipAndSortingLayer;
  struct TransformLayer;
  struct ContentLayer;

  struct RootLayer {
    RootLayer();

    // 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(bool is_clipped,
                         const gfx::Rect& clip_rect,
                         unsigned sorting_context_id,
                         const gfx::Transform& transform,
                         base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                         const gfx::RectF& contents_rect,
                         const gfx::Rect& rect,
                         unsigned background_color,
                         unsigned edge_aa_mask,
                         float opacity);

    // 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,
                    RootLayer* old_layer,
                    float scale_factor);

    std::vector<ClipAndSortingLayer> clip_and_sorting_layers;
    base::scoped_nsobject<CALayer> ca_layer;

   private:
    DISALLOW_COPY_AND_ASSIGN(RootLayer);
  };
  struct ClipAndSortingLayer {
    ClipAndSortingLayer(bool is_clipped,
                        gfx::Rect clip_rect,
                        unsigned sorting_context_id,
                        bool is_singleton_sorting_context);
    ClipAndSortingLayer(ClipAndSortingLayer&& layer);

    // See the behavior of RootLayer for the effects of these functions on the
    // |ca_layer| member and |old_layer| argument.
    ~ClipAndSortingLayer();
    void AddContentLayer(const gfx::Transform& transform,
                         base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                         const gfx::RectF& contents_rect,
                         const gfx::Rect& rect,
                         unsigned background_color,
                         unsigned edge_aa_mask,
                         float opacity);
    void CommitToCA(CALayer* superlayer,
                    ClipAndSortingLayer* old_layer,
                    float scale_factor);

    std::vector<TransformLayer> transform_layers;
    bool is_clipped = false;
    gfx::Rect clip_rect;
    unsigned sorting_context_id = 0;
    bool is_singleton_sorting_context = false;
    base::scoped_nsobject<CALayer> ca_layer;

   private:
    DISALLOW_COPY_AND_ASSIGN(ClipAndSortingLayer);
  };
  struct TransformLayer {
    TransformLayer(const gfx::Transform& transform);
    TransformLayer(TransformLayer&& layer);

    // See the behavior of RootLayer for the effects of these functions on the
    // |ca_layer| member and |old_layer| argument.
    ~TransformLayer();
    void AddContentLayer(base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                         const gfx::RectF& contents_rect,
                         const gfx::Rect& rect,
                         unsigned background_color,
                         unsigned edge_aa_mask,
                         float opacity);
    void CommitToCA(CALayer* superlayer,
                    TransformLayer* old_layer,
                    float scale_factor);

    gfx::Transform transform;
    std::vector<ContentLayer> content_layers;
    base::scoped_nsobject<CALayer> ca_layer;

   private:
    DISALLOW_COPY_AND_ASSIGN(TransformLayer);
  };
  struct ContentLayer {
    ContentLayer(base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
                 const gfx::RectF& contents_rect,
                 const gfx::Rect& rect,
                 unsigned background_color,
                 unsigned edge_aa_mask,
                 float opacity);
    ContentLayer(ContentLayer&& layer);

    // See the behavior of RootLayer for the effects of these functions on the
    // |ca_layer| member and |old_layer| argument.
    ~ContentLayer();
    void CommitToCA(CALayer* parent,
                    ContentLayer* old_layer,
                    float scale_factor);

    const base::ScopedCFTypeRef<IOSurfaceRef> io_surface;
    gfx::RectF contents_rect;
    gfx::Rect rect;
    unsigned background_color = 0;
    // 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;
    base::scoped_nsobject<CALayer> ca_layer;

   private:
    DISALLOW_COPY_AND_ASSIGN(ContentLayer);
  };

  RootLayer root_layer_;
  float scale_factor_ = 1;
  bool has_committed_ = false;

 private:
  DISALLOW_COPY_AND_ASSIGN(CALayerTree);
};

}  // namespace content

#endif  // CONTENT_COMMON_GPU_CA_LAYER_TREE_MAC_H_