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

#include "third_party/blink/renderer/core/paint/paint_layer_painter.h"

#include "base/optional.h"
#include "third_party/blink/renderer/core/frame/local_frame_view.h"
#include "third_party/blink/renderer/core/frame/settings.h"
#include "third_party/blink/renderer/core/layout/layout_video.h"
#include "third_party/blink/renderer/core/layout/layout_view.h"
#include "third_party/blink/renderer/core/paint/clip_path_clipper.h"
#include "third_party/blink/renderer/core/paint/compositing/composited_layer_mapping.h"
#include "third_party/blink/renderer/core/paint/ng/ng_box_fragment_painter.h"
#include "third_party/blink/renderer/core/paint/object_paint_properties.h"
#include "third_party/blink/renderer/core/paint/paint_info.h"
#include "third_party/blink/renderer/core/paint/paint_layer.h"
#include "third_party/blink/renderer/core/paint/paint_layer_paint_order_iterator.h"
#include "third_party/blink/renderer/core/paint/paint_layer_scrollable_area.h"
#include "third_party/blink/renderer/core/paint/paint_timing_detector.h"
#include "third_party/blink/renderer/core/paint/scrollable_area_painter.h"
#include "third_party/blink/renderer/platform/geometry/float_point_3d.h"
#include "third_party/blink/renderer/platform/graphics/graphics_layer.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h"
#include "third_party/blink/renderer/platform/graphics/paint/geometry_mapper.h"
#include "third_party/blink/renderer/platform/graphics/paint/scoped_display_item_fragment.h"
#include "third_party/blink/renderer/platform/graphics/paint/scoped_paint_chunk_hint.h"
#include "third_party/blink/renderer/platform/graphics/paint/subsequence_recorder.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"

namespace blink {

void PaintLayerPainter::Paint(GraphicsContext& context,
                              const CullRect& cull_rect,
                              const GlobalPaintFlags global_paint_flags,
                              PaintLayerFlags paint_flags) {
  PaintLayerPaintingInfo painting_info(&paint_layer_, cull_rect,
                                       global_paint_flags, PhysicalOffset());
  if (!paint_layer_.PaintsIntoOwnOrGroupedBacking(global_paint_flags))
    Paint(context, painting_info, paint_flags);
}

static ShouldRespectOverflowClipType ShouldRespectOverflowClip(
    PaintLayerFlags paint_flags,
    const LayoutObject& layout_object) {
  return (paint_flags & kPaintLayerPaintingOverflowContents)
             ? kIgnoreOverflowClip
             : kRespectOverflowClip;
}

bool PaintLayerPainter::PaintedOutputInvisible(const ComputedStyle& style) {
  if (style.HasNonInitialBackdropFilter())
    return false;

  // Always paint when 'will-change: opacity' is present. Reduces jank for
  // common animation implementation approaches, for example, an element that
  // starts with opacity zero and later begins to animate.
  if (style.HasWillChangeOpacityHint())
    return false;

  // 0.0004f < 1/2048. With 10-bit color channels (only available on the
  // newest Macs; otherwise it's 8-bit), we see that an alpha of 1/2048 or
  // less leads to a color output of less than 0.5 in all channels, hence
  // not visible.
  static const float kMinimumVisibleOpacity = 0.0004f;
  if (style.Opacity() < kMinimumVisibleOpacity)
    return true;

  return false;
}

PaintResult PaintLayerPainter::Paint(
    GraphicsContext& context,
    const PaintLayerPaintingInfo& painting_info,
    PaintLayerFlags paint_flags) {
  if (paint_layer_.GetLayoutObject().GetFrameView()->ShouldThrottleRendering())
    return kFullyPainted;

  // Non self-painting layers without self-painting descendants don't need to be
  // painted as their layoutObject() should properly paint itself.
  if (!paint_layer_.IsSelfPaintingLayer() &&
      !paint_layer_.HasSelfPaintingLayerDescendant())
    return kFullyPainted;

  // If this layer is totally invisible then there is nothing to paint.
  // In CompositeAfterPaint we simplify this optimization by painting even when
  // effectively invisible but skipping the painted content during layerization
  // in PaintArtifactCompositor.
  if (paint_layer_.PaintsWithTransparency(
          painting_info.GetGlobalPaintFlags())) {
    if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() &&
        PaintedOutputInvisible(paint_layer_.GetLayoutObject().StyleRef()))
      return kFullyPainted;

    paint_flags |= kPaintLayerHaveTransparency;
  }

