text: // Copyright 2014 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 PaintLayerPainter_h
  #define PaintLayerPainter_h
  
  #include "core/CoreExport.h"
  #include "core/paint/PaintLayerFragment.h"
  #include "core/paint/PaintLayerPaintingInfo.h"
  #include "wtf/Allocator.h"
  
  namespace blink {
  
  class ClipRect;
  class PaintLayer;
  class GraphicsContext;
  class LayoutPoint;
  
  // This class is responsible for painting self-painting PaintLayer.
  //
  // See PainterLayer SELF-PAINTING LAYER section about what 'self-painting'
  // means and how it impacts this class.
  class CORE_EXPORT PaintLayerPainter {
    STACK_ALLOCATED();
  
   public:
    enum FragmentPolicy { AllowMultipleFragments, ForceSingleFragment };
  
    // When adding new values, must update the number of bits of
    // PaintLayer::m_previousPaintingResult.
    enum PaintResult {
      // The layer is fully painted. This includes cases that nothing needs
      // painting regardless of the paint rect.
      FullyPainted,
      // Some part of the layer is out of the paint rect and may be not fully
      // painted.  The results cannot be cached because they may change when paint
      // rect changes.
      MayBeClippedByPaintDirtyRect
    };
  
    PaintLayerPainter(PaintLayer& paintLayer) : m_paintLayer(paintLayer) {}
  
    // The paint() method paints the layers that intersect the damage rect from
    // back to front.  paint() assumes that the caller will clip to the bounds of
    // damageRect if necessary.
    void paint(GraphicsContext&,
               const LayoutRect& damageRect,
               const GlobalPaintFlags = GlobalPaintNormalPhase,
               PaintLayerFlags = 0);
    // paintLayer() assumes that the caller will clip to the bounds of the
    // painting dirty if necessary.
    PaintResult paintLayer(GraphicsContext&,
                           const PaintLayerPaintingInfo&,
                           PaintLayerFlags);
    // paintLayerContents() assumes that the caller will clip to the bounds of the
    // painting dirty rect if necessary.
    PaintResult paintLayerContents(GraphicsContext&,
                                   const PaintLayerPaintingInfo&,
                                   PaintLayerFlags,
                                   FragmentPolicy = AllowMultipleFragments);
  
    void paintOverlayScrollbars(GraphicsContext&,
                                const LayoutRect& damageRect,
                                const GlobalPaintFlags);
  
   private:
    enum ClipState { HasNotClipped, HasClipped };
  
    PaintResult paintLayerContentsCompositingAllPhases(
        GraphicsContext&,
        const PaintLayerPaintingInfo&,
        PaintLayerFlags,
        FragmentPolicy = AllowMultipleFragments);
    PaintResult paintLayerWithTransform(GraphicsContext&,
                                        const PaintLayerPaintingInfo&,
                                        PaintLayerFlags);
    PaintResult paintFragmentByApplyingTransform(
        GraphicsContext&,
        const PaintLayerPaintingInfo&,
        PaintLayerFlags,
        const LayoutPoint& fragmentTranslation);
  
    PaintResult paintChildren(unsigned childrenToVisit,
                              GraphicsContext&,
                              const PaintLayerPaintingInfo&,
                              PaintLayerFlags);
    bool atLeastOneFragmentIntersectsDamageRect(
        PaintLayerFragments&,
        const PaintLayerPaintingInfo&,
        PaintLayerFlags,
        const LayoutPoint& offsetFromRoot);
    void paintFragmentWithPhase(PaintPhase,
                                const PaintLayerFragment&,
                                GraphicsContext&,
                                const ClipRect&,
                                const PaintLayerPaintingInfo&,
                                PaintLayerFlags,
                                ClipState);
    void paintBackgroundForFragments(const PaintLayerFragments&,
                                     GraphicsContext&,
                                     const LayoutRect& transparencyPaintDirtyRect,
                                     const PaintLayerPaintingInfo&,
                                     PaintLayerFlags);
    void paintForegroundForFragments(const PaintLayerFragments&,
                                     GraphicsContext&,
                                     const LayoutRect& transparencyPaintDirtyRect,
                                     const PaintLayerPaintingInfo&,
                                     bool selectionOnly,
                                     PaintLayerFlags);
    void paintForegroundForFragmentsWithPhase(PaintPhase,
                                              const PaintLayerFragments&,
                                              GraphicsContext&,
                                              const PaintLayerPaintingInfo&,
                                              PaintLayerFlags,
                                              ClipState);
    void paintSelfOutlineForFragments(const PaintLayerFragments&,
                                      GraphicsContext&,
                                      const PaintLayerPaintingInfo&,
                                      PaintLayerFlags);
    void paintOverflowControlsForFragments(const PaintLayerFragments&,
                                           GraphicsContext&,
                                           const PaintLayerPaintingInfo&,
                                           PaintLayerFlags);
    void paintMaskForFragments(const PaintLayerFragments&,
                               GraphicsContext&,
                               const PaintLayerPaintingInfo&,
                               PaintLayerFlags);
    void paintChildClippingMaskForFragments(const PaintLayerFragments&,
                                            GraphicsContext&,
                                            const PaintLayerPaintingInfo&,
                                            PaintLayerFlags);
  
    static bool needsToClip(const PaintLayerPaintingInfo& localPaintingInfo,
                            const ClipRect&);
  
    // Returns whether this layer should be painted during sofware painting (i.e.,
    // not via calls from CompositedLayerMapping to draw into composited layers).
    bool shouldPaintLayerInSoftwareMode(const GlobalPaintFlags,
                                        PaintLayerFlags paintFlags);
  
    PaintLayer& m_paintLayer;
  };
  
  }  // namespace blink
  
  #endif  // PaintLayerPainter_h
  