  // If the transform can't be inverted, then don't paint anything.
  if (paint_layer_.PaintsWithTransform(painting_info.GetGlobalPaintFlags()) &&
      !paint_layer_.RenderableTransform(painting_info.GetGlobalPaintFlags())
           .IsInvertible()) {
    return kFullyPainted;
  }

  paint_flags |= kPaintLayerPaintingCompositingAllPhases;
  return PaintLayerContents(context, painting_info, paint_flags);
}

static bool ShouldCreateSubsequence(
    const PaintLayer& paint_layer,
    const GraphicsContext& context,
    const PaintLayerPaintingInfo& painting_info) {
  // Caching is not needed during printing or painting previews.
  if (paint_layer.GetLayoutObject().GetDocument().IsPrintingOrPaintingPreview())
    return false;

  if (context.GetPaintController().IsSkippingCache())
    return false;

  if (!paint_layer.SupportsSubsequenceCaching())
    return false;

  // Don't create subsequence during special painting to avoid cache conflict
  // with normal painting.
  if (painting_info.GetGlobalPaintFlags() &
      kGlobalPaintFlattenCompositingLayers)
    return false;

  // Don't create subsequence for a composited layer because if it can be
  // cached, we can skip the whole painting in GraphicsLayer::paint() with
  // CachedDisplayItemList.  This also avoids conflict of
  // PaintLayer::previousXXX() when paintLayer is composited scrolling and is
  // painted twice for GraphicsLayers of container and scrolling contents.
  if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() &&
      (paint_layer.GetCompositingState() == kPaintsIntoOwnBacking))
    return false;

  return true;
}

static bool ShouldRepaintSubsequence(
    PaintLayer& paint_layer,
    const PaintLayerPaintingInfo& painting_info) {
  // Repaint subsequence if the layer is marked for needing repaint.
  if (paint_layer.SelfOrDescendantNeedsRepaint())
    return true;

  // Repaint if previously the layer may be clipped by cull rect, and cull rect
  // changes.
  if (!RuntimeEnabledFeatures::CullRectUpdateEnabled() &&
      paint_layer.PreviousCullRect() != painting_info.cull_rect) {
    if (paint_layer.PreviousPaintResult() == kMayBeClippedByCullRect)
      return true;
    // When PaintUnderInvalidationChecking is enabled, always repaint the
    // subsequence when the paint rect changes because we will strictly match
    // new and cached subsequences. Normally we can reuse the cached fully
    // painted subsequence even if we would partially paint this time.
    if (RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled())
      return true;
  }

  return false;
}

static bool IsUnclippedLayoutView(const PaintLayer& layer) {
  // If MainFrameClipsContent is false which means that WebPreferences::
  // record_whole_document is true, we should not cull the scrolling contents
  // of the main frame.
  if (IsA<LayoutView>(layer.GetLayoutObject())) {
    const auto* frame = layer.GetLayoutObject().GetFrame();
    if (frame && !frame->ClipsContent())
      return true;
  }
  return false;
}

bool PaintLayerPainter::ShouldUseInfiniteCullRect(
    GlobalPaintFlags global_flags) {
  bool is_printing = paint_layer_.GetLayoutObject().GetDocument().Printing();
  if (IsUnclippedLayoutView(paint_layer_) && !is_printing)
    return true;

  // Cull rects and clips can't be propagated across a filter which moves
  // pixels, since the input of the filter may be outside the cull rect /
  // clips yet still result in painted output.
  // TODO(wangxianzhu): With CullRectUpdate, we can let CullRect support
  // mapping for pixel moving filters to avoid this infinite cull rect.
  if (paint_layer_.HasFilterThatMovesPixels() &&
      // However during printing, we don't want filter outset to cross page
      // boundaries. This also avoids performance issue because the PDF renderer
      // is super slow for big filters. Otherwise all filtered contents would
      // appear in the painted result of every page.
      // TODO(crbug.com/1098995): For now we don't adjust cull rect for clips.
      // When we do, we need to check if we are painting under a real clip.
      // This won't be a problem when we use block fragments for printing.
      !is_printing)
    return true;

  // Cull rect mapping doesn't work under perspective in some cases.
  // See http://crbug.com/887558 for details.
  if (paint_layer_.GetLayoutObject().StyleRef().HasPerspective())
    return true;

  // We do not apply cull rect optimizations across transforms for two
  // reasons:
  //   1) Performance: We can optimize transform changes by not repainting.
  //   2) Complexity: Difficulty updating clips when ancestor transforms
  //      change.
  // For these reasons, we use an infinite dirty rect here.
  // The reasons don't apply for CullRectUpdate.
  if (!RuntimeEnabledFeatures::CullRectUpdateEnabled() &&
      paint_layer_.PaintsWithTransform(global_flags) &&
      // The reasons don't apply for printing though, because when we enter and
      // leaving printing mode, full invalidations occur.
      !is_printing)
    return true;

  return false;
}

void PaintLayerPainter::AdjustForPaintProperties(
    const GraphicsContext& context,
    PaintLayerPaintingInfo& painting_info,
    PaintLayerFlags& paint_flags) {
  const auto& first_fragment = paint_layer_.GetLayoutObject().FirstFragment();

  bool should_use_infinite_cull_rect =
      ShouldUseInfiniteCullRect(painting_info.GetGlobalPaintFlags());
  if (should_use_infinite_cull_rect) {
    painting_info.cull_rect = CullRect::Infinite();
    // Avoid clipping during CollectFragments.
    if (IsUnclippedLayoutView(paint_layer_))
      paint_flags |= kPaintLayerPaintingOverflowContents;
  }

  if (painting_info.root_layer == &paint_layer_)
    return;

  if (!should_use_infinite_cull_rect) {
    // painting_info.cull_rect is currently in |painting_info.root_layer|'s
    // pixel-snapped border box space. We need to adjust it into
    // |paint_layer_|'s space. This handles the following cases:
    // - The current layer has PaintOffsetTranslation;
    // - The current layer's transform state escapes the root layers contents
    //   transform, e.g. a fixed-position layer;
    // - Scroll offsets.
    const auto& first_root_fragment =
        painting_info.root_layer->GetLayoutObject().FirstFragment();
    const auto* source_transform =
        &first_root_fragment.LocalBorderBoxProperties().Transform();
    const auto& destination_transform =
        first_fragment.LocalBorderBoxProperties().Transform();
    if (source_transform == &destination_transform)
      return;

    if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
      auto& cull_rect = painting_info.cull_rect;
      // CullRect::ApplyTransforms() requires the cull rect in the source
      // transform space. Convert cull_rect from the root layer's local space.
      cull_rect.MoveBy(RoundedIntPoint(first_root_fragment.PaintOffset()));
      base::Optional<CullRect> old_cull_rect;
      if (!paint_layer_.SelfOrDescendantNeedsRepaint() &&
          !RuntimeEnabledFeatures::CullRectUpdateEnabled()) {
        old_cull_rect = paint_layer_.PreviousCullRect();
        // Convert old_cull_rect into the layer's transform space.
        old_cull_rect->MoveBy(RoundedIntPoint(first_fragment.PaintOffset()));
      }
      if (paint_flags & kPaintLayerPaintingOverflowContents) {
        // Use PostScrollTranslation as the source transform to avoid clipping
        // of the scrolling contents in CullRect::ApplyTransforms().
        source_transform = &first_root_fragment.PostScrollTranslation();
        // Map cull_rect into scrolling contents space (i.e. source_transform).
        if (const auto* properties = first_root_fragment.PaintProperties()) {
          if (const auto* scroll_translation = properties->ScrollTranslation())
            cull_rect.Move(-scroll_translation->Translation2D());
        }
      }
      cull_rect.ApplyTransforms(source_transform->Unalias(),
                                destination_transform.Unalias(), old_cull_rect);
      // Convert cull_rect from the layer's transform space to the layer's local
      // space.
      cull_rect.MoveBy(-RoundedIntPoint(first_fragment.PaintOffset()));
    } else if (!painting_info.cull_rect.IsInfinite()) {
      auto rect = painting_info.cull_rect.Rect();
      first_root_fragment.MapRectToFragment(first_fragment, rect);
      painting_info.cull_rect = CullRect(rect);
    }
  }

  // We reach here if the layer requires infinite cull rect or has different
  // transform space from the current root layer. Use the current layer as
  // the new root layer.
  painting_info.root_layer = &paint_layer_;
  // These flags no longer apply for the new root layer.
  paint_flags &= ~kPaintLayerPaintingSkipRootBackground;
  paint_flags &= ~kPaintLayerPaintingOverflowContents;
  paint_flags &= ~kPaintLayerPaintingCompositingScrollingPhase;

  if (first_fragment.PaintProperties() &&
      first_fragment.PaintProperties()->PaintOffsetTranslation()) {
    painting_info.sub_pixel_accumulation = first_fragment.PaintOffset();
  }
}

static IntRect FirstFragmentVisualRect(const LayoutBoxModelObject& object) {
  // We don't want to include overflowing contents.
  PhysicalRect overflow_rect =
      object.IsBox() ? To<LayoutBox>(object).PhysicalSelfVisualOverflowRect()
                     : object.PhysicalVisualOverflowRect();
  overflow_rect.Move(object.FirstFragment().PaintOffset());
  return EnclosingIntRect(overflow_rect);
}

PaintResult PaintLayerPainter::PaintLayerContents(
    GraphicsContext& context,
    const PaintLayerPaintingInfo& painting_info_arg,
    PaintLayerFlags paint_flags_arg) {
  DCHECK(paint_layer_.IsSelfPaintingLayer() ||
         paint_layer_.HasSelfPaintingLayerDescendant());

  const auto& object = paint_layer_.GetLayoutObject();
  PaintResult result = kFullyPainted;
  if (object.GetFrameView()->ShouldThrottleRendering())
    return result;

  // A paint layer should always have LocalBorderBoxProperties when it's ready
  // for paint.
  if (!object.FirstFragment().HasLocalBorderBoxProperties()) {
    // TODO(crbug.com/848056): This can happen e.g. when we paint a filter
    // referencing a SVG foreign object through feImage, especially when there
    // is circular references. Should find a better solution.
    if (!RuntimeEnabledFeatures::CullRectUpdateEnabled())
      paint_layer_.SetPreviousCullRect(CullRect());
    return kMayBeClippedByCullRect;
  }

  bool selection_drag_image_only = painting_info_arg.GetGlobalPaintFlags() &
                                   kGlobalPaintSelectionDragImageOnly;
  if (selection_drag_image_only && !object.IsSelected())
    return result;

  IgnorePaintTimingScope ignore_paint_timing;
  if (object.StyleRef().Opacity() == 0.0f) {
    IgnorePaintTimingScope::IncrementIgnoreDepth();
  }
  // Explicitly compute opacity of documentElement, as it is special-cased in
  // Largest Contentful Paint.
  bool is_document_element_invisible = false;
  if (const auto* document_element = object.GetDocument().documentElement()) {
    if (document_element->GetLayoutObject() &&
        document_element->GetLayoutObject()->StyleRef().Opacity() == 0.0f) {
      is_document_element_invisible = true;
    }
  }
  IgnorePaintTimingScope::SetIsDocumentElementInvisible(
      is_document_element_invisible);

  PaintLayerFlags paint_flags = paint_flags_arg;
  PaintLayerPaintingInfo painting_info = painting_info_arg;
  AdjustForPaintProperties(context, painting_info, paint_flags);

  bool is_self_painting_layer = paint_layer_.IsSelfPaintingLayer();
  bool is_painting_overlay_overflow_controls =
      paint_flags & kPaintLayerPaintingOverlayOverflowControls;
  bool is_painting_scrolling_content =
      paint_flags & kPaintLayerPaintingCompositingScrollingPhase;
  bool is_painting_composited_foreground =
      paint_flags & kPaintLayerPaintingCompositingForegroundPhase;
  bool is_painting_composited_background =
      paint_flags & kPaintLayerPaintingCompositingBackgroundPhase;
  bool is_painting_composited_decoration =
      paint_flags & kPaintLayerPaintingCompositingDecorationPhase;
  bool is_painting_overflow_contents =
      paint_flags & kPaintLayerPaintingOverflowContents;
  bool is_painting_mask = paint_flags & kPaintLayerPaintingCompositingMaskPhase;

  // Outline always needs to be painted even if we have no visible content.
  // It is painted as part of the decoration phase which paints content that
  // is not scrolled and should be above scrolled content.
  bool should_paint_self_outline =
      is_self_painting_layer && !is_painting_overlay_overflow_controls &&
      is_painting_composited_decoration && object.StyleRef().HasOutline();

  PhysicalOffset subpixel_accumulation =
      (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() &&
       !(painting_info.GetGlobalPaintFlags() &
         kGlobalPaintFlattenCompositingLayers) &&
       paint_layer_.GetCompositingState() == kPaintsIntoOwnBacking)
          ? paint_layer_.SubpixelAccumulation()
          : painting_info.sub_pixel_accumulation;

  ShouldRespectOverflowClipType respect_overflow_clip =
      ShouldRespectOverflowClip(paint_flags, object);

  bool should_paint_content =
      paint_layer_.HasVisibleContent() &&
      // Content under a LayoutSVGHiddenContainer is auxiliary resources for
      // painting. Foreign content should never paint in this situation, as it
      // is primary, not auxiliary.
      !paint_layer_.IsUnderSVGHiddenContainer() && is_self_painting_layer &&
      !is_painting_overlay_overflow_controls;

  bool should_create_subsequence =
      should_paint_content &&
      ShouldCreateSubsequence(paint_layer_, context, painting_info);

  base::Optional<SubsequenceRecorder> subsequence_recorder;
  if (should_create_subsequence) {
    if (!ShouldRepaintSubsequence(paint_layer_, painting_info) &&
        SubsequenceRecorder::UseCachedSubsequenceIfPossible(context,
                                                            paint_layer_)) {
      return paint_layer_.PreviousPaintResult();
    }
    DCHECK(paint_layer_.SupportsSubsequenceCaching());
    subsequence_recorder.emplace(context, paint_layer_);
  }

  PhysicalOffset offset_from_root =
      paint_layer_.GetLayoutObject().FirstFragment().PaintOffset();
  if (const PaintLayer* root = painting_info.root_layer)
    offset_from_root -= root->GetLayoutObject().FirstFragment().PaintOffset();
  offset_from_root += subpixel_accumulation;

  IntRect visual_rect = FirstFragmentVisualRect(object);
  if (RuntimeEnabledFeatures::CullRectUpdateEnabled()) {
    if (object.FirstFragment().NextFragment()) {
      result = kMayBeClippedByCullRect;
    } else if (!object.FirstFragment().GetCullRect().Rect().Contains(
                   visual_rect)) {
      result = kMayBeClippedByCullRect;
    } else if (const auto* box = DynamicTo<LayoutBox>(object)) {
      PhysicalRect contents_visual_rect =
          box->PhysicalContentsVisualOverflowRect();
      contents_visual_rect.Move(object.FirstFragment().PaintOffset());
      if (!PhysicalRect(object.FirstFragment().GetContentsCullRect().Rect())
               .Contains(contents_visual_rect)) {
        result = kMayBeClippedByCullRect;
      }
    }
  } else {
    PhysicalRect bounds = paint_layer_.PhysicalBoundingBox(offset_from_root);
    if (!PhysicalRect(painting_info.cull_rect.Rect()).Contains(bounds))
      result = kMayBeClippedByCullRect;
  }

  PaintLayerPaintingInfo local_painting_info(painting_info);
  local_painting_info.sub_pixel_accumulation = subpixel_accumulation;

  PaintLayerFragments layer_fragments;

  if (should_paint_content || should_paint_self_outline ||
      is_painting_overlay_overflow_controls) {
    // Collect the fragments. This will compute the clip rectangles and paint
    // offsets for each layer fragment.
    paint_layer_.CollectFragments(
        layer_fragments, local_painting_info.root_layer,
        &local_painting_info.cull_rect, kIgnoreOverlayScrollbarSize,
        respect_overflow_clip, &offset_from_root,
        local_painting_info.sub_pixel_accumulation);

    // PaintLayer::CollectFragments depends on the paint dirty rect in
    // complicated ways. For now, always assume a partially painted output
    // for fragmented content.
    if (layer_fragments.size() > 1)
      result = kMayBeClippedByCullRect;

    if (should_paint_content) {
      should_paint_content = AtLeastOneFragmentIntersectsDamageRect(
          layer_fragments, local_painting_info, paint_flags, offset_from_root);
      if (!should_paint_content)
        result = kMayBeClippedByCullRect;
    }
  }

  bool is_painting_root_layer = (&paint_layer_) == painting_info.root_layer;
  bool should_paint_background =
      should_paint_content && !selection_drag_image_only &&
      (is_painting_composited_background ||
       (is_painting_root_layer &&
        !(paint_flags & kPaintLayerPaintingSkipRootBackground)));
  bool should_paint_neg_z_order_list =
      !is_painting_overlay_overflow_controls &&
      (is_painting_scrolling_content ? is_painting_overflow_contents
                                     : is_painting_composited_background);
  bool should_paint_own_contents =
      is_painting_composited_foreground && should_paint_content;
  bool should_paint_normal_flow_and_pos_z_order_lists =
      is_painting_composited_foreground &&
      !is_painting_overlay_overflow_controls;
  bool is_video = IsA<LayoutVideo>(object);

  base::Optional<ScopedPaintChunkHint> paint_chunk_hint;
  if (should_paint_content) {
    paint_chunk_hint.emplace(context.GetPaintController(),
                             object.FirstFragment().LocalBorderBoxProperties(),
                             paint_layer_, DisplayItem::kLayerChunk,
                             visual_rect);
  }

  if (should_paint_background) {
    PaintBackgroundForFragmentsWithPhase(PaintPhase::kSelfBlockBackgroundOnly,
                                         layer_fragments, context,
                                         local_painting_info, paint_flags);
  }

  if (should_paint_neg_z_order_list) {
    if (PaintChildren(kNegativeZOrderChildren, context, painting_info,
                      paint_flags) == kMayBeClippedByCullRect)
      result = kMayBeClippedByCullRect;
  }

  if (should_paint_own_contents) {
    base::Optional<ScopedPaintChunkHint> paint_chunk_hint_foreground;
    if (paint_chunk_hint && paint_chunk_hint->HasCreatedPaintChunk()) {
      // Hint a foreground chunk if we have created any chunks, to give the
      // paint chunk after the previous forced paint chunks a stable id.
      paint_chunk_hint_foreground.emplace(
          context.GetPaintController(), paint_layer_,
          DisplayItem::kLayerChunkForeground, visual_rect);
    }
    if (selection_drag_image_only) {
      PaintForegroundForFragmentsWithPhase(PaintPhase::kSelectionDragImage,
                                           layer_fragments, context,
                                           local_painting_info, paint_flags);
    } else {
      PaintForegroundForFragments(layer_fragments, context, local_painting_info,
                                  paint_flags);
    }
  }

  if (!is_video && should_paint_self_outline) {
    PaintBackgroundForFragmentsWithPhase(PaintPhase::kSelfOutlineOnly,
                                         layer_fragments, context,
                                         local_painting_info, paint_flags);
  }

  if (should_paint_normal_flow_and_pos_z_order_lists) {
    if (PaintChildren(kNormalFlowAndPositiveZOrderChildren, context,
                      painting_info, paint_flags) == kMayBeClippedByCullRect)
      result = kMayBeClippedByCullRect;
  }

  if (paint_layer_.GetScrollableArea() &&
      paint_layer_.GetScrollableArea()
          ->ShouldOverflowControlsPaintAsOverlay()) {
    if (is_painting_overlay_overflow_controls ||
        !paint_layer_.NeedsReorderOverlayOverflowControls()) {
      PaintOverlayOverflowControlsForFragments(
          layer_fragments, context, local_painting_info, paint_flags);
    }
  }

  if (is_video && should_paint_self_outline) {
    // We paint outlines for video later so that they aren't obscured by the
    // video controls.
    PaintBackgroundForFragmentsWithPhase(PaintPhase::kSelfOutlineOnly,
                                         layer_fragments, context,
                                         local_painting_info, paint_flags);
  }

  if (is_painting_mask && should_paint_content && !selection_drag_image_only) {
    if (const auto* properties = object.FirstFragment().PaintProperties()) {
      if (properties->Mask()) {
        PaintBackgroundForFragmentsWithPhase(PaintPhase::kMask, layer_fragments,
                                             context, local_painting_info,
                                             paint_flags);
      }
      if (properties->ClipPathMask()) {
        PhysicalOffset visual_offset_from_root =
            paint_layer_.EnclosingPaginationLayer()
                ? paint_layer_.VisualOffsetFromAncestor(
                      local_painting_info.root_layer, subpixel_accumulation)
                : offset_from_root;
        ClipPathClipper::PaintClipPathAsMaskImage(context, object, object,
                                                  visual_offset_from_root);
      }
    }
  }

  paint_layer_.SetPreviousPaintResult(result);
  if (!RuntimeEnabledFeatures::CullRectUpdateEnabled())
    paint_layer_.SetPreviousCullRect(local_painting_info.cull_rect);
  return result;
}

bool PaintLayerPainter::AtLeastOneFragmentIntersectsDamageRect(
    PaintLayerFragments& fragments,
    const PaintLayerPaintingInfo& local_painting_info,
    PaintLayerFlags local_paint_flags,
    const PhysicalOffset& offset_from_root) {
  if (&paint_layer_ == local_painting_info.root_layer &&
      (local_paint_flags & kPaintLayerPaintingOverflowContents))
    return true;

  // Skip the optimization if the layer is fragmented to avoid complexity
  // about overflows in fragments. LayoutObject painters will do cull rect
  // optimization later.
  if (paint_layer_.EnclosingPaginationLayer() || fragments.size() > 1)
    return true;

  return paint_layer_.IntersectsDamageRect(fragments[0].layer_bounds,
                                           fragments[0].background_rect.Rect(),
                                           offset_from_root);
}

template <typename Function>
static void ForAllFragments(GraphicsContext& context,
                            const PaintLayerFragments& fragments,
                            const Function& function) {
  for (wtf_size_t i = 0; i < fragments.size(); ++i) {
    base::Optional<ScopedDisplayItemFragment> scoped_display_item_fragment;
    if (i)
      scoped_display_item_fragment.emplace(context, i);
    function(fragments[i]);
  }
}

PaintResult PaintLayerPainter::PaintChildren(
    PaintLayerIteration children_to_visit,
    GraphicsContext& context,
    const PaintLayerPaintingInfo& painting_info,
    PaintLayerFlags paint_flags) {
  PaintResult result = kFullyPainted;
  if (!paint_layer_.HasSelfPaintingLayerDescendant())
    return result;

  if (paint_layer_.GetLayoutObject().ChildPaintBlockedByDisplayLock())
    return result;

  PaintLayerPaintOrderIterator iterator(paint_layer_, children_to_visit);
  while (PaintLayer* child = iterator.Next()) {
    // If this Layer should paint into its own backing or a grouped backing,
    // that will be done via CompositedLayerMapping::PaintContents() and
    // CompositedLayerMapping::DoPaintTask().
    if (child->PaintsIntoOwnOrGroupedBacking(
            painting_info.GetGlobalPaintFlags()))
      continue;

    if (child->IsReplacedNormalFlowStacking())
      continue;

    if (PaintLayerPainter(*child).Paint(context, painting_info, paint_flags) ==
        kMayBeClippedByCullRect)
      result = kMayBeClippedByCullRect;

    if (const auto* layers_painting_overlay_overflow_controls_after =
            iterator.LayersPaintingOverlayOverflowControlsAfter(child)) {
      for (auto* reparent_overflow_controls_layer :
           *layers_painting_overlay_overflow_controls_after) {
        DCHECK(reparent_overflow_controls_layer
                   ->NeedsReorderOverlayOverflowControls());
        if (PaintLayerPainter(*reparent_overflow_controls_layer)
                .Paint(context, painting_info,
                       kPaintLayerPaintingOverlayOverflowControls) ==
            kMayBeClippedByCullRect)
          result = kMayBeClippedByCullRect;
      }
    }
  }

  return result;
}

void PaintLayerPainter::PaintOverlayOverflowControlsForFragments(
    const PaintLayerFragments& layer_fragments,
    GraphicsContext& context,
    const PaintLayerPaintingInfo& painting_info,
    PaintLayerFlags paint_flags) {
  DCHECK(
      paint_layer_.GetScrollableArea() &&
      paint_layer_.GetScrollableArea()->ShouldOverflowControlsPaintAsOverlay());

  // We don't need to paint composited overflow controls.
  if (paint_layer_.GetScrollableArea()->HasLayerForHorizontalScrollbar() ||
      paint_layer_.GetScrollableArea()->HasLayerForVerticalScrollbar() ||
      paint_layer_.GetScrollableArea()->HasLayerForScrollCorner())
    return;

  PaintBackgroundForFragmentsWithPhase(PaintPhase::kOverlayOverflowControls,
                                       layer_fragments, context, painting_info,
                                       paint_flags);
}

void PaintLayerPainter::PaintFragmentWithPhase(
    PaintPhase phase,
    const PaintLayerFragment& fragment,
    GraphicsContext& context,
    const CullRect& cull_rect,
    const PaintLayerPaintingInfo& painting_info,
    PaintLayerFlags paint_flags) {
  DCHECK(paint_layer_.IsSelfPaintingLayer());

  auto chunk_properties = fragment.fragment_data->LocalBorderBoxProperties();
  if (phase == PaintPhase::kMask) {
    const auto* properties = fragment.fragment_data->PaintProperties();
    DCHECK(properties);
    DCHECK(properties->Mask());
    chunk_properties.SetEffect(*properties->Mask());
  }
  ScopedPaintChunkProperties fragment_paint_chunk_properties(
      context.GetPaintController(), chunk_properties, paint_layer_,
      DisplayItem::PaintPhaseToDrawingType(phase));

  PaintInfo paint_info(
      context, cull_rect, phase, painting_info.GetGlobalPaintFlags(),
      paint_flags, &painting_info.root_layer->GetLayoutObject(),
      fragment.fragment_data ? fragment.fragment_data->LogicalTopInFlowThread()
                             : LayoutUnit());
  if (paint_layer_.GetLayoutObject().ChildPaintBlockedByDisplayLock())
    paint_info.SetDescendantPaintingBlocked(true);

  if (fragment.physical_fragment)
    NGBoxFragmentPainter(*fragment.physical_fragment).Paint(paint_info);
  else
    paint_layer_.GetLayoutObject().Paint(paint_info);
}

static CullRect LegacyCullRect(const PaintLayerFragment& fragment,
                               const ClipRect& clip_rect) {
  DCHECK(!RuntimeEnabledFeatures::CullRectUpdateEnabled());
  PhysicalRect new_cull_rect(clip_rect.Rect());
  // Now |new_cull_rect| is in the pixel-snapped border box space of
  // |fragment.root_fragment_data|. Adjust it to the containing transform node's
  // space in which we will paint.
  new_cull_rect.Move(PhysicalOffset(
      RoundedIntPoint(fragment.root_fragment_data->PaintOffset())));
  return CullRect(PixelSnappedIntRect(new_cull_rect));
}

void PaintLayerPainter::PaintBackgroundForFragmentsWithPhase(
    PaintPhase phase,
    const PaintLayerFragments& layer_fragments,
    GraphicsContext& context,
    const PaintLayerPaintingInfo& local_painting_info,
    PaintLayerFlags paint_flags) {
  ForAllFragments(
      context, layer_fragments, [&](const PaintLayerFragment& fragment) {
        CullRect cull_rect =
            RuntimeEnabledFeatures::CullRectUpdateEnabled()
                ? fragment.fragment_data->GetCullRect()
                : LegacyCullRect(fragment, fragment.background_rect);
        if (!cull_rect.Rect().IsEmpty()) {
          PaintFragmentWithPhase(phase, fragment, context, cull_rect,
                                 local_painting_info, paint_flags);
        }
      });
}

void PaintLayerPainter::PaintForegroundForFragments(
    const PaintLayerFragments& layer_fragments,
    GraphicsContext& context,
    const PaintLayerPaintingInfo& local_painting_info,
    PaintLayerFlags paint_flags) {
  PaintForegroundForFragmentsWithPhase(
      PaintPhase::kDescendantBlockBackgroundsOnly, layer_fragments, context,
      local_painting_info, paint_flags);

  if (paint_layer_.GetLayoutObject().GetDocument().InForcedColorsMode()) {
    PaintForegroundForFragmentsWithPhase(PaintPhase::kForcedColorsModeBackplate,
                                         layer_fragments, context,
                                         local_painting_info, paint_flags);
  }

  if (RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled() ||
      paint_layer_.NeedsPaintPhaseFloat()) {
    PaintForegroundForFragmentsWithPhase(PaintPhase::kFloat, layer_fragments,
                                         context, local_painting_info,
                                         paint_flags);
  }

  PaintForegroundForFragmentsWithPhase(PaintPhase::kForeground, layer_fragments,
                                       context, local_painting_info,
                                       paint_flags);

  if (RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled() ||
      paint_layer_.NeedsPaintPhaseDescendantOutlines()) {
    PaintForegroundForFragmentsWithPhase(PaintPhase::kDescendantOutlinesOnly,
                                         layer_fragments, context,
                                         local_painting_info, paint_flags);
  }
}

void PaintLayerPainter::PaintForegroundForFragmentsWithPhase(
    PaintPhase phase,
    const PaintLayerFragments& layer_fragments,
    GraphicsContext& context,
    const PaintLayerPaintingInfo& local_painting_info,
    PaintLayerFlags paint_flags) {
  ForAllFragments(
      context, layer_fragments, [&](const PaintLayerFragment& fragment) {
        CullRect cull_rect;
        if (RuntimeEnabledFeatures::CullRectUpdateEnabled()) {
          // In CullRectUpdate, this function is the same as
          // PaintBackgroundForFragmentsWithPhase(). The contents cull rect will
          // be applied by ScopedBoxContentsPaintState.
          cull_rect = fragment.fragment_data->GetCullRect();
        } else {
          cull_rect = LegacyCullRect(fragment, fragment.foreground_rect);
        }
        if (!cull_rect.Rect().IsEmpty()) {
          PaintFragmentWithPhase(phase, fragment, context, cull_rect,
                                 local_painting_info, paint_flags);
        }
      });
}

void PaintLayerPainter::PaintOverlayOverflowControls(
    GraphicsContext& context,
    const CullRect& cull_rect,
    const GlobalPaintFlags paint_flags) {
  PaintLayerPaintingInfo painting_info(&paint_layer_, cull_rect, paint_flags,
                                       PhysicalOffset());
  Paint(context, painting_info, kPaintLayerPaintingOverlayOverflowControls);
}

}  // namespace blink