Bug 1687263: part 4) Defer and in some cases avoid removing spellchecking-ranges...

[gecko.git] / layout / painting / FrameLayerBuilder.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "FrameLayerBuilder.h"

#include <algorithm>
#include <deque>
#include <functional>
#include <utility>

#include "ActiveLayerTracker.h"
#include "BasicLayers.h"
#include "ImageContainer.h"
#include "ImageLayers.h"
#include "LayerTreeInvalidation.h"
#include "LayerUserData.h"
#include "Layers.h"
#include "MaskLayerImageCache.h"
#include "MatrixStack.h"
#include "TransformClipNode.h"
#include "UnitTransforms.h"
#include "Units.h"
#include "gfx2DGlue.h"
#include "gfxContext.h"
#include "gfxEnv.h"
#include "gfxUtils.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/DisplayPortUtils.h"
#include "mozilla/EffectCompositor.h"
#include "mozilla/LayerAnimationInfo.h"
#include "mozilla/LayerTimelineMarker.h"
#include "mozilla/LookAndFeel.h"
#include "mozilla/Maybe.h"
#include "mozilla/PerfStats.h"
#include "mozilla/PresShell.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ReverseIterator.h"
#include "mozilla/StaticPrefs_gfx.h"
#include "mozilla/StaticPrefs_layers.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/SVGIntegrationUtils.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/EffectsInfo.h"
#include "mozilla/dom/ProfileTimelineMarkerBinding.h"
#include "mozilla/dom/RemoteBrowser.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/Matrix.h"
#include "mozilla/gfx/Tools.h"
#include "mozilla/layers/ShadowLayers.h"
#include "mozilla/layers/TextureClient.h"
#include "mozilla/layers/TextureWrapperImage.h"
#include "mozilla/layers/WebRenderUserData.h"
#include "nsDisplayList.h"
#include "nsDocShell.h"
#include "nsIScrollableFrame.h"
#include "nsImageFrame.h"
#include "nsLayoutUtils.h"
#include "nsPresContext.h"
#include "nsPrintfCString.h"
#include "nsSubDocumentFrame.h"
#include "nsTransitionManager.h"
#include "nsTHashMap.h"

using namespace mozilla::layers;
using namespace mozilla::gfx;
using mozilla::UniquePtr;
using mozilla::WrapUnique;

// PaintedLayerData::mAssignedDisplayItems is a std::vector, which is
// non-memmovable
MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::PaintedLayerData);

namespace mozilla {

class PaintedDisplayItemLayerUserData;

static nsTHashSet<DisplayItemData*>* sAliveDisplayItemDatas;

// DO NOT MODIFY THE ARRAY RETURNED BY THIS FUNCTION.
// It might be the static empty array.
SmallPointerArray<DisplayItemData>& GetDisplayItemDataArray(
    const nsIFrame* aFrame) {
  static SmallPointerArray<DisplayItemData> sEmpty;
  MOZ_ASSERT(sEmpty.IsEmpty());
  auto* array = aFrame->DisplayItemData();
  return array ? *array : sEmpty;
}

/**
 * The address of gPaintedDisplayItemLayerUserData is used as the user
 * data key for PaintedLayers created by FrameLayerBuilder.
 * It identifies PaintedLayers used to draw non-layer content, which are
 * therefore eligible for recycling. We want display items to be able to
 * create their own dedicated PaintedLayers in BuildLayer, if necessary,
 * and we wouldn't want to accidentally recycle those.
 * The user data is a PaintedDisplayItemLayerUserData.
 */
uint8_t gPaintedDisplayItemLayerUserData;
/**
 * The address of gColorLayerUserData is used as the user
 * data key for ColorLayers created by FrameLayerBuilder.
 * The user data is null.
 */
uint8_t gColorLayerUserData;
/**
 * The address of gImageLayerUserData is used as the user
 * data key for ImageLayers created by FrameLayerBuilder.
 * The user data is null.
 */
uint8_t gImageLayerUserData;
/**
 * The address of gLayerManagerUserData is used as the user
 * data key for retained LayerManagers managed by FrameLayerBuilder.
 * The user data is a LayerManagerData.
 */
uint8_t gLayerManagerUserData;
/**
 * The address of gMaskLayerUserData is used as the user
 * data key for mask layers managed by FrameLayerBuilder.
 * The user data is a MaskLayerUserData.
 */
uint8_t gMaskLayerUserData;
/**
 * The address of gCSSMaskLayerUserData is used as the user
 * data key for mask layers of css masking managed by FrameLayerBuilder.
 * The user data is a CSSMaskLayerUserData.
 */
uint8_t gCSSMaskLayerUserData;

// a global cache of image containers used for mask layers
static MaskLayerImageCache* gMaskLayerImageCache = nullptr;

static inline MaskLayerImageCache* GetMaskLayerImageCache() {
  if (!gMaskLayerImageCache) {
    gMaskLayerImageCache = new MaskLayerImageCache();
  }

  return gMaskLayerImageCache;
}

struct InactiveLayerData {
  RefPtr<layers::BasicLayerManager> mLayerManager;
  RefPtr<layers::Layer> mLayer;
  UniquePtr<layers::LayerProperties> mProps;

  ~InactiveLayerData();
};

struct AssignedDisplayItem {
  AssignedDisplayItem(nsPaintedDisplayItem* aItem, LayerState aLayerState,
                      DisplayItemData* aData, const nsRect& aContentRect,
                      DisplayItemEntryType aType, const bool aHasOpacity,
                      const RefPtr<TransformClipNode>& aTransform,
                      const bool aIsMerged);
  AssignedDisplayItem(AssignedDisplayItem&& aRhs) = default;

  bool HasOpacity() const { return mHasOpacity; }

  bool HasTransform() const { return mTransform; }

  nsPaintedDisplayItem* mItem;
  DisplayItemData* mDisplayItemData;

  /**
   * If the display item is being rendered as an inactive
   * layer, then this stores the layer manager being
   * used for the inactive transaction.
   */
  UniquePtr<InactiveLayerData> mInactiveLayerData;
  RefPtr<TransformClipNode> mTransform;

  nsRect mContentRect;
  LayerState mLayerState;
  DisplayItemEntryType mType;

  bool mReused;
  bool mMerged;
  bool mHasOpacity;
  bool mHasPaintRect;
};

struct DisplayItemEntry {
  DisplayItemEntry(nsDisplayItem* aItem, DisplayItemEntryType aType)
      : mItem(aItem), mType(aType) {}

  nsDisplayItem* mItem;
  DisplayItemEntryType mType;
};

/**
 * Returns true if the given |aType| is an effect start marker.
 */
static bool IsEffectStartMarker(DisplayItemEntryType aType) {
  return aType == DisplayItemEntryType::PushOpacity ||
         aType == DisplayItemEntryType::PushOpacityWithBg ||
         aType == DisplayItemEntryType::PushTransform;
}

/**
 * Returns true if the given |aType| is an effect end marker.
 */
static bool IsEffectEndMarker(DisplayItemEntryType aType) {
  return aType == DisplayItemEntryType::PopOpacity ||
         aType == DisplayItemEntryType::PopTransform;
}

enum class MarkerType { StartMarker, EndMarker };

/**
 * Returns true if the given nsDisplayOpacity |aItem| has had opacity applied
 * to its children and can be flattened away.
 */
static bool IsOpacityAppliedToChildren(nsDisplayItem* aItem) {
  MOZ_ASSERT(aItem->GetType() == DisplayItemType::TYPE_OPACITY);
  return static_cast<nsDisplayOpacity*>(aItem)->OpacityAppliedToChildren();
}

/**
 * Returns true if the given display item type supports flattening with markers.
 */
static bool SupportsFlatteningWithMarkers(const DisplayItemType& aType) {
  return aType == DisplayItemType::TYPE_OPACITY ||
         aType == DisplayItemType::TYPE_TRANSFORM;
}

/**
 * Adds the effect marker to |aMarkers| based on the type of |aItem| and whether
 * |markerType| is a start or end marker.
 */
template <MarkerType markerType>
static bool AddMarkerIfNeeded(nsDisplayItem* aItem,
                              std::deque<DisplayItemEntry>& aMarkers) {
  const DisplayItemType type = aItem->GetType();
  if (!SupportsFlatteningWithMarkers(type)) {
    return false;
  }

  DisplayItemEntryType marker;

// Just a fancy way to avoid writing two separate functions to select between
// PUSH and POP markers. This is done during compile time based on |markerType|.
#define GET_MARKER(start_marker, end_marker)                      \
  std::conditional<                                               \
      markerType == MarkerType::StartMarker,                      \
      std::integral_constant<DisplayItemEntryType, start_marker>, \
      std::integral_constant<DisplayItemEntryType, end_marker>>::type::value;

  switch (type) {
    case DisplayItemType::TYPE_OPACITY:
      if (IsOpacityAppliedToChildren(aItem)) {
        // TODO(miko): I am not a fan of this. The more correct solution would
        // be to return an enum from nsDisplayItem::ShouldFlattenAway(), so that
        // we could distinguish between different flattening methods and avoid
        // entering this function when markers are not needed.
        return false;
      }

      marker = GET_MARKER(DisplayItemEntryType::PushOpacity,
                          DisplayItemEntryType::PopOpacity);
      break;
    case DisplayItemType::TYPE_TRANSFORM:
      marker = GET_MARKER(DisplayItemEntryType::PushTransform,
                          DisplayItemEntryType::PopTransform);
      break;
    default:
      MOZ_ASSERT_UNREACHABLE("Invalid display item type!");
      break;
  }

  aMarkers.emplace_back(aItem, marker);
  return true;
}

DisplayItemData::DisplayItemData(LayerManagerData* aParent, uint32_t aKey,
                                 Layer* aLayer, nsIFrame* aFrame)

    : mRefCnt(0),
      mParent(aParent),
      mLayer(aLayer),
      mDisplayItemKey(aKey),
      mItem(nullptr),
      mUsed(true),
      mIsInvalid(false),
      mReusedItem(false) {
  MOZ_COUNT_CTOR(DisplayItemData);

  if (!sAliveDisplayItemDatas) {
    sAliveDisplayItemDatas = new nsTHashSet<DisplayItemData*>();
  }
  MOZ_RELEASE_ASSERT(!sAliveDisplayItemDatas->Contains(this));
  sAliveDisplayItemDatas->Insert(this);

  MOZ_RELEASE_ASSERT(mLayer);
  if (aFrame) {
    AddFrame(aFrame);
  }
}

void DisplayItemData::Destroy() {
  // Get the pres context.
  RefPtr<nsPresContext> presContext = mFrameList[0]->PresContext();

  // Call our destructor.
  this->~DisplayItemData();

  // Don't let the memory be freed, since it will be recycled
  // instead. Don't call the global operator delete.
  presContext->PresShell()->FreeByObjectID(eArenaObjectID_DisplayItemData,
                                           this);
}

void DisplayItemData::AddFrame(nsIFrame* aFrame) {
  MOZ_RELEASE_ASSERT(mLayer);
  MOZ_RELEASE_ASSERT(!mFrameList.Contains(aFrame));
  mFrameList.AppendElement(aFrame);

  SmallPointerArray<DisplayItemData>* array = aFrame->DisplayItemData();

  if (!array) {
    array = new SmallPointerArray<DisplayItemData>();
    aFrame->SetProperty(nsIFrame::DisplayItemDataProperty(), array);
  }

  array->AppendElement(this);
}

void DisplayItemData::RemoveFrame(nsIFrame* aFrame) {
  MOZ_RELEASE_ASSERT(mLayer);
  bool result = mFrameList.RemoveElement(aFrame);
  MOZ_RELEASE_ASSERT(result, "Can't remove a frame that wasn't added!");

  SmallPointerArray<DisplayItemData>* array = aFrame->DisplayItemData();
  if (array) {
    array->RemoveElement(this);
  }
}

void DisplayItemData::EndUpdate() {
  MOZ_RELEASE_ASSERT(mLayer);
  mIsInvalid = false;
  mUsed = false;
  mReusedItem = false;
  mOldTransform = nullptr;
}

void DisplayItemData::EndUpdate(UniquePtr<nsDisplayItemGeometry>&& aGeometry) {
  MOZ_RELEASE_ASSERT(mLayer);
  MOZ_ASSERT(mItem);
  MOZ_ASSERT(mGeometry || aGeometry);

  if (aGeometry) {
    mGeometry = std::move(aGeometry);
  }
  mClip = mItem->GetClip();
  mChangedFrameInvalidations.SetEmpty();

  EndUpdate();
}

void DisplayItemData::BeginUpdate(Layer* aLayer, LayerState aState,
                                  bool aFirstUpdate,
                                  nsPaintedDisplayItem* aItem /* = nullptr */) {
  bool isReused = false;
  bool isMerged = false;

  if (aItem) {
    isReused = !aFirstUpdate ? aItem->IsReused() : false;

    const nsDisplayWrapList* wraplist = aItem->AsDisplayWrapList();
    isMerged = wraplist && wraplist->HasMergedFrames();
  }

  BeginUpdate(aLayer, aState, aItem, isReused, isMerged);
}

void DisplayItemData::BeginUpdate(Layer* aLayer, LayerState aState,
                                  nsPaintedDisplayItem* aItem, bool aIsReused,
                                  bool aIsMerged) {
  MOZ_RELEASE_ASSERT(mLayer);
  MOZ_RELEASE_ASSERT(aLayer);
  mLayer = aLayer;
  mOptLayer = nullptr;
  mInactiveManager = nullptr;
  mLayerState = aState;
  mUsed = true;

  mItem = aItem;
  mReusedItem = aIsReused;

  if (!aItem) {
    return;
  }

  if (!aIsMerged && mFrameList.Length() == 1) {
    MOZ_ASSERT(mFrameList[0] == aItem->Frame());
    return;
  }

  // We avoid adding or removing element unnecessarily
  // since we have to modify userdata each time
  CopyableAutoTArray<nsIFrame*, 4> copy(mFrameList);
  if (!copy.RemoveElement(aItem->Frame())) {
    AddFrame(aItem->Frame());
    mChangedFrameInvalidations.Or(mChangedFrameInvalidations,
                                  aItem->Frame()->InkOverflowRect());
  }

  if (aIsMerged) {
    MOZ_ASSERT(aItem->AsDisplayWrapList());

    for (nsIFrame* frame : aItem->AsDisplayWrapList()->GetMergedFrames()) {
      if (!copy.RemoveElement(frame)) {
        AddFrame(frame);
        mChangedFrameInvalidations.Or(mChangedFrameInvalidations,
                                      frame->InkOverflowRect());
      }
    }
  }

  for (nsIFrame* frame : copy) {
    RemoveFrame(frame);
    mChangedFrameInvalidations.Or(mChangedFrameInvalidations,
                                  frame->InkOverflowRect());
  }
}

static const nsIFrame* sDestroyedFrame = nullptr;
DisplayItemData::~DisplayItemData() {
  MOZ_COUNT_DTOR(DisplayItemData);

  for (nsIFrame* frame : mFrameList) {
    if (frame == sDestroyedFrame) {
      continue;
    }

    SmallPointerArray<DisplayItemData>* array = frame->DisplayItemData();
    if (array) {
      array->RemoveElement(this);
    }
  }

  MOZ_RELEASE_ASSERT(sAliveDisplayItemDatas);
  const bool removed = sAliveDisplayItemDatas->EnsureRemoved(this);
  MOZ_RELEASE_ASSERT(removed);

  if (sAliveDisplayItemDatas->Count() == 0) {
    delete sAliveDisplayItemDatas;
    sAliveDisplayItemDatas = nullptr;
  }
}

void DisplayItemData::NotifyRemoved() {
  if (mDisplayItemKey > static_cast<uint8_t>(DisplayItemType::TYPE_MAX)) {
    // This is sort of a hack. The display item key has higher bits set, which
    // means that it is not the only display item for the frame.
    // This branch skips separator transforms.
    return;
  }

  const DisplayItemType type = GetDisplayItemTypeFromKey(mDisplayItemKey);

  if (type == DisplayItemType::TYPE_REMOTE) {
    // TYPE_REMOTE doesn't support merging, so access it directly
    MOZ_ASSERT(mFrameList.Length() == 1);
    if (mFrameList.Length() != 1) {
      return;
    }

    // This is a remote browser that is going away, notify it that it is now
    // hidden
    nsIFrame* frame = mFrameList[0];
    nsSubDocumentFrame* subdoc = static_cast<nsSubDocumentFrame*>(frame);
    nsFrameLoader* frameLoader = subdoc->FrameLoader();
    if (frameLoader && frameLoader->GetRemoteBrowser()) {
      frameLoader->GetRemoteBrowser()->UpdateEffects(
          mozilla::dom::EffectsInfo::FullyHidden());
    }
  }

  if (type != DisplayItemType::TYPE_TRANSFORM &&
      type != DisplayItemType::TYPE_OPACITY &&
      type != DisplayItemType::TYPE_BACKGROUND_COLOR) {
    return;
  }

  for (nsIFrame* frame : mFrameList) {
    EffectCompositor::ClearIsRunningOnCompositor(frame, type);
  }
}

const nsRegion& DisplayItemData::GetChangedFrameInvalidations() {
  return mChangedFrameInvalidations;
}

DisplayItemData* DisplayItemData::AssertDisplayItemData(
    DisplayItemData* aData) {
  MOZ_RELEASE_ASSERT(aData);
  MOZ_RELEASE_ASSERT(sAliveDisplayItemDatas &&
                     sAliveDisplayItemDatas->Contains(aData));
  MOZ_RELEASE_ASSERT(aData->mLayer);
  return aData;
}

void* DisplayItemData::operator new(size_t sz, nsPresContext* aPresContext) {
  // Check the recycle list first.
  return aPresContext->PresShell()->AllocateByObjectID(
      eArenaObjectID_DisplayItemData, sz);
}

/**
 * This is the userdata we associate with a layer manager.
 */
class LayerManagerData : public LayerUserData {
 public:
  explicit LayerManagerData(LayerManager* aManager)
      : mLayerManager(aManager),
#ifdef DEBUG_DISPLAY_ITEM_DATA
        mParent(nullptr),
#endif
        mInvalidateAllLayers(false) {
    MOZ_COUNT_CTOR(LayerManagerData);
  }
  ~LayerManagerData() override { MOZ_COUNT_DTOR(LayerManagerData); }

#ifdef DEBUG_DISPLAY_ITEM_DATA
  void Dump(const char* aPrefix = "") {
    printf_stderr("%sLayerManagerData %p\n", aPrefix, this);

    for (auto& data : mDisplayItems) {
      nsAutoCString prefix;
      prefix += aPrefix;
      prefix += "  ";

      const char* layerState;
      switch (data->mLayerState) {
        case LayerState::LAYER_NONE:
          layerState = "LAYER_NONE";
          break;
        case LayerState::LAYER_INACTIVE:
          layerState = "LAYER_INACTIVE";
          break;
        case LayerState::LAYER_ACTIVE:
          layerState = "LAYER_ACTIVE";
          break;
        case LayerState::LAYER_ACTIVE_FORCE:
          layerState = "LAYER_ACTIVE_FORCE";
          break;
        case LayerState::LAYER_ACTIVE_EMPTY:
          layerState = "LAYER_ACTIVE_EMPTY";
          break;
        case LayerState::LAYER_SVG_EFFECTS:
          layerState = "LAYER_SVG_EFFECTS";
          break;
      }
      uint32_t mask = (1 << TYPE_BITS) - 1;

      nsAutoCString str;
      str += prefix;
      str += nsPrintfCString("Frame %p ", data->mFrameList[0]);
      str += nsDisplayItem::DisplayItemTypeName(
          static_cast<nsDisplayItem::Type>(data->mDisplayItemKey & mask));
      if ((data->mDisplayItemKey >> TYPE_BITS)) {
        str += nsPrintfCString("(%i)", data->mDisplayItemKey >> TYPE_BITS);
      }
      str += nsPrintfCString(", %s, Layer %p", layerState, data->mLayer.get());
      if (data->mOptLayer) {
        str += nsPrintfCString(", OptLayer %p", data->mOptLayer.get());
      }
      if (data->mInactiveManager) {
        str += nsPrintfCString(", InactiveLayerManager %p",
                               data->mInactiveManager.get());
      }
      str += "\n";

      printf_stderr("%s", str.get());

      if (data->mInactiveManager) {
        prefix += "  ";
        printf_stderr("%sDumping inactive layer info:\n", prefix.get());
        LayerManagerData* lmd = static_cast<LayerManagerData*>(
            data->mInactiveManager->GetUserData(&gLayerManagerUserData));
        lmd->Dump(prefix.get());
      }
    }
  }
#endif

  /**
   * Tracks which frames have layers associated with them.
   */
  LayerManager* mLayerManager;
#ifdef DEBUG_DISPLAY_ITEM_DATA
  LayerManagerData* mParent;
#endif
  std::vector<RefPtr<DisplayItemData>> mDisplayItems;
  bool mInvalidateAllLayers;
};

/* static */
void FrameLayerBuilder::DestroyDisplayItemDataFor(nsIFrame* aFrame) {
  RemoveFrameFromLayerManager(aFrame);

  // Destroying a WebRenderUserDataTable can cause destruction of other objects
  // which can remove frame properties in their destructor. If we delete a frame
  // property it runs the destructor of the stored object in the middle of
  // updating the frame property table, so if the destruction of that object
  // causes another update to the frame property table it would leave the frame
  // property table in an inconsistent state. So we remove it from the table and
  // then destroy it. (bug 1530657)
  WebRenderUserDataTable* userDataTable =
      aFrame->TakeProperty(WebRenderUserDataProperty::Key());
  if (userDataTable) {
    for (const auto& data : userDataTable->Values()) {
      data->RemoveFromTable();
    }
    delete userDataTable;
  }
}

/**
 * We keep a stack of these to represent the PaintedLayers that are
 * currently available to have display items added to.
 * We use a stack here because as much as possible we want to
 * assign display items to existing PaintedLayers, and to the lowest
 * PaintedLayer in z-order. This reduces the number of layers and
 * makes it more likely a display item will be rendered to an opaque
 * layer, giving us the best chance of getting subpixel AA.
 */
class PaintedLayerData {
 public:
  PaintedLayerData()
      : mAnimatedGeometryRoot(nullptr),
        mASR(nullptr),
        mClipChain(nullptr),
        mReferenceFrame(nullptr),
        mLayer(nullptr),
        mSolidColor(NS_RGBA(0, 0, 0, 0)),
        mIsSolidColorInVisibleRegion(false),
        mNeedComponentAlpha(false),
        mForceTransparentSurface(false),
        mHideAllLayersBelow(false),
        mOpaqueForAnimatedGeometryRootParent(false),
        mBackfaceHidden(false),
        mDTCRequiresTargetConfirmation(false),
        mImage(nullptr),
        mItemClip(nullptr),
        mNewChildLayersIndex(-1)
#ifdef DEBUG
        ,
        mTransformLevel(0)
#endif
  {
  }

  PaintedLayerData(PaintedLayerData&& aRhs) = default;

  ~PaintedLayerData() { MOZ_ASSERT(mTransformLevel == 0); }

#ifdef MOZ_DUMP_PAINTING
  /**
   * Keep track of important decisions for debugging.
   */
  nsCString mLog;

#  define FLB_LOG_PAINTED_LAYER_DECISION(pld, ...) \
    if (StaticPrefs::layers_dump_decision()) {     \
      pld->mLog.AppendPrintf("\t\t\t\t");          \
      pld->mLog.AppendPrintf(__VA_ARGS__);         \
    }
#else
#  define FLB_LOG_PAINTED_LAYER_DECISION(...)
#endif

  /**
   * Disables component alpha for |aItem| if the component alpha bounds are not
   * contained in |mOpaqueRegion|. Alternatively if possible, sets
   * |mNeedComponentAlpha| to true for this PaintedLayerData.
   */
  bool SetupComponentAlpha(ContainerState* aState, nsPaintedDisplayItem* aItem,
                           const nsIntRect& aVisibleRect,
                           const TransformClipNode* aTransform);

  /**
   * Record that an item has been added to the PaintedLayer, so we
   * need to update our regions.
   * @param aVisibleRect the area of the item that's visible
   */
  void Accumulate(ContainerState* aState, nsDisplayItem* aItem,
                  const nsIntRect& aVisibleRect, const nsRect& aContentRect,
                  const DisplayItemClip& aClip, LayerState aLayerState,
                  nsDisplayList* aList, DisplayItemEntryType aType,
                  nsTArray<size_t>& aOpacityIndices,
                  const RefPtr<TransformClipNode>& aTransform);

  UniquePtr<InactiveLayerData> CreateInactiveLayerData(
      ContainerState* aState, nsPaintedDisplayItem* aItem,
      DisplayItemData* aData);

  /**
   * Updates the status of |mTransform| and |aOpacityIndices|, based on |aType|.
   */
  void UpdateEffectStatus(DisplayItemEntryType aType,
                          nsTArray<size_t>& aOpacityIndices);

  AnimatedGeometryRoot* GetAnimatedGeometryRoot() {
    return mAnimatedGeometryRoot;
  }

  /**
   * A region including the horizontal pan, vertical pan, and no action regions.
   */
  nsRegion CombinedTouchActionRegion();

  /**
   * Add the given hit test info to the hit regions for this PaintedLayer.
   */
  void AccumulateHitTestItem(ContainerState* aState, nsDisplayItem* aItem,
                             const DisplayItemClip& aClip,
                             TransformClipNode* aTransform);

  void HitRegionsUpdated();

  /**
   * If this represents only a nsDisplayImage, and the image type supports being
   * optimized to an ImageLayer, returns true.
   */
  bool CanOptimizeToImageLayer(nsDisplayListBuilder* aBuilder);

  /**
   * If this represents only a nsDisplayImage, and the image type supports being
   * optimized to an ImageLayer, returns an ImageContainer for the underlying
   * image if one is available.
   */
  already_AddRefed<ImageContainer> GetContainerForImageLayer(
      nsDisplayListBuilder* aBuilder);

  bool VisibleAboveRegionIntersects(const nsIntRegion& aRegion) const {
    return !mVisibleAboveRegion.Intersect(aRegion).IsEmpty();
  }
  bool VisibleRegionIntersects(const nsIntRegion& aRegion) const {
    return !mVisibleRegion.Intersect(aRegion).IsEmpty();
  }

  /**
   * The owning ContainerState that created this PaintedLayerData.
   */
  ContainerState* mState;

  /**
   * The region of visible content in the layer, relative to the
   * container layer (which is at the snapped top-left of the display
   * list reference frame).
   */
  nsIntRegion mVisibleRegion;
  /**
   * The region of visible content in the layer that is opaque.
   * Same coordinate system as mVisibleRegion.
   */
  nsIntRegion mOpaqueRegion;
  /**
   * The definitely-hit region for this PaintedLayer.
   */
  nsRegion mHitRegion;
  /**
   * The maybe-hit region for this PaintedLayer.
   */
  nsRegion mMaybeHitRegion;
  /**
   * The dispatch-to-content hit region for this PaintedLayer.
   */
  nsRegion mDispatchToContentHitRegion;
  /**
   * The region for this PaintedLayer that is sensitive to events
   * but disallows panning and zooming. This is an approximation
   * and any deviation from the true region will be part of the
   * mDispatchToContentHitRegion.
   */
  nsRegion mNoActionRegion;
  /**
   * The region for this PaintedLayer that is sensitive to events and
   * allows horizontal panning but not zooming. This is an approximation
   * and any deviation from the true region will be part of the
   * mDispatchToContentHitRegion.
   */
  nsRegion mHorizontalPanRegion;
  /**
   * The region for this PaintedLayer that is sensitive to events and
   * allows vertical panning but not zooming. This is an approximation
   * and any deviation from the true region will be part of the
   * mDispatchToContentHitRegion.
   */
  nsRegion mVerticalPanRegion;

  bool mCollapsedTouchActions = false;
  /**
   * Scaled versions of the bounds of mHitRegion and mMaybeHitRegion.
   * We store these because FindPaintedLayerFor() needs to consume them
   * in this form, and it's a hot code path so we don't want to scale
   * them inside that function.
   */
  nsIntRect mScaledHitRegionBounds;
  nsIntRect mScaledMaybeHitRegionBounds;
  /**
   * The "active scrolled root" for all content in the layer. Must
   * be non-null; all content in a PaintedLayer must have the same
   * active scrolled root.
   */
  AnimatedGeometryRoot* mAnimatedGeometryRoot;
  const ActiveScrolledRoot* mASR;
  /**
   * The chain of clips that should apply to this layer.
   */
  const DisplayItemClipChain* mClipChain;
  /**
   * The offset between mAnimatedGeometryRoot and the reference frame.
   */
  nsPoint mAnimatedGeometryRootOffset;
  /**
   * If non-null, the frame from which we'll extract "fixed positioning"
   * metadata for this layer. This can be a position:fixed frame or a viewport
   * frame; the latter case is used for background-attachment:fixed content.
   */
  const nsIFrame* mReferenceFrame;
  PaintedLayer* mLayer;
  /**
   * If mIsSolidColorInVisibleRegion is true, this is the color of the visible
   * region.
   */
  nscolor mSolidColor;
  /**
   * True if every pixel in mVisibleRegion will have color mSolidColor.
   */
  bool mIsSolidColorInVisibleRegion;
  /**
   * True if there is any text visible in the layer that's over
   * transparent pixels in the layer.
   */
  bool mNeedComponentAlpha;
  /**
   * Set if the layer should be treated as transparent, even if its entire
   * area is covered by opaque display items. For example, this needs to
   * be set if something is going to "punch holes" in the layer by clearing
   * part of its surface.
   */
  bool mForceTransparentSurface;
  /**
   * Set if all layers below this PaintedLayer should be hidden.
   */
  bool mHideAllLayersBelow;
  /**
   * Set if the opaque region for this layer can be applied to the parent
   * animated geometry root of this layer's animated geometry root.
   * We set this when a PaintedLayer's animated geometry root is a scrollframe
   * and the PaintedLayer completely fills the displayport of the scrollframe.
   */
  bool mOpaqueForAnimatedGeometryRootParent;
  /**
   * Set if the backface of this region is hidden to the user.
   * Content that backface is hidden should not be draw on the layer
   * with visible backface.
   */
  bool mBackfaceHidden;
  /**
   * Set to true if events targeting the dispatch-to-content region
   * require target confirmation.
   * See CompositorHitTestFlags::eRequiresTargetConfirmation and
   * EventRegions::mDTCRequiresTargetConfirmation.
   */
  bool mDTCRequiresTargetConfirmation;
  /**
   * Stores the pointer to the nsDisplayImage if we want to
   * convert this to an ImageLayer.
   */
  nsDisplayImageContainer* mImage;
  /**
   * Stores the clip that we need to apply to the image or, if there is no
   * image, a clip for SOME item in the layer. There is no guarantee which
   * item's clip will be stored here and mItemClip should not be used to clip
   * the whole layer - only some part of the clip should be used, as determined
   * by PaintedDisplayItemLayerUserData::GetCommonClipCount() - which may even
   * be no part at all.
   */
  const DisplayItemClip* mItemClip;
  /**
   * Index of this layer in mNewChildLayers.
   */
  int32_t mNewChildLayersIndex;
  /**
   * The region of visible content above the layer and below the
   * next PaintedLayerData currently in the stack, if any.
   * This is a conservative approximation: it contains the true region.
   */
  nsIntRegion mVisibleAboveRegion;
  /**
   * All the display items that have been assigned to this painted layer.
   * These items get added by Accumulate().
   */
  std::vector<AssignedDisplayItem> mAssignedDisplayItems;

#ifdef DEBUG
  /**
   * Tracks the level of transform to ensure balanced PUSH/POP markers.
   */
  int mTransformLevel;
#endif
};

struct NewLayerEntry {
  NewLayerEntry()
      : mAnimatedGeometryRoot(nullptr),
        mASR(nullptr),
        mClipChain(nullptr),
        mScrollMetadataASR(nullptr),
        mLayerContentsVisibleRect(0, 0, -1, -1),
        mLayerState(LayerState::LAYER_INACTIVE),
        mHideAllLayersBelow(false),
        mOpaqueForAnimatedGeometryRootParent(false),
        mUntransformedVisibleRegion(false),
        mIsFixedToRootScrollFrame(false) {}
  // mLayer is null if the previous entry is for a PaintedLayer that hasn't
  // been optimized to some other form (yet).
  RefPtr<Layer> mLayer;
  AnimatedGeometryRoot* mAnimatedGeometryRoot;
  const ActiveScrolledRoot* mASR;
  const DisplayItemClipChain* mClipChain;
  const ActiveScrolledRoot* mScrollMetadataASR;
  // If non-null, this ScrollMetadata is set to the be the first ScrollMetadata
  // on the layer.
  UniquePtr<ScrollMetadata> mBaseScrollMetadata;
  // The following are only used for retained layers (for occlusion
  // culling of those layers). These regions are all relative to the
  // container reference frame.
  nsIntRegion mVisibleRegion;
  nsIntRegion mOpaqueRegion;
  // This rect is in the layer's own coordinate space. The computed visible
  // region for the layer cannot extend beyond this rect.
  nsIntRect mLayerContentsVisibleRect;
  LayerState mLayerState;
  bool mHideAllLayersBelow;
  // When mOpaqueForAnimatedGeometryRootParent is true, the opaque region of
  // this layer is opaque in the same position even subject to the animation of
  // geometry of mAnimatedGeometryRoot. For example when mAnimatedGeometryRoot
  // is a scrolled frame and the scrolled content is opaque everywhere in the
  // displayport, we can set this flag.
  // When this flag is set, we can treat this opaque region as covering
  // content whose animated geometry root is the animated geometry root for
  // mAnimatedGeometryRoot->GetParent().
  bool mOpaqueForAnimatedGeometryRootParent;

  // mVisibleRegion is relative to the associated frame before
  // transform.
  bool mUntransformedVisibleRegion;
  bool mIsFixedToRootScrollFrame;
};

class PaintedLayerDataTree;

/**
 * This is tree node type for PaintedLayerDataTree.
 * Each node corresponds to a different animated geometry root, and contains
 * a stack of PaintedLayerDatas, in bottom-to-top order.
 * There is at most one node per animated geometry root. The ancestor and
 * descendant relations in PaintedLayerDataTree tree mirror those in the frame
 * tree.
 * Each node can have clip that describes the potential extents that items in
 * this node can cover. If mHasClip is false, it means that the node's contents
 * can move anywhere.
 * Testing against the clip instead of the node's actual contents has the
 * advantage that the node's contents can move or animate without affecting
 * content in other nodes. So we don't need to re-layerize during animations
 * (sync or async), and during async animations everything is guaranteed to
 * look correct.
 * The contents of a node's PaintedLayerData stack all share the node's
 * animated geometry root. The child nodes are on top of the PaintedLayerData
 * stack, in z-order, and the clip rects of the child nodes are allowed to
 * intersect with the visible region or visible above region of their parent
 * node's PaintedLayerDatas.
 */
class PaintedLayerDataNode {
 public:
  PaintedLayerDataNode(PaintedLayerDataTree& aTree,
                       PaintedLayerDataNode* aParent,
                       AnimatedGeometryRoot* aAnimatedGeometryRoot);
  ~PaintedLayerDataNode();

  AnimatedGeometryRoot* GetAnimatedGeometryRoot() const {
    return mAnimatedGeometryRoot;
  }

  /**
   * Whether this node's contents can potentially intersect aRect.
   * aRect is in our tree's ContainerState's coordinate space.
   */
  bool Intersects(const nsIntRect& aRect) const {
    return !mHasClip || mClipRect.Intersects(aRect);
  }

  /**
   * Create a PaintedLayerDataNode for aAnimatedGeometryRoot, add it to our
   * children, and return it.
   */
  PaintedLayerDataNode* AddChildNodeFor(
      AnimatedGeometryRoot* aAnimatedGeometryRoot);

  /**
   * Find a PaintedLayerData in our mPaintedLayerDataStack that aItem can be
   * added to. Creates a new PaintedLayerData by calling
   * aNewPaintedLayerCallback if necessary.
   */
  template <typename NewPaintedLayerCallbackType>
  PaintedLayerData* FindPaintedLayerFor(
      const nsIntRect& aVisibleRect, bool aBackfaceHidden,
      const ActiveScrolledRoot* aASR, const DisplayItemClipChain* aClipChain,
      NewPaintedLayerCallbackType aNewPaintedLayerCallback);

  /**
   * Find an opaque background color for aRegion. Pulls a color from the parent
   * geometry root if appropriate, but only if that color is present underneath
   * the whole clip of this node, so that this node's contents can animate or
   * move (possibly async) without having to change the background color.
   * @param aUnderIndex Searching will start in mPaintedLayerDataStack right
   *                    below aUnderIndex.
   */
  enum { ABOVE_TOP = -1 };
  nscolor FindOpaqueBackgroundColor(const nsIntRegion& aRegion,
                                    int32_t aUnderIndex = ABOVE_TOP) const;
  /**
   * Same as FindOpaqueBackgroundColor, but only returns a color if absolutely
   * nothing is in between, so that it can be used for a layer that can move
   * anywhere inside our clip.
   */
  nscolor FindOpaqueBackgroundColorCoveringEverything() const;

  /**
   * Adds aRect to this node's top PaintedLayerData's mVisibleAboveRegion,
   * or mVisibleAboveBackgroundRegion if mPaintedLayerDataStack is empty.
   */
  void AddToVisibleAboveRegion(const nsIntRect& aRect);
  /**
   * Call this if all of our existing content can potentially be covered, so
   * nothing can merge with it and all new content needs to create new items
   * on top. This will finish all of our children and pop our whole
   * mPaintedLayerDataStack.
   */
  void SetAllDrawingAbove();

  /**
   * Finish this node: Finish all children, finish our PaintedLayer contents,
   * and (if requested) adjust our parent's visible above region to include
   * our clip.
   */
  void Finish(bool aParentNeedsAccurateVisibleAboveRegion);

  /**
   * Finish any children that intersect aRect.
   */
  void FinishChildrenIntersecting(const nsIntRect& aRect);

  /**
   * Finish all children.
   */
  void FinishAllChildren() { FinishAllChildren(true); }

 protected:
  /**
   * Finish all items in mPaintedLayerDataStack and clear the stack.
   */
  void PopAllPaintedLayerData();
  /**
   * Finish all of our child nodes, but don't touch mPaintedLayerDataStack.
   */
  void FinishAllChildren(bool aThisNodeNeedsAccurateVisibleAboveRegion);
  /**
   * Pass off opaque background color searching to our parent node, if we have
   * one.
   */
  nscolor FindOpaqueBackgroundColorInParentNode() const;

  PaintedLayerDataTree& mTree;
  PaintedLayerDataNode* mParent;
  AnimatedGeometryRoot* mAnimatedGeometryRoot;

  /**
   * Our contents: a PaintedLayerData stack and our child nodes.
   */
  AutoTArray<PaintedLayerData, 3> mPaintedLayerDataStack;

  /**
   * UniquePtr is used here in the sense of "unique ownership", i.e. there is
   * only one owner. Not in the sense of "this is the only pointer to the
   * node": There are two other, non-owning, pointers to our child nodes: The
   * node's respective children point to their parent node with their mParent
   * pointer, and the tree keeps a map of animated geometry root to node in its
   * mNodes member. These outside pointers are the reason that mChildren isn't
   * just an nsTArray<PaintedLayerDataNode> (since the pointers would become
   * invalid whenever the array expands its capacity).
   */
  nsTArray<UniquePtr<PaintedLayerDataNode>> mChildren;

  /**
   * The region that's covered between our "background" and the bottom of
   * mPaintedLayerDataStack. This is used to indicate whether we can pull
   * a background color from our parent node. If mVisibleAboveBackgroundRegion
   * should be considered infinite, mAllDrawingAboveBackground will be true and
   * the value of mVisibleAboveBackgroundRegion will be meaningless.
   */
  nsIntRegion mVisibleAboveBackgroundRegion;

  /**
   * Our clip, if we have any. If not, that means we can move anywhere, and
   * mHasClip will be false and mClipRect will be meaningless.
   */
  nsIntRect mClipRect;
  bool mHasClip;

  /**
   * Whether mVisibleAboveBackgroundRegion should be considered infinite.
   */
  bool mAllDrawingAboveBackground;
};

class ContainerState;

/**
 * A tree of PaintedLayerDataNodes. At any point in time, the tree only
 * contains nodes for animated geometry roots that new items can potentially
 * merge into. Any time content is added on top that overlaps existing things
 * in such a way that we no longer want to merge new items with some existing
 * content, that existing content gets "finished".
 * The public-facing methods of this class are FindPaintedLayerFor,
 * AddingOwnLayer, and Finish. The other public methods are for
 * PaintedLayerDataNode.
 * The tree calls out to its containing ContainerState for some things.
 * All coordinates / rects in the tree or the tree nodes are in the
 * ContainerState's coordinate space, i.e. relative to the reference frame and
 * in layer pixels.
 * The clip rects of sibling nodes never overlap. This is ensured by finishing
 * existing nodes before adding new ones, if this property were to be violated.
 * The root tree node doesn't get finished until the ContainerState is
 * finished.
 * The tree's root node is always the root reference frame of the builder. We
 * don't stop at the container state's mContainerAnimatedGeometryRoot because
 * some of our contents can have animated geometry roots that are not
 * descendants of the container's animated geometry root. Every animated
 * geometry root we encounter for our contents needs to have a defined place in
 * the tree.
 */
class PaintedLayerDataTree {
 public:
  PaintedLayerDataTree(ContainerState& aContainerState,
                       nscolor& aBackgroundColor)
      : mContainerState(aContainerState),
        mContainerUniformBackgroundColor(aBackgroundColor),
        mForInactiveLayer(false) {}

  ~PaintedLayerDataTree() {
    MOZ_ASSERT(!mRoot);
    MOZ_ASSERT(mNodes.Count() == 0);
  }

  void InitializeForInactiveLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot);

  /**
   * Notify our contents that some non-PaintedLayer content has been added.
   * *aRect needs to be a rectangle that doesn't move with respect to
   * aAnimatedGeometryRoot and that contains the added item.
   * If aRect is null, the extents will be considered infinite.
   * If aOutUniformBackgroundColor is non-null, it will be set to an opaque
   * color that can be pulled into the background of the added content, or
   * transparent if that is not possible.
   */
  void AddingOwnLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot,
                      const nsIntRect* aRect,
                      nscolor* aOutUniformBackgroundColor);

  /**
   * Find a PaintedLayerData for aItem. This can either be an existing
   * PaintedLayerData from inside a node in our tree, or a new one that gets
   * created by a call out to aNewPaintedLayerCallback.
   */
  template <typename NewPaintedLayerCallbackType>
  PaintedLayerData* FindPaintedLayerFor(
      AnimatedGeometryRoot* aAnimatedGeometryRoot,
      const ActiveScrolledRoot* aASR, const DisplayItemClipChain* aClipChain,
      const nsIntRect& aVisibleRect, const bool aBackfaceHidden,
      NewPaintedLayerCallbackType aNewPaintedLayerCallback);

  /**
   * Finish everything.
   */
  void Finish();

  /**
   * Get the parent animated geometry root of aAnimatedGeometryRoot.
   * That's either aAnimatedGeometryRoot's animated geometry root, or, if
   * that's aAnimatedGeometryRoot itself, then it's the animated geometry
   * root for aAnimatedGeometryRoot's cross-doc parent frame.
   */
  AnimatedGeometryRoot* GetParentAnimatedGeometryRoot(
      AnimatedGeometryRoot* aAnimatedGeometryRoot);

  /**
   * Whether aAnimatedGeometryRoot has an intrinsic clip that doesn't move with
   * respect to aAnimatedGeometryRoot's parent animated geometry root.
   * If aAnimatedGeometryRoot is a scroll frame, this will be the scroll frame's
   * scroll port, otherwise there is no clip.
   * This method doesn't have much to do with PaintedLayerDataTree, but this is
   * where we have easy access to a display list builder, which we use to get
   * the clip rect result into the right coordinate space.
   */
  bool IsClippedWithRespectToParentAnimatedGeometryRoot(
      AnimatedGeometryRoot* aAnimatedGeometryRoot, nsIntRect* aOutClip);

  /**
   * Called by PaintedLayerDataNode when it is finished, so that we can drop
   * our pointers to it.
   */
  void NodeWasFinished(AnimatedGeometryRoot* aAnimatedGeometryRoot);

  nsDisplayListBuilder* Builder() const;
  ContainerState& ContState() const { return mContainerState; }
  nscolor UniformBackgroundColor() const {
    return mContainerUniformBackgroundColor;
  }

 protected:
  /**
   * Finish all nodes that potentially intersect *aRect, where *aRect is a rect
   * that doesn't move with respect to aAnimatedGeometryRoot.
   * If aRect is null, *aRect will be considered infinite.
   */
  void FinishPotentiallyIntersectingNodes(
      AnimatedGeometryRoot* aAnimatedGeometryRoot, const nsIntRect* aRect);

  /**
   * Make sure that there is a node for aAnimatedGeometryRoot and all of its
   * ancestor geometry roots. Return the node for aAnimatedGeometryRoot.
   */
  PaintedLayerDataNode* EnsureNodeFor(
      AnimatedGeometryRoot* aAnimatedGeometryRoot);

  /**
   * Find an existing node in the tree for an ancestor of aAnimatedGeometryRoot.
   * *aOutAncestorChild will be set to the last ancestor that was encountered
   * in the search up from aAnimatedGeometryRoot; it will be a child animated
   * geometry root of the result, if neither are null.
   */
  PaintedLayerDataNode* FindNodeForAncestorAnimatedGeometryRoot(
      AnimatedGeometryRoot* aAnimatedGeometryRoot,
      AnimatedGeometryRoot** aOutAncestorChild);

  ContainerState& mContainerState;
  Maybe<PaintedLayerDataNode> mRoot;

  /**
   * The uniform opaque color from behind this container layer, or
   * NS_RGBA(0,0,0,0) if the background behind this container layer is not
   * uniform and opaque. This color can be pulled into PaintedLayers that are
   * directly above the background.
   */
  nscolor mContainerUniformBackgroundColor;

  /**
   * A hash map for quick access the node belonging to a particular animated
   * geometry root.
   */
  nsTHashMap<nsPtrHashKey<AnimatedGeometryRoot>, PaintedLayerDataNode*> mNodes;

  bool mForInactiveLayer;
};

/**
 * This is a helper object used to build up the layer children for
 * a ContainerLayer.
 */
class ContainerState {
 public:
  ContainerState(nsDisplayListBuilder* aBuilder, LayerManager* aManager,
                 FrameLayerBuilder* aLayerBuilder, nsIFrame* aContainerFrame,
                 nsDisplayItem* aContainerItem, const nsRect& aContainerBounds,
                 ContainerLayer* aContainerLayer,
                 const ContainerLayerParameters& aParameters,
                 nscolor aBackgroundColor,
                 const ActiveScrolledRoot* aContainerASR,
                 const ActiveScrolledRoot* aContainerScrollMetadataASR,
                 const ActiveScrolledRoot* aContainerCompositorASR)
      : mBuilder(aBuilder),
        mManager(aManager),
        mLayerBuilder(aLayerBuilder),
        mContainerFrame(aContainerFrame),
        mContainerLayer(aContainerLayer),
        mContainerBounds(aContainerBounds),
        mContainerASR(aContainerASR),
        mContainerScrollMetadataASR(aContainerScrollMetadataASR),
        mContainerCompositorASR(aContainerCompositorASR),
        mParameters(aParameters),
        mPaintedLayerDataTree(*this, aBackgroundColor),
        mLastDisplayPortAGR(nullptr),
        mContainerItem(aContainerItem) {
    nsPresContext* presContext = aContainerFrame->PresContext();
    mAppUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
    mContainerReferenceFrame = const_cast<nsIFrame*>(
        aContainerItem ? aContainerItem->ReferenceFrameForChildren()
                       : mBuilder->FindReferenceFrameFor(mContainerFrame));
    bool isAtRoot = !aContainerItem ||
                    (aContainerItem->Frame() == mBuilder->RootReferenceFrame());
    MOZ_ASSERT(!isAtRoot ||
               mContainerReferenceFrame == mBuilder->RootReferenceFrame());
    mContainerAnimatedGeometryRoot =
        isAtRoot ? aBuilder->GetRootAnimatedGeometryRoot()
                 : aContainerItem->GetAnimatedGeometryRoot();
    MOZ_ASSERT(
        !mBuilder->IsPaintingToWindow() ||
        nsLayoutUtils::IsAncestorFrameCrossDoc(
            mBuilder->RootReferenceFrame(), *mContainerAnimatedGeometryRoot));
    // When AllowResidualTranslation is false, display items will be drawn
    // scaled with a translation by integer pixels, so we know how the snapping
    // will work.
    mSnappingEnabled = aManager->IsSnappingEffectiveTransforms() &&
                       !mParameters.AllowResidualTranslation();
    CollectOldLayers();
  }

  /**
   * This is the method that actually walks a display list and builds
   * the child layers.
   */
  void ProcessDisplayItems(nsDisplayList* aList);
  /**
   * This finalizes all the open PaintedLayers by popping every element off
   * mPaintedLayerDataStack, then sets the children of the container layer
   * to be all the layers in mNewChildLayers in that order and removes any
   * layers as children of the container that aren't in mNewChildLayers.
   * @param aTextContentFlags if any child layer has CONTENT_COMPONENT_ALPHA,
   * set *aTextContentFlags to CONTENT_COMPONENT_ALPHA
   */
  void Finish(uint32_t* aTextContentFlags,
              const nsIntRect& aContainerPixelBounds,
              nsDisplayList* aChildItems);

  nscoord GetAppUnitsPerDevPixel() { return mAppUnitsPerDevPixel; }

  nsIntRect ScaleToNearestPixels(const nsRect& aRect) const {
    return aRect.ScaleToNearestPixels(mParameters.mXScale, mParameters.mYScale,
                                      mAppUnitsPerDevPixel);
  }
  nsIntRect ScaleToOutsidePixels(const nsRect& aRect,
                                 bool aSnap = false) const {
    if (aRect.IsEmpty()) {
      return nsIntRect();
    }
    if (aSnap && mSnappingEnabled) {
      return ScaleToNearestPixels(aRect);
    }
    return aRect.ScaleToOutsidePixels(mParameters.mXScale, mParameters.mYScale,
                                      mAppUnitsPerDevPixel);
  }
  nsIntRect ScaleToInsidePixels(const nsRect& aRect, bool aSnap = false) const {
    if (aSnap && mSnappingEnabled) {
      return ScaleToNearestPixels(aRect);
    }
    return aRect.ScaleToInsidePixels(mParameters.mXScale, mParameters.mYScale,
                                     mAppUnitsPerDevPixel);
  }
  nsIntRegion ScaleRegionToNearestPixels(const nsRegion& aRegion) const {
    return aRegion.ScaleToNearestPixels(
        mParameters.mXScale, mParameters.mYScale, mAppUnitsPerDevPixel);
  }
  nsIntRegion ScaleRegionToInsidePixels(const nsRegion& aRegion,
                                        bool aSnap = false) const {
    if (aSnap && mSnappingEnabled) {
      return ScaleRegionToNearestPixels(aRegion);
    }
    return aRegion.ScaleToInsidePixels(mParameters.mXScale, mParameters.mYScale,
                                       mAppUnitsPerDevPixel);
  }

  nsIntRegion ScaleRegionToOutsidePixels(const nsRegion& aRegion,
                                         bool aSnap = false) const {
    if (aRegion.IsEmpty()) {
      return nsIntRegion();
    }
    if (aSnap && mSnappingEnabled) {
      return ScaleRegionToNearestPixels(aRegion);
    }
    return aRegion.ScaleToOutsidePixels(
        mParameters.mXScale, mParameters.mYScale, mAppUnitsPerDevPixel);
  }

  nsIFrame* GetContainerFrame() const { return mContainerFrame; }
  nsDisplayListBuilder* Builder() const { return mBuilder; }
  FrameLayerBuilder* LayerBuilder() const { return mLayerBuilder; }

  /**
   * Check if we are currently inside an inactive layer.
   */
  bool IsInInactiveLayer() const {
    return mLayerBuilder->GetContainingPaintedLayerData();
  }

  /**
   * Sets aOuterVisibleRegion as aLayer's visible region.
   * @param aOuterVisibleRegion
   *   is in the coordinate space of the container reference frame.
   * @param aLayerContentsVisibleRect, if non-null, is in the layer's own
   *   coordinate system.
   * @param aOuterUntransformed is true if the given aOuterVisibleRegion
   *   is already untransformed with the matrix of the layer.
   */
  void SetOuterVisibleRegionForLayer(
      Layer* aLayer, const nsIntRegion& aOuterVisibleRegion,
      const nsIntRect* aLayerContentsVisibleRect = nullptr,
      bool aOuterUntransformed = false) const;

  /**
   * Try to determine whether the PaintedLayer aData has a single opaque color
   * covering aRect. If successful, return that color, otherwise return
   * NS_RGBA(0,0,0,0).
   * If aRect turns out not to intersect any content in the layer,
   * *aOutIntersectsLayer will be set to false.
   */
  nscolor FindOpaqueBackgroundColorInLayer(const PaintedLayerData* aData,
                                           const nsIntRect& aRect,
                                           bool* aOutIntersectsLayer) const;

  /**
   * Indicate that we are done adding items to the PaintedLayer represented by
   * aData. Make sure that a real PaintedLayer exists for it, and set the final
   * visible region and opaque-content.
   */
  template <typename FindOpaqueBackgroundColorCallbackType>
  void FinishPaintedLayerData(
      PaintedLayerData& aData,
      FindOpaqueBackgroundColorCallbackType aFindOpaqueBackgroundColor);

 protected:
  friend class PaintedLayerData;
  friend class FLBDisplayListIterator;

  LayerManager::PaintedLayerCreationHint GetLayerCreationHint(
      AnimatedGeometryRoot* aAnimatedGeometryRoot);

  /**
   * Creates a new PaintedLayer and sets up the transform on the PaintedLayer
   * to account for scrolling.
   */
  already_AddRefed<PaintedLayer> CreatePaintedLayer(PaintedLayerData* aData);

  /**
   * Find a PaintedLayer for recycling, recycle it and prepare it for use, or
   * return null if no suitable layer was found.
   */
  already_AddRefed<PaintedLayer> AttemptToRecyclePaintedLayer(
      AnimatedGeometryRoot* aAnimatedGeometryRoot, nsDisplayItem* aItem,
      const nsPoint& aTopLeft, const nsIFrame* aReferenceFrame);
  /**
   * Recycle aLayer and do any necessary invalidation.
   */
  PaintedDisplayItemLayerUserData* RecyclePaintedLayer(
      PaintedLayer* aLayer, AnimatedGeometryRoot* aAnimatedGeometryRoot,
      bool& didResetScrollPositionForLayerPixelAlignment);

  /**
   * Perform the last step of CreatePaintedLayer / AttemptToRecyclePaintedLayer:
   * Initialize aData, set up the layer's transform for scrolling, and
   * invalidate the layer for layer pixel alignment changes if necessary.
   */
  void PreparePaintedLayerForUse(
      PaintedLayer* aLayer, PaintedDisplayItemLayerUserData* aData,
      AnimatedGeometryRoot* aAnimatedGeometryRoot,
      const nsIFrame* aReferenceFrame, const nsPoint& aTopLeft,
      bool aDidResetScrollPositionForLayerPixelAlignment);

  /**
   * Attempt to prepare an ImageLayer based upon the provided PaintedLayerData.
   * Returns nullptr on failure.
   */
  already_AddRefed<Layer> PrepareImageLayer(PaintedLayerData* aData);

  /**
   * Attempt to prepare a ColorLayer based upon the provided PaintedLayerData.
   * Returns nullptr on failure.
   */
  already_AddRefed<Layer> PrepareColorLayer(PaintedLayerData* aData);

  /**
   * Grab the next recyclable ColorLayer, or create one if there are no
   * more recyclable ColorLayers.
   */
  already_AddRefed<ColorLayer> CreateOrRecycleColorLayer(
      PaintedLayer* aPainted);
  /**
   * Grab the next recyclable ImageLayer, or create one if there are no
   * more recyclable ImageLayers.
   */
  already_AddRefed<ImageLayer> CreateOrRecycleImageLayer(
      PaintedLayer* aPainted);
  /**
   * Grab a recyclable ImageLayer for use as a mask layer for aLayer (that is a
   * mask layer which has been used for aLayer before), or create one if such
   * a layer doesn't exist.
   *
   * Since mask layers can exist either on the layer directly, or as a side-
   * attachment to FrameMetrics (for ancestor scrollframe clips), we key the
   * recycle operation on both the originating layer and the mask layer's
   * index in the layer, if any.
   */
  struct MaskLayerKey;
  template <typename UserData>
  already_AddRefed<ImageLayer> CreateOrRecycleMaskImageLayerFor(
      const MaskLayerKey& aKey, UserData* (*aGetUserData)(Layer* aLayer),
      void (*aSetDefaultUserData)(Layer* aLayer));
  /**
   * Grabs all PaintedLayers and ColorLayers from the ContainerLayer and makes
   * them available for recycling.
   */
  void CollectOldLayers();
  /**
   * If aItem used to belong to a PaintedLayer, invalidates the area of
   * aItem in that layer. If aNewLayer is a PaintedLayer, invalidates the area
   * of aItem in that layer.
   */
  void InvalidateForLayerChange(nsDisplayItem* aItem, PaintedLayer* aNewLayer,
                                DisplayItemData* aData);
  /**
   * Returns true if aItem's opaque area (in aOpaque) covers the entire
   * scrollable area of its presshell.
   */
  bool ItemCoversScrollableArea(nsDisplayItem* aItem, const nsRegion& aOpaque);

  /**
   * Set ScrollMetadata and scroll-induced clipping on aEntry's layer.
   */
  void SetupScrollingMetadata(NewLayerEntry* aEntry);

  /**
   * Applies occlusion culling.
   * For each layer in mNewChildLayers, remove from its visible region the
   * opaque regions of the layers at higher z-index, but only if they have
   * the same animated geometry root and fixed-pos frame ancestor.
   * The opaque region for the child layers that share the same animated
   * geometry root as the container frame is returned in
   * *aOpaqueRegionForContainer.
   *
   * Also sets scroll metadata on the layers.
   */
  void PostprocessRetainedLayers(nsIntRegion* aOpaqueRegionForContainer);

  /**
   * Computes the snapped opaque area of aItem. Sets aList's opaque flag
   * if it covers the entire list bounds. Sets *aHideAllLayersBelow to true
   * this item covers the entire viewport so that all layers below are
   * permanently invisible.
   */
  nsIntRegion ComputeOpaqueRect(nsDisplayItem* aItem,
                                AnimatedGeometryRoot* aAnimatedGeometryRoot,
                                const ActiveScrolledRoot* aASR,
                                const DisplayItemClip& aClip,
                                nsDisplayList* aList, bool* aHideAllLayersBelow,
                                bool* aOpaqueForAnimatedGeometryRootParent);

  /**
   * Fills a PaintedLayerData object that is initialized for a layer that the
   * current item will be assigned to. Also creates mNewChildLayers entries.
   * @param  aData                 The PaintedLayerData that will be filled.
   * @param  aVisibleRect          The visible rect of the item.
   * @param  aAnimatedGeometryRoot The item's animated geometry root.
   * @param  aASR                  The active scrolled root that moves this
   * PaintedLayer.
   * @param  aClipChain            The clip chain that the compositor needs to
   *                               apply to this layer.
   * @param  aScrollMetadataASR    The leaf ASR for which scroll metadata needs
   * to be set on the layer, because either the layer itself or its scrolled
   * clip need to move with that ASR.
   * @param  aTopLeft              The offset between aAnimatedGeometryRoot and
   *                               the reference frame.
   * @param  aReferenceFrame       The reference frame for the item.
   * @param  aBackfaceHidden       The backface visibility for the item frame.
   */
  void NewPaintedLayerData(
      PaintedLayerData* aData, AnimatedGeometryRoot* aAnimatedGeometryRoot,
      const ActiveScrolledRoot* aASR, const DisplayItemClipChain* aClipChain,
      const ActiveScrolledRoot* aScrollMetadataASR, const nsPoint& aTopLeft,
      const nsIFrame* aReferenceFrame, const bool aBackfaceHidden);

  /* Build a mask layer to represent the clipping region. Will return null if
   * there is no clipping specified or a mask layer cannot be built.
   * Builds an ImageLayer for the appropriate backend; the mask is relative to
   * aLayer's visible region.
   * aLayer is the layer to be clipped.
   * relative to the container reference frame
   * aRoundedRectClipCount is used when building mask layers for PaintedLayers,
   */
  void SetupMaskLayer(Layer* aLayer, const DisplayItemClip& aClip);

  /**
   * If |aClip| has rounded corners, create a mask layer for them, and
   * add it to |aLayer|'s ancestor mask layers, returning an index into
   * the array of ancestor mask layers. Returns an empty Maybe if
   * |aClip| does not have rounded corners, or if no mask layer could
   * be created.
   */
  Maybe<size_t> SetupMaskLayerForScrolledClip(Layer* aLayer,
                                              const DisplayItemClip& aClip);

  /**
   * Create/find a mask layer with suitable size for aMaskItem to paint
   * css-positioned-masking onto.
   */
  void SetupMaskLayerForCSSMask(Layer* aLayer,
                                nsDisplayMasksAndClipPaths* aMaskItem);

  already_AddRefed<Layer> CreateMaskLayer(
      Layer* aLayer, const DisplayItemClip& aClip,
      const Maybe<size_t>& aForAncestorMaskLayer);

  /**
   * Get the display port for an AGR.
   * The result would be cached for later reusing.
   */
  nsRect GetDisplayPortForAnimatedGeometryRoot(
      AnimatedGeometryRoot* aAnimatedGeometryRoot);

  nsDisplayListBuilder* mBuilder;
  LayerManager* mManager;
  FrameLayerBuilder* mLayerBuilder;
  nsIFrame* mContainerFrame;
  nsIFrame* mContainerReferenceFrame;
  AnimatedGeometryRoot* mContainerAnimatedGeometryRoot;
  ContainerLayer* mContainerLayer;
  nsRect mContainerBounds;

  // Due to the way we store scroll annotations in the layer tree, we need to
  // keep track of three (possibly different) ASRs here.
  // mContainerASR is the ASR of the container display item that this
  // ContainerState was created for.
  // mContainerScrollMetadataASR is the ASR of the leafmost scroll metadata
  // that's in effect on mContainerLayer.
  // mContainerCompositorASR is the ASR that mContainerLayer moves with on
  // the compositor / APZ side, taking into account both the scroll meta data
  // and the fixed position annotation on itself and its ancestors.
  const ActiveScrolledRoot* mContainerASR;
  const ActiveScrolledRoot* mContainerScrollMetadataASR;
  const ActiveScrolledRoot* mContainerCompositorASR;
#ifdef DEBUG
  nsRect mAccumulatedChildBounds;
#endif
  ContainerLayerParameters mParameters;
  /**
   * The region of PaintedLayers that should be invalidated every time
   * we recycle one.
   */
  nsIntRegion mInvalidPaintedContent;
  PaintedLayerDataTree mPaintedLayerDataTree;
  /**
   * We collect the list of children in here. During ProcessDisplayItems,
   * the layers in this array either have mContainerLayer as their parent,
   * or no parent.
   * PaintedLayers have two entries in this array: the second one is used only
   * if the PaintedLayer is optimized away to a ColorLayer or ImageLayer. It's
   * essential that this array is only appended to, since PaintedLayerData
   * records the index of its PaintedLayer in this array.
   */
  typedef AutoTArray<NewLayerEntry, 1> AutoLayersArray;
  AutoLayersArray mNewChildLayers;
  nsTHashSet<RefPtr<PaintedLayer>> mPaintedLayersAvailableForRecycling;
  nscoord mAppUnitsPerDevPixel;
  bool mSnappingEnabled;

  struct MaskLayerKey {
    MaskLayerKey() : mLayer(nullptr) {}
    MaskLayerKey(Layer* aLayer, const Maybe<size_t>& aAncestorIndex)
        : mLayer(aLayer), mAncestorIndex(aAncestorIndex) {}

    PLDHashNumber Hash() const {
      // Hash the layer and add the layer index to the hash.
      return (NS_PTR_TO_UINT32(mLayer) >> 2) +
             (mAncestorIndex ? (*mAncestorIndex + 1) : 0);
    }
    bool operator==(const MaskLayerKey& aOther) const {
      return mLayer == aOther.mLayer && mAncestorIndex == aOther.mAncestorIndex;
    }

    Layer* mLayer;
    Maybe<size_t> mAncestorIndex;
  };

  nsTHashMap<nsGenericHashKey<MaskLayerKey>, RefPtr<ImageLayer>>
      mRecycledMaskImageLayers;
  // Keep display port of AGR to avoid wasting time on doing the same
  // thing repeatly.
  AnimatedGeometryRoot* mLastDisplayPortAGR;
  nsRect mLastDisplayPortRect;

  nsDisplayItem* mContainerItem;

  // Cache ScrollMetadata so it doesn't need recomputed if the ASR and clip are
  // unchanged. If mASR == nullptr then mMetadata is not valid.
  struct CachedScrollMetadata {
    const ActiveScrolledRoot* mASR;
    const DisplayItemClip* mClip;
    Maybe<ScrollMetadata> mMetadata;

    CachedScrollMetadata() : mASR(nullptr), mClip(nullptr) {}
  };
  CachedScrollMetadata mCachedScrollMetadata;
};

class FLBDisplayListIterator : public FlattenedDisplayListIterator {
 public:
  FLBDisplayListIterator(nsDisplayListBuilder* aBuilder, nsDisplayList* aList,
                         ContainerState* aState)
      : FlattenedDisplayListIterator(aBuilder, aList, false), mState(aState) {
    MOZ_ASSERT(mState);
    ResolveFlattening();
  }

  DisplayItemEntry GetNextEntry() {
    if (!mMarkers.empty()) {
      DisplayItemEntry entry = mMarkers.front();
      mMarkers.pop_front();
      return entry;
    }

    return DisplayItemEntry{GetNextItem(), DisplayItemEntryType::Item};
  }

  bool HasNext() const override {
    return FlattenedDisplayListIterator::HasNext() || !mMarkers.empty();
  }

 private:
  bool ShouldFlattenNextItem() override {
    if (!FlattenedDisplayListIterator::ShouldFlattenNextItem()) {
      return false;
    }

    nsDisplayItem* next = PeekNext();
    const DisplayItemType type = next->GetType();
    if (type == DisplayItemType::TYPE_SVG_WRAPPER) {
      // We mark SetContainsSVG for the CONTENT_FRAME_TIME_WITH_SVG metric
      if (RefPtr<LayerManager> lm = mState->mBuilder->GetWidgetLayerManager()) {
        lm->SetContainsSVG(true);
      }
    }

    if (!SupportsFlatteningWithMarkers(type)) {
      return true;
    }

    if (type == DisplayItemType::TYPE_OPACITY &&
        IsOpacityAppliedToChildren(next)) {
      // This is the previous opacity flattening path, where the opacity has
      // been applied to children.
      return true;
    }

    if (mState->IsInInactiveLayer() || !ItemWantsInactiveLayer(next)) {
      // Do not flatten nested inactive display items, or display items that
      // want an active layer.
      return false;
    }

    // If we reach here, we will emit an effect start marker for
    // nsDisplayTransform or nsDisplayOpacity.
    MOZ_ASSERT(type == DisplayItemType::TYPE_TRANSFORM ||
               !IsOpacityAppliedToChildren(next));
    return true;
  }

  void EnterChildList(nsDisplayItem* aContainerItem) override {
    mFlattenedLists.AppendElement(aContainerItem);
    AddMarkerIfNeeded<MarkerType::StartMarker>(aContainerItem, mMarkers);
  }

  void ExitChildList() override {
    MOZ_ASSERT(!mFlattenedLists.IsEmpty());
    nsDisplayItem* aContainerItem = mFlattenedLists.PopLastElement();
    AddMarkerIfNeeded<MarkerType::EndMarker>(aContainerItem, mMarkers);
  }

  bool ItemWantsInactiveLayer(nsDisplayItem* aItem) {
    const LayerState layerState = aItem->GetLayerState(
        mState->mBuilder, mState->mManager, mState->mParameters);

    return layerState == LayerState::LAYER_INACTIVE;
  }

  std::deque<DisplayItemEntry> mMarkers;
  AutoTArray<nsDisplayItem*, 16> mFlattenedLists;
  ContainerState* mState;
};

class PaintedDisplayItemLayerUserData : public LayerUserData {
 public:
  PaintedDisplayItemLayerUserData()
      : mForcedBackgroundColor(NS_RGBA(0, 0, 0, 0)),
        mXScale(1.f),
        mYScale(1.f),
        mAppUnitsPerDevPixel(0),
        mTranslation(0, 0),
        mAnimatedGeometryRootPosition(0, 0),
        mLastItemCount(0),
        mContainerLayerFrame(nullptr),
        mDisabledAlpha(false) {}

  NS_INLINE_DECL_REFCOUNTING(PaintedDisplayItemLayerUserData);

  /**
   * A color that should be painted over the bounds of the layer's visible
   * region before any other content is painted.
   */
  nscolor mForcedBackgroundColor;

  /**
   * The resolution scale used.
   */
  float mXScale, mYScale;

  /**
   * The appunits per dev pixel for the items in this layer.
   */
  nscoord mAppUnitsPerDevPixel;

  /**
   * The offset from the PaintedLayer's 0,0 to the
   * reference frame. This isn't necessarily the same as the transform
   * set on the PaintedLayer since we might also be applying an extra
   * offset specified by the parent ContainerLayer/
   */
  nsIntPoint mTranslation;

  /**
   * We try to make 0,0 of the PaintedLayer be the top-left of the
   * border-box of the "active scrolled root" frame (i.e. the nearest ancestor
   * frame for the display items that is being actively scrolled). But
   * we force the PaintedLayer transform to be an integer translation, and we
   * may have a resolution scale, so we have to snap the PaintedLayer transform,
   * so 0,0 may not be exactly the top-left of the active scrolled root. Here we
   * store the coordinates in PaintedLayer space of the top-left of the
   * active scrolled root.
   */
  gfxPoint mAnimatedGeometryRootPosition;

  nsIntRegion mRegionToInvalidate;

  // The offset between the active scrolled root of this layer
  // and the root of the container for the previous and current
  // paints respectively.
  nsPoint mLastAnimatedGeometryRootOrigin;
  nsPoint mAnimatedGeometryRootOrigin;

  RefPtr<ColorLayer> mColorLayer;
  RefPtr<ImageLayer> mImageLayer;

  // The region for which display item visibility for this layer has already
  // been calculated. Used to reduce the number of calls to
  // RecomputeVisibilityForItems if it is known in advance that a larger
  // region will be painted during a transaction than in a single call to
  // DrawPaintedLayer, for example when progressive paint is enabled.
  nsIntRegion mVisibilityComputedRegion;

  // The area for which we called RecomputeVisibilityForItems on the
  // previous paint.
  nsRect mPreviousRecomputeVisibilityRect;

  // The number of items assigned to this layer on the previous paint.
  size_t mLastItemCount;

  // The translation set on this PaintedLayer during the previous paint. This
  // is needed when invalidating based on a display item's geometry information
  // from the previous paint.
  Maybe<nsIntPoint> mLastPaintOffset;

  // Temporary state only valid during the FrameLayerBuilder's lifetime.
  // FLB's mPaintedLayerItems is responsible for cleaning these up when
  // we finish painting to avoid dangling pointers.
  std::vector<AssignedDisplayItem> mItems;
  nsIFrame* mContainerLayerFrame;

  /**
   * This is set when the painted layer has no component alpha.
   */
  bool mDisabledAlpha;

 protected:
  ~PaintedDisplayItemLayerUserData() override = default;
};

FrameLayerBuilder::FrameLayerBuilder()
    : mRetainingManager(nullptr),
      mDisplayListBuilder(nullptr),
      mContainingPaintedLayer(nullptr),
      mInactiveLayerClip(nullptr),
      mInvalidateAllLayers(false),
      mInLayerTreeCompressionMode(false),
      mIsInactiveLayerManager(false) {
  MOZ_COUNT_CTOR(FrameLayerBuilder);
}

FrameLayerBuilder::~FrameLayerBuilder() {
  GetMaskLayerImageCache()->Sweep();
  for (PaintedDisplayItemLayerUserData* userData : mPaintedLayerItems) {
    userData->mLastPaintOffset = Some(userData->mTranslation);
    userData->mItems.clear();
    userData->mContainerLayerFrame = nullptr;
  }
  MOZ_COUNT_DTOR(FrameLayerBuilder);
}

void FrameLayerBuilder::AddPaintedLayerItemsEntry(
    PaintedDisplayItemLayerUserData* aData) {
  mPaintedLayerItems.AppendElement(aData);
}

/*
 * User data for layers which will be used as masks.
 */
struct MaskLayerUserData : public LayerUserData {
  MaskLayerUserData()
      : mScaleX(-1.0f), mScaleY(-1.0f), mAppUnitsPerDevPixel(-1) {}
  MaskLayerUserData(const DisplayItemClip& aClip, int32_t aAppUnitsPerDevPixel,
                    const ContainerLayerParameters& aParams)
      : mScaleX(aParams.mXScale),
        mScaleY(aParams.mYScale),
        mOffset(aParams.mOffset),
        mAppUnitsPerDevPixel(aAppUnitsPerDevPixel) {
    aClip.AppendRoundedRects(&mRoundedClipRects);
  }

  void operator=(MaskLayerUserData&& aOther) {
    mScaleX = aOther.mScaleX;
    mScaleY = aOther.mScaleY;
    mOffset = aOther.mOffset;
    mAppUnitsPerDevPixel = aOther.mAppUnitsPerDevPixel;
    mRoundedClipRects = std::move(aOther.mRoundedClipRects);
  }

  bool operator==(const MaskLayerUserData& aOther) const {
    return mRoundedClipRects == aOther.mRoundedClipRects &&
           mScaleX == aOther.mScaleX && mScaleY == aOther.mScaleY &&
           mOffset == aOther.mOffset &&
           mAppUnitsPerDevPixel == aOther.mAppUnitsPerDevPixel;
  }

  // Keeps a MaskLayerImageKey alive by managing its mLayerCount member-var
  MaskLayerImageCache::MaskLayerImageKeyRef mImageKey;
  // properties of the mask layer; the mask layer may be re-used if these
  // remain unchanged.
  nsTArray<DisplayItemClip::RoundedRect> mRoundedClipRects;
  // scale from the masked layer which is applied to the mask
  float mScaleX, mScaleY;
  // The ContainerLayerParameters offset which is applied to the mask's
  // transform.
  nsIntPoint mOffset;
  int32_t mAppUnitsPerDevPixel;
};

/*
 * User data for layers which will be used as masks for css positioned mask.
 */
struct CSSMaskLayerUserData : public LayerUserData {
  CSSMaskLayerUserData() : mMaskStyle(nsStyleImageLayers::LayerType::Mask) {}

  CSSMaskLayerUserData(nsIFrame* aFrame, const nsIntRect& aMaskBounds,
                       const nsPoint& aMaskLayerOffset)
      : mMaskBounds(aMaskBounds),
        mMaskStyle(aFrame->StyleSVGReset()->mMask),
        mMaskLayerOffset(aMaskLayerOffset) {}

  void operator=(CSSMaskLayerUserData&& aOther) {
    mMaskBounds = aOther.mMaskBounds;
    mMaskStyle = std::move(aOther.mMaskStyle);
    mMaskLayerOffset = aOther.mMaskLayerOffset;
  }

  bool operator==(const CSSMaskLayerUserData& aOther) const {
    if (!mMaskBounds.IsEqualInterior(aOther.mMaskBounds)) {
      return false;
    }

    // Make sure we draw the same portion of the mask onto mask layer.
    if (mMaskLayerOffset != aOther.mMaskLayerOffset) {
      return false;
    }

    return mMaskStyle == aOther.mMaskStyle;
  }

 private:
  nsIntRect mMaskBounds;
  nsStyleImageLayers mMaskStyle;
  nsPoint mMaskLayerOffset;  // The offset from the origin of mask bounds to
                             // the origin of mask layer.
};

/*
 * A helper object to create a draw target for painting mask and create a
 * image container to hold the drawing result. The caller can then bind this
 * image container with a image mask layer via ImageLayer::SetContainer.
 */
class MaskImageData {
 public:
  MaskImageData(const gfx::IntSize& aSize, LayerManager* aLayerManager)
      : mTextureClientLocked(false),
        mSize(aSize),
        mLayerManager(aLayerManager) {
    MOZ_ASSERT(!mSize.IsEmpty());
    MOZ_ASSERT(mLayerManager);
  }

  ~MaskImageData() {
    if (mTextureClientLocked) {
      MOZ_ASSERT(mTextureClient);
      // Clear DrawTarget before Unlock.
      mDrawTarget = nullptr;
      mTextureClient->Unlock();
    }
  }

  gfx::DrawTarget* CreateDrawTarget() {
    if (mDrawTarget) {
      return mDrawTarget;
    }

    if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
      mDrawTarget = mLayerManager->CreateOptimalMaskDrawTarget(mSize);
      return mDrawTarget;
    }

    MOZ_ASSERT(mLayerManager->GetBackendType() ==
                   LayersBackend::LAYERS_CLIENT ||
               mLayerManager->GetBackendType() == LayersBackend::LAYERS_WR);

    KnowsCompositor* knowsCompositor = mLayerManager->AsKnowsCompositor();
    if (!knowsCompositor) {
      return nullptr;
    }
    mTextureClient = TextureClient::CreateForDrawing(
        knowsCompositor, SurfaceFormat::A8, mSize, BackendSelector::Content,
        TextureFlags::DISALLOW_BIGIMAGE,
        TextureAllocationFlags::ALLOC_CLEAR_BUFFER);
    if (!mTextureClient) {
      return nullptr;
    }

    mTextureClientLocked = mTextureClient->Lock(OpenMode::OPEN_READ_WRITE);
    if (!mTextureClientLocked) {
      return nullptr;
    }

    mDrawTarget = mTextureClient->BorrowDrawTarget();
    return mDrawTarget;
  }

  already_AddRefed<ImageContainer> CreateImageAndImageContainer() {
    RefPtr<ImageContainer> container = LayerManager::CreateImageContainer();
    RefPtr<Image> image = CreateImage();

    if (!image) {
      return nullptr;
    }
    container->SetCurrentImageInTransaction(image);

    return container.forget();
  }

 private:
  already_AddRefed<Image> CreateImage() {
    if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC &&
        mDrawTarget) {
      RefPtr<SourceSurface> surface = mDrawTarget->Snapshot();
      RefPtr<SourceSurfaceImage> image = new SourceSurfaceImage(mSize, surface);
      // Disallow BIGIMAGE (splitting into multiple textures) for mask
      // layer images
      image->SetTextureFlags(TextureFlags::DISALLOW_BIGIMAGE);
      return image.forget();
    }

    if ((mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT ||
         mLayerManager->GetBackendType() == LayersBackend::LAYERS_WR) &&
        mTextureClient && mDrawTarget) {
      RefPtr<TextureWrapperImage> image = new TextureWrapperImage(
          mTextureClient, gfx::IntRect(gfx::IntPoint(0, 0), mSize));
      return image.forget();
    }

    return nullptr;
  }

  bool mTextureClientLocked;
  gfx::IntSize mSize;
  LayerManager* mLayerManager;
  RefPtr<gfx::DrawTarget> mDrawTarget;
  RefPtr<TextureClient> mTextureClient;
};

/* static */
void FrameLayerBuilder::Shutdown() {
  if (gMaskLayerImageCache) {
    delete gMaskLayerImageCache;
    gMaskLayerImageCache = nullptr;
  }
}

void FrameLayerBuilder::Init(nsDisplayListBuilder* aBuilder,
                             LayerManager* aManager,
                             PaintedLayerData* aLayerData,
                             bool aIsInactiveLayerManager,
                             const DisplayItemClip* aInactiveLayerClip) {
  mDisplayListBuilder = aBuilder;
  mRootPresContext =
      aBuilder->RootReferenceFrame()->PresContext()->GetRootPresContext();
  mContainingPaintedLayer = aLayerData;
  mIsInactiveLayerManager = aIsInactiveLayerManager;
  mInactiveLayerClip = aInactiveLayerClip;
  aManager->SetUserData(&gLayerManagerLayerBuilder, this);
}

void FrameLayerBuilder::FlashPaint(gfxContext* aContext) {
  float r = float(rand()) / float(RAND_MAX);
  float g = float(rand()) / float(RAND_MAX);
  float b = float(rand()) / float(RAND_MAX);
  aContext->SetColor(sRGBColor(r, g, b, 0.4f));
  aContext->Paint();
}

DisplayItemData* FrameLayerBuilder::GetDisplayItemData(nsIFrame* aFrame,
                                                       uint32_t aKey) {
  for (auto* did : GetDisplayItemDataArray(aFrame)) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    if (data->mDisplayItemKey == aKey && data->FirstFrame() == aFrame &&
        data->mLayer->Manager() == mRetainingManager) {
      return data;
    }
  }

  return nullptr;
}

#ifdef MOZ_DUMP_PAINTING
static nsACString& AppendToString(nsACString& s, const nsIntRect& r,
                                  const char* pfx = "", const char* sfx = "") {
  s += pfx;
  s += nsPrintfCString("(x=%d, y=%d, w=%d, h=%d)", r.x, r.y, r.width, r.height);
  return s += sfx;
}

static nsACString& AppendToString(nsACString& s, const nsIntRegion& r,
                                  const char* pfx = "", const char* sfx = "") {
  s += pfx;

  s += "< ";
  for (auto iter = r.RectIter(); !iter.Done(); iter.Next()) {
    AppendToString(s, iter.Get()) += "; ";
  }
  s += ">";

  return s += sfx;
}
#endif  // MOZ_DUMP_PAINTING

/**
 * Invalidate aRegion in aLayer. aLayer is in the coordinate system
 * *after* aTranslation has been applied, so we need to
 * apply the inverse of that transform before calling InvalidateRegion.
 */
static void InvalidatePostTransformRegion(PaintedLayer* aLayer,
                                          const nsIntRegion& aRegion,
                                          const nsIntPoint& aTranslation) {
  // Convert the region from the coordinates of the container layer
  // (relative to the snapped top-left of the display list reference frame)
  // to the PaintedLayer's own coordinates
  nsIntRegion rgn = aRegion;

  rgn.MoveBy(-aTranslation);
  aLayer->InvalidateRegion(rgn);
#ifdef MOZ_DUMP_PAINTING
  if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
    nsAutoCString str;
    AppendToString(str, rgn);
    printf_stderr("Invalidating layer %p: %s\n", aLayer, str.get());
  }
#endif
}

static PaintedDisplayItemLayerUserData* GetPaintedDisplayItemLayerUserData(
    Layer* aLayer) {
  return static_cast<PaintedDisplayItemLayerUserData*>(
      aLayer->GetUserData(&gPaintedDisplayItemLayerUserData));
}

static nsIntPoint GetTranslationForPaintedLayer(PaintedLayer* aLayer) {
  PaintedDisplayItemLayerUserData* layerData =
      GetPaintedDisplayItemLayerUserData(aLayer);
  NS_ASSERTION(layerData, "Must be a tracked painted layer!");

  return layerData->mTranslation;
}

/**
 * Get the translation transform that was in aLayer when we last painted. It's
 * either the transform saved by ~FrameLayerBuilder(), or else the transform
 * that's currently in the layer (which must be an integer translation).
 */
static nsIntPoint GetLastPaintOffset(PaintedLayer* aLayer) {
  auto* layerData = GetPaintedDisplayItemLayerUserData(aLayer);
  MOZ_ASSERT(layerData);
  return layerData->mLastPaintOffset.valueOr(layerData->mTranslation);
}

static void InvalidatePreTransformRect(PaintedLayer* aLayer,
                                       const nsRect& aRect,
                                       const DisplayItemClip& aClip,
                                       const nsIntPoint& aTranslation,
                                       TransformClipNode* aTransform) {
  auto* data = GetPaintedDisplayItemLayerUserData(aLayer);

  nsRect rect = aClip.ApplyNonRoundedIntersection(aRect);

  if (aTransform) {
    rect = aTransform->TransformRect(rect, data->mAppUnitsPerDevPixel);
  }

  nsIntRect pixelRect = rect.ScaleToOutsidePixels(data->mXScale, data->mYScale,
                                                  data->mAppUnitsPerDevPixel);

  InvalidatePostTransformRegion(aLayer, pixelRect, aTranslation);
}

/**
 * Some frames can have multiple, nested, retaining layer managers
 * associated with them (normal manager, inactive managers, SVG effects).
 * In these cases we store the 'outermost' LayerManager data property
 * on the frame since we can walk down the chain from there.
 *
 * If one of these frames has just been destroyed, we will free the inner
 * layer manager when removing the entry from mFramesWithLayers. Destroying
 * the layer manager destroys the LayerManagerData and calls into
 * the DisplayItemData destructor. If the inner layer manager had any
 * items with the same frame, then we attempt to retrieve properties
 * from the deleted frame.
 *
 * Cache the destroyed frame pointer here so we can avoid crashing in this case.
 */

/* static */
void FrameLayerBuilder::RemoveFrameFromLayerManager(nsIFrame* aFrame) {
  MOZ_RELEASE_ASSERT(!sDestroyedFrame);
  sDestroyedFrame = aFrame;

  SmallPointerArray<DisplayItemData>* array =
      aFrame->TakeProperty(nsIFrame::DisplayItemDataProperty());

  // Hold a reference to all the items so that they don't get
  // deleted from under us.
  nsTArray<RefPtr<DisplayItemData>> arrayCopy;

  if (array) {
    for (DisplayItemData* data : *array) {
      arrayCopy.AppendElement(data);
    }
  }

#ifdef DEBUG_DISPLAY_ITEM_DATA
  if (array && array->Length()) {
    LayerManagerData* rootData = array->ElementAt(0)->mParent;
    while (rootData->mParent) {
      rootData = rootData->mParent;
    }
    printf_stderr("Removing frame %p - dumping display data\n", aFrame);
    rootData->Dump();
  }
#endif

  for (DisplayItemData* data : arrayCopy) {
    PaintedLayer* t = data->mLayer ? data->mLayer->AsPaintedLayer() : nullptr;
    if (t) {
      auto* paintedData = GetPaintedDisplayItemLayerUserData(t);
      if (paintedData && data->mGeometry) {
        const int32_t appUnitsPerDevPixel = paintedData->mAppUnitsPerDevPixel;
        nsRegion rgn = data->mGeometry->ComputeInvalidationRegion();
        nsIntRegion pixelRgn = rgn.ToOutsidePixels(appUnitsPerDevPixel);

        if (data->mTransform) {
          pixelRgn = data->mTransform->TransformRegion(pixelRgn);
        }

        pixelRgn =
            pixelRgn.ScaleRoundOut(paintedData->mXScale, paintedData->mYScale);

        pixelRgn.MoveBy(-GetTranslationForPaintedLayer(t));

        paintedData->mRegionToInvalidate.Or(paintedData->mRegionToInvalidate,
                                            pixelRgn);
        paintedData->mRegionToInvalidate.SimplifyOutward(8);
      }
    }

    auto it = std::find(data->mParent->mDisplayItems.begin(),
                        data->mParent->mDisplayItems.end(), data);
    MOZ_ASSERT(it != data->mParent->mDisplayItems.end());
    std::iter_swap(it, data->mParent->mDisplayItems.end() - 1);
    data->mParent->mDisplayItems.pop_back();
  }

  if (aFrame->IsSubDocumentFrame()) {
    const nsSubDocumentFrame* subdoc =
        static_cast<const nsSubDocumentFrame*>(aFrame);
    nsFrameLoader* frameLoader = subdoc->FrameLoader();
    if (frameLoader && frameLoader->GetRemoteBrowser()) {
      // This is a remote browser that is going away, notify it that it is now
      // hidden
      frameLoader->GetRemoteBrowser()->UpdateEffects(
          mozilla::dom::EffectsInfo::FullyHidden());
    }
  }

  arrayCopy.Clear();
  delete array;
  sDestroyedFrame = nullptr;
}

void FrameLayerBuilder::DidBeginRetainedLayerTransaction(
    LayerManager* aManager) {
  mRetainingManager = aManager;
  LayerManagerData* data = static_cast<LayerManagerData*>(
      aManager->GetUserData(&gLayerManagerUserData));
  if (data) {
    mInvalidateAllLayers = data->mInvalidateAllLayers;
  } else {
    data = new LayerManagerData(aManager);
    aManager->SetUserData(&gLayerManagerUserData, data);
  }
}

void FrameLayerBuilder::DidEndTransaction() {
  GetMaskLayerImageCache()->Sweep();
}

void FrameLayerBuilder::WillEndTransaction() {
  if (!mRetainingManager) {
    return;
  }

  // We need to save the data we'll need to support retaining.
  LayerManagerData* data = static_cast<LayerManagerData*>(
      mRetainingManager->GetUserData(&gLayerManagerUserData));
  NS_ASSERTION(data, "Must have data!");

  // Update all the frames that used to have layers.
  auto iter = data->mDisplayItems.begin();
  while (iter != data->mDisplayItems.end()) {
    DisplayItemData* did = iter->get();
    if (!did->mUsed) {
      // This item was visible, but isn't anymore.
      PaintedLayer* t = did->mLayer->AsPaintedLayer();
      if (t && did->mGeometry) {
#ifdef MOZ_DUMP_PAINTING
        if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
          printf_stderr(
              "Invalidating unused display item (%i) belonging to "
              "frame %p from layer %p\n",
              did->mDisplayItemKey, did->mFrameList[0], t);
        }
#endif
        InvalidatePreTransformRect(
            t, did->mGeometry->ComputeInvalidationRegion(), did->mClip,
            GetLastPaintOffset(t), did->mTransform);
      }

      did->NotifyRemoved();

      // Remove this item. Swapping it with the last element first is
      // quicker than erasing from the middle.
      if (iter != data->mDisplayItems.end() - 1) {
        std::iter_swap(iter, data->mDisplayItems.end() - 1);
        data->mDisplayItems.pop_back();
      } else {
        data->mDisplayItems.pop_back();
        break;
      }

      // Don't increment iter because we still need to process the item which
      // was moved.

    } else {
      ComputeGeometryChangeForItem(did);
      iter++;
    }
  }

  data->mInvalidateAllLayers = false;
}

/* static */
DisplayItemData* FrameLayerBuilder::GetDisplayItemDataForManager(
    nsPaintedDisplayItem* aItem, LayerManager* aManager) {
  for (auto* did : GetDisplayItemDataArray(aItem->Frame())) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    if (data->mDisplayItemKey == aItem->GetPerFrameKey() &&
        data->mLayer->Manager() == aManager) {
      return data;
    }
  }

  return nullptr;
}

bool FrameLayerBuilder::HasRetainedDataFor(const nsIFrame* aFrame,
                                           uint32_t aDisplayItemKey) {
  for (auto* did : GetDisplayItemDataArray(aFrame)) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    if (data->mDisplayItemKey == aDisplayItemKey) {
      return true;
    }
  }

  if (RefPtr<WebRenderUserData> data =
          GetWebRenderUserData<WebRenderFallbackData>(aFrame,
                                                      aDisplayItemKey)) {
    return true;
  }

  return false;
}

DisplayItemData* FrameLayerBuilder::GetOldLayerForFrame(
    nsIFrame* aFrame, uint32_t aDisplayItemKey,
    DisplayItemData* aOldData, /* = nullptr */
    LayerManager* aOldLayerManager /* = nullptr */) {
  // If we need to build a new layer tree, then just refuse to recycle
  // anything.
  if (!mRetainingManager || mInvalidateAllLayers) {
    return nullptr;
  }

  MOZ_ASSERT(!aOldData || aOldLayerManager,
             "You must provide aOldLayerManager to check aOldData's validity.");
  MOZ_ASSERT_IF(aOldData, aOldLayerManager == aOldData->mLayer->Manager());

  DisplayItemData* data = aOldData;
  if (!data || aOldLayerManager != mRetainingManager) {
    data = GetDisplayItemData(aFrame, aDisplayItemKey);
  }

  MOZ_ASSERT(data == GetDisplayItemData(aFrame, aDisplayItemKey));

  return data;
}

Layer* FrameLayerBuilder::GetOldLayerFor(nsDisplayItem* aItem,
                                         nsDisplayItemGeometry** aOldGeometry,
                                         DisplayItemClip** aOldClip) {
  uint32_t key = aItem->GetPerFrameKey();
  nsIFrame* frame = aItem->Frame();

  DisplayItemData* oldData = GetOldLayerForFrame(frame, key);
  if (oldData) {
    if (aOldGeometry) {
      *aOldGeometry = oldData->mGeometry.get();
    }
    if (aOldClip) {
      *aOldClip = &oldData->mClip;
    }
    return oldData->mLayer;
  }

  return nullptr;
}

/* static */
DisplayItemData* FrameLayerBuilder::GetOldDataFor(nsDisplayItem* aItem) {
  for (auto* did : GetDisplayItemDataArray(aItem->Frame())) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    if (data->mDisplayItemKey == aItem->GetPerFrameKey()) {
      return data;
    }
  }

  return nullptr;
}

// Reset state that should not persist when a layer is recycled.
static void ResetLayerStateForRecycling(Layer* aLayer) {
  // Currently, this clears the mask layer and ancestor mask layers.
  // Other cleanup may be added here.
  aLayer->SetMaskLayer(nullptr);
  aLayer->SetAncestorMaskLayers({});
}

already_AddRefed<ColorLayer> ContainerState::CreateOrRecycleColorLayer(
    PaintedLayer* aPainted) {
  auto* data = GetPaintedDisplayItemLayerUserData(aPainted);
  RefPtr<ColorLayer> layer = data->mColorLayer;
  if (layer) {
    ResetLayerStateForRecycling(layer);
    layer->ClearExtraDumpInfo();
  } else {
    // Create a new layer
    layer = mManager->CreateColorLayer();
    if (!layer) {
      return nullptr;
    }
    // Mark this layer as being used for painting display items
    data->mColorLayer = layer;
    layer->SetUserData(&gColorLayerUserData, nullptr);

    // Remove other layer types we might have stored for this PaintedLayer
    data->mImageLayer = nullptr;
  }
  return layer.forget();
}

already_AddRefed<ImageLayer> ContainerState::CreateOrRecycleImageLayer(
    PaintedLayer* aPainted) {
  auto* data = GetPaintedDisplayItemLayerUserData(aPainted);
  RefPtr<ImageLayer> layer = data->mImageLayer;
  if (layer) {
    ResetLayerStateForRecycling(layer);
    layer->ClearExtraDumpInfo();
  } else {
    // Create a new layer
    layer = mManager->CreateImageLayer();
    if (!layer) {
      return nullptr;
    }
    // Mark this layer as being used for painting display items
    data->mImageLayer = layer;
    layer->SetUserData(&gImageLayerUserData, nullptr);

    // Remove other layer types we might have stored for this PaintedLayer
    data->mColorLayer = nullptr;
  }
  return layer.forget();
}

template <typename UserData>
already_AddRefed<ImageLayer> ContainerState::CreateOrRecycleMaskImageLayerFor(
    const MaskLayerKey& aKey, UserData* (*aGetUserData)(Layer* aLayer),
    void (*aSetDefaultUserData)(Layer* aLayer)) {
  RefPtr<ImageLayer> result = mRecycledMaskImageLayers.Get(aKey);

  if (result && aGetUserData(result.get())) {
    mRecycledMaskImageLayers.Remove(aKey);
    aKey.mLayer->ClearExtraDumpInfo();
    // XXX if we use clip on mask layers, null it out here
  } else {
    // Create a new layer
    result = mManager->CreateImageLayer();
    if (!result) {
      return nullptr;
    }
    aSetDefaultUserData(result);
  }

  return result.forget();
}

static const double SUBPIXEL_OFFSET_EPSILON = 0.02;

/**
 * This normally computes NSToIntRoundUp(aValue). However, if that would
 * give a residual near 0.5 while aOldResidual is near -0.5, or
 * it would give a residual near -0.5 while aOldResidual is near 0.5, then
 * instead we return the integer in the other direction so that the residual
 * is close to aOldResidual.
 */
static int32_t RoundToMatchResidual(double aValue, double aOldResidual) {
  int32_t v = NSToIntRoundUp(aValue);
  double residual = aValue - v;
  if (aOldResidual < 0) {
    if (residual > 0 &&
        fabs(residual - 1.0 - aOldResidual) < SUBPIXEL_OFFSET_EPSILON) {
      // Round up instead
      return int32_t(ceil(aValue));
    }
  } else if (aOldResidual > 0) {
    if (residual < 0 &&
        fabs(residual + 1.0 - aOldResidual) < SUBPIXEL_OFFSET_EPSILON) {
      // Round down instead
      return int32_t(floor(aValue));
    }
  }
  return v;
}

static void ResetScrollPositionForLayerPixelAlignment(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  nsIScrollableFrame* sf =
      nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot);
  if (sf) {
    sf->ResetScrollPositionForLayerPixelAlignment();
  }
}

static void InvalidateEntirePaintedLayer(
    PaintedLayer* aLayer, AnimatedGeometryRoot* aAnimatedGeometryRoot,
    const char* aReason) {
#ifdef MOZ_DUMP_PAINTING
  if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
    printf_stderr("Invalidating entire layer %p: %s\n", aLayer, aReason);
  }
#endif
  aLayer->InvalidateWholeLayer();
  aLayer->SetInvalidRectToVisibleRegion();
  ResetScrollPositionForLayerPixelAlignment(aAnimatedGeometryRoot);
}

LayerManager::PaintedLayerCreationHint ContainerState::GetLayerCreationHint(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  // Check whether the layer will be scrollable. This is used as a hint to
  // influence whether tiled layers are used or not.

  // Check creation hint inherited from our parent.
  if (mParameters.mLayerCreationHint == LayerManager::SCROLLABLE) {
    return LayerManager::SCROLLABLE;
  }

  // Check whether there's any active scroll frame on the animated geometry
  // root chain.
  for (AnimatedGeometryRoot* agr = aAnimatedGeometryRoot;
       agr && agr != mContainerAnimatedGeometryRoot; agr = agr->mParentAGR) {
    nsIFrame* fParent = nsLayoutUtils::GetCrossDocParentFrameInProcess(*agr);
    if (!fParent) {
      break;
    }
    nsIScrollableFrame* scrollable = do_QueryFrame(fParent);
    if (scrollable) {
      return LayerManager::SCROLLABLE;
    }
  }
  return LayerManager::NONE;
}

already_AddRefed<PaintedLayer> ContainerState::AttemptToRecyclePaintedLayer(
    AnimatedGeometryRoot* aAnimatedGeometryRoot, nsDisplayItem* aItem,
    const nsPoint& aTopLeft, const nsIFrame* aReferenceFrame) {
  Layer* oldLayer = mLayerBuilder->GetOldLayerFor(aItem);
  if (!oldLayer || !oldLayer->AsPaintedLayer()) {
    return nullptr;
  }

  if (!mPaintedLayersAvailableForRecycling.EnsureRemoved(
          oldLayer->AsPaintedLayer())) {
    // Not found.
    return nullptr;
  }

  // Try to recycle the layer.
  RefPtr<PaintedLayer> layer = oldLayer->AsPaintedLayer();

  // Check if the layer hint has changed and whether or not the layer should
  // be recreated because of it.
  if (!layer->IsOptimizedFor(GetLayerCreationHint(aAnimatedGeometryRoot))) {
    return nullptr;
  }

  bool didResetScrollPositionForLayerPixelAlignment = false;
  PaintedDisplayItemLayerUserData* data =
      RecyclePaintedLayer(layer, aAnimatedGeometryRoot,
                          didResetScrollPositionForLayerPixelAlignment);
  PreparePaintedLayerForUse(layer, data, aAnimatedGeometryRoot, aReferenceFrame,
                            aTopLeft,
                            didResetScrollPositionForLayerPixelAlignment);

  return layer.forget();
}

static void ReleaseLayerUserData(void* aData) {
  PaintedDisplayItemLayerUserData* userData =
      static_cast<PaintedDisplayItemLayerUserData*>(aData);
  userData->Release();
}

already_AddRefed<PaintedLayer> ContainerState::CreatePaintedLayer(
    PaintedLayerData* aData) {
  LayerManager::PaintedLayerCreationHint creationHint =
      GetLayerCreationHint(aData->mAnimatedGeometryRoot);

  // Create a new painted layer
  RefPtr<PaintedLayer> layer =
      mManager->CreatePaintedLayerWithHint(creationHint);
  if (!layer) {
    return nullptr;
  }

  // Mark this layer as being used for painting display items
  RefPtr<PaintedDisplayItemLayerUserData> userData =
      new PaintedDisplayItemLayerUserData();
  userData->mDisabledAlpha =
      mParameters.mDisableSubpixelAntialiasingInDescendants;
  userData.get()->AddRef();
  layer->SetUserData(&gPaintedDisplayItemLayerUserData, userData,
                     ReleaseLayerUserData);
  ResetScrollPositionForLayerPixelAlignment(aData->mAnimatedGeometryRoot);

  PreparePaintedLayerForUse(layer, userData, aData->mAnimatedGeometryRoot,
                            aData->mReferenceFrame,
                            aData->mAnimatedGeometryRootOffset, true);

  return layer.forget();
}

PaintedDisplayItemLayerUserData* ContainerState::RecyclePaintedLayer(
    PaintedLayer* aLayer, AnimatedGeometryRoot* aAnimatedGeometryRoot,
    bool& didResetScrollPositionForLayerPixelAlignment) {
  // Clear clip rect and mask layer so we don't accidentally stay clipped.
  // We will reapply any necessary clipping.
  ResetLayerStateForRecycling(aLayer);
  aLayer->ClearExtraDumpInfo();

  auto* data = GetPaintedDisplayItemLayerUserData(aLayer);
  NS_ASSERTION(data, "Recycled PaintedLayers must have user data");

  // This gets called on recycled PaintedLayers that are going to be in the
  // final layer tree, so it's a convenient time to invalidate the
  // content that changed where we don't know what PaintedLayer it belonged
  // to, or if we need to invalidate the entire layer, we can do that.
  // This needs to be done before we update the PaintedLayer to its new
  // transform. See nsGfxScrollFrame::InvalidateInternal, where
  // we ensure that mInvalidPaintedContent is updated according to the
  // scroll position as of the most recent paint.
  if (!FuzzyEqual(data->mXScale, mParameters.mXScale, 0.00001f) ||
      !FuzzyEqual(data->mYScale, mParameters.mYScale, 0.00001f) ||
      data->mAppUnitsPerDevPixel != mAppUnitsPerDevPixel) {
#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      printf_stderr("Recycled layer %p changed scale\n", aLayer);
    }
#endif
    InvalidateEntirePaintedLayer(aLayer, aAnimatedGeometryRoot,
                                 "recycled layer changed state");
    didResetScrollPositionForLayerPixelAlignment = true;
  }
  if (!data->mRegionToInvalidate.IsEmpty()) {
#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      printf_stderr("Invalidating deleted frame content from layer %p\n",
                    aLayer);
    }
#endif
    aLayer->InvalidateRegion(data->mRegionToInvalidate);
#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      nsAutoCString str;
      AppendToString(str, data->mRegionToInvalidate);
      printf_stderr("Invalidating layer %p: %s\n", aLayer, str.get());
    }
#endif
    data->mRegionToInvalidate.SetEmpty();
  }
  return data;
}

void ContainerState::PreparePaintedLayerForUse(
    PaintedLayer* aLayer, PaintedDisplayItemLayerUserData* aData,
    AnimatedGeometryRoot* aAnimatedGeometryRoot,
    const nsIFrame* aReferenceFrame, const nsPoint& aTopLeft,
    bool didResetScrollPositionForLayerPixelAlignment) {
  aData->mXScale = mParameters.mXScale;
  aData->mYScale = mParameters.mYScale;
  aData->mLastAnimatedGeometryRootOrigin = aData->mAnimatedGeometryRootOrigin;
  aData->mAnimatedGeometryRootOrigin = aTopLeft;
  aData->mAppUnitsPerDevPixel = mAppUnitsPerDevPixel;
  aLayer->SetAllowResidualTranslation(mParameters.AllowResidualTranslation());

  // Set up transform so that 0,0 in the PaintedLayer corresponds to the
  // (pixel-snapped) top-left of the aAnimatedGeometryRoot.
  nsPoint offset =
      (*aAnimatedGeometryRoot)->GetOffsetToCrossDoc(aReferenceFrame);
  nscoord appUnitsPerDevPixel =
      (*aAnimatedGeometryRoot)->PresContext()->AppUnitsPerDevPixel();
  gfxPoint scaledOffset(
      NSAppUnitsToDoublePixels(offset.x, appUnitsPerDevPixel) *
          mParameters.mXScale,
      NSAppUnitsToDoublePixels(offset.y, appUnitsPerDevPixel) *
          mParameters.mYScale);
  // We call RoundToMatchResidual here so that the residual after rounding
  // is close to aData->mAnimatedGeometryRootPosition if possible.
  nsIntPoint pixOffset(
      RoundToMatchResidual(scaledOffset.x,
                           aData->mAnimatedGeometryRootPosition.x),
      RoundToMatchResidual(scaledOffset.y,
                           aData->mAnimatedGeometryRootPosition.y));
  aData->mTranslation = pixOffset;
  pixOffset += mParameters.mOffset;
  Matrix matrix = Matrix::Translation(pixOffset.x, pixOffset.y);
  aLayer->SetBaseTransform(Matrix4x4::From2D(matrix));

  aData->mVisibilityComputedRegion.SetEmpty();

  // Calculate exact position of the top-left of the active scrolled root.
  // This might not be 0,0 due to the snapping in ScaleToNearestPixels.
  gfxPoint animatedGeometryRootTopLeft =
      scaledOffset - ThebesPoint(matrix.GetTranslation()) + mParameters.mOffset;
  const bool disableAlpha =
      mParameters.mDisableSubpixelAntialiasingInDescendants;
  if (aData->mDisabledAlpha != disableAlpha) {
    aData->mAnimatedGeometryRootPosition = animatedGeometryRootTopLeft;
    InvalidateEntirePaintedLayer(aLayer, aAnimatedGeometryRoot,
                                 "change of subpixel-AA");
    aData->mDisabledAlpha = disableAlpha;
    return;
  }

  // FIXME: Temporary workaround for bug 681192 and bug 724786.
#ifndef MOZ_WIDGET_ANDROID
  // If it has changed, then we need to invalidate the entire layer since the
  // pixels in the layer buffer have the content at a (subpixel) offset
  // from what we need.
  if (!animatedGeometryRootTopLeft.WithinEpsilonOf(
          aData->mAnimatedGeometryRootPosition, SUBPIXEL_OFFSET_EPSILON)) {
    aData->mAnimatedGeometryRootPosition = animatedGeometryRootTopLeft;
    InvalidateEntirePaintedLayer(aLayer, aAnimatedGeometryRoot,
                                 "subpixel offset");
  } else if (didResetScrollPositionForLayerPixelAlignment) {
    aData->mAnimatedGeometryRootPosition = animatedGeometryRootTopLeft;
  }
#else
  Unused << didResetScrollPositionForLayerPixelAlignment;
#endif
}

#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
/**
 * Returns the appunits per dev pixel for the item's frame
 */
static int32_t AppUnitsPerDevPixel(nsDisplayItem* aItem) {
  // The underlying frame for zoom items is the root frame of the subdocument.
  // But zoom display items report their bounds etc using the parent document's
  // APD because zoom items act as a conversion layer between the two different
  // APDs.
  if (aItem->GetType() == DisplayItemType::TYPE_ZOOM) {
    return static_cast<nsDisplayZoom*>(aItem)->GetParentAppUnitsPerDevPixel();
  }
  return aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
}
#endif

/**
 * Set the visible region for aLayer.
 * aOuterVisibleRegion is the visible region relative to the parent layer.
 * aLayerContentsVisibleRect, if non-null, is a rectangle in the layer's
 * own coordinate system to which the layer's visible region is restricted.
 * Consumes *aOuterVisibleRegion.
 */
static void SetOuterVisibleRegion(
    Layer* aLayer, nsIntRegion* aOuterVisibleRegion,
    const nsIntRect* aLayerContentsVisibleRect = nullptr,
    bool aOuterUntransformed = false) {
  Matrix4x4 transform = aLayer->GetTransform();
  Matrix transform2D;
  if (aOuterUntransformed) {
    if (aLayerContentsVisibleRect) {
      aOuterVisibleRegion->And(*aOuterVisibleRegion,
                               *aLayerContentsVisibleRect);
    }
  } else if (transform.Is2D(&transform2D) &&
             !transform2D.HasNonIntegerTranslation()) {
    aOuterVisibleRegion->MoveBy(-int(transform2D._31), -int(transform2D._32));
    if (aLayerContentsVisibleRect) {
      aOuterVisibleRegion->And(*aOuterVisibleRegion,
                               *aLayerContentsVisibleRect);
    }
  } else {
    nsIntRect outerRect = aOuterVisibleRegion->GetBounds();
    // if 'transform' is not invertible, then nothing will be displayed
    // for the layer, so it doesn't really matter what we do here
    Rect outerVisible(outerRect.x, outerRect.y, outerRect.width,
                      outerRect.height);
    transform.Invert();

    Rect layerContentsVisible = Rect::MaxIntRect();

    if (aLayerContentsVisibleRect) {
      NS_ASSERTION(aLayerContentsVisibleRect->width >= 0 &&
                       aLayerContentsVisibleRect->height >= 0,
                   "Bad layer contents rectangle");
      // restrict to aLayerContentsVisibleRect before call GfxRectToIntRect,
      // in case layerVisible is extremely large (as it can be when
      // projecting through the inverse of a 3D transform)
      layerContentsVisible = Rect(
          aLayerContentsVisibleRect->x, aLayerContentsVisibleRect->y,
          aLayerContentsVisibleRect->width, aLayerContentsVisibleRect->height);
    }

    Rect layerVisible =
        transform.ProjectRectBounds(outerVisible, layerContentsVisible);

    layerVisible.RoundOut();

    IntRect intRect;
    if (!layerVisible.ToIntRect(&intRect)) {
      intRect = IntRect::MaxIntRect();
    }

    *aOuterVisibleRegion = intRect;
  }

  aLayer->SetVisibleRegion(
      LayerIntRegion::FromUnknownRegion(*aOuterVisibleRegion));
}

void ContainerState::SetOuterVisibleRegionForLayer(
    Layer* aLayer, const nsIntRegion& aOuterVisibleRegion,
    const nsIntRect* aLayerContentsVisibleRect,
    bool aOuterUntransformed) const {
  nsIntRegion visRegion = aOuterVisibleRegion;
  if (!aOuterUntransformed) {
    visRegion.MoveBy(mParameters.mOffset);
  }
  SetOuterVisibleRegion(aLayer, &visRegion, aLayerContentsVisibleRect,
                        aOuterUntransformed);
}

nscolor ContainerState::FindOpaqueBackgroundColorInLayer(
    const PaintedLayerData* aData, const nsIntRect& aRect,
    bool* aOutIntersectsLayer) const {
  *aOutIntersectsLayer = true;

  // Scan the candidate's display items.
  nsIntRect deviceRect = aRect;
  nsRect appUnitRect = ToAppUnits(deviceRect, mAppUnitsPerDevPixel);
  appUnitRect.ScaleInverseRoundOut(mParameters.mXScale, mParameters.mYScale);

  for (auto& assignedItem : Reversed(aData->mAssignedDisplayItems)) {
    if (assignedItem.HasOpacity() || assignedItem.HasTransform()) {
      // We cannot easily calculate the opaque background color for items inside
      // a flattened effect.
      continue;
    }

    if (IsEffectEndMarker(assignedItem.mType)) {
      // An optimization: the underlying display item for effect markers is the
      // same for both start and end markers. Skip the effect end markers.
      continue;
    }

    nsDisplayItem* item = assignedItem.mItem;
    bool snap;
    nsRect bounds = item->GetBounds(mBuilder, &snap);
    if (snap && mSnappingEnabled) {
      nsIntRect snappedBounds = ScaleToNearestPixels(bounds);
      if (!snappedBounds.Intersects(deviceRect)) continue;

      if (!snappedBounds.Contains(deviceRect)) return NS_RGBA(0, 0, 0, 0);

    } else {
      // The layer's visible rect is already (close enough to) pixel
      // aligned, so no need to round out and in here.
      if (!bounds.Intersects(appUnitRect)) continue;

      if (!bounds.Contains(appUnitRect)) return NS_RGBA(0, 0, 0, 0);
    }

    if (item->IsInvisibleInRect(appUnitRect)) {
      continue;
    }

    if (item->GetClip().IsRectAffectedByClip(deviceRect, mParameters.mXScale,
                                             mParameters.mYScale,
                                             mAppUnitsPerDevPixel)) {
      return NS_RGBA(0, 0, 0, 0);
    }

    MOZ_ASSERT(!assignedItem.HasOpacity() && !assignedItem.HasTransform());
    Maybe<nscolor> color = item->IsUniform(mBuilder);

    if (color && NS_GET_A(*color) == 255) {
      return *color;
    }

    return NS_RGBA(0, 0, 0, 0);
  }

  *aOutIntersectsLayer = false;
  return NS_RGBA(0, 0, 0, 0);
}

nscolor PaintedLayerDataNode::FindOpaqueBackgroundColor(
    const nsIntRegion& aTargetVisibleRegion, int32_t aUnderIndex) const {
  if (aUnderIndex == ABOVE_TOP) {
    aUnderIndex = mPaintedLayerDataStack.Length();
  }
  for (int32_t i = aUnderIndex - 1; i >= 0; --i) {
    const PaintedLayerData* candidate = &mPaintedLayerDataStack[i];
    if (candidate->VisibleAboveRegionIntersects(aTargetVisibleRegion)) {
      // Some non-PaintedLayer content between target and candidate; this is
      // hopeless
      return NS_RGBA(0, 0, 0, 0);
    }

    if (!candidate->VisibleRegionIntersects(aTargetVisibleRegion)) {
      // The layer doesn't intersect our target, ignore it and move on
      continue;
    }

    bool intersectsLayer = true;
    nsIntRect rect = aTargetVisibleRegion.GetBounds();
    nscolor color = mTree.ContState().FindOpaqueBackgroundColorInLayer(
        candidate, rect, &intersectsLayer);
    if (!intersectsLayer) {
      continue;
    }
    return color;
  }
  if (mAllDrawingAboveBackground ||
      !mVisibleAboveBackgroundRegion.Intersect(aTargetVisibleRegion)
           .IsEmpty()) {
    // Some non-PaintedLayer content is between this node's background and
    // target.
    return NS_RGBA(0, 0, 0, 0);
  }
  return FindOpaqueBackgroundColorInParentNode();
}

nscolor PaintedLayerDataNode::FindOpaqueBackgroundColorCoveringEverything()
    const {
  if (!mPaintedLayerDataStack.IsEmpty() || mAllDrawingAboveBackground ||
      !mVisibleAboveBackgroundRegion.IsEmpty()) {
    return NS_RGBA(0, 0, 0, 0);
  }
  return FindOpaqueBackgroundColorInParentNode();
}

nscolor PaintedLayerDataNode::FindOpaqueBackgroundColorInParentNode() const {
  if (mParent) {
    if (mHasClip) {
      // Check whether our parent node has uniform content behind our whole
      // clip.
      // There's one tricky case here: If our parent node is also a scrollable,
      // and is currently scrolled in such a way that this inner one is
      // clipped by it, then it's not really clear how we should determine
      // whether we have a uniform background in the parent: There might be
      // non-uniform content in the parts that our scroll port covers in the
      // parent and that are currently outside the parent's clip.
      // For now, we'll fail to pull a background color in that case.
      return mParent->FindOpaqueBackgroundColor(mClipRect);
    }
    return mParent->FindOpaqueBackgroundColorCoveringEverything();
  }
  // We are the root.
  return mTree.UniformBackgroundColor();
}

bool PaintedLayerData::CanOptimizeToImageLayer(nsDisplayListBuilder* aBuilder) {
  if (!mImage) {
    return false;
  }

  return mImage->CanOptimizeToImageLayer(mLayer->Manager(), aBuilder);
}

already_AddRefed<ImageContainer> PaintedLayerData::GetContainerForImageLayer(
    nsDisplayListBuilder* aBuilder) {
  if (!mImage) {
    return nullptr;
  }

  return mImage->GetContainer(mLayer->Manager(), aBuilder);
}

PaintedLayerDataNode::PaintedLayerDataNode(
    PaintedLayerDataTree& aTree, PaintedLayerDataNode* aParent,
    AnimatedGeometryRoot* aAnimatedGeometryRoot)
    : mTree(aTree),
      mParent(aParent),
      mAnimatedGeometryRoot(aAnimatedGeometryRoot),
      mAllDrawingAboveBackground(false) {
  MOZ_ASSERT(nsLayoutUtils::IsAncestorFrameCrossDoc(
      mTree.Builder()->RootReferenceFrame(), *mAnimatedGeometryRoot));
  mHasClip = mTree.IsClippedWithRespectToParentAnimatedGeometryRoot(
      mAnimatedGeometryRoot, &mClipRect);
}

PaintedLayerDataNode::~PaintedLayerDataNode() {
  MOZ_ASSERT(mPaintedLayerDataStack.IsEmpty());
  MOZ_ASSERT(mChildren.IsEmpty());
}

PaintedLayerDataNode* PaintedLayerDataNode::AddChildNodeFor(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  MOZ_ASSERT(aAnimatedGeometryRoot->mParentAGR == mAnimatedGeometryRoot);
  UniquePtr<PaintedLayerDataNode> child =
      MakeUnique<PaintedLayerDataNode>(mTree, this, aAnimatedGeometryRoot);
  mChildren.AppendElement(std::move(child));
  return mChildren.LastElement().get();
}

template <typename NewPaintedLayerCallbackType>
PaintedLayerData* PaintedLayerDataNode::FindPaintedLayerFor(
    const nsIntRect& aVisibleRect, const bool aBackfaceHidden,
    const ActiveScrolledRoot* aASR, const DisplayItemClipChain* aClipChain,
    NewPaintedLayerCallbackType aNewPaintedLayerCallback) {
  if (!mPaintedLayerDataStack.IsEmpty()) {
    PaintedLayerData* lowestUsableLayer = nullptr;
    for (auto& data : Reversed(mPaintedLayerDataStack)) {
      if (data.mVisibleAboveRegion.Intersects(aVisibleRect)) {
        break;
      }
      if (data.mBackfaceHidden == aBackfaceHidden && data.mASR == aASR &&
          data.mClipChain == aClipChain) {
        lowestUsableLayer = &data;
      }
      // Also check whether the event-regions intersect the visible rect,
      // unless we're in an inactive layer, in which case the event-regions
      // will be hoisted out into their own layer.
      // For performance reasons, we check the intersection with the bounds
      // of the event-regions.
      if (!mTree.ContState().IsInInactiveLayer() &&
          (data.mScaledHitRegionBounds.Intersects(aVisibleRect) ||
           data.mScaledMaybeHitRegionBounds.Intersects(aVisibleRect))) {
        break;
      }
      // If the visible region intersects with the current layer then we
      // can't possibly use any of the layers below it, so stop the search
      // now.
      //
      // If we're trying to minimize painted layer size and we don't
      // intersect the current visible region, then make sure we don't
      // use this painted layer.
      if (data.mVisibleRegion.Intersects(aVisibleRect)) {
        break;
      }

      if (StaticPrefs::layout_smaller_painted_layers()) {
        lowestUsableLayer = nullptr;
      }
    }
    if (lowestUsableLayer) {
      return lowestUsableLayer;
    }
  }
  PaintedLayerData* data = mPaintedLayerDataStack.AppendElement();
  aNewPaintedLayerCallback(data);

  return data;
}

void PaintedLayerDataNode::FinishChildrenIntersecting(const nsIntRect& aRect) {
  for (int32_t i = mChildren.Length() - 1; i >= 0; i--) {
    if (mChildren[i]->Intersects(aRect)) {
      mChildren[i]->Finish(true);
      mChildren.RemoveElementAt(i);
    }
  }
}

void PaintedLayerDataNode::FinishAllChildren(
    bool aThisNodeNeedsAccurateVisibleAboveRegion) {
  for (int32_t i = mChildren.Length() - 1; i >= 0; i--) {
    mChildren[i]->Finish(aThisNodeNeedsAccurateVisibleAboveRegion);
  }
  mChildren.Clear();
}

void PaintedLayerDataNode::Finish(bool aParentNeedsAccurateVisibleAboveRegion) {
  // Skip "visible above region" maintenance, because this node is going away.
  FinishAllChildren(false);

  PopAllPaintedLayerData();

  if (mParent && aParentNeedsAccurateVisibleAboveRegion) {
    if (mHasClip) {
      mParent->AddToVisibleAboveRegion(mClipRect);
    } else {
      mParent->SetAllDrawingAbove();
    }
  }
  mTree.NodeWasFinished(mAnimatedGeometryRoot);
}

void PaintedLayerDataNode::AddToVisibleAboveRegion(const nsIntRect& aRect) {
  nsIntRegion& visibleAboveRegion =
      mPaintedLayerDataStack.IsEmpty()
          ? mVisibleAboveBackgroundRegion
          : mPaintedLayerDataStack.LastElement().mVisibleAboveRegion;
  visibleAboveRegion.Or(visibleAboveRegion, aRect);
  visibleAboveRegion.SimplifyOutward(8);
}

void PaintedLayerDataNode::SetAllDrawingAbove() {
  PopAllPaintedLayerData();
  mAllDrawingAboveBackground = true;
  mVisibleAboveBackgroundRegion.SetEmpty();
}

void PaintedLayerDataNode::PopAllPaintedLayerData() {
  for (int32_t index = mPaintedLayerDataStack.Length() - 1; index >= 0;
       index--) {
    PaintedLayerData& data = mPaintedLayerDataStack[index];
    mTree.ContState().FinishPaintedLayerData(data, [this, &data, index]() {
      return this->FindOpaqueBackgroundColor(data.mVisibleRegion, index);
    });
  }
  mPaintedLayerDataStack.Clear();
}

void PaintedLayerDataTree::InitializeForInactiveLayer(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  mForInactiveLayer = true;
  mRoot.emplace(*this, nullptr, aAnimatedGeometryRoot);
}

nsDisplayListBuilder* PaintedLayerDataTree::Builder() const {
  return mContainerState.Builder();
}

void PaintedLayerDataTree::Finish() {
  if (mRoot) {
    mRoot->Finish(false);
  }
  MOZ_ASSERT(mNodes.Count() == 0);
  mRoot.reset();
}

void PaintedLayerDataTree::NodeWasFinished(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  mNodes.Remove(aAnimatedGeometryRoot);
}

void PaintedLayerDataTree::AddingOwnLayer(
    AnimatedGeometryRoot* aAnimatedGeometryRoot, const nsIntRect* aRect,
    nscolor* aOutUniformBackgroundColor) {
  PaintedLayerDataNode* node = nullptr;
  if (mForInactiveLayer) {
    node = mRoot.ptr();
  } else {
    FinishPotentiallyIntersectingNodes(aAnimatedGeometryRoot, aRect);
    node = EnsureNodeFor(aAnimatedGeometryRoot);
  }
  if (aRect) {
    if (aOutUniformBackgroundColor) {
      *aOutUniformBackgroundColor = node->FindOpaqueBackgroundColor(*aRect);
    }
    node->AddToVisibleAboveRegion(*aRect);
  } else {
    if (aOutUniformBackgroundColor) {
      *aOutUniformBackgroundColor =
          node->FindOpaqueBackgroundColorCoveringEverything();
    }
    node->SetAllDrawingAbove();
  }
}

template <typename NewPaintedLayerCallbackType>
PaintedLayerData* PaintedLayerDataTree::FindPaintedLayerFor(
    AnimatedGeometryRoot* aAnimatedGeometryRoot, const ActiveScrolledRoot* aASR,
    const DisplayItemClipChain* aClipChain, const nsIntRect& aVisibleRect,
    const bool aBackfaceHidden,
    NewPaintedLayerCallbackType aNewPaintedLayerCallback) {
  const nsIntRect* bounds = &aVisibleRect;
  PaintedLayerDataNode* node = nullptr;
  if (mForInactiveLayer) {
    node = mRoot.ptr();
  } else {
    FinishPotentiallyIntersectingNodes(aAnimatedGeometryRoot, bounds);
    node = EnsureNodeFor(aAnimatedGeometryRoot);
  }

  PaintedLayerData* data =
      node->FindPaintedLayerFor(aVisibleRect, aBackfaceHidden, aASR, aClipChain,
                                aNewPaintedLayerCallback);
  return data;
}

void PaintedLayerDataTree::FinishPotentiallyIntersectingNodes(
    AnimatedGeometryRoot* aAnimatedGeometryRoot, const nsIntRect* aRect) {
  AnimatedGeometryRoot* ancestorThatIsChildOfCommonAncestor = nullptr;
  PaintedLayerDataNode* ancestorNode = FindNodeForAncestorAnimatedGeometryRoot(
      aAnimatedGeometryRoot, &ancestorThatIsChildOfCommonAncestor);
  if (!ancestorNode) {
    // None of our ancestors are in the tree. This should only happen if this
    // is the very first item we're looking at.
    MOZ_ASSERT(!mRoot);
    return;
  }

  if (ancestorNode->GetAnimatedGeometryRoot() == aAnimatedGeometryRoot) {
    // aAnimatedGeometryRoot already has a node in the tree.
    // This is the common case.
    MOZ_ASSERT(!ancestorThatIsChildOfCommonAncestor);
    if (aRect) {
      ancestorNode->FinishChildrenIntersecting(*aRect);
    } else {
      ancestorNode->FinishAllChildren();
    }
    return;
  }

  // We have found an existing ancestor, but it's a proper ancestor of our
  // animated geometry root.
  // ancestorThatIsChildOfCommonAncestor is the last animated geometry root
  // encountered on the way up from aAnimatedGeometryRoot to ancestorNode.
  MOZ_ASSERT(ancestorThatIsChildOfCommonAncestor);
  MOZ_ASSERT(nsLayoutUtils::IsAncestorFrameCrossDoc(
      *ancestorThatIsChildOfCommonAncestor, *aAnimatedGeometryRoot));
  MOZ_ASSERT(ancestorThatIsChildOfCommonAncestor->mParentAGR ==
             ancestorNode->GetAnimatedGeometryRoot());

  // ancestorThatIsChildOfCommonAncestor is not in the tree yet!
  MOZ_ASSERT(!mNodes.Get(ancestorThatIsChildOfCommonAncestor));

  // We're about to add a node for ancestorThatIsChildOfCommonAncestor, so we
  // finish all intersecting siblings.
  nsIntRect clip;
  if (IsClippedWithRespectToParentAnimatedGeometryRoot(
          ancestorThatIsChildOfCommonAncestor, &clip)) {
    ancestorNode->FinishChildrenIntersecting(clip);
  } else {
    ancestorNode->FinishAllChildren();
  }
}

PaintedLayerDataNode* PaintedLayerDataTree::EnsureNodeFor(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  MOZ_ASSERT(aAnimatedGeometryRoot);
  PaintedLayerDataNode* node = mNodes.Get(aAnimatedGeometryRoot);
  if (node) {
    return node;
  }

  AnimatedGeometryRoot* parentAnimatedGeometryRoot =
      aAnimatedGeometryRoot->mParentAGR;
  if (!parentAnimatedGeometryRoot) {
    MOZ_ASSERT(!mRoot);
    MOZ_ASSERT(*aAnimatedGeometryRoot == Builder()->RootReferenceFrame());
    mRoot.emplace(*this, nullptr, aAnimatedGeometryRoot);
    node = mRoot.ptr();
  } else {
    PaintedLayerDataNode* parentNode =
        EnsureNodeFor(parentAnimatedGeometryRoot);
    MOZ_ASSERT(parentNode);
    node = parentNode->AddChildNodeFor(aAnimatedGeometryRoot);
  }
  MOZ_ASSERT(node);
  mNodes.InsertOrUpdate(aAnimatedGeometryRoot, node);
  return node;
}

bool PaintedLayerDataTree::IsClippedWithRespectToParentAnimatedGeometryRoot(
    AnimatedGeometryRoot* aAnimatedGeometryRoot, nsIntRect* aOutClip) {
  if (mForInactiveLayer) {
    return false;
  }
  nsIScrollableFrame* scrollableFrame =
      nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot);
  if (!scrollableFrame) {
    return false;
  }
  nsIFrame* scrollFrame = do_QueryFrame(scrollableFrame);
  nsRect scrollPort = scrollableFrame->GetScrollPortRect() +
                      Builder()->ToReferenceFrame(scrollFrame);
  *aOutClip = mContainerState.ScaleToNearestPixels(scrollPort);
  return true;
}

PaintedLayerDataNode*
PaintedLayerDataTree::FindNodeForAncestorAnimatedGeometryRoot(
    AnimatedGeometryRoot* aAnimatedGeometryRoot,
    AnimatedGeometryRoot** aOutAncestorChild) {
  if (!aAnimatedGeometryRoot) {
    return nullptr;
  }
  PaintedLayerDataNode* node = mNodes.Get(aAnimatedGeometryRoot);
  if (node) {
    return node;
  }
  *aOutAncestorChild = aAnimatedGeometryRoot;
  return FindNodeForAncestorAnimatedGeometryRoot(
      aAnimatedGeometryRoot->mParentAGR, aOutAncestorChild);
}

static bool CanOptimizeAwayPaintedLayer(PaintedLayerData* aData,
                                        FrameLayerBuilder* aLayerBuilder) {
  if (!aLayerBuilder->IsBuildingRetainedLayers()) {
    return false;
  }

  // If there's no painted layer with valid content in it that we can reuse,
  // always create a color or image layer (and potentially throw away an
  // existing completely invalid painted layer).
  if (aData->mLayer->GetValidRegion().IsEmpty()) {
    return true;
  }

  // There is an existing painted layer we can reuse. Throwing it away can make
  // compositing cheaper (see bug 946952), but it might cause us to re-allocate
  // the painted layer frequently due to an animation. So we only discard it if
  // we're in tree compression mode, which is triggered at a low frequency.
  return aLayerBuilder->CheckInLayerTreeCompressionMode();
}

#ifdef DEBUG
static int32_t FindIndexOfLayerIn(nsTArray<NewLayerEntry>& aArray,
                                  Layer* aLayer) {
  for (uint32_t i = 0; i < aArray.Length(); ++i) {
    if (aArray[i].mLayer == aLayer) {
      return i;
    }
  }
  return -1;
}
#endif

already_AddRefed<Layer> ContainerState::PrepareImageLayer(
    PaintedLayerData* aData) {
  RefPtr<ImageContainer> imageContainer =
      aData->GetContainerForImageLayer(mBuilder);
  if (!imageContainer) {
    return nullptr;
  }

  RefPtr<ImageLayer> imageLayer = CreateOrRecycleImageLayer(aData->mLayer);
  imageLayer->SetContainer(imageContainer);
  aData->mImage->ConfigureLayer(imageLayer, mParameters);
  imageLayer->SetPostScale(mParameters.mXScale, mParameters.mYScale);

  if (aData->mItemClip->HasClip()) {
    ParentLayerIntRect clip = ViewAs<ParentLayerPixel>(
        ScaleToNearestPixels(aData->mItemClip->GetClipRect()));
    clip.MoveBy(ViewAs<ParentLayerPixel>(mParameters.mOffset));
    imageLayer->SetClipRect(Some(clip));
  } else {
    imageLayer->SetClipRect(Nothing());
  }

  FLB_LOG_PAINTED_LAYER_DECISION(aData, "  Selected image layer=%p\n",
                                 imageLayer.get());

  return imageLayer.forget();
}

already_AddRefed<Layer> ContainerState::PrepareColorLayer(
    PaintedLayerData* aData) {
  RefPtr<ColorLayer> colorLayer = CreateOrRecycleColorLayer(aData->mLayer);
  colorLayer->SetColor(ToDeviceColor(aData->mSolidColor));

  // Copy transform
  colorLayer->SetBaseTransform(aData->mLayer->GetBaseTransform());
  colorLayer->SetPostScale(aData->mLayer->GetPostXScale(),
                           aData->mLayer->GetPostYScale());

  nsIntRect visibleRect = aData->mVisibleRegion.GetBounds();
  visibleRect.MoveBy(-GetTranslationForPaintedLayer(aData->mLayer));
  colorLayer->SetBounds(visibleRect);
  colorLayer->SetClipRect(Nothing());

  FLB_LOG_PAINTED_LAYER_DECISION(aData, "  Selected color layer=%p\n",
                                 colorLayer.get());

  return colorLayer.forget();
}

static void SetBackfaceHiddenForLayer(bool aBackfaceHidden, Layer* aLayer) {
  if (aBackfaceHidden) {
    aLayer->SetContentFlags(aLayer->GetContentFlags() |
                            Layer::CONTENT_BACKFACE_HIDDEN);
  } else {
    aLayer->SetContentFlags(aLayer->GetContentFlags() &
                            ~Layer::CONTENT_BACKFACE_HIDDEN);
  }
}

template <typename FindOpaqueBackgroundColorCallbackType>
void ContainerState::FinishPaintedLayerData(
    PaintedLayerData& aData,
    FindOpaqueBackgroundColorCallbackType aFindOpaqueBackgroundColor) {
  PaintedLayerData* data = &aData;

  if (!data->mLayer) {
    // No layer was recycled, so we create a new one.
    RefPtr<PaintedLayer> paintedLayer = CreatePaintedLayer(data);
    data->mLayer = paintedLayer;

    NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, paintedLayer) < 0,
                 "Layer already in list???");
    mNewChildLayers[data->mNewChildLayersIndex].mLayer =
        std::move(paintedLayer);
  }

  auto* userData = GetPaintedDisplayItemLayerUserData(data->mLayer);
  NS_ASSERTION(userData, "where did our user data go?");
  userData->mLastItemCount = data->mAssignedDisplayItems.size();

  NewLayerEntry* newLayerEntry = &mNewChildLayers[data->mNewChildLayersIndex];

  RefPtr<Layer> layer;
  bool canOptimizeToImageLayer = data->CanOptimizeToImageLayer(mBuilder);

  FLB_LOG_PAINTED_LAYER_DECISION(data, "Selecting layer for pld=%p\n", data);
  FLB_LOG_PAINTED_LAYER_DECISION(
      data, "  Solid=%i, hasImage=%c, canOptimizeAwayPaintedLayer=%i\n",
      data->mIsSolidColorInVisibleRegion, canOptimizeToImageLayer ? 'y' : 'n',
      CanOptimizeAwayPaintedLayer(data, mLayerBuilder));

  if ((data->mIsSolidColorInVisibleRegion || canOptimizeToImageLayer) &&
      CanOptimizeAwayPaintedLayer(data, mLayerBuilder)) {
    NS_ASSERTION(
        !(data->mIsSolidColorInVisibleRegion && canOptimizeToImageLayer),
        "Can't be a solid color as well as an image!");

    layer = canOptimizeToImageLayer ? PrepareImageLayer(data)
                                    : PrepareColorLayer(data);

    if (layer) {
      NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, layer) < 0,
                   "Layer already in list???");
      NS_ASSERTION(newLayerEntry->mLayer == data->mLayer,
                   "Painted layer at wrong index");
      // Store optimized layer in reserved slot
      NewLayerEntry* paintedLayerEntry = newLayerEntry;
      newLayerEntry = &mNewChildLayers[data->mNewChildLayersIndex + 1];
      NS_ASSERTION(!newLayerEntry->mLayer, "Slot already occupied?");
      newLayerEntry->mLayer = layer;
      newLayerEntry->mAnimatedGeometryRoot = data->mAnimatedGeometryRoot;
      newLayerEntry->mASR = paintedLayerEntry->mASR;
      newLayerEntry->mClipChain = paintedLayerEntry->mClipChain;
      newLayerEntry->mScrollMetadataASR = paintedLayerEntry->mScrollMetadataASR;

      // Hide the PaintedLayer. We leave it in the layer tree so that we
      // can find and recycle it later.
      ParentLayerIntRect emptyRect;
      data->mLayer->SetClipRect(Some(emptyRect));
      data->mLayer->SetVisibleRegion(LayerIntRegion());
      data->mLayer->InvalidateWholeLayer();
      data->mLayer->SetEventRegions(EventRegions());
    }
  }

  if (!layer) {
    // We couldn't optimize to an image layer or a color layer above.
    layer = data->mLayer;
    layer->SetClipRect(Nothing());
    FLB_LOG_PAINTED_LAYER_DECISION(data, "  Selected painted layer=%p\n",
                                   layer.get());
  }

  for (auto& item : data->mAssignedDisplayItems) {
    MOZ_ASSERT(item.mItem->GetType() !=
               DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO);

    if (IsEffectEndMarker(item.mType)) {
      // Do not invalidate for end markers.
      continue;
    }

    InvalidateForLayerChange(item.mItem, data->mLayer, item.mDisplayItemData);
    mLayerBuilder->AddPaintedDisplayItem(data, item, layer);
    item.mDisplayItemData = nullptr;
  }

  if (mLayerBuilder->IsBuildingRetainedLayers()) {
    newLayerEntry->mVisibleRegion = data->mVisibleRegion;
    newLayerEntry->mOpaqueRegion = data->mOpaqueRegion;
    newLayerEntry->mHideAllLayersBelow = data->mHideAllLayersBelow;
    newLayerEntry->mOpaqueForAnimatedGeometryRootParent =
        data->mOpaqueForAnimatedGeometryRootParent;
  } else {
    SetOuterVisibleRegionForLayer(layer, data->mVisibleRegion);
  }

#ifdef MOZ_DUMP_PAINTING
  if (!data->mLog.IsEmpty()) {
    PaintedLayerData* containingPld =
        mLayerBuilder->GetContainingPaintedLayerData();
    if (containingPld && containingPld->mLayer) {
      containingPld->mLayer->AddExtraDumpInfo(nsCString(data->mLog));
    } else {
      layer->AddExtraDumpInfo(nsCString(data->mLog));
    }
  }
#endif

  mLayerBuilder->AddPaintedLayerItemsEntry(userData);

  nsIntRegion transparentRegion;
  transparentRegion.Sub(data->mVisibleRegion, data->mOpaqueRegion);
  bool isOpaque = transparentRegion.IsEmpty();
  // For translucent PaintedLayers, try to find an opaque background
  // color that covers the entire area beneath it so we can pull that
  // color into this layer to make it opaque.
  if (layer == data->mLayer) {
    nscolor backgroundColor = NS_RGBA(0, 0, 0, 0);
    if (!isOpaque) {
      backgroundColor = aFindOpaqueBackgroundColor();
      if (NS_GET_A(backgroundColor) == 255) {
        isOpaque = true;
      }
    }

    // Store the background color
    if (userData->mForcedBackgroundColor != backgroundColor) {
      // Invalidate the entire target PaintedLayer since we're changing
      // the background color
#ifdef MOZ_DUMP_PAINTING
      if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
        printf_stderr(
            "Forced background color has changed from #%08X to #%08X "
            "on layer %p\n",
            userData->mForcedBackgroundColor, backgroundColor, data->mLayer);
        nsAutoCString str;
        AppendToString(str, data->mLayer->GetValidRegion());
        printf_stderr("Invalidating layer %p: %s\n", data->mLayer, str.get());
      }
#endif
      data->mLayer->InvalidateWholeLayer();
    }
    userData->mForcedBackgroundColor = backgroundColor;
  } else {
    // mask layer for image and color layers
    SetupMaskLayer(layer, *data->mItemClip);
  }

  uint32_t flags = 0;
  nsIWidget* widget = mContainerReferenceFrame->PresContext()->GetRootWidget();
  // See bug 941095. Not quite ready to disable this.
  bool hidpi = false && widget && widget->GetDefaultScale().scale >= 2;
  if (hidpi) {
    flags |= Layer::CONTENT_DISABLE_SUBPIXEL_AA;
  }
  if (isOpaque && !data->mForceTransparentSurface) {
    flags |= Layer::CONTENT_OPAQUE;
  } else if (data->mNeedComponentAlpha && !hidpi) {
    flags |= Layer::CONTENT_COMPONENT_ALPHA;
  }
  layer->SetContentFlags(flags);

  userData->mItems = std::move(data->mAssignedDisplayItems);
  userData->mContainerLayerFrame = GetContainerFrame();

  PaintedLayerData* containingPaintedLayerData =
      mLayerBuilder->GetContainingPaintedLayerData();
  // If we're building layers for an inactive layer, the event regions are
  // clipped to the inactive layer's clip prior to being combined into the
  // event regions of the containing PLD.
  // For the dispatch-to-content and maybe-hit regions, rounded corners on
  // the clip are ignored, since these are approximate regions. For the
  // remaining regions, rounded corners in the clip cause the region to
  // be combined into the corresponding "imprecise" region of the
  // containing's PLD (e.g. the maybe-hit region instead of the hit region).
  const DisplayItemClip* inactiveLayerClip =
      mLayerBuilder->GetInactiveLayerClip();
  if (containingPaintedLayerData) {
    if (!data->mDispatchToContentHitRegion.GetBounds().IsEmpty()) {
      nsRect rect = nsLayoutUtils::TransformFrameRectToAncestor(
          mContainerReferenceFrame,
          data->mDispatchToContentHitRegion.GetBounds(),
          containingPaintedLayerData->mReferenceFrame);
      if (inactiveLayerClip) {
        rect = inactiveLayerClip->ApplyNonRoundedIntersection(rect);
      }
      containingPaintedLayerData->mDispatchToContentHitRegion.Or(
          containingPaintedLayerData->mDispatchToContentHitRegion, rect);
      containingPaintedLayerData->mDispatchToContentHitRegion.SimplifyOutward(
          8);
      if (data->mDTCRequiresTargetConfirmation) {
        containingPaintedLayerData->mDTCRequiresTargetConfirmation = true;
      }
    }
    if (!data->mMaybeHitRegion.GetBounds().IsEmpty()) {
      nsRect rect = nsLayoutUtils::TransformFrameRectToAncestor(
          mContainerReferenceFrame, data->mMaybeHitRegion.GetBounds(),
          containingPaintedLayerData->mReferenceFrame);
      if (inactiveLayerClip) {
        rect = inactiveLayerClip->ApplyNonRoundedIntersection(rect);
      }
      containingPaintedLayerData->mMaybeHitRegion.Or(
          containingPaintedLayerData->mMaybeHitRegion, rect);
      containingPaintedLayerData->mMaybeHitRegion.SimplifyOutward(8);
    }
    Maybe<Matrix4x4Flagged> matrixCache;
    nsLayoutUtils::TransformToAncestorAndCombineRegions(
        data->mHitRegion, mContainerReferenceFrame,
        containingPaintedLayerData->mReferenceFrame,
        &containingPaintedLayerData->mHitRegion,
        &containingPaintedLayerData->mMaybeHitRegion, &matrixCache,
        inactiveLayerClip);
    // See the comment in nsDisplayList::AddFrame, where the touch action
    // regions are handled. The same thing applies here.
    bool alreadyHadRegions =
        !containingPaintedLayerData->mNoActionRegion.IsEmpty() ||
        !containingPaintedLayerData->mHorizontalPanRegion.IsEmpty() ||
        !containingPaintedLayerData->mVerticalPanRegion.IsEmpty();
    nsLayoutUtils::TransformToAncestorAndCombineRegions(
        data->mNoActionRegion, mContainerReferenceFrame,
        containingPaintedLayerData->mReferenceFrame,
        &containingPaintedLayerData->mNoActionRegion,
        &containingPaintedLayerData->mDispatchToContentHitRegion, &matrixCache,
        inactiveLayerClip);
    nsLayoutUtils::TransformToAncestorAndCombineRegions(
        data->mHorizontalPanRegion, mContainerReferenceFrame,
        containingPaintedLayerData->mReferenceFrame,
        &containingPaintedLayerData->mHorizontalPanRegion,
        &containingPaintedLayerData->mDispatchToContentHitRegion, &matrixCache,
        inactiveLayerClip);
    nsLayoutUtils::TransformToAncestorAndCombineRegions(
        data->mVerticalPanRegion, mContainerReferenceFrame,
        containingPaintedLayerData->mReferenceFrame,
        &containingPaintedLayerData->mVerticalPanRegion,
        &containingPaintedLayerData->mDispatchToContentHitRegion, &matrixCache,
        inactiveLayerClip);
    if (alreadyHadRegions) {
      containingPaintedLayerData->mDispatchToContentHitRegion.OrWith(
          containingPaintedLayerData->CombinedTouchActionRegion());
    }
    containingPaintedLayerData->HitRegionsUpdated();
  } else {
    EventRegions regions(
        ScaleRegionToOutsidePixels(data->mHitRegion),
        ScaleRegionToOutsidePixels(data->mMaybeHitRegion),
        ScaleRegionToOutsidePixels(data->mDispatchToContentHitRegion),
        ScaleRegionToOutsidePixels(data->mNoActionRegion),
        ScaleRegionToOutsidePixels(data->mHorizontalPanRegion),
        ScaleRegionToOutsidePixels(data->mVerticalPanRegion),
        data->mDTCRequiresTargetConfirmation);

    Matrix mat = layer->GetTransform().As2D();
    mat.Invert();
    regions.ApplyTranslationAndScale(mat._31, mat._32, mat._11, mat._22);

    layer->SetEventRegions(regions);
  }

  SetBackfaceHiddenForLayer(data->mBackfaceHidden, data->mLayer);
  if (layer != data->mLayer) {
    SetBackfaceHiddenForLayer(data->mBackfaceHidden, layer);
  }
}

static bool IsItemAreaInWindowOpaqueRegion(
    nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem,
    const nsRect& aComponentAlphaBounds) {
  if (!aItem->Frame()->PresContext()->IsChrome()) {
    // Assume that Web content is always in the window opaque region.
    return true;
  }
  if (aItem->ReferenceFrame() != aBuilder->RootReferenceFrame()) {
    // aItem is probably in some transformed subtree.
    // We're not going to bother figuring out where this landed, we're just
    // going to assume it might have landed over a transparent part of
    // the window.
    return false;
  }
  return aBuilder->GetWindowOpaqueRegion().Contains(aComponentAlphaBounds);
}

void PaintedLayerData::UpdateEffectStatus(DisplayItemEntryType aType,
                                          nsTArray<size_t>& aOpacityIndices) {
  switch (aType) {
    case DisplayItemEntryType::PushOpacity:
      // The index of the new assigned display item in |mAssignedDisplayItems|
      // array will be the current length of the array.
      aOpacityIndices.AppendElement(mAssignedDisplayItems.size());
      break;
    case DisplayItemEntryType::PopOpacity:
      MOZ_ASSERT(!aOpacityIndices.IsEmpty());
      aOpacityIndices.RemoveLastElement();
      break;
#ifdef DEBUG
    case DisplayItemEntryType::PopTransform:
      MOZ_ASSERT(mTransformLevel >= 0);
      mTransformLevel--;
      break;
    case DisplayItemEntryType::PushTransform:
      mTransformLevel++;
      break;
#endif
    default:
      break;
  }
}

bool PaintedLayerData::SetupComponentAlpha(
    ContainerState* aState, nsPaintedDisplayItem* aItem,
    const nsIntRect& aVisibleRect, const TransformClipNode* aTransform) {
  nsRect componentAlphaBounds =
      aItem->GetComponentAlphaBounds(aState->mBuilder);

  if (componentAlphaBounds.IsEmpty()) {
    // The item does not require component alpha, nothing do do here.
    return false;
  }

  if (aTransform) {
    componentAlphaBounds = aTransform->TransformRect(
        componentAlphaBounds, aState->mAppUnitsPerDevPixel);
  }

  const nsIntRect pixelBounds =
      aState->ScaleToOutsidePixels(componentAlphaBounds, false);

  const nsIntRect visibleRect = pixelBounds.Intersect(aVisibleRect);

  if (!mOpaqueRegion.Contains(visibleRect)) {
    nsRect buildingRect = aItem->GetBuildingRect();

    if (aTransform) {
      buildingRect =
          aTransform->TransformRect(buildingRect, aState->mAppUnitsPerDevPixel);
    }

    const nsRect tightBounds = componentAlphaBounds.Intersect(buildingRect);

    if (IsItemAreaInWindowOpaqueRegion(aState->mBuilder, aItem, tightBounds)) {
      mNeedComponentAlpha = true;
    } else {
      // There is no opaque background below the item, disable component alpha.
      aItem->DisableComponentAlpha();
      return false;
    }
  }

  return true;
}

UniquePtr<InactiveLayerData> PaintedLayerData::CreateInactiveLayerData(
    ContainerState* aState, nsPaintedDisplayItem* aItem,
    DisplayItemData* aData) {
  RefPtr<BasicLayerManager> tempManager;
  if (aData) {
    tempManager = aData->InactiveManager();
  }
  if (!tempManager) {
    tempManager = new BasicLayerManager(BasicLayerManager::BLM_INACTIVE);
  }
  UniquePtr<InactiveLayerData> data = MakeUnique<InactiveLayerData>();
  data->mLayerManager = tempManager;

  FrameLayerBuilder* layerBuilder = new FrameLayerBuilder();
  // Ownership of layerBuilder is passed to tempManager.
  layerBuilder->Init(aState->Builder(), tempManager, this, true,
                     &aItem->GetClip());

  tempManager->BeginTransaction();
  if (aState->LayerBuilder()->GetRetainingLayerManager()) {
    layerBuilder->DidBeginRetainedLayerTransaction(tempManager);
  }

  data->mProps = LayerProperties::CloneFrom(tempManager->GetRoot());
  data->mLayer = aItem->BuildLayer(aState->Builder(), tempManager,
                                   ContainerLayerParameters());
  return data;
}

void PaintedLayerData::Accumulate(ContainerState* aState, nsDisplayItem* aItem,
                                  const nsIntRect& aVisibleRect,
                                  const nsRect& aContentRect,
                                  const DisplayItemClip& aClip,
                                  LayerState aLayerState, nsDisplayList* aList,
                                  DisplayItemEntryType aType,
                                  nsTArray<size_t>& aOpacityIndices,
                                  const RefPtr<TransformClipNode>& aTransform) {
  if (aItem->HasHitTestInfo()) {
    AccumulateHitTestItem(aState, aItem, aClip, aTransform);
  }

  if (aItem->GetType() == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
    // These items only carry hit test information.
    return;
  }

  nsPaintedDisplayItem* item = aItem->AsPaintedDisplayItem();
  // If aItem is nullptr, the cast to nsPaintedDisplayItem failed.
  MOZ_ASSERT(item, "Can only accumulate display items that are painted!");

  FLB_LOG_PAINTED_LAYER_DECISION(
      this, "Accumulating dp=%s(%p), f=%p against pld=%p\n", item->Name(), item,
      item->Frame(), this);

  const bool hasOpacity = aOpacityIndices.Length() > 0;
  UpdateEffectStatus(aType, aOpacityIndices);

  const DisplayItemClip* oldClip = mItemClip;
  mItemClip = &aClip;

  const bool isMerged =
      item->AsDisplayWrapList() && item->AsDisplayWrapList()->HasMergedFrames();

  if (IsEffectEndMarker(aType)) {
    mAssignedDisplayItems.emplace_back(item, aLayerState, nullptr, aContentRect,
                                       aType, hasOpacity, aTransform, isMerged);
    return;
  }

  bool clipMatches =
      (oldClip == mItemClip) || (oldClip && *oldClip == *mItemClip);

  DisplayItemData* oldData = aState->mLayerBuilder->GetOldLayerForFrame(
      item->Frame(), item->GetPerFrameKey());

  mAssignedDisplayItems.emplace_back(item, aLayerState, oldData, aContentRect,
                                     aType, hasOpacity, aTransform, isMerged);

  if (aLayerState != LayerState::LAYER_NONE) {
    FLB_LOG_PAINTED_LAYER_DECISION(this, "Creating nested FLB for item %p\n",
                                   item);
    mAssignedDisplayItems.back().mInactiveLayerData =
        CreateInactiveLayerData(aState, item, oldData);
  }

  if (aState->mBuilder->NeedToForceTransparentSurfaceForItem(item)) {
    mForceTransparentSurface = true;
  }

  if (aState->mParameters.mDisableSubpixelAntialiasingInDescendants) {
    // Disable component alpha.
    // Note that the transform (if any) on the PaintedLayer is always an integer
    // translation so we don't have to factor that in here.
    item->DisableComponentAlpha();
  } else {
    const bool needsComponentAlpha =
        SetupComponentAlpha(aState, item, aVisibleRect, aTransform);

    if (needsComponentAlpha) {
      // This display item needs background copy when pushing opacity group.
      for (size_t i : aOpacityIndices) {
        AssignedDisplayItem& item = mAssignedDisplayItems[i];
        MOZ_ASSERT(item.mType == DisplayItemEntryType::PushOpacity ||
                   item.mType == DisplayItemEntryType::PushOpacityWithBg);
        item.mType = DisplayItemEntryType::PushOpacityWithBg;
      }
    }
  }

  if (aTransform && aType == DisplayItemEntryType::Item) {
    // Bounds transformed with axis-aligned transforms could be included in the
    // opaque region calculations. For simplicity, this is currently not done.
    return;
  }

  if (!mIsSolidColorInVisibleRegion && mOpaqueRegion.Contains(aVisibleRect) &&
      mVisibleRegion.Contains(aVisibleRect) && !mImage) {
    // A very common case! Most pages have a PaintedLayer with the page
    // background (opaque) visible and most or all of the page content over the
    // top of that background.
    // The rest of this method won't do anything. mVisibleRegion and
    // mOpaqueRegion don't need updating. mVisibleRegion contains aVisibleRect
    // already, mOpaqueRegion contains aVisibleRect and therefore whatever the
    // opaque region of the item is. mVisibleRegion must contain mOpaqueRegion
    // and therefore aVisibleRect.
    return;
  }

  nsIntRegion opaquePixels;

  // Active opacity means no opaque pixels.
  if (!hasOpacity) {
    opaquePixels = aState->ComputeOpaqueRect(
        item, mAnimatedGeometryRoot, mASR, aClip, aList, &mHideAllLayersBelow,
        &mOpaqueForAnimatedGeometryRootParent);
    opaquePixels.AndWith(aVisibleRect);
  }

  /* Mark as available for conversion to image layer if this is a nsDisplayImage
   * and it's the only thing visible in this layer.
   */
  if (nsIntRegion(aVisibleRect).Contains(mVisibleRegion) &&
      opaquePixels.Contains(mVisibleRegion) &&
      item->SupportsOptimizingToImage()) {
    mImage = static_cast<nsDisplayImageContainer*>(item);
    FLB_LOG_PAINTED_LAYER_DECISION(
        this, "  Tracking image: nsDisplayImageContainer covers the layer\n");
  } else if (mImage) {
    FLB_LOG_PAINTED_LAYER_DECISION(this, "  No longer tracking image\n");
    mImage = nullptr;
  }

  bool isFirstVisibleItem = mVisibleRegion.IsEmpty();

  Maybe<nscolor> uniformColor;
  if (!hasOpacity) {
    uniformColor = item->IsUniform(aState->mBuilder);
  }

  // Some display items have to exist (so they can set forceTransparentSurface
  // below) but don't draw anything. They'll return true for isUniform but
  // a color with opacity 0.
  if (!uniformColor || NS_GET_A(*uniformColor) > 0) {
    // Make sure that the visible area is covered by uniform pixels. In
    // particular this excludes cases where the edges of the item are not
    // pixel-aligned (thus the item will not be truly uniform).
    if (uniformColor) {
      bool snap;
      nsRect bounds = item->GetBounds(aState->mBuilder, &snap);
      if (!aState->ScaleToInsidePixels(bounds, snap).Contains(aVisibleRect)) {
        uniformColor = Nothing();
        FLB_LOG_PAINTED_LAYER_DECISION(
            this, "  Display item does not cover the visible rect\n");
      }
    }
    if (uniformColor) {
      if (isFirstVisibleItem) {
        // This color is all we have
        mSolidColor = *uniformColor;
        mIsSolidColorInVisibleRegion = true;
      } else if (mIsSolidColorInVisibleRegion &&
                 mVisibleRegion.IsEqual(nsIntRegion(aVisibleRect)) &&
                 clipMatches) {
        // we can just blend the colors together
        mSolidColor = NS_ComposeColors(mSolidColor, *uniformColor);
      } else {
        FLB_LOG_PAINTED_LAYER_DECISION(
            this, "  Layer not a solid color: Can't blend colors togethers\n");
        mIsSolidColorInVisibleRegion = false;
      }
    } else {
      FLB_LOG_PAINTED_LAYER_DECISION(this,
                                     "  Layer is not a solid color: Display "
                                     "item is not uniform over the visible "
                                     "bound\n");
      mIsSolidColorInVisibleRegion = false;
    }

    mVisibleRegion.Or(mVisibleRegion, aVisibleRect);
    mVisibleRegion.SimplifyOutward(4);
  }

  if (!opaquePixels.IsEmpty()) {
    for (auto iter = opaquePixels.RectIter(); !iter.Done(); iter.Next()) {
      // We don't use SimplifyInward here since it's not defined exactly
      // what it will discard. For our purposes the most important case
      // is a large opaque background at the bottom of z-order (e.g.,
      // a canvas background), so we need to make sure that the first rect
      // we see doesn't get discarded.
      nsIntRegion tmp;
      tmp.Or(mOpaqueRegion, iter.Get());
      // Opaque display items in chrome documents whose window is partially
      // transparent are always added to the opaque region. This helps ensure
      // that we get as much subpixel-AA as possible in the chrome.
      if (tmp.GetNumRects() <= 4 || item->Frame()->PresContext()->IsChrome()) {
        mOpaqueRegion = std::move(tmp);
      }
    }
  }
}

nsRegion PaintedLayerData::CombinedTouchActionRegion() {
  nsRegion result;
  result.Or(mHorizontalPanRegion, mVerticalPanRegion);
  result.OrWith(mNoActionRegion);
  return result;
}

void PaintedLayerData::AccumulateHitTestItem(ContainerState* aState,
                                             nsDisplayItem* aItem,
                                             const DisplayItemClip& aClip,
                                             TransformClipNode* aTransform) {
  const auto& hitTestInfo = aItem->GetHitTestInfo();
  nsRect area = hitTestInfo.Area();
  const CompositorHitTestInfo& flags = hitTestInfo.Info();

  FLB_LOG_PAINTED_LAYER_DECISION(
      this,
      "Accumulating hit test info %p against pld=%p, "
      "area: [%d, %d, %d, %d], flags: 0x%x]\n",
      aItem, this, area.x, area.y, area.width, area.height, flags.serialize());

  area = aClip.ApplyNonRoundedIntersection(area);

  if (aTransform) {
    area = aTransform->TransformRect(area, aState->mAppUnitsPerDevPixel);
  }

  if (area.IsEmpty()) {
    FLB_LOG_PAINTED_LAYER_DECISION(
        this, "Discarded empty hit test info %p for pld=%p\n", aItem, this);
    return;
  }

  bool hasRoundedCorners = aClip.GetRoundedRectCount() > 0;

  // use the NS_FRAME_SIMPLE_EVENT_REGIONS to avoid calling the slightly
  // expensive HasNonZeroCorner function if we know from a previous run that
  // the frame has zero corners.
  nsIFrame* frame = aItem->Frame();
  bool simpleRegions = frame->HasAnyStateBits(NS_FRAME_SIMPLE_EVENT_REGIONS);
  if (!simpleRegions) {
    if (nsLayoutUtils::HasNonZeroCorner(frame->StyleBorder()->mBorderRadius)) {
      hasRoundedCorners = true;
    } else {
      frame->AddStateBits(NS_FRAME_SIMPLE_EVENT_REGIONS);
    }
  }

  if (hasRoundedCorners || frame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
    mMaybeHitRegion.OrWith(area);
  } else {
    mHitRegion.OrWith(area);
  }

  const auto dtcFlags = flags & CompositorHitTestDispatchToContent;
  if (!dtcFlags.isEmpty()) {
    mDispatchToContentHitRegion.OrWith(area);

    if (flags.contains(CompositorHitTestFlags::eRequiresTargetConfirmation)) {
      mDTCRequiresTargetConfirmation = true;
    }
  }

  const auto touchFlags = flags & CompositorHitTestTouchActionMask;
  if (!touchFlags.isEmpty()) {
    // If there are multiple touch-action areas, there are multiple elements
    // with touch-action properties. We don't know what the relationship is
    // between those elements in terms of DOM ancestry, and so we don't know how
    // to combine the regions properly. Instead, we just add all the areas to
    // the dispatch-to-content region, so that the APZ knows to check with the
    // main thread. See bug 1286957.
    if (mCollapsedTouchActions) {
      mDispatchToContentHitRegion.OrWith(area);
    } else if (touchFlags == CompositorHitTestTouchActionMask) {
      // everything was disabled, so touch-action:none
      mNoActionRegion.OrWith(area);
    } else {
      // The event regions code does not store enough information to actually
      // represent all the different states. Prior to the introduction of
      // CompositorHitTestInfo here in bug 1389149, the following two cases
      // were effectively getting collapsed:
      //   (1) touch-action: auto
      //   (2) touch-action: manipulation
      // In both of these cases, none of {mNoActionRegion, mHorizontalPanRegion,
      // mVerticalPanRegion} were modified, and so the fact that case (2) should
      // have prevented double-tap-zooming was getting lost.
      // With CompositorHitTestInfo we can now represent that case correctly,
      // but only if we use CompositorHitTestInfo all the way to the compositor
      // (i.e. in the WebRender-enabled case). In the non-WebRender case where
      // we still use the event regions, we must collapse these two cases back
      // together. Or add another region to the event regions to fix this
      // properly.
      if (touchFlags !=
          CompositorHitTestFlags::eTouchActionDoubleTapZoomDisabled) {
        if (!flags.contains(CompositorHitTestFlags::eTouchActionPanXDisabled)) {
          // pan-x is allowed
          mHorizontalPanRegion.OrWith(area);
        }
        if (!flags.contains(CompositorHitTestFlags::eTouchActionPanYDisabled)) {
          // pan-y is allowed
          mVerticalPanRegion.OrWith(area);
        }
      } else {
        // the touch-action: manipulation case described above. To preserve the
        // existing behaviour, don't touch either mHorizontalPanRegion or
        // mVerticalPanRegion
      }
    }
  }

  if (!mCollapsedTouchActions) {
    // If there are multiple touch-action areas, there are multiple elements
    // with touch-action properties. We don't know what the relationship is
    // between those elements in terms of DOM ancestry, and so we don't know how
    // to combine the regions properly. Instead, we just add all the areas to
    // the dispatch-to-content region, so that the APZ knows to check with the
    // main thread. See bug 1286957.
    const int alreadyHadRegions = mNoActionRegion.GetNumRects() +
                                  mHorizontalPanRegion.GetNumRects() +
                                  mVerticalPanRegion.GetNumRects();

    if (alreadyHadRegions > 1) {
      mDispatchToContentHitRegion.OrWith(CombinedTouchActionRegion());
      mNoActionRegion.SetEmpty();
      mHorizontalPanRegion.SetEmpty();
      mVerticalPanRegion.SetEmpty();
      mCollapsedTouchActions = true;
    }
  }

  // Avoid quadratic performance as a result of the region growing to include
  // and arbitrarily large number of rects, which can happen on some pages.
  mMaybeHitRegion.SimplifyOutward(8);
  mDispatchToContentHitRegion.SimplifyOutward(8);

  HitRegionsUpdated();
}

void PaintedLayerData::HitRegionsUpdated() {
  // Calculate scaled versions of the bounds of mHitRegion and mMaybeHitRegion
  // for quick access in FindPaintedLayerFor().
  mScaledHitRegionBounds = mState->ScaleToOutsidePixels(mHitRegion.GetBounds());
  mScaledMaybeHitRegionBounds =
      mState->ScaleToOutsidePixels(mMaybeHitRegion.GetBounds());
}

void ContainerState::NewPaintedLayerData(
    PaintedLayerData* aData, AnimatedGeometryRoot* aAnimatedGeometryRoot,
    const ActiveScrolledRoot* aASR, const DisplayItemClipChain* aClipChain,
    const ActiveScrolledRoot* aScrollMetadataASR, const nsPoint& aTopLeft,
    const nsIFrame* aReferenceFrame, const bool aBackfaceHidden) {
  aData->mState = this;
  aData->mAnimatedGeometryRoot = aAnimatedGeometryRoot;
  aData->mASR = aASR;
  aData->mClipChain = aClipChain;
  aData->mAnimatedGeometryRootOffset = aTopLeft;
  aData->mReferenceFrame = aReferenceFrame;
  aData->mBackfaceHidden = aBackfaceHidden;

  aData->mNewChildLayersIndex = mNewChildLayers.Length();
  NewLayerEntry* newLayerEntry = mNewChildLayers.AppendElement();
  newLayerEntry->mAnimatedGeometryRoot = aAnimatedGeometryRoot;
  newLayerEntry->mASR = aASR;
  newLayerEntry->mScrollMetadataASR = aScrollMetadataASR;
  newLayerEntry->mClipChain = aClipChain;
  // newLayerEntry->mOpaqueRegion is filled in later from
  // paintedLayerData->mOpaqueRegion, if necessary.

  // Allocate another entry for this layer's optimization to
  // ColorLayer/ImageLayer
  mNewChildLayers.AppendElement();
}

#ifdef MOZ_DUMP_PAINTING
static void DumpPaintedImage(nsDisplayItem* aItem, SourceSurface* aSurface) {
  nsCString string(aItem->Name());
  string.Append('-');
  string.AppendInt((uint64_t)aItem);
  fprintf_stderr(gfxUtils::sDumpPaintFile, "<script>array[\"%s\"]=\"",
                 string.BeginReading());
  gfxUtils::DumpAsDataURI(aSurface, gfxUtils::sDumpPaintFile);
  fprintf_stderr(gfxUtils::sDumpPaintFile, "\";</script>\n");
}
#endif

static void PaintInactiveLayer(nsDisplayListBuilder* aBuilder,
                               LayerManager* aManager, nsDisplayItem* aItem,
                               gfxContext* aContext, gfxContext* aCtx) {
  // This item has an inactive layer. Render it to a PaintedLayer
  // using a temporary BasicLayerManager.
  BasicLayerManager* basic = static_cast<BasicLayerManager*>(aManager);
  RefPtr<gfxContext> context = aContext;
#ifdef MOZ_DUMP_PAINTING
  int32_t appUnitsPerDevPixel = AppUnitsPerDevPixel(aItem);
  nsIntRect itemVisibleRect =
      aItem->GetPaintRect().ToOutsidePixels(appUnitsPerDevPixel);

  RefPtr<DrawTarget> tempDT;
  if (gfxEnv::DumpPaint()) {
    tempDT = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
        itemVisibleRect.Size(), SurfaceFormat::B8G8R8A8);
    if (tempDT) {
      context = gfxContext::CreateOrNull(tempDT);
      if (!context) {
        // Leave this as crash, it's in the debugging code, we want to know
        gfxDevCrash(LogReason::InvalidContext)
            << "PaintInactive context problem " << gfx::hexa(tempDT);
        return;
      }
      context->SetMatrix(
          Matrix::Translation(-itemVisibleRect.x, -itemVisibleRect.y));
    }
  }
#endif
  basic->BeginTransaction();
  basic->SetTarget(context);

  if (aItem->GetType() == DisplayItemType::TYPE_MASK) {
    static_cast<nsDisplayMasksAndClipPaths*>(aItem)->PaintAsLayer(aBuilder,
                                                                  aCtx, basic);
    if (basic->InTransaction()) {
      basic->AbortTransaction();
    }
  } else if (aItem->GetType() == DisplayItemType::TYPE_FILTER) {
    static_cast<nsDisplayFilters*>(aItem)->PaintAsLayer(aBuilder, aCtx, basic);
    if (basic->InTransaction()) {
      basic->AbortTransaction();
    }
  } else {
    basic->EndTransaction(FrameLayerBuilder::DrawPaintedLayer, aBuilder);
  }
  FrameLayerBuilder* builder = static_cast<FrameLayerBuilder*>(
      basic->GetUserData(&gLayerManagerLayerBuilder));
  if (builder) {
    builder->DidEndTransaction();
  }

  basic->SetTarget(nullptr);

#ifdef MOZ_DUMP_PAINTING
  if (gfxEnv::DumpPaint() && tempDT) {
    RefPtr<SourceSurface> surface = tempDT->Snapshot();
    DumpPaintedImage(aItem, surface);

    DrawTarget* drawTarget = aContext->GetDrawTarget();
    Rect rect(itemVisibleRect.x, itemVisibleRect.y, itemVisibleRect.width,
              itemVisibleRect.height);
    drawTarget->DrawSurface(surface, rect, Rect(Point(0, 0), rect.Size()));

    aItem->SetPainted();
  }
#endif
}

nsRect ContainerState::GetDisplayPortForAnimatedGeometryRoot(
    AnimatedGeometryRoot* aAnimatedGeometryRoot) {
  if (mLastDisplayPortAGR == aAnimatedGeometryRoot) {
    return mLastDisplayPortRect;
  }

  mLastDisplayPortAGR = aAnimatedGeometryRoot;

  nsIScrollableFrame* sf =
      nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot);
  if (sf == nullptr ||
      nsLayoutUtils::UsesAsyncScrolling(*aAnimatedGeometryRoot)) {
    mLastDisplayPortRect = nsRect();
    return mLastDisplayPortRect;
  }

  bool usingDisplayport = DisplayPortUtils::GetDisplayPort(
      (*aAnimatedGeometryRoot)->GetContent(), &mLastDisplayPortRect,
      DisplayPortOptions().With(DisplayportRelativeTo::ScrollFrame));
  if (!usingDisplayport) {
    // No async scrolling, so all that matters is that the layer contents
    // cover the scrollport.
    mLastDisplayPortRect = sf->GetScrollPortRect();
  }
  nsIFrame* scrollFrame = do_QueryFrame(sf);
  mLastDisplayPortRect +=
      scrollFrame->GetOffsetToCrossDoc(mContainerReferenceFrame);
  return mLastDisplayPortRect;
}

nsIntRegion ContainerState::ComputeOpaqueRect(
    nsDisplayItem* aItem, AnimatedGeometryRoot* aAnimatedGeometryRoot,
    const ActiveScrolledRoot* aASR, const DisplayItemClip& aClip,
    nsDisplayList* aList, bool* aHideAllLayersBelow,
    bool* aOpaqueForAnimatedGeometryRootParent) {
  bool snapOpaque;
  nsRegion opaque = aItem->GetOpaqueRegion(mBuilder, &snapOpaque);
  MOZ_ASSERT(!opaque.IsComplex());
  if (opaque.IsEmpty()) {
    return nsIntRegion();
  }

  nsIntRegion opaquePixels;
  nsRegion opaqueClipped;
  for (auto iter = opaque.RectIter(); !iter.Done(); iter.Next()) {
    opaqueClipped.Or(opaqueClipped,
                     aClip.ApproximateIntersectInward(iter.Get()));
  }
  if (aAnimatedGeometryRoot == mContainerAnimatedGeometryRoot &&
      aASR == mContainerASR && opaqueClipped.Contains(mContainerBounds)) {
    *aHideAllLayersBelow = true;
    aList->SetIsOpaque();
  }
  // Add opaque areas to the "exclude glass" region. Only do this when our
  // container layer is going to be the rootmost layer, otherwise transforms
  // etc will mess us up (and opaque contributions from other containers are
  // not needed).
  if (!nsLayoutUtils::GetCrossDocParentFrameInProcess(mContainerFrame)) {
    mBuilder->AddWindowOpaqueRegion(aItem->Frame(), opaqueClipped.GetBounds());
  }
  opaquePixels = ScaleRegionToInsidePixels(opaqueClipped, snapOpaque);

  if (IsInInactiveLayer()) {
    return opaquePixels;
  }

  const nsRect& displayport =
      GetDisplayPortForAnimatedGeometryRoot(aAnimatedGeometryRoot);
  if (!displayport.IsEmpty() &&
      opaquePixels.Contains(ScaleRegionToNearestPixels(displayport))) {
    *aOpaqueForAnimatedGeometryRootParent = true;
  }
  return opaquePixels;
}

Maybe<size_t> ContainerState::SetupMaskLayerForScrolledClip(
    Layer* aLayer, const DisplayItemClip& aClip) {
  if (aClip.GetRoundedRectCount() > 0) {
    Maybe<size_t> maskLayerIndex = Some(aLayer->GetAncestorMaskLayerCount());
    if (RefPtr<Layer> maskLayer =
            CreateMaskLayer(aLayer, aClip, maskLayerIndex)) {
      aLayer->AddAncestorMaskLayer(maskLayer);
      return maskLayerIndex;
    }
    // Fall through to |return Nothing()|.
  }
  return Nothing();
}

static const ActiveScrolledRoot* GetASRForPerspective(
    const ActiveScrolledRoot* aASR, nsIFrame* aPerspectiveFrame) {
  for (const ActiveScrolledRoot* asr = aASR; asr; asr = asr->mParent) {
    nsIFrame* scrolledFrame = asr->mScrollableFrame->GetScrolledFrame();
    // In OOP documents, the root scrollable frame of the in-process root
    // document is always active, so using IsAncestorFrameCrossDocInProcess
    // should be fine here.
    if (nsLayoutUtils::IsAncestorFrameCrossDocInProcess(scrolledFrame,
                                                        aPerspectiveFrame)) {
      return asr;
    }
  }
  return nullptr;
}

static CSSMaskLayerUserData* GetCSSMaskLayerUserData(Layer* aMaskLayer) {
  if (!aMaskLayer) {
    return nullptr;
  }

  return static_cast<CSSMaskLayerUserData*>(
      aMaskLayer->GetUserData(&gCSSMaskLayerUserData));
}

static void SetCSSMaskLayerUserData(Layer* aMaskLayer) {
  MOZ_ASSERT(aMaskLayer);

  aMaskLayer->SetUserData(&gCSSMaskLayerUserData, new CSSMaskLayerUserData());
}

void ContainerState::SetupMaskLayerForCSSMask(
    Layer* aLayer, nsDisplayMasksAndClipPaths* aMaskItem) {
  RefPtr<ImageLayer> maskLayer = CreateOrRecycleMaskImageLayerFor(
      MaskLayerKey(aLayer, Nothing()), GetCSSMaskLayerUserData,
      SetCSSMaskLayerUserData);
  CSSMaskLayerUserData* oldUserData = GetCSSMaskLayerUserData(maskLayer.get());
  MOZ_ASSERT(oldUserData);

  bool snap;
  nsRect bounds = aMaskItem->GetBounds(mBuilder, &snap);
  nsIntRect itemRect = ScaleToOutsidePixels(bounds, snap);

  // Setup mask layer offset.
  // We do not repaint mask for mask position change, so update base transform
  // each time is required.
  Matrix4x4 matrix;
  matrix.PreTranslate(itemRect.x, itemRect.y, 0);
  matrix.PreTranslate(mParameters.mOffset.x, mParameters.mOffset.y, 0);
  maskLayer->SetBaseTransform(matrix);

  nsPoint maskLayerOffset = aMaskItem->ToReferenceFrame() - bounds.TopLeft();

  CSSMaskLayerUserData newUserData(aMaskItem->Frame(), itemRect,
                                   maskLayerOffset);
  nsRect dirtyRect;
  if (!aMaskItem->IsInvalid(dirtyRect) && *oldUserData == newUserData) {
    aLayer->SetMaskLayer(maskLayer);
    return;
  }

  int32_t maxSize = mManager->GetMaxTextureSize();
  IntSize surfaceSize(std::min(itemRect.width, maxSize),
                      std::min(itemRect.height, maxSize));

  if (surfaceSize.IsEmpty()) {
    // Return early if we know that the size of this mask surface is empty.
    return;
  }

  MaskImageData imageData(surfaceSize, mManager);
  RefPtr<DrawTarget> dt = imageData.CreateDrawTarget();
  if (!dt || !dt->IsValid()) {
    NS_WARNING("Could not create DrawTarget for mask layer.");
    return;
  }

  RefPtr<gfxContext> maskCtx = gfxContext::CreateOrNull(dt);
  maskCtx->SetMatrix(Matrix::Translation(-itemRect.TopLeft()));
  maskCtx->Multiply(
      gfxMatrix::Scaling(mParameters.mXScale, mParameters.mYScale));

  bool isPaintFinished = aMaskItem->PaintMask(mBuilder, maskCtx);

  RefPtr<ImageContainer> imgContainer =
      imageData.CreateImageAndImageContainer();
  if (!imgContainer) {
    return;
  }
  maskLayer->SetContainer(imgContainer);

  if (isPaintFinished) {
    *oldUserData = std::move(newUserData);
  }
  aLayer->SetMaskLayer(maskLayer);
}

static bool IsScrollThumbLayer(nsDisplayItem* aItem) {
  return aItem->GetType() == DisplayItemType::TYPE_OWN_LAYER &&
         static_cast<nsDisplayOwnLayer*>(aItem)->IsScrollThumbLayer();
}

template <typename ClearFn, typename SelectFn>
static void ProcessDisplayItemMarker(DisplayItemEntryType aMarker,
                                     ClearFn ClearLayerSelectionIfNeeded,
                                     SelectFn SelectLayerIfNeeded) {
  switch (aMarker) {
    case DisplayItemEntryType::PushTransform:
    case DisplayItemEntryType::PushOpacity:
      SelectLayerIfNeeded();
      break;
    case DisplayItemEntryType::PopTransform:
    case DisplayItemEntryType::PopOpacity:
      ClearLayerSelectionIfNeeded();
      break;
    default:
      break;
  }
}
/*
 * Iterate through the non-clip items in aList and its descendants.
 * For each item we compute the effective clip rect. Each item is assigned
 * to a layer. We invalidate the areas in PaintedLayers where an item
 * has moved from one PaintedLayer to another. Also,
 * aState->mInvalidPaintedContent is invalidated in every PaintedLayer.
 * We set the clip rect for items that generated their own layer, and
 * create a mask layer to do any rounded rect clipping.
 * (PaintedLayers don't need a clip rect on the layer, we clip the items
 * individually when we draw them.)
 * We set the visible rect for all layers, although the actual setting
 * of visible rects for some PaintedLayers is deferred until the calling
 * of ContainerState::Finish.
 */
void ContainerState::ProcessDisplayItems(nsDisplayList* aList) {
  AUTO_PROFILER_LABEL("ContainerState::ProcessDisplayItems",
                      GRAPHICS_LayerBuilding);
  PerfStats::AutoMetricRecording<PerfStats::Metric::LayerBuilding>
      autoRecording;

  nsPoint topLeft(0, 0);

  int32_t maxLayers = StaticPrefs::layers_max_active();
  int layerCount = 0;

  if (!mManager->IsWidgetLayerManager()) {
    mPaintedLayerDataTree.InitializeForInactiveLayer(
        mContainerAnimatedGeometryRoot);
  }

  AnimatedGeometryRoot* lastAnimatedGeometryRoot = nullptr;
  nsPoint lastTopLeft;

  // Tracks the PaintedLayerData that the item will be accumulated in, if it is
  // non-null.
  PaintedLayerData* selectedLayer = nullptr;
  AutoTArray<size_t, 2> opacityIndices;

  // AGR and ASR for the container item that was flattened.
  AnimatedGeometryRoot* containerAGR = nullptr;
  const ActiveScrolledRoot* containerASR = nullptr;
  nsIFrame* containerReferenceFrame = nullptr;
  RefPtr<TransformClipNode> transformNode = nullptr;

  const auto InTransform = [&]() { return transformNode; };

  const auto InOpacity = [&]() {
    return selectedLayer && opacityIndices.Length() > 0;
  };

  FLBDisplayListIterator iter(mBuilder, aList, this);
  while (iter.HasNext()) {
    DisplayItemEntry e = iter.GetNextEntry();
    DisplayItemEntryType marker = e.mType;
    nsDisplayItem* item = e.mItem;
    MOZ_ASSERT(item);
    DisplayItemType itemType = item->GetType();
    const bool isHitTestItem =
        itemType == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO;

    NS_ASSERTION(mAppUnitsPerDevPixel == AppUnitsPerDevPixel(item),
                 "items in a container layer should all have the same app "
                 "units per dev pixel");

    if (mBuilder->NeedToForceTransparentSurfaceForItem(item)) {
      aList->SetNeedsTransparentSurface();
    }

    LayerState layerState = LayerState::LAYER_NONE;
    if (marker == DisplayItemEntryType::Item) {
      layerState = item->GetLayerState(mBuilder, mManager, mParameters);

      if (layerState == LayerState::LAYER_INACTIVE &&
          nsDisplayItem::ForceActiveLayers()) {
        layerState = LayerState::LAYER_ACTIVE;
      }
    }

    AnimatedGeometryRoot* itemAGR = item->GetAnimatedGeometryRoot();
    const ActiveScrolledRoot* itemASR = item->GetActiveScrolledRoot();
    const DisplayItemClipChain* itemClipChain = item->GetClipChain();
    const DisplayItemClipChain* layerClipChain = nullptr;
    const DisplayItemClip* itemClipPtr = &item->GetClip();

    const bool inEffect = InTransform() || InOpacity();
    if (mManager->IsWidgetLayerManager() && !inEffect) {
      if (itemClipChain && itemClipChain->mASR == itemASR &&
          itemType != DisplayItemType::TYPE_STICKY_POSITION) {
        layerClipChain = itemClipChain->mParent;
      } else {
        layerClipChain = itemClipChain;
      }
    } else {
      // Inside a flattened effect or inactive layer, use container AGR and ASR.
      itemAGR = inEffect ? containerAGR : mContainerAnimatedGeometryRoot;
      itemASR = inEffect ? containerASR : mContainerASR;

      if (!IsEffectEndMarker(marker)) {
        // No need to fuse clip chain for effect end markers, since it was
        // already done for effect start markers.
        item->FuseClipChainUpTo(mBuilder, itemASR);
        itemClipChain = item->GetClipChain();
      }

      itemClipPtr = itemClipChain ? &itemClipChain->mClip : nullptr;
    }

    const DisplayItemClip& itemClip =
        itemClipPtr ? *itemClipPtr : DisplayItemClip::NoClip();

    if (inEffect && marker == DisplayItemEntryType::Item) {
      // Fast-path for items inside flattened inactive layers. This works
      // because the layer state of the item cannot be active, otherwise the
      // parent item would not have been flattened.
      MOZ_ASSERT(selectedLayer);
      selectedLayer->Accumulate(this, item, nsIntRect(), nsRect(), itemClip,
                                layerState, aList, marker, opacityIndices,
                                transformNode);
      continue;
    }

    // Items outside of flattened effects and non-item markers inside flattened
    // effects are processed here.
    MOZ_ASSERT(!inEffect || (marker != DisplayItemEntryType::Item));

    if (itemAGR == lastAnimatedGeometryRoot) {
      topLeft = lastTopLeft;
    } else {
      lastTopLeft = topLeft =
          (*itemAGR)->GetOffsetToCrossDoc(mContainerReferenceFrame);
      lastAnimatedGeometryRoot = itemAGR;
    }

    const ActiveScrolledRoot* scrollMetadataASR =
        layerClipChain
            ? ActiveScrolledRoot::PickDescendant(itemASR, layerClipChain->mASR)
            : itemASR;

    const bool prerenderedTransform =
        itemType == DisplayItemType::TYPE_TRANSFORM &&
        static_cast<nsDisplayTransform*>(item)->MayBeAnimated(mBuilder);

    bool snap = false;
    nsRect itemContent = isHitTestItem ? item->GetHitTestInfo().Area()
                                       : item->GetBounds(mBuilder, &snap);

    nsIntRect itemDrawRect = ScaleToOutsidePixels(itemContent, snap);
    ParentLayerIntRect clipRect;
    if (itemClip.HasClip()) {
      const nsRect& itemClipRect = itemClip.GetClipRect();
      itemContent.IntersectRect(itemContent, itemClipRect);
      clipRect = ViewAs<ParentLayerPixel>(ScaleToNearestPixels(itemClipRect));

      if (!prerenderedTransform && !IsScrollThumbLayer(item)) {
        itemDrawRect.IntersectRect(itemDrawRect, clipRect.ToUnknownRect());
      }

      clipRect.MoveBy(ViewAs<ParentLayerPixel>(mParameters.mOffset));
    }

    if (marker == DisplayItemEntryType::PopTransform) {
      MOZ_ASSERT(transformNode);
      transformNode = transformNode->Parent();
    }

    nsRect itemVisibleRectAu = itemContent;
    if (transformNode) {
      // If we are within transform, transform itemContent and itemDrawRect.
      MOZ_ASSERT(transformNode);

      itemContent =
          transformNode->TransformRect(itemContent, mAppUnitsPerDevPixel);

      itemDrawRect = transformNode->TransformRect(itemDrawRect);
    }

#ifdef DEBUG
    nsRect bounds = itemContent;

    if (inEffect || isHitTestItem) {
      bounds.SetEmpty();
    }

    if (!bounds.IsEmpty() && itemASR != mContainerASR) {
      if (Maybe<nsRect> clip =
              item->GetClipWithRespectToASR(mBuilder, mContainerASR)) {
        bounds = clip.ref();
      }
    }

    ((nsRect&)mAccumulatedChildBounds)
        .UnionRect(mAccumulatedChildBounds, bounds);
#endif

    nsIntRect itemVisibleRect = itemDrawRect;

    // We intersect the building rect with the clipped item bounds to get a
    // tighter visible rect.
    if (!prerenderedTransform) {
      nsRect itemBuildingRect = item->GetBuildingRect();

      if (transformNode) {
        itemBuildingRect = transformNode->TransformRect(itemBuildingRect,
                                                        mAppUnitsPerDevPixel);
      }

      itemVisibleRect = itemVisibleRect.Intersect(
          ScaleToOutsidePixels(itemBuildingRect, false));
    }

    const bool forceInactive = maxLayers != -1 && layerCount >= maxLayers;

    // Assign the item to a layer
    bool treatInactiveItemAsActive =
        (layerState == LayerState::LAYER_INACTIVE &&
         mLayerBuilder->GetContainingPaintedLayerData());
    if (layerState == LayerState::LAYER_ACTIVE_FORCE ||
        treatInactiveItemAsActive ||
        (!forceInactive && (layerState == LayerState::LAYER_ACTIVE_EMPTY ||
                            layerState == LayerState::LAYER_ACTIVE))) {
      layerCount++;

      // Currently we do not support flattening effects within nested inactive
      // layer trees.
      MOZ_ASSERT(selectedLayer == nullptr);
      MOZ_ASSERT(marker == DisplayItemEntryType::Item);

      // LayerState::LAYER_ACTIVE_EMPTY means the layer is created just for its
      // metadata. We should never see an empty layer with any visible content!
      NS_ASSERTION(
          layerState != LayerState::LAYER_ACTIVE_EMPTY ||
              itemVisibleRect.IsEmpty(),
          "State is LayerState::LAYER_ACTIVE_EMPTY but visible rect is not.");

      // As long as the new layer isn't going to be a PaintedLayer,
      // InvalidateForLayerChange doesn't need the new layer pointer.
      // We also need to check the old data now, because BuildLayer
      // can overwrite it.
      DisplayItemData* oldData = mLayerBuilder->GetOldLayerForFrame(
          item->Frame(), item->GetPerFrameKey());
      InvalidateForLayerChange(item, nullptr, oldData);

      // 3D-transformed layers don't necessarily draw in the order in which
      // they're added to their parent container layer.
      bool mayDrawOutOfOrder = itemType == DisplayItemType::TYPE_TRANSFORM &&
                               (item->Combines3DTransformWithAncestors() ||
                                item->Frame()->Extend3DContext());

      // Let mPaintedLayerDataTree know about this item, so that
      // FindPaintedLayerFor and FindOpaqueBackgroundColor are aware of this
      // item, even though it's not in any PaintedLayerDataStack.
      // Ideally we'd only need the "else" case here and have
      // mPaintedLayerDataTree figure out the right clip from the animated
      // geometry root that we give it, but it can't easily figure about
      // overflow:hidden clips on ancestors just by looking at the frame.
      // So we'll do a little hand holding and pass the clip instead of the
      // visible rect for the two important cases.
      nscolor uniformColor = NS_RGBA(0, 0, 0, 0);
      nscolor* uniformColorPtr =
          (mayDrawOutOfOrder || IsInInactiveLayer()) ? nullptr : &uniformColor;
      nsIntRect clipRectUntyped;
      nsIntRect* clipPtr = nullptr;
      if (itemClip.HasClip()) {
        clipRectUntyped = clipRect.ToUnknownRect();
        clipPtr = &clipRectUntyped;
      }

      bool isStickyNotClippedToDisplayPort =
          itemType == DisplayItemType::TYPE_STICKY_POSITION &&
          !static_cast<nsDisplayStickyPosition*>(item)
               ->IsClippedToDisplayPort();
      bool hasScrolledClip =
          layerClipChain && layerClipChain->mClip.HasClip() &&
          (!ActiveScrolledRoot::IsAncestor(layerClipChain->mASR, itemASR) ||
           isStickyNotClippedToDisplayPort);

      if (hasScrolledClip) {
        // If the clip is scrolled, reserve just the area of the clip for
        // layerization, so that elements outside the clip can still merge
        // into the same layer.
        const ActiveScrolledRoot* clipASR = layerClipChain->mASR;
        AnimatedGeometryRoot* clipAGR =
            mBuilder->AnimatedGeometryRootForASR(clipASR);
        nsIntRect scrolledClipRect =
            ScaleToNearestPixels(layerClipChain->mClip.GetClipRect()) +
            mParameters.mOffset;
        mPaintedLayerDataTree.AddingOwnLayer(clipAGR, &scrolledClipRect,
                                             uniformColorPtr);
      } else if (item->ShouldFixToViewport(mBuilder) && itemClip.HasClip() &&
                 item->AnimatedGeometryRootForScrollMetadata() != itemAGR &&
                 !nsLayoutUtils::UsesAsyncScrolling(item->Frame())) {
        // This is basically the same as the case above, but for the non-APZ
        // case. At the moment, when APZ is off, there is only the root ASR
        // (because scroll frames without display ports don't create ASRs) and
        // the whole clip chain is always just one fused clip.
        // Bug 1336516 aims to change that and to remove this workaround.
        AnimatedGeometryRoot* clipAGR =
            item->AnimatedGeometryRootForScrollMetadata();
        nsIntRect scrolledClipRect =
            ScaleToNearestPixels(itemClip.GetClipRect()) + mParameters.mOffset;
        mPaintedLayerDataTree.AddingOwnLayer(clipAGR, &scrolledClipRect,
                                             uniformColorPtr);
      } else if (IsScrollThumbLayer(item) && mManager->IsWidgetLayerManager()) {
        // For scrollbar thumbs, the clip we care about is the clip added by the
        // slider frame.
        mPaintedLayerDataTree.AddingOwnLayer(itemAGR->mParentAGR, clipPtr,
                                             uniformColorPtr);
      } else if (prerenderedTransform && mManager->IsWidgetLayerManager()) {
        if (itemAGR->mParentAGR) {
          mPaintedLayerDataTree.AddingOwnLayer(itemAGR->mParentAGR, clipPtr,
                                               uniformColorPtr);
        } else {
          mPaintedLayerDataTree.AddingOwnLayer(itemAGR, nullptr,
                                               uniformColorPtr);
        }
      } else {
        // Using itemVisibleRect here isn't perfect. itemVisibleRect can be
        // larger or smaller than the potential bounds of item's contents in
        // itemAGR: It's too large if there's a clipped display
        // port somewhere among item's contents (see bug 1147673), and it can
        // be too small if the contents can move, because it only looks at the
        // contents' current bounds and doesn't anticipate any animations.
        // Time will tell whether this is good enough, or whether we need to do
        // something more sophisticated here.
        mPaintedLayerDataTree.AddingOwnLayer(itemAGR, &itemVisibleRect,
                                             uniformColorPtr);
      }

      ContainerLayerParameters params = mParameters;
      params.mBackgroundColor = uniformColor;
      params.mLayerCreationHint = GetLayerCreationHint(itemAGR);
      if (!transformNode) {
        params.mItemVisibleRect = &itemVisibleRectAu;
      } else {
        // We only use mItemVisibleRect for getting the visible rect for
        // remote browsers (which should never have inactive transforms), so we
        // avoid doing transforms on itemVisibleRectAu above and can't report
        // an accurate bounds here.
        params.mItemVisibleRect = nullptr;
      }
      params.mScrollMetadataASR =
          ActiveScrolledRoot::IsAncestor(scrollMetadataASR,
                                         mContainerScrollMetadataASR)
              ? mContainerScrollMetadataASR
              : scrollMetadataASR;
      params.mCompositorASR =
          params.mScrollMetadataASR != mContainerScrollMetadataASR
              ? params.mScrollMetadataASR
              : mContainerCompositorASR;
      if (itemType == DisplayItemType::TYPE_FIXED_POSITION) {
        params.mCompositorASR = itemASR;
      }

      // Perspective items have a single child item, an nsDisplayTransform.
      // If the perspective item is scrolled, but the perspective-inducing
      // frame is outside the scroll frame (indicated by item->Frame()
      // being outside that scroll frame), we have to take special care to
      // make APZ scrolling work properly. APZ needs us to put the scroll
      // frame's FrameMetrics on our child transform ContainerLayer instead.
      // We make a similar adjustment for OwnLayer items built for frames
      // with perspective transforms (e.g. when they have rounded corners).
      // It's worth investigating whether this ASR adjustment can be done at
      // display item creation time.
      bool deferASRForPerspective =
          itemType == DisplayItemType::TYPE_PERSPECTIVE ||
          (itemType == DisplayItemType::TYPE_OWN_LAYER &&
           item->Frame()->IsTransformed() && item->Frame()->HasPerspective());
      if (deferASRForPerspective) {
        scrollMetadataASR = GetASRForPerspective(
            scrollMetadataASR,
            item->Frame()->GetContainingBlock(nsIFrame::SKIP_SCROLLED_FRAME));
        params.mScrollMetadataASR = scrollMetadataASR;
        itemASR = scrollMetadataASR;
      }

      // Just use its layer.
      // Set layerContentsVisibleRect.width/height to -1 to indicate we
      // currently don't know. If BuildContainerLayerFor gets called by
      // item->BuildLayer, this will be set to a proper rect.
      nsIntRect layerContentsVisibleRect(0, 0, -1, -1);
      params.mLayerContentsVisibleRect = &layerContentsVisibleRect;

      // If this display item wants to build inactive layers but we are treating
      // it as active because we are already inside an inactive layer tree,
      // we need to make sure that the display item's clip is reflected in
      // FrameLayerBuilder::mInactiveLayerClip (which is normally set in
      // AddPaintedDisplayItem() when entering an inactive layer tree).
      // We intersect the display item's clip into any existing inactive layer
      // clip.
      const DisplayItemClip* originalInactiveClip = nullptr;
      DisplayItemClip combinedInactiveClip;
      if (treatInactiveItemAsActive) {
        originalInactiveClip = mLayerBuilder->GetInactiveLayerClip();
        if (originalInactiveClip) {
          combinedInactiveClip = *originalInactiveClip;
        }
        DisplayItemClip nestedClip = item->GetClip();
        if (nestedClip.HasClip()) {
          nsRect nestedClipRect = nestedClip.NonRoundedIntersection();

          // Transform the nested clip to be relative to the same reference
          // frame as the existing mInactiveLayerClip, so that we can intersect
          // them below.
          nestedClipRect = nsLayoutUtils::TransformFrameRectToAncestor(
              item->ReferenceFrame(), nestedClipRect,
              mLayerBuilder->GetContainingPaintedLayerData()->mReferenceFrame);

          nestedClip.SetTo(nestedClipRect);
          combinedInactiveClip.IntersectWith(nestedClip);
          mLayerBuilder->SetInactiveLayerClip(&combinedInactiveClip);
        }
      }

      RefPtr<Layer> ownLayer =
          item->AsPaintedDisplayItem()->BuildLayer(mBuilder, mManager, params);

      // If above we combined a nested clip into mInactiveLayerClip, restore
      // the original inactive layer clip here.
      if (treatInactiveItemAsActive) {
        mLayerBuilder->SetInactiveLayerClip(originalInactiveClip);
      }

      if (!ownLayer) {
        continue;
      }

      NS_ASSERTION(!ownLayer->AsPaintedLayer(),
                   "Should never have created a dedicated Painted layer!");

      SetBackfaceHiddenForLayer(item->BackfaceIsHidden(), ownLayer);

      nsRect invalid;
      if (item->IsInvalid(invalid)) {
        ownLayer->SetInvalidRectToVisibleRegion();
      }

      // If it's not a ContainerLayer, we need to apply the scale transform
      // ourselves.
      if (!ownLayer->AsContainerLayer()) {
        ownLayer->SetPostScale(mParameters.mXScale, mParameters.mYScale);
      }

      // Update that layer's clip and visible rects.
      NS_ASSERTION(ownLayer->Manager() == mManager, "Wrong manager");
      NS_ASSERTION(!ownLayer->HasUserData(&gLayerManagerUserData),
                   "We shouldn't have a FrameLayerBuilder-managed layer here!");
      NS_ASSERTION(itemClip.HasClip() || itemClip.GetRoundedRectCount() == 0,
                   "If we have rounded rects, we must have a clip rect");

      // It has its own layer. Update that layer's clip and visible rects.
      ownLayer->SetClipRect(Nothing());
      ownLayer->SetScrolledClip(Nothing());
      ownLayer->SetAncestorMaskLayers({});
      if (itemClip.HasClip()) {
        ownLayer->SetClipRect(Some(clipRect));

        // rounded rectangle clipping using mask layers
        // (must be done after visible rect is set on layer)
        if (itemClip.GetRoundedRectCount() > 0) {
          SetupMaskLayer(ownLayer, itemClip);
        }
      }

      if (hasScrolledClip) {
        const DisplayItemClip& scrolledClip = layerClipChain->mClip;
        LayerClip scrolledLayerClip;
        scrolledLayerClip.SetClipRect(ViewAs<ParentLayerPixel>(
            ScaleToNearestPixels(scrolledClip.GetClipRect()) +
            mParameters.mOffset));
        if (scrolledClip.GetRoundedRectCount() > 0) {
          scrolledLayerClip.SetMaskLayerIndex(
              SetupMaskLayerForScrolledClip(ownLayer.get(), scrolledClip));
        }
        ownLayer->SetScrolledClip(Some(scrolledLayerClip));
      }

      if (item->GetType() == DisplayItemType::TYPE_MASK) {
        MOZ_ASSERT(itemClip.GetRoundedRectCount() == 0);

        nsDisplayMasksAndClipPaths* maskItem =
            static_cast<nsDisplayMasksAndClipPaths*>(item);
        SetupMaskLayerForCSSMask(ownLayer, maskItem);

        if (iter.PeekNext() && iter.PeekNext()->GetType() ==
                                   DisplayItemType::TYPE_SCROLL_INFO_LAYER) {
          // Since we do build a layer for mask, there is no need for this
          // scroll info layer anymore.
          iter.GetNextItem();
        }
      }

      // Convert the visible rect to a region and give the item
      // a chance to try restrict it further.
      nsIntRegion itemVisibleRegion = itemVisibleRect;
      nsRegion tightBounds = item->GetTightBounds(mBuilder, &snap);
      if (!tightBounds.IsEmpty()) {
        itemVisibleRegion.AndWith(
            ScaleRegionToOutsidePixels(tightBounds, snap));
      }

      ContainerLayer* oldContainer = ownLayer->GetParent();
      if (oldContainer && oldContainer != mContainerLayer) {
        oldContainer->RemoveChild(ownLayer);
      }
      NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, ownLayer) < 0,
                   "Layer already in list???");

      // NewLayerEntry::mClipChain is used by SetupScrollingMetadata() to
      // populate any scroll clips in the scroll metadata. Perspective layers
      // have their ASR adjusted such that a scroll metadata that would normally
      // go on the perspective layer goes on its transform layer child instead.
      // However, the transform item's clip chain does not contain the
      // corresponding scroll clip, so we use the perspective item's clip
      // chain instead.
      const DisplayItemClipChain* clipChainForScrollClips = layerClipChain;
      if (itemType == DisplayItemType::TYPE_TRANSFORM && mContainerItem &&
          mContainerItem->GetType() == DisplayItemType::TYPE_PERSPECTIVE) {
        clipChainForScrollClips = mContainerItem->GetClipChain();
      }

      NewLayerEntry* newLayerEntry = mNewChildLayers.AppendElement();
      newLayerEntry->mLayer = ownLayer;
      newLayerEntry->mAnimatedGeometryRoot = itemAGR;
      newLayerEntry->mASR = itemASR;
      newLayerEntry->mScrollMetadataASR = scrollMetadataASR;
      newLayerEntry->mClipChain = clipChainForScrollClips;
      newLayerEntry->mLayerState = layerState;
      if (itemType == DisplayItemType::TYPE_FIXED_POSITION) {
        newLayerEntry->mIsFixedToRootScrollFrame =
            item->Frame()->StyleDisplay()->mPosition ==
                StylePositionProperty::Fixed &&
            nsLayoutUtils::IsReallyFixedPos(item->Frame());
      }

      float contentXScale = 1.0f;
      float contentYScale = 1.0f;
      if (ContainerLayer* ownContainer = ownLayer->AsContainerLayer()) {
        contentXScale = 1 / ownContainer->GetPreXScale();
        contentYScale = 1 / ownContainer->GetPreYScale();
      }
      // nsDisplayTransform::BuildLayer must set layerContentsVisibleRect.
      // We rely on this to ensure 3D transforms compute a reasonable
      // layer visible region.
      NS_ASSERTION(itemType != DisplayItemType::TYPE_TRANSFORM ||
                       layerContentsVisibleRect.width >= 0,
                   "Transform items must set layerContentsVisibleRect!");
      if (mLayerBuilder->IsBuildingRetainedLayers()) {
        newLayerEntry->mLayerContentsVisibleRect = layerContentsVisibleRect;
        if (itemType == DisplayItemType::TYPE_PERSPECTIVE ||
            (itemType == DisplayItemType::TYPE_TRANSFORM &&
             (item->Combines3DTransformWithAncestors() ||
              item->Frame()->Extend3DContext() ||
              item->Frame()->HasPerspective()))) {
          // Give untransformed visible region as outer visible region
          // to avoid failure caused by singular transforms.
          newLayerEntry->mUntransformedVisibleRegion = true;
          newLayerEntry->mVisibleRegion =
              item->GetBuildingRectForChildren().ScaleToOutsidePixels(
                  contentXScale, contentYScale, mAppUnitsPerDevPixel);
        } else {
          newLayerEntry->mVisibleRegion = itemVisibleRegion;
        }
        newLayerEntry->mOpaqueRegion = ComputeOpaqueRect(
            item, itemAGR, itemASR, itemClip, aList,
            &newLayerEntry->mHideAllLayersBelow,
            &newLayerEntry->mOpaqueForAnimatedGeometryRootParent);
      } else {
        bool useChildrenVisible = itemType == DisplayItemType::TYPE_TRANSFORM &&
                                  (item->Frame()->IsPreserve3DLeaf() ||
                                   item->Frame()->HasPerspective());
        const nsIntRegion& visible =
            useChildrenVisible
                ? item->GetBuildingRectForChildren().ScaleToOutsidePixels(
                      contentXScale, contentYScale, mAppUnitsPerDevPixel)
                : itemVisibleRegion;

        SetOuterVisibleRegionForLayer(ownLayer, visible,
                                      layerContentsVisibleRect.width >= 0
                                          ? &layerContentsVisibleRect
                                          : nullptr,
                                      useChildrenVisible);
      }
      if (itemType == DisplayItemType::TYPE_SCROLL_INFO_LAYER) {
        nsDisplayScrollInfoLayer* scrollItem =
            static_cast<nsDisplayScrollInfoLayer*>(item);
        newLayerEntry->mOpaqueForAnimatedGeometryRootParent = false;
        newLayerEntry->mBaseScrollMetadata = scrollItem->ComputeScrollMetadata(
            mBuilder, ownLayer->Manager(), mParameters);
      }

      /**
       * No need to allocate geometry for items that aren't
       * part of a PaintedLayer.
       */
      if (ownLayer->Manager() == mLayerBuilder->GetRetainingLayerManager()) {
        oldData = mLayerBuilder->GetOldLayerForFrame(item->Frame(),
                                                     item->GetPerFrameKey());

        mLayerBuilder->StoreDataForFrame(item->AsPaintedDisplayItem(), ownLayer,
                                         layerState, oldData);
      }
    } else {
      const bool backfaceHidden = item->In3DContextAndBackfaceIsHidden();

      // When container item hit test info is processed, we need to use the same
      // reference frame as the container children.
      const nsIFrame* referenceFrame = item == mContainerItem
                                           ? mContainerReferenceFrame
                                           : item->ReferenceFrame();

      PaintedLayerData* paintedLayerData = selectedLayer;

      if (!paintedLayerData) {
        paintedLayerData = mPaintedLayerDataTree.FindPaintedLayerFor(
            itemAGR, itemASR, layerClipChain, itemVisibleRect, backfaceHidden,
            [&](PaintedLayerData* aData) {
              NewPaintedLayerData(aData, itemAGR, itemASR, layerClipChain,
                                  scrollMetadataASR, topLeft, referenceFrame,
                                  backfaceHidden);
            });
      }
      MOZ_ASSERT(paintedLayerData);

      paintedLayerData->Accumulate(this, item, itemVisibleRect, itemContent,
                                   itemClip, layerState, aList, marker,
                                   opacityIndices, transformNode);

      if (!paintedLayerData->mLayer) {
        // Try to recycle the old layer of this display item.
        RefPtr<PaintedLayer> layer = AttemptToRecyclePaintedLayer(
            itemAGR, item, topLeft,
            inEffect ? containerReferenceFrame : referenceFrame);
        if (layer) {
          paintedLayerData->mLayer = layer;

          auto* userData = GetPaintedDisplayItemLayerUserData(layer);
          paintedLayerData->mAssignedDisplayItems.reserve(
              userData->mLastItemCount);

          NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, layer) < 0,
                       "Layer already in list???");
          mNewChildLayers[paintedLayerData->mNewChildLayersIndex].mLayer =
              std::move(layer);
        }
      }

      const auto ClearLayerSelectionIfNeeded = [&]() {
        if (!InOpacity() && !InTransform()) {
          selectedLayer = nullptr;
          containerAGR = nullptr;
          containerASR = nullptr;
          containerReferenceFrame = nullptr;
        }
      };

      const auto SelectLayerIfNeeded = [&]() {
        if (!selectedLayer) {
          selectedLayer = paintedLayerData;
          containerAGR = itemAGR;
          containerASR = itemASR;
          containerReferenceFrame = const_cast<nsIFrame*>(referenceFrame);
        }
      };

      if (marker == DisplayItemEntryType::PushTransform) {
        nsDisplayTransform* transform = static_cast<nsDisplayTransform*>(item);

        const Matrix4x4Flagged& matrix = transform->GetTransformForRendering();

        Maybe<gfx::IntRect> clip;
        if (itemClip.HasClip()) {
          const nsRect nonRoundedClip = itemClip.NonRoundedIntersection();
          clip.emplace(nonRoundedClip.ToNearestPixels(mAppUnitsPerDevPixel));
        }

        transformNode = new TransformClipNode(transformNode, matrix, clip);
      }

      ProcessDisplayItemMarker(marker, ClearLayerSelectionIfNeeded,
                               SelectLayerIfNeeded);
    }

    nsDisplayList* childItems = item->GetSameCoordinateSystemChildren();
    if (childItems && childItems->NeedsTransparentSurface()) {
      aList->SetNeedsTransparentSurface();
    }
  }

  MOZ_ASSERT(selectedLayer == nullptr);
}

void ContainerState::InvalidateForLayerChange(nsDisplayItem* aItem,
                                              PaintedLayer* aNewLayer,
                                              DisplayItemData* aData) {
  NS_ASSERTION(aItem->GetPerFrameKey(),
               "Display items that render using Thebes must have a key");
  Layer* oldLayer = aData ? aData->mLayer.get() : nullptr;
  if (aNewLayer != oldLayer && oldLayer) {
    // The item has changed layers.
    // Invalidate the old bounds in the old layer and new bounds in the new
    // layer.
    PaintedLayer* t = oldLayer->AsPaintedLayer();
    if (t && aData->mGeometry) {
      // Note that whenever the layer's scale changes, we invalidate the whole
      // thing, so it doesn't matter whether we are using the old scale at last
      // paint or a new scale here
#ifdef MOZ_DUMP_PAINTING
      if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
        printf_stderr("Display item type %s(%p) changed layers %p to %p!\n",
                      aItem->Name(), aItem->Frame(), t, aNewLayer);
      }
#endif
      InvalidatePreTransformRect(
          t, aData->mGeometry->ComputeInvalidationRegion(), aData->mClip,
          GetLastPaintOffset(t), aData->mTransform);
    }
    // Clear the old geometry so that invalidation thinks the item has been
    // added this paint.
    aData->mGeometry = nullptr;
  }
}

static nsRect GetInvalidationRect(nsDisplayItemGeometry* aGeometry,
                                  const DisplayItemClip& aClip,
                                  TransformClipNode* aTransform,
                                  const int32_t aA2D) {
  const nsRect& rect = aGeometry->ComputeInvalidationRegion();
  const nsRect clipped = aClip.ApplyNonRoundedIntersection(rect);

  if (aTransform) {
    return aTransform->TransformRect(clipped, aA2D);
  }

  return clipped;
}

void FrameLayerBuilder::ComputeGeometryChangeForItem(DisplayItemData* aData) {
  nsDisplayItem* item = aData->mItem;
  PaintedLayer* paintedLayer = aData->mLayer->AsPaintedLayer();
  // If aData->mOptLayer is presence, means this item has been optimized to the
  // separate layer. Thus, skip geometry change calculation.
  if (aData->mOptLayer || !item || !paintedLayer) {
    aData->EndUpdate();
    return;
  }

  // If we're a reused display item, then we can't be invalid, so no need to
  // do an in-depth comparison. If we haven't previously stored geometry
  // for this item (if it was an active layer), then we can't skip this
  // yet.
  UniquePtr<nsDisplayItemGeometry> geometry;
  if (aData->mReusedItem && aData->mGeometry) {
    aData->EndUpdate();
    return;
  }

  auto* layerData = GetPaintedDisplayItemLayerUserData(aData->mLayer);
  nsPoint shift = layerData->mAnimatedGeometryRootOrigin -
                  layerData->mLastAnimatedGeometryRootOrigin;

  const DisplayItemClip& clip = item->GetClip();
  const int32_t appUnitsPerDevPixel = layerData->mAppUnitsPerDevPixel;

  // If the frame is marked as invalidated, and didn't specify a rect to
  // invalidate then we want to invalidate both the old and new bounds,
  // otherwise we only want to invalidate the changed areas. If we do get an
  // invalid rect, then we want to add this on top of the change areas.
  nsRect invalid;
  nsIntRegion invalidPixels;

  if (!aData->mGeometry) {
    // This item is being added for the first time, invalidate its entire area.
    geometry = WrapUnique(item->AllocateGeometry(mDisplayListBuilder));

    const nsRect bounds = GetInvalidationRect(
        geometry.get(), clip, aData->mTransform, appUnitsPerDevPixel);

    invalidPixels = bounds.ScaleToOutsidePixels(
        layerData->mXScale, layerData->mYScale, appUnitsPerDevPixel);
#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      printf_stderr("Display item type %s(%p) added to layer %p!\n",
                    item->Name(), item->Frame(), aData->mLayer.get());
    }
#endif
  } else if (aData->mIsInvalid ||
             (item->IsInvalid(invalid) && invalid.IsEmpty())) {
    // Layout marked item/frame as needing repainting (without an explicit
    // rect), invalidate the entire old and new areas.
    geometry = WrapUnique(item->AllocateGeometry(mDisplayListBuilder));

    nsRect oldArea =
        GetInvalidationRect(aData->mGeometry.get(), aData->mClip,
                            aData->mOldTransform, appUnitsPerDevPixel);
    oldArea.MoveBy(shift);

    nsRect newArea = GetInvalidationRect(
        geometry.get(), clip, aData->mTransform, appUnitsPerDevPixel);

    nsRegion combined;
    combined.Or(oldArea, newArea);
    invalidPixels = combined.ScaleToOutsidePixels(
        layerData->mXScale, layerData->mYScale, appUnitsPerDevPixel);
#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      printf_stderr(
          "Display item type %s(%p) (in layer %p) belongs to an "
          "invalidated frame!\n",
          item->Name(), item->Frame(), aData->mLayer.get());
    }
#endif
  } else {
    // Let the display item check for geometry changes and decide what needs to
    // be repainted.
    const nsRegion& changedFrameInvalidations =
        aData->GetChangedFrameInvalidations();

    if (aData->mTransform) {
      // If this display item is inside a flattened transform the offset is
      // already included in the root transform, so there is no need to shift.
      shift = nsPoint();
    }

    aData->mGeometry->MoveBy(shift);

    nsRegion combined;
    item->ComputeInvalidationRegion(mDisplayListBuilder, aData->mGeometry.get(),
                                    &combined);

    // Only allocate a new geometry object if something actually changed,
    // otherwise the existing one should be fine. We always reallocate for
    // inactive layers, since these types don't implement
    // ComputeInvalidateRegion (and rely on the ComputeDifferences call in
    // AddPaintedDisplayItem instead).
    if (!combined.IsEmpty() ||
        aData->mLayerState == LayerState::LAYER_INACTIVE ||
        item->NeedsGeometryUpdates()) {
      geometry = WrapUnique(item->AllocateGeometry(mDisplayListBuilder));
    }

    aData->mClip.AddOffsetAndComputeDifference(
        shift, aData->mGeometry->ComputeInvalidationRegion(), clip,
        geometry ? geometry->ComputeInvalidationRegion()
                 : aData->mGeometry->ComputeInvalidationRegion(),
        &combined);

    // Add in any rect that the frame specified
    combined.Or(combined, invalid);
    combined.Or(combined, changedFrameInvalidations);

    // Restrict invalidation to the clipped region
    nsRegion clipRegion;
    if (clip.ComputeRegionInClips(&aData->mClip, shift, &clipRegion)) {
      combined.And(combined, clipRegion);
    }

    invalidPixels = combined.ToOutsidePixels(appUnitsPerDevPixel);

    if (aData->mTransform) {
      invalidPixels = aData->mTransform->TransformRegion(invalidPixels);
    }

    invalidPixels.ScaleRoundOut(layerData->mXScale, layerData->mYScale);

#ifdef MOZ_DUMP_PAINTING
    if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
      if (!combined.IsEmpty()) {
        printf_stderr(
            "Display item type %s(%p) (in layer %p) changed geometry!\n",
            item->Name(), item->Frame(), aData->mLayer.get());
      }
    }
#endif
  }

  if (!invalidPixels.IsEmpty()) {
    InvalidatePostTransformRegion(paintedLayer, invalidPixels,
                                  layerData->mTranslation);
  }

  aData->EndUpdate(std::move(geometry));
}

void FrameLayerBuilder::AddPaintedDisplayItem(PaintedLayerData* aLayerData,
                                              AssignedDisplayItem& aItem,
                                              Layer* aLayer) {
  PaintedLayer* layer = aLayerData->mLayer;
  auto* paintedData = GetPaintedDisplayItemLayerUserData(layer);

  if (layer->Manager() == mRetainingManager) {
    DisplayItemData* data = aItem.mDisplayItemData;
    if (data && !data->mUsed) {
      data->BeginUpdate(layer, aItem.mLayerState, aItem.mItem, aItem.mReused,
                        aItem.mMerged);
    } else {
      data = StoreDataForFrame(aItem.mItem, layer, aItem.mLayerState, nullptr);
    }
    data->mInactiveManager = aItem.mInactiveLayerData
                                 ? aItem.mInactiveLayerData->mLayerManager
                                 : nullptr;
    // We optimized this PaintedLayer into a ColorLayer/ImageLayer. Store the
    // optimized layer here.
    if (aLayer != layer) {
      data->mOptLayer = aLayer;
    }

    data->mOldTransform = data->mTransform;
    data->mTransform = aItem.mTransform;
  }

  if (aItem.mInactiveLayerData) {
    RefPtr<BasicLayerManager> tempManager =
        aItem.mInactiveLayerData->mLayerManager;
    FrameLayerBuilder* layerBuilder = tempManager->GetLayerBuilder();
    Layer* tmpLayer = aItem.mInactiveLayerData->mLayer;

    // We have no easy way of detecting if this transaction will ever actually
    // get finished. For now, I've just silenced the warning with nested
    // transactions in BasicLayers.cpp
    if (!tmpLayer) {
      tempManager->EndTransaction(nullptr, nullptr);
      tempManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
      aItem.mItem = nullptr;
      return;
    }

    bool snap;
    nsRect visibleRect = aItem.mItem->GetBuildingRect().Intersect(
        aItem.mItem->GetBounds(mDisplayListBuilder, &snap));
    nsIntRegion rgn =
        visibleRect.ToOutsidePixels(paintedData->mAppUnitsPerDevPixel);

    // Convert the visible rect to a region and give the item
    // a chance to try restrict it further.
    nsRegion tightBounds =
        aItem.mItem->GetTightBounds(mDisplayListBuilder, &snap);
    if (!tightBounds.IsEmpty()) {
      rgn.AndWith(
          tightBounds.ToOutsidePixels(paintedData->mAppUnitsPerDevPixel));
    }
    SetOuterVisibleRegion(tmpLayer, &rgn);

    DisplayItemData* data = nullptr;
    // If BuildLayer didn't call BuildContainerLayerFor, then our new layer
    // won't have been stored in layerBuilder. Manually add it now.
    if (mRetainingManager) {
#ifdef DEBUG_DISPLAY_ITEM_DATA
      LayerManagerData* parentLmd = static_cast<LayerManagerData*>(
          layer->Manager()->GetUserData(&gLayerManagerUserData));
      LayerManagerData* lmd = static_cast<LayerManagerData*>(
          tempManager->GetUserData(&gLayerManagerUserData));
      lmd->mParent = parentLmd;
#endif
      data =
          layerBuilder->GetDisplayItemDataForManager(aItem.mItem, tempManager);
      data = layerBuilder->StoreDataForFrame(aItem.mItem, tmpLayer,
                                             LayerState::LAYER_ACTIVE, data);
      data->mOldTransform = data->mTransform;
      data->mTransform = aItem.mTransform;
    }

    tempManager->SetRoot(tmpLayer);
    layerBuilder->WillEndTransaction();
    tempManager->AbortTransaction();

    if (gfxUtils::DumpDisplayList() || gfxEnv::DumpPaint()) {
      fprintf_stderr(
          gfxUtils::sDumpPaintFile,
          "Basic layer tree for painting contents of display item %s(%p):\n",
          aItem.mItem->Name(), aItem.mItem->Frame());
      std::stringstream stream;
      tempManager->Dump(stream, "", gfxEnv::DumpPaintToFile());
      fprint_stderr(gfxUtils::sDumpPaintFile,
                    stream);  // not a typo, fprint_stderr declared in nsDebug.h
    }

    nsIntPoint offset =
        GetLastPaintOffset(layer) - GetTranslationForPaintedLayer(layer);
    aItem.mInactiveLayerData->mProps->MoveBy(-offset);
    // Effective transforms are needed by ComputeDifferences().
    tmpLayer->ComputeEffectiveTransforms(Matrix4x4());
    nsIntRegion invalid;
    if (!aItem.mInactiveLayerData->mProps->ComputeDifferences(tmpLayer, invalid,
                                                              nullptr)) {
      nsRect visible = aItem.mItem->Frame()->InkOverflowRect();
      invalid = visible.ToOutsidePixels(paintedData->mAppUnitsPerDevPixel);
    }
    if (aItem.mLayerState == LayerState::LAYER_SVG_EFFECTS) {
      invalid = SVGIntegrationUtils::AdjustInvalidAreaForSVGEffects(
          aItem.mItem->Frame(), aItem.mItem->ToReferenceFrame(), invalid);
    }
    if (!invalid.IsEmpty()) {
#ifdef MOZ_DUMP_PAINTING
      if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
        printf_stderr(
            "Inactive LayerManager(%p) for display item %s(%p) has "
            "an invalid region - invalidating layer %p\n",
            tempManager.get(), aItem.mItem->Name(), aItem.mItem->Frame(),
            layer);
      }
#endif

      if (data && data->mTransform) {
        invalid = data->mTransform->TransformRegion(invalid);
      }

      invalid.ScaleRoundOut(paintedData->mXScale, paintedData->mYScale);

      InvalidatePostTransformRegion(layer, invalid,
                                    GetTranslationForPaintedLayer(layer));
    }
  }
}

DisplayItemData* FrameLayerBuilder::StoreDataForFrame(
    nsPaintedDisplayItem* aItem, Layer* aLayer, LayerState aState,
    DisplayItemData* aData) {
  MOZ_ASSERT(aItem);

  if (aData) {
    if (!aData->mUsed) {
      aData->BeginUpdate(aLayer, aState, false, aItem);
    }
    return aData;
  }

  LayerManagerData* lmd = static_cast<LayerManagerData*>(
      mRetainingManager->GetUserData(&gLayerManagerUserData));

  RefPtr<DisplayItemData> data = new (aItem->Frame()->PresContext())
      DisplayItemData(lmd, aItem->GetPerFrameKey(), aLayer);

  data->BeginUpdate(aLayer, aState, true, aItem);

  lmd->mDisplayItems.push_back(data);
  return data;
}

void FrameLayerBuilder::StoreDataForFrame(nsIFrame* aFrame,
                                          uint32_t aDisplayItemKey,
                                          Layer* aLayer, LayerState aState) {
  DisplayItemData* oldData = GetDisplayItemData(aFrame, aDisplayItemKey);
  if (oldData && oldData->mFrameList.Length() == 1) {
    oldData->BeginUpdate(aLayer, aState, false);
    return;
  }

  LayerManagerData* lmd = static_cast<LayerManagerData*>(
      mRetainingManager->GetUserData(&gLayerManagerUserData));

  RefPtr<DisplayItemData> data = new (aFrame->PresContext())
      DisplayItemData(lmd, aDisplayItemKey, aLayer, aFrame);

  data->BeginUpdate(aLayer, aState, true);

  lmd->mDisplayItems.push_back(data);
}

AssignedDisplayItem::AssignedDisplayItem(
    nsPaintedDisplayItem* aItem, LayerState aLayerState, DisplayItemData* aData,
    const nsRect& aContentRect, DisplayItemEntryType aType,
    const bool aHasOpacity, const RefPtr<TransformClipNode>& aTransform,
    const bool aIsMerged)
    : mItem(aItem),
      mDisplayItemData(aData),
      mTransform(aTransform),
      mContentRect(aContentRect),
      mLayerState(aLayerState),
      mType(aType),
      mReused(aItem->IsReused()),
      mMerged(aIsMerged),
      mHasOpacity(aHasOpacity),
      mHasPaintRect(aItem->HasPaintRect()) {}

InactiveLayerData::~InactiveLayerData() {
  if (mLayerManager) {
    mLayerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
  }
}

bool FrameLayerBuilder::CheckInLayerTreeCompressionMode() {
  if (mInLayerTreeCompressionMode) {
    return true;
  }

  // If we wanted to be in layer tree compression mode, but weren't, then
  // scheduled a delayed repaint where we will be.
  mRootPresContext->PresShell()->GetRootFrame()->SchedulePaint(
      nsIFrame::PAINT_DELAYED_COMPRESS, false);

  return false;
}

void ContainerState::CollectOldLayers() {
  for (Layer* layer = mContainerLayer->GetFirstChild(); layer;
       layer = layer->GetNextSibling()) {
    NS_ASSERTION(!layer->HasUserData(&gMaskLayerUserData),
                 "Mask layers should not be part of the layer tree.");
    if (layer->HasUserData(&gPaintedDisplayItemLayerUserData)) {
      NS_ASSERTION(layer->AsPaintedLayer(), "Wrong layer type");
      mPaintedLayersAvailableForRecycling.Insert(
          static_cast<PaintedLayer*>(layer));
    }

    if (Layer* maskLayer = layer->GetMaskLayer()) {
      NS_ASSERTION(maskLayer->GetType() == Layer::TYPE_IMAGE,
                   "Could not recycle mask layer, unsupported layer type.");
      mRecycledMaskImageLayers.InsertOrUpdate(
          MaskLayerKey(layer, Nothing()),
          RefPtr{static_cast<ImageLayer*>(maskLayer)});
    }
    for (size_t i = 0; i < layer->GetAncestorMaskLayerCount(); i++) {
      Layer* maskLayer = layer->GetAncestorMaskLayerAt(i);

      NS_ASSERTION(maskLayer->GetType() == Layer::TYPE_IMAGE,
                   "Could not recycle mask layer, unsupported layer type.");
      mRecycledMaskImageLayers.InsertOrUpdate(
          MaskLayerKey(layer, Some(i)),
          RefPtr{static_cast<ImageLayer*>(maskLayer)});
    }
  }
}

struct OpaqueRegionEntry {
  AnimatedGeometryRoot* mAnimatedGeometryRoot;
  const ActiveScrolledRoot* mASR;
  nsIntRegion mOpaqueRegion;
};

static OpaqueRegionEntry* FindOpaqueRegionEntry(
    nsTArray<OpaqueRegionEntry>& aEntries,
    AnimatedGeometryRoot* aAnimatedGeometryRoot,
    const ActiveScrolledRoot* aASR) {
  for (uint32_t i = 0; i < aEntries.Length(); ++i) {
    OpaqueRegionEntry* d = &aEntries[i];
    if (d->mAnimatedGeometryRoot == aAnimatedGeometryRoot && d->mASR == aASR) {
      return d;
    }
  }
  return nullptr;
}

static const ActiveScrolledRoot* FindDirectChildASR(
    const ActiveScrolledRoot* aParent, const ActiveScrolledRoot* aDescendant) {
  MOZ_ASSERT(aDescendant, "can't start at the root when looking for a child");
  MOZ_ASSERT(ActiveScrolledRoot::IsAncestor(aParent, aDescendant));
  const ActiveScrolledRoot* directChild = aDescendant;
  while (directChild->mParent != aParent) {
    directChild = directChild->mParent;
    MOZ_RELEASE_ASSERT(directChild, "this must not be null");
  }
  return directChild;
}

static void FixUpFixedPositionLayer(
    Layer* aLayer, const ActiveScrolledRoot* aTargetASR,
    const ActiveScrolledRoot* aLeafScrollMetadataASR,
    const ActiveScrolledRoot* aContainerScrollMetadataASR,
    const ActiveScrolledRoot* aContainerCompositorASR,
    bool aIsFixedToRootScrollFrame) {
  if (!aLayer->GetIsFixedPosition()) {
    return;
  }

  // Analyze ASRs to figure out if we need to fix up fixedness annotations on
  // the layer. Fixed annotations are required in multiple cases:
  //  - Sometimes we set scroll metadata on a layer for a scroll frame that we
  //    don't want the layer to be moved by. (We have to do this if there is a
  //    scrolled clip that is moved by that scroll frame.) So we set the fixed
  //    annotation so that the compositor knows that it should ignore that
  //    scroll metadata when determining the layer's position.
  //  - Sometimes there is a scroll meta data on aLayer's parent layer for a
  //    scroll frame that we don't want aLayer to be moved by. The most common
  //    way for this to happen is with containerful root scrolling, where the
  //    scroll metadata for the root scroll frame is on a container layer that
  //    wraps the whole document's contents.
  //  - Sometimes it's just needed for hit testing, i.e. figuring out what
  //    scroll frame should be scrolled by events over the layer.
  // A fixed layer needs to be annotated with the scroll ID of the scroll frame
  // that it is *fixed with respect to*, i.e. the outermost scroll frame which
  // does not move the layer. nsDisplayFixedPosition only ever annotates layers
  // with the scroll ID of the presshell's root scroll frame, which is
  // sometimes the wrong thing to do, so we correct it here. Specifically,
  // it's the wrong thing to do if the fixed frame's containing block is a
  // transformed frame - in that case, the fixed frame needs to scroll along
  // with the transformed frame instead of being fixed with respect to the rsf.
  // (It would be nice to compute the annotation only in one place and get it
  // right, instead of fixing it up after the fact like this, but this will
  // need to do for now.)
  // compositorASR is the ASR that the layer would move with on the compositor
  // if there were no fixed annotation on it.
  const ActiveScrolledRoot* compositorASR =
      aLeafScrollMetadataASR == aContainerScrollMetadataASR
          ? aContainerCompositorASR
          : aLeafScrollMetadataASR;

  // The goal of the annotation is to have the layer move with aTargetASR.
  if (compositorASR && aTargetASR != compositorASR) {
    // Mark this layer as fixed with respect to the child scroll frame of
    // aTargetASR.
    aLayer->SetFixedPositionData(
        FindDirectChildASR(aTargetASR, compositorASR)->GetViewId(),
        aLayer->GetFixedPositionAnchor(), aLayer->GetFixedPositionSides());
  } else {
    // Remove the fixed annotation from the layer, unless this layers is fixed
    // to the document's root scroll frame - in that case, the annotation is
    // needed for hit testing, because fixed layers in iframes should scroll
    // the iframe, even though their position is not affected by scrolling in
    // the iframe. (The APZ hit testing code has a special case for this.)
    // nsDisplayFixedPosition has annotated this layer with the document's
    // root scroll frame's scroll id.
    aLayer->SetIsFixedPosition(aIsFixedToRootScrollFrame);
  }
}

void ContainerState::SetupScrollingMetadata(NewLayerEntry* aEntry) {
  if (!mBuilder->IsPaintingToWindow()) {
    // async scrolling not possible, and async scrolling info not computed
    // for this paint.
    return;
  }

  const ActiveScrolledRoot* startASR = aEntry->mScrollMetadataASR;
  const ActiveScrolledRoot* stopASR = mContainerScrollMetadataASR;
  if (!ActiveScrolledRoot::IsAncestor(stopASR, startASR)) {
    if (ActiveScrolledRoot::IsAncestor(startASR, stopASR)) {
      // startASR and stopASR are in the same branch of the ASR tree, but
      // startASR is closer to the root. Just start at stopASR so that the loop
      // below doesn't actually do anything.
      startASR = stopASR;
    } else {
      // startASR and stopASR are in different branches of the
      // ASR tree. Find a common ancestor and make that the stopASR.
      // This can happen when there's a scrollable frame inside a fixed layer
      // which has a scrolled clip. As far as scroll metadata is concerned,
      // the scroll frame's scroll metadata will be a child of the scroll ID
      // that scrolls the clip on the fixed layer. But as far as ASRs are
      // concerned, those two ASRs are siblings, parented to the ASR of the
      // fixed layer.
      do {
        stopASR = stopASR->mParent;
      } while (!ActiveScrolledRoot::IsAncestor(stopASR, startASR));
    }
  }

  FixUpFixedPositionLayer(aEntry->mLayer, aEntry->mASR, startASR,
                          mContainerScrollMetadataASR, mContainerCompositorASR,
                          aEntry->mIsFixedToRootScrollFrame);

  AutoTArray<ScrollMetadata, 2> metricsArray;
  if (aEntry->mBaseScrollMetadata) {
    metricsArray.AppendElement(*aEntry->mBaseScrollMetadata);

    // The base FrameMetrics was not computed by the nsIScrollableframe, so it
    // should not have a mask layer.
    MOZ_ASSERT(!aEntry->mBaseScrollMetadata->HasMaskLayer());
  }

  // Any extra mask layers we need to attach to ScrollMetadatas.
  // The list may already contain an entry added for the layer's scrolled clip
  // so add to it rather than overwriting it (we clear the list when recycling
  // a layer).
  nsTArray<RefPtr<Layer>> maskLayers(
      aEntry->mLayer->GetAllAncestorMaskLayers().Clone());

  // Iterate over the ASR chain and create the corresponding scroll metadatas.
  // This loop is slightly tricky because the scrollframe-to-clip relationship
  // is reversed between DisplayItemClipChain and ScrollMetadata:
  //  - DisplayItemClipChain associates the clip with the scroll frame that
  //    this clip is *moved by*, i.e. the clip is moving inside the scroll
  //    frame.
  //  - ScrollMetaData associates the scroll frame with the clip that's
  //    *just outside* the scroll frame, i.e. not moved by the scroll frame
  //    itself.
  // This discrepancy means that the leaf clip item of the clip chain is never
  // applied to any scroll meta data. Instead, it was applied earlier as the
  // layer's clip (or fused with the painted layer contents), or it was applied
  // as a ScrolledClip on the layer.
  const DisplayItemClipChain* clipChain = aEntry->mClipChain;

  for (const ActiveScrolledRoot* asr = startASR; asr != stopASR;
       asr = asr->mParent) {
    if (!asr) {
      MOZ_ASSERT_UNREACHABLE("Should have encountered stopASR on the way up.");
      break;
    }
    if (clipChain && clipChain->mASR == asr) {
      clipChain = clipChain->mParent;
    }

    nsIScrollableFrame* scrollFrame = asr->mScrollableFrame;
    const DisplayItemClip* clip = (clipChain && clipChain->mASR == asr->mParent)
                                      ? &clipChain->mClip
                                      : nullptr;

    scrollFrame->ClipLayerToDisplayPort(aEntry->mLayer, clip, mParameters);

    Maybe<ScrollMetadata> metadata;
    if (mCachedScrollMetadata.mASR == asr &&
        mCachedScrollMetadata.mClip == clip) {
      metadata = mCachedScrollMetadata.mMetadata;
    } else {
      metadata = scrollFrame->ComputeScrollMetadata(aEntry->mLayer->Manager(),
                                                    mContainerReferenceFrame,
                                                    Some(mParameters), clip);
      mBuilder->AddScrollFrameToNotify(scrollFrame);
      mCachedScrollMetadata.mASR = asr;
      mCachedScrollMetadata.mClip = clip;
      mCachedScrollMetadata.mMetadata = metadata;
    }

    if (!metadata) {
      continue;
    }

    if (clip && clip->HasClip() && clip->GetRoundedRectCount() > 0) {
      // The clip in between this scrollframe and its ancestor scrollframe
      // requires a mask layer. Since this mask layer should not move with
      // the APZC associated with this FrameMetrics, we attach the mask
      // layer as an additional, separate clip.
      Maybe<size_t> nextIndex = Some(maskLayers.Length());
      RefPtr<Layer> maskLayer =
          CreateMaskLayer(aEntry->mLayer, *clip, nextIndex);
      if (maskLayer) {
        MOZ_ASSERT(metadata->HasScrollClip());
        metadata->ScrollClip().SetMaskLayerIndex(nextIndex);
        maskLayers.AppendElement(maskLayer);
      }
    }

    metricsArray.AppendElement(*metadata);
  }

  // Watch out for FrameMetrics copies in profiles
  aEntry->mLayer->SetScrollMetadata(metricsArray);
  aEntry->mLayer->SetAncestorMaskLayers(maskLayers);
}

static inline Maybe<ParentLayerIntRect> GetStationaryClipInContainer(
    Layer* aLayer) {
  if (size_t metricsCount = aLayer->GetScrollMetadataCount()) {
    return aLayer->GetScrollMetadata(metricsCount - 1).GetClipRect();
  }
  return aLayer->GetClipRect();
}

void ContainerState::PostprocessRetainedLayers(
    nsIntRegion* aOpaqueRegionForContainer) {
  AutoTArray<OpaqueRegionEntry, 4> opaqueRegions;
  bool hideAll = false;
  int32_t opaqueRegionForContainer = -1;

  for (int32_t i = mNewChildLayers.Length() - 1; i >= 0; --i) {
    NewLayerEntry* e = &mNewChildLayers.ElementAt(i);
    if (!e->mLayer) {
      continue;
    }

    OpaqueRegionEntry* data =
        FindOpaqueRegionEntry(opaqueRegions, e->mAnimatedGeometryRoot, e->mASR);

    SetupScrollingMetadata(e);

    if (hideAll) {
      e->mVisibleRegion.SetEmpty();
    } else if (!e->mLayer->IsScrollbarContainer()) {
      Maybe<ParentLayerIntRect> clipRect =
          GetStationaryClipInContainer(e->mLayer);
      if (clipRect && opaqueRegionForContainer >= 0 &&
          opaqueRegions[opaqueRegionForContainer].mOpaqueRegion.Contains(
              clipRect->ToUnknownRect())) {
        e->mVisibleRegion.SetEmpty();
      } else if (data) {
        e->mVisibleRegion.Sub(e->mVisibleRegion, data->mOpaqueRegion);
      }
    }

    SetOuterVisibleRegionForLayer(e->mLayer, e->mVisibleRegion,
                                  e->mLayerContentsVisibleRect.width >= 0
                                      ? &e->mLayerContentsVisibleRect
                                      : nullptr,
                                  e->mUntransformedVisibleRegion);

    if (!e->mOpaqueRegion.IsEmpty()) {
      AnimatedGeometryRoot* animatedGeometryRootToCover =
          e->mAnimatedGeometryRoot;
      const ActiveScrolledRoot* asrToCover = e->mASR;
      if (e->mOpaqueForAnimatedGeometryRootParent &&
          e->mAnimatedGeometryRoot->mParentAGR ==
              mContainerAnimatedGeometryRoot) {
        animatedGeometryRootToCover = mContainerAnimatedGeometryRoot;
        asrToCover = mContainerASR;
        data = FindOpaqueRegionEntry(opaqueRegions, animatedGeometryRootToCover,
                                     asrToCover);
      }

      if (!data) {
        if (animatedGeometryRootToCover == mContainerAnimatedGeometryRoot &&
            asrToCover == mContainerASR) {
          NS_ASSERTION(opaqueRegionForContainer == -1, "Already found it?");
          opaqueRegionForContainer = opaqueRegions.Length();
        }
        data = opaqueRegions.AppendElement();
        data->mAnimatedGeometryRoot = animatedGeometryRootToCover;
        data->mASR = asrToCover;
      }

      nsIntRegion clippedOpaque = e->mOpaqueRegion;
      Maybe<ParentLayerIntRect> clipRect = e->mLayer->GetCombinedClipRect();
      if (clipRect) {
        clippedOpaque.AndWith(clipRect->ToUnknownRect());
      }
      if (e->mLayer->GetScrolledClip()) {
        // The clip can move asynchronously, so we can't rely on opaque parts
        // staying visible.
        clippedOpaque.SetEmpty();
      } else if (e->mHideAllLayersBelow) {
        hideAll = true;
      }
      data->mOpaqueRegion.Or(data->mOpaqueRegion, clippedOpaque);
    }

    if (e->mLayer->GetType() == Layer::TYPE_READBACK) {
      // ReadbackLayers need to accurately read what's behind them. So,
      // we don't want to do any occlusion culling of layers behind them.
      // Theoretically we could just punch out the ReadbackLayer's rectangle
      // from all mOpaqueRegions, but that's probably not worth doing.
      opaqueRegions.Clear();
      opaqueRegionForContainer = -1;
    }
  }

  if (opaqueRegionForContainer >= 0) {
    aOpaqueRegionForContainer->Or(
        *aOpaqueRegionForContainer,
        opaqueRegions[opaqueRegionForContainer].mOpaqueRegion);
  }
}

void ContainerState::Finish(uint32_t* aTextContentFlags,
                            const nsIntRect& aContainerPixelBounds,
                            nsDisplayList* aChildItems) {
  mPaintedLayerDataTree.Finish();

  NS_ASSERTION(mContainerBounds.IsEqualInterior(mAccumulatedChildBounds),
               "Bounds computation mismatch");

  if (mLayerBuilder->IsBuildingRetainedLayers()) {
    nsIntRegion containerOpaqueRegion;
    PostprocessRetainedLayers(&containerOpaqueRegion);
    if (containerOpaqueRegion.Contains(aContainerPixelBounds)) {
      aChildItems->SetIsOpaque();
    }
  }

  uint32_t textContentFlags = 0;

  // Make sure that current/existing layers are added to the parent and are
  // in the correct order.
  Layer* layer = nullptr;
  Layer* prevChild = nullptr;
  for (uint32_t i = 0; i < mNewChildLayers.Length(); ++i, prevChild = layer) {
    if (!mNewChildLayers[i].mLayer) {
      continue;
    }

    layer = mNewChildLayers[i].mLayer;

    if (!layer->GetVisibleRegion().IsEmpty()) {
      textContentFlags |= layer->GetContentFlags() &
                          (Layer::CONTENT_COMPONENT_ALPHA |
                           Layer::CONTENT_COMPONENT_ALPHA_DESCENDANT |
                           Layer::CONTENT_DISABLE_FLATTENING);
    }

    if (!layer->GetParent()) {
      // This is not currently a child of the container, so just add it
      // now.
      mContainerLayer->InsertAfter(layer, prevChild);
    } else {
      NS_ASSERTION(layer->GetParent() == mContainerLayer,
                   "Layer shouldn't be the child of some other container");
      if (layer->GetPrevSibling() != prevChild) {
        mContainerLayer->RepositionChild(layer, prevChild);
      }
    }
  }

  // Remove old layers that have become unused.
  if (!layer) {
    layer = mContainerLayer->GetFirstChild();
  } else {
    layer = layer->GetNextSibling();
  }
  while (layer) {
    Layer* layerToRemove = layer;
    layer = layer->GetNextSibling();
    mContainerLayer->RemoveChild(layerToRemove);
  }

  *aTextContentFlags = textContentFlags;
}

static void RestrictScaleToMaxLayerSize(Size& aScale,
                                        const nsRect& aVisibleRect,
                                        nsIFrame* aContainerFrame,
                                        Layer* aContainerLayer) {
  if (!aContainerLayer->Manager()->IsWidgetLayerManager()) {
    return;
  }

  nsIntRect pixelSize = aVisibleRect.ScaleToOutsidePixels(
      aScale.width, aScale.height,
      aContainerFrame->PresContext()->AppUnitsPerDevPixel());

  int32_t maxLayerSize = aContainerLayer->GetMaxLayerSize();

  if (pixelSize.width > maxLayerSize) {
    float scale = (float)pixelSize.width / maxLayerSize;
    scale = gfxUtils::ClampToScaleFactor(scale);
    aScale.width /= scale;
  }
  if (pixelSize.height > maxLayerSize) {
    float scale = (float)pixelSize.height / maxLayerSize;
    scale = gfxUtils::ClampToScaleFactor(scale);
    aScale.height /= scale;
  }
}

static nsSize ComputeDesiredDisplaySizeForAnimation(nsIFrame* aContainerFrame) {
  // Use the size of the nearest widget as the maximum size.  This
  // is important since it might be a popup that is bigger than the
  // pres context's size.
  nsPresContext* presContext = aContainerFrame->PresContext();
  nsIWidget* widget = aContainerFrame->GetNearestWidget();
  if (widget) {
    return LayoutDevicePixel::ToAppUnits(widget->GetClientSize(),
                                         presContext->AppUnitsPerDevPixel());
  }

  return presContext->GetVisibleArea().Size();
}

/* static */
Size FrameLayerBuilder::ChooseScale(nsIFrame* aContainerFrame,
                                    nsDisplayItem* aContainerItem,
                                    const nsRect& aVisibleRect, float aXScale,
                                    float aYScale, const Matrix& aTransform2d,
                                    bool aCanDraw2D) {
  Size scale;
  // XXX Should we do something for 3D transforms?
  if (aCanDraw2D && !aContainerFrame->Combines3DTransformWithAncestors() &&
      !aContainerFrame->HasPerspective()) {
    // If the container's transform is animated off main thread, fix a suitable
    // scale size for animation
    if (aContainerItem &&
        aContainerItem->GetType() == DisplayItemType::TYPE_TRANSFORM &&
        // FIXME: What we need is only transform, rotate, and scale, not
        // translate, so it's be better to use a property set, instead of
        // display item type here.
        EffectCompositor::HasAnimationsForCompositor(
            aContainerFrame, DisplayItemType::TYPE_TRANSFORM)) {
      nsSize displaySize =
          ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
      // compute scale using the animation on the container, taking ancestors in
      // to account
      nsSize scaledVisibleSize = nsSize(aVisibleRect.Width() * aXScale,
                                        aVisibleRect.Height() * aYScale);
      scale = nsLayoutUtils::ComputeSuitableScaleForAnimation(
          aContainerFrame, scaledVisibleSize, displaySize);
      // multiply by the scale inherited from ancestors--we use a uniform
      // scale factor to prevent blurring when the layer is rotated.
      float incomingScale = std::max(aXScale, aYScale);
      scale.width *= incomingScale;
      scale.height *= incomingScale;
    } else {
      // Scale factors are normalized to a power of 2 to reduce the number of
      // resolution changes
      scale = aTransform2d.ScaleFactors();
      // For frames with a changing scale transform round scale factors up to
      // nearest power-of-2 boundary so that we don't keep having to redraw
      // the content as it scales up and down. Rounding up to nearest
      // power-of-2 boundary ensures we never scale up, only down --- avoiding
      // jaggies. It also ensures we never scale down by more than a factor of
      // 2, avoiding bad downscaling quality.
      Matrix frameTransform;
      if (ActiveLayerTracker::IsScaleSubjectToAnimation(aContainerFrame)) {
        scale.width = gfxUtils::ClampToScaleFactor(scale.width);
        scale.height = gfxUtils::ClampToScaleFactor(scale.height);

        // Limit animated scale factors to not grow excessively beyond the
        // display size.
        nsSize maxScale(4, 4);
        if (!aVisibleRect.IsEmpty()) {
          nsSize displaySize =
              ComputeDesiredDisplaySizeForAnimation(aContainerFrame);
          maxScale = Max(maxScale, displaySize / aVisibleRect.Size());
        }
        if (scale.width > maxScale.width) {
          scale.width = gfxUtils::ClampToScaleFactor(maxScale.width, true);
        }
        if (scale.height > maxScale.height) {
          scale.height = gfxUtils::ClampToScaleFactor(maxScale.height, true);
        }
      } else {
        // XXX Do we need to move nearly-integer values to integers here?
      }
    }
    // If the scale factors are too small, just use 1.0. The content is being
    // scaled out of sight anyway.
    if (fabs(scale.width) < 1e-8 || fabs(scale.height) < 1e-8) {
      scale = Size(1.0, 1.0);
    }
  } else {
    scale = Size(1.0, 1.0);
  }

  // Prevent the scale from getting too large, to avoid excessive memory
  // allocation. Usually memory allocation is limited by the visible region,
  // which should be restricted to the display port. But at very large scales
  // the visible region itself can become excessive due to rounding errors.
  // Clamping the scale here prevents that.
  scale =
      Size(std::min(scale.width, 32768.0f), std::min(scale.height, 32768.0f));

  return scale;
}

static bool ChooseScaleAndSetTransform(
    FrameLayerBuilder* aLayerBuilder, nsDisplayListBuilder* aDisplayListBuilder,
    nsIFrame* aContainerFrame, nsDisplayItem* aContainerItem,
    const nsRect& aVisibleRect, const Matrix4x4* aTransform,
    const ContainerLayerParameters& aIncomingScale, ContainerLayer* aLayer,
    ContainerLayerParameters& aOutgoingScale) {
  nsIntPoint offset;

  Matrix4x4 transform =
      Matrix4x4::Scaling(aIncomingScale.mXScale, aIncomingScale.mYScale, 1.0);
  if (aTransform) {
    // aTransform is applied first, then the scale is applied to the result
    transform = (*aTransform) * transform;
    // Set any matrix entries close to integers to be those exact integers.
    // This protects against floating-point inaccuracies causing problems
    // in the checks below.
    // We use the fixed epsilon version here because we don't want the nudging
    // to depend on the scroll position.
    transform.NudgeToIntegersFixedEpsilon();
  }
  Matrix transform2d;
  if (aContainerFrame && aLayerBuilder->GetContainingPaintedLayerData() &&
      (!aTransform ||
       (aTransform->Is2D(&transform2d) && !transform2d.HasNonTranslation()))) {
    // When we have an inactive ContainerLayer, translate the container by the
    // offset to the reference frame (and offset all child layers by the
    // reverse) so that the coordinate space of the child layers isn't affected
    // by scrolling. This gets confusing for complicated transform (since we'd
    // have to compute the scale factors for the matrix), so we don't bother.
    // Any frames that are building an nsDisplayTransform for a css transform
    // would have 0,0 as their offset to the reference frame, so this doesn't
    // matter.
    nsPoint appUnitOffset =
        aDisplayListBuilder->ToReferenceFrame(aContainerFrame);
    nscoord appUnitsPerDevPixel =
        aContainerFrame->PresContext()->AppUnitsPerDevPixel();
    offset = nsIntPoint(NS_lround(NSAppUnitsToDoublePixels(
                                      appUnitOffset.x, appUnitsPerDevPixel) *
                                  aIncomingScale.mXScale),
                        NS_lround(NSAppUnitsToDoublePixels(
                                      appUnitOffset.y, appUnitsPerDevPixel) *
                                  aIncomingScale.mYScale));
  }
  transform.PostTranslate(offset.x + aIncomingScale.mOffset.x,
                          offset.y + aIncomingScale.mOffset.y, 0);

  if (transform.IsSingular()) {
    return false;
  }

  bool canDraw2D = transform.CanDraw2D(&transform2d);
  Size scale = FrameLayerBuilder::ChooseScale(
      aContainerFrame, aContainerItem, aVisibleRect, aIncomingScale.mXScale,
      aIncomingScale.mYScale, transform2d, canDraw2D);

  // If this is a transform container layer, then pre-rendering might
  // mean we try render a layer bigger than the max texture size. If we have
  // tiling, that's not a problem, since we'll automatically choose a tiled
  // layer for layers of that size. If not, we need to apply clamping to
  // prevent this.
  if (aTransform && !StaticPrefs::layers_enable_tiles_AtStartup()) {
    RestrictScaleToMaxLayerSize(scale, aVisibleRect, aContainerFrame, aLayer);
  }

  // Store the inverse of our resolution-scale on the layer
  aLayer->SetBaseTransform(transform);
  aLayer->SetPreScale(1.0f / scale.width, 1.0f / scale.height);
  aLayer->SetInheritedScale(aIncomingScale.mXScale, aIncomingScale.mYScale);

  aOutgoingScale = ContainerLayerParameters(scale.width, scale.height, -offset,
                                            aIncomingScale);
  if (aTransform) {
    aOutgoingScale.mInTransformedSubtree = true;
    if (ActiveLayerTracker::IsTransformAnimated(aDisplayListBuilder,
                                                aContainerFrame)) {
      aOutgoingScale.mInActiveTransformedSubtree = true;
    }
  }
  if ((aLayerBuilder->IsBuildingRetainedLayers() &&
       (!canDraw2D || transform2d.HasNonIntegerTranslation())) ||
      aContainerFrame->Extend3DContext() ||
      aContainerFrame->Combines3DTransformWithAncestors() ||
      // For async transform animation, the value would be changed at
      // any time, integer translation is not always true.
      aContainerFrame->HasAnimationOfTransform()) {
    aOutgoingScale.mDisableSubpixelAntialiasingInDescendants = true;
  }
  return true;
}

already_AddRefed<ContainerLayer> FrameLayerBuilder::BuildContainerLayerFor(
    nsDisplayListBuilder* aBuilder, LayerManager* aManager,
    nsIFrame* aContainerFrame, nsDisplayItem* aContainerItem,
    nsDisplayList* aChildren, const ContainerLayerParameters& aParameters,
    const Matrix4x4* aTransform, uint32_t aFlags) {
  uint32_t containerDisplayItemKey =
      aContainerItem ? aContainerItem->GetPerFrameKey() : 0;
  NS_ASSERTION(aContainerFrame,
               "Container display items here should have a frame");
  NS_ASSERTION(!aContainerItem || aContainerItem->Frame() == aContainerFrame,
               "Container display item must match given frame");

  if (!aParameters.mXScale || !aParameters.mYScale) {
    return nullptr;
  }

  RefPtr<ContainerLayer> containerLayer;
  if (aManager == mRetainingManager) {
    // Using GetOldLayerFor will search merged frames, as well as the underlying
    // frame. The underlying frame can change when a page scrolls, so this
    // avoids layer recreation in the situation that a new underlying frame is
    // picked for a layer.
    Layer* oldLayer = nullptr;
    if (aContainerItem) {
      oldLayer = GetOldLayerFor(aContainerItem);
    } else {
      DisplayItemData* data =
          GetOldLayerForFrame(aContainerFrame, containerDisplayItemKey);
      if (data) {
        oldLayer = data->mLayer;
      }
    }

    if (oldLayer) {
      NS_ASSERTION(oldLayer->Manager() == aManager, "Wrong manager");
      if (oldLayer->HasUserData(&gPaintedDisplayItemLayerUserData)) {
        // The old layer for this item is actually our PaintedLayer
        // because we rendered its layer into that PaintedLayer. So we
        // don't actually have a retained container layer.
      } else {
        NS_ASSERTION(oldLayer->GetType() == Layer::TYPE_CONTAINER,
                     "Wrong layer type");
        containerLayer = static_cast<ContainerLayer*>(oldLayer);
        ResetLayerStateForRecycling(containerLayer);
      }
    }
  }
  if (!containerLayer) {
    // No suitable existing layer was found.
    containerLayer = aManager->CreateContainerLayer();
    if (!containerLayer) return nullptr;
  }

  if (aContainerItem &&
      aContainerItem->GetType() == DisplayItemType::TYPE_SCROLL_INFO_LAYER) {
    // Empty layers only have metadata and should never have display items. We
    // early exit because later, invalidation will walk up the frame tree to
    // determine which painted layer gets invalidated. Since an empty layer
    // should never have anything to paint, it should never be invalidated.
    NS_ASSERTION(aChildren->IsEmpty(), "Should have no children");
    return containerLayer.forget();
  }

  const ActiveScrolledRoot* containerASR =
      aContainerItem ? aContainerItem->GetActiveScrolledRoot() : nullptr;
  const ActiveScrolledRoot* containerScrollMetadataASR =
      aParameters.mScrollMetadataASR;
  const ActiveScrolledRoot* containerCompositorASR = aParameters.mCompositorASR;

  ContainerLayerParameters scaleParameters;
  nsRect bounds =
      aChildren->GetClippedBoundsWithRespectToASR(aBuilder, containerASR);
  nsRect childrenVisible =
      aContainerItem ? aContainerItem->GetBuildingRectForChildren()
                     : aContainerFrame->InkOverflowRectRelativeToSelf();
  if (!ChooseScaleAndSetTransform(
          this, aBuilder, aContainerFrame, aContainerItem,
          bounds.Intersect(childrenVisible), aTransform, aParameters,
          containerLayer, scaleParameters)) {
    return nullptr;
  }

  if (mRetainingManager) {
    if (aContainerItem) {
      nsPaintedDisplayItem* item = aContainerItem->AsPaintedDisplayItem();
      MOZ_ASSERT(item, "Only painted display items should build layers");

      DisplayItemData* data =
          GetDisplayItemDataForManager(item, mRetainingManager);
      StoreDataForFrame(item, containerLayer, LayerState::LAYER_ACTIVE, data);
    } else {
      StoreDataForFrame(aContainerFrame, containerDisplayItemKey,
                        containerLayer, LayerState::LAYER_ACTIVE);
    }
  }

  nsIntRect pixBounds;
  nscoord appUnitsPerDevPixel;

  nscolor backgroundColor = NS_RGBA(0, 0, 0, 0);
  if (aFlags & CONTAINER_ALLOW_PULL_BACKGROUND_COLOR) {
    backgroundColor = aParameters.mBackgroundColor;
  }

  uint32_t flags;
  ContainerState state(aBuilder, aManager, aManager->GetLayerBuilder(),
                       aContainerFrame, aContainerItem, bounds, containerLayer,
                       scaleParameters, backgroundColor, containerASR,
                       containerScrollMetadataASR, containerCompositorASR);

  state.ProcessDisplayItems(aChildren);

  // Set CONTENT_COMPONENT_ALPHA if any of our children have it.
  // This is suboptimal ... a child could have text that's over transparent
  // pixels in its own layer, but over opaque parts of previous siblings.
  pixBounds = state.ScaleToOutsidePixels(bounds, false);
  appUnitsPerDevPixel = state.GetAppUnitsPerDevPixel();
  state.Finish(&flags, pixBounds, aChildren);

  // CONTENT_COMPONENT_ALPHA is propogated up to the nearest CONTENT_OPAQUE
  // ancestor so that BasicLayerManager knows when to copy the background into
  // pushed groups. Accelerated layers managers can't necessarily do this (only
  // when the visible region is a simple rect), so we propogate
  // CONTENT_COMPONENT_ALPHA_DESCENDANT all the way to the root.
  if (flags & Layer::CONTENT_COMPONENT_ALPHA) {
    flags |= Layer::CONTENT_COMPONENT_ALPHA_DESCENDANT;
  }

  // Make sure that rounding the visible region out didn't add any area
  // we won't paint
  if (aChildren->IsOpaque() && !aChildren->NeedsTransparentSurface()) {
    bounds.ScaleRoundIn(scaleParameters.mXScale, scaleParameters.mYScale);
    if (bounds.Contains(ToAppUnits(pixBounds, appUnitsPerDevPixel))) {
      // Clear CONTENT_COMPONENT_ALPHA and add CONTENT_OPAQUE instead.
      flags &= ~Layer::CONTENT_COMPONENT_ALPHA;
      flags |= Layer::CONTENT_OPAQUE;
    }
  }
  if (nsLayoutUtils::ShouldSnapToGrid(aContainerFrame)) {
    flags |= Layer::CONTENT_SNAP_TO_GRID;
  }
  containerLayer->SetContentFlags(flags);
  // If aContainerItem is non-null some BuildContainerLayer further up the
  // call stack is responsible for setting containerLayer's visible region.
  if (!aContainerItem) {
    containerLayer->SetVisibleRegion(
        LayerIntRegion::FromUnknownRegion(pixBounds));
  }
  if (aParameters.mLayerContentsVisibleRect) {
    *aParameters.mLayerContentsVisibleRect =
        pixBounds + scaleParameters.mOffset;
  }

  nsPresContext::ClearNotifySubDocInvalidationData(containerLayer);

  return containerLayer.forget();
}

Layer* FrameLayerBuilder::GetLeafLayerFor(nsDisplayListBuilder* aBuilder,
                                          nsDisplayItem* aItem) {
  Layer* layer = GetOldLayerFor(aItem);
  if (!layer) {
    return nullptr;
  }
  if (layer->HasUserData(&gPaintedDisplayItemLayerUserData)) {
    // This layer was created to render Thebes-rendered content for this
    // display item. The display item should not use it for its own
    // layer rendering.
    return nullptr;
  }
  ResetLayerStateForRecycling(layer);
  return layer;
}

/* static */
void FrameLayerBuilder::InvalidateAllLayers(LayerManager* aManager) {
  LayerManagerData* data = static_cast<LayerManagerData*>(
      aManager->GetUserData(&gLayerManagerUserData));
  if (data) {
    data->mInvalidateAllLayers = true;
  }
}

/* static */
void FrameLayerBuilder::InvalidateAllLayersForFrame(nsIFrame* aFrame) {
  for (auto* did : GetDisplayItemDataArray(aFrame)) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    data->mParent->mInvalidateAllLayers = true;
  }
}

/* static */
Layer* FrameLayerBuilder::GetDedicatedLayer(nsIFrame* aFrame,
                                            DisplayItemType aDisplayItemKey) {
  // TODO: This isn't completely correct, since a frame could exist as a layer
  // in the normal widget manager, and as a different layer (or no layer)
  // in the secondary manager
  for (auto* did : GetDisplayItemDataArray(aFrame)) {
    DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
    if (!data->mParent->mLayerManager->IsWidgetLayerManager()) {
      continue;
    }

    if (GetDisplayItemTypeFromKey(data->mDisplayItemKey) == aDisplayItemKey) {
      if (data->mOptLayer) {
        return data->mOptLayer;
      }

      Layer* layer = data->mLayer;
      if (!layer->HasUserData(&gColorLayerUserData) &&
          !layer->HasUserData(&gImageLayerUserData) &&
          !layer->HasUserData(&gPaintedDisplayItemLayerUserData)) {
        return layer;
      }
    }
  }

  return nullptr;
}

/* static */
void FrameLayerBuilder::EnumerateGenerationForDedicatedLayers(
    const nsIFrame* aFrame, AnimationGenerationCallback aCallback) {
  std::bitset<static_cast<uint32_t>(DisplayItemType::TYPE_MAX)> notFoundTypes;
  for (auto displayItemType : LayerAnimationInfo::sDisplayItemTypes) {
    notFoundTypes.set(static_cast<uint32_t>(displayItemType));
  }

  for (auto displayItemType : LayerAnimationInfo::sDisplayItemTypes) {
    // For transform animations, the animation is on the primary frame but
    // |aFrame| is the style frame.
    const nsIFrame* frameToQuery =
        displayItemType == DisplayItemType::TYPE_TRANSFORM
            ? nsLayoutUtils::GetPrimaryFrameFromStyleFrame(aFrame)
            : aFrame;

    for (auto* did : GetDisplayItemDataArray(frameToQuery)) {
      DisplayItemData* data = DisplayItemData::AssertDisplayItemData(did);
      if (!data->mParent->mLayerManager->IsWidgetLayerManager()) {
        continue;
      }

      if (GetDisplayItemTypeFromKey(data->mDisplayItemKey) != displayItemType) {
        continue;
      }

      notFoundTypes.reset(static_cast<uint32_t>(displayItemType));

      Maybe<uint64_t> generation;
      if (data->mOptLayer) {
        generation = data->mOptLayer->GetAnimationGeneration();
      } else if (!data->mLayer->HasUserData(&gColorLayerUserData) &&
                 !data->mLayer->HasUserData(&gImageLayerUserData) &&
                 !data->mLayer->HasUserData(
                     &gPaintedDisplayItemLayerUserData)) {
        generation = data->mLayer->GetAnimationGeneration();
      }

      if (!aCallback(generation, displayItemType)) {
        return;
      }

      break;
    }
  }

  // Bail out if we have already enumerated all possible layers for the given
  // display item types.
  if (notFoundTypes.none()) {
    return;
  }

  // If there are any display item types that the nsIFrame doesn't have, we need
  // to call the callback function for them respectively.
  for (auto displayItemType : LayerAnimationInfo::sDisplayItemTypes) {
    if (notFoundTypes[static_cast<uint32_t>(displayItemType)] &&
        !aCallback(Nothing(), displayItemType)) {
      return;
    }
  }
}

gfxSize FrameLayerBuilder::GetPaintedLayerScaleForFrame(nsIFrame* aFrame) {
  MOZ_ASSERT(aFrame, "need a frame");

  nsPresContext* presCtx = aFrame->PresContext()->GetRootPresContext();

  if (!presCtx) {
    presCtx = aFrame->PresContext();
    MOZ_ASSERT(presCtx);
  }

  nsIFrame* root = presCtx->PresShell()->GetRootFrame();

  MOZ_ASSERT(root);

  float resolution = presCtx->PresShell()->GetResolution();

  Matrix4x4Flagged transform = Matrix4x4::Scaling(resolution, resolution, 1.0);
  if (aFrame != root) {
    // aTransform is applied first, then the scale is applied to the result
    transform = nsLayoutUtils::GetTransformToAncestor(RelativeTo{aFrame},
                                                      RelativeTo{root}) *
                transform;
  }

  Matrix transform2d;
  if (transform.CanDraw2D(&transform2d)) {
    return ThebesMatrix(transform2d).ScaleFactors();
  }

  return gfxSize(1.0, 1.0);
}

#ifdef MOZ_DUMP_PAINTING
static void DebugPaintItem(DrawTarget& aDrawTarget, nsPresContext* aPresContext,
                           nsPaintedDisplayItem* aItem,
                           nsDisplayListBuilder* aBuilder) {
  bool snap;
  Rect bounds = NSRectToRect(aItem->GetBounds(aBuilder, &snap),
                             aPresContext->AppUnitsPerDevPixel());

  const IntSize size = IntSize::Truncate(bounds.width, bounds.height);
  if (size.IsEmpty()) {
    return;
  }

  RefPtr<DrawTarget> tempDT =
      aDrawTarget.CreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8);
  RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempDT);
  if (!context) {
    // Leave this as crash, it's in the debugging code, we want to know
    gfxDevCrash(LogReason::InvalidContext)
        << "DebugPaintItem context problem " << gfx::hexa(tempDT);
    return;
  }
  context->SetMatrix(Matrix::Translation(-bounds.x, -bounds.y));

  aItem->Paint(aBuilder, context);
  RefPtr<SourceSurface> surface = tempDT->Snapshot();
  DumpPaintedImage(aItem, surface);

  aDrawTarget.DrawSurface(surface, bounds, Rect(Point(0, 0), bounds.Size()));

  aItem->SetPainted();
}
#endif

/* static */
void FrameLayerBuilder::RecomputeVisibilityForItems(
    std::vector<AssignedDisplayItem>& aItems, nsDisplayListBuilder* aBuilder,
    const nsIntRegion& aRegionToDraw, nsRect& aPreviousRectToDraw,
    const nsIntPoint& aOffset, int32_t aAppUnitsPerDevPixel, float aXScale,
    float aYScale) {
  // Update visible regions. We perform visibility analysis to take account
  // of occlusion culling.
  nsRegion visible = aRegionToDraw.ToAppUnits(aAppUnitsPerDevPixel);
  visible.MoveBy(NSIntPixelsToAppUnits(aOffset.x, aAppUnitsPerDevPixel),
                 NSIntPixelsToAppUnits(aOffset.y, aAppUnitsPerDevPixel));
  visible.ScaleInverseRoundOut(aXScale, aYScale);

  // We're going to read from previousRectToDraw for every iteration, let's do
  // that on the stack, and just update the heap allocated one now. By the end
  // of this function {visible} will have been modified by occlusion culling.
  nsRect previousRectToDraw = aPreviousRectToDraw;
  aPreviousRectToDraw = visible.GetBounds();

  for (uint32_t i = aItems.size(); i > 0; --i) {
    AssignedDisplayItem* cdi = &aItems[i - 1];
    if (!cdi->mItem) {
      continue;
    }

    if (cdi->mHasPaintRect &&
        !cdi->mContentRect.Intersects(visible.GetBounds()) &&
        !cdi->mContentRect.Intersects(previousRectToDraw)) {
      continue;
    }

    if (IsEffectEndMarker(cdi->mType) || cdi->HasOpacity() ||
        cdi->HasTransform()) {
      // The visibility calculations are skipped when the item is an effect end
      // marker, or when the display item is within a flattened effect group.
      // This is because RecomputeVisibility has already been called for the
      // group item, and all the children.
      continue;
    }

    const DisplayItemClip& clip = cdi->mItem->GetClip();

    NS_ASSERTION(AppUnitsPerDevPixel(cdi->mItem) == aAppUnitsPerDevPixel,
                 "a painted layer should contain items only at the same zoom");

    MOZ_ASSERT(clip.HasClip() || clip.GetRoundedRectCount() == 0,
               "If we have rounded rects, we must have a clip rect");

    if (!clip.IsRectAffectedByClip(visible.GetBounds())) {
      cdi->mItem->RecomputeVisibility(aBuilder, &visible);
      continue;
    }

    // Do a little dance to account for the fact that we're clipping
    // to cdi->mClipRect
    nsRegion clipped;
    clipped.And(visible, clip.NonRoundedIntersection());
    nsRegion finalClipped = clipped;
    cdi->mItem->RecomputeVisibility(aBuilder, &finalClipped);
    // If we have rounded clip rects, don't subtract from the visible
    // region since we aren't displaying everything inside the rect.
    if (clip.GetRoundedRectCount() == 0) {
      nsRegion removed;
      removed.Sub(clipped, finalClipped);
      nsRegion newVisible;
      newVisible.Sub(visible, removed);
      // Don't let the visible region get too complex.
      if (newVisible.GetNumRects() <= 15) {
        visible = std::move(newVisible);
      }
    }
  }
}

/**
 * Tracks and caches the item clip.
 */
struct ItemClipTracker {
  explicit ItemClipTracker(gfxContext* aContext,
                           const int32_t aAppUnitsPerDevPixel)
      : mContext(aContext),
        mHasClip(false),
        mAppUnitsPerDevPixel(aAppUnitsPerDevPixel) {}

  /**
   * Returns true if a clip is set.
   */
  bool HasClip() const { return mHasClip; }

  /**
   * Returns true if the given |aClip| is set.
   */
  bool HasClip(const DisplayItemClip* aClip) const {
    MOZ_ASSERT(aClip && aClip->HasClip());
    return mHasClip && mCurrentClip == *aClip;
  }

  /**
   * Removes the clip, if there is one.
   */
  void Restore() {
    if (mCurrentClip.HasClip()) {
      mCurrentClip = DisplayItemClip::NoClip();
    }

    if (!HasClip()) {
      return;
    }

    mContext->Restore();
    mHasClip = false;
  };

  /**
   * Sets the clip to |aClip|, if it is not set already.
   */
  void ChangeClipIfNeeded(const DisplayItemClip* aClip) {
    MOZ_ASSERT(aClip && aClip->HasClip());

    if (HasClip(aClip)) {
      // Reuse the old clip.
      return;
    }

    // Remove the previous clip and save the current state.
    Restore();
    mContext->Save();

    // Apply the new clip.
    mHasClip = true;
    mCurrentClip = *aClip;
    mCurrentClip.ApplyTo(mContext, mAppUnitsPerDevPixel);
    mContext->NewPath();
  }

 private:
  gfxContext* mContext;
  bool mHasClip;
  const int32_t mAppUnitsPerDevPixel;

  DisplayItemClip mCurrentClip;
};

/**
 * Tracks clips managed by |PushClip()| and |PopClip()|.
 * If allowed by the caller, the top clip may be reused when a new clip that
 * matches the previous one is pushed to the stack.
 */
struct ClipStack {
  explicit ClipStack(gfxContext* aContext, const int32_t aAppUnitsPerDevPixel)
      : mContext(aContext),
        mAppUnitsPerDevPixel(aAppUnitsPerDevPixel),
        mDeferredPopClip(false) {}

  ~ClipStack() {
    MOZ_ASSERT(!mDeferredPopClip);
    MOZ_ASSERT(!HasClips());
  }

  /**
   * Returns true if there are clips set.
   */
  bool HasClips() const { return mClips.Length() > 0; }

  /**
   * Returns the clip at the top of the stack.
   */
  const DisplayItemClip& TopClip() const {
    MOZ_ASSERT(HasClips());
    return mClips.LastElement();
  }

  /**
   * Returns true if the top clip matches the given |aClip|.
   */
  bool TopClipMatches(const DisplayItemClip& aClip) {
    return HasClips() && TopClip() == aClip;
  }

  /**
   * Pops the current top clip. If |aDeferPopClip| is true, the top clip will
   * not be popped before the next call to |PopClip(false)|.
   * This allows the previously set clip to be reused during the next
   * |PushClip()| call, if the new clip is identical with the top clip.
   */
  void PopClip(bool aDeferPopClip) {
    MOZ_ASSERT(HasClips());

    if (aDeferPopClip) {
      // Do not allow reusing clip with nested effects.
      MOZ_ASSERT(!mDeferredPopClip);
      mDeferredPopClip = true;
      return;
    }

    if (TopClip().HasClip()) {
      mContext->Restore();
    }

    mClips.RemoveLastElement();
    mDeferredPopClip = false;
  }

  /**
   * Pops the clip, if a call to |PopClip()| has been deferred.
   */
  void PopDeferredClip() {
    if (mDeferredPopClip) {
      PopClip(false);
    }
  }

  /**
   * Pushes the given |aClip| to the stack.
   */
  void PushClip(const DisplayItemClip& aClip) {
    if (mDeferredPopClip && TopClipMatches(aClip)) {
      // Reuse this clip. Defer the decision to reuse it again until the next
      // call to PopClip().
      mDeferredPopClip = false;
      return;
    }

    PopDeferredClip();

    mClips.AppendElement(aClip);

    // Save the current state and apply new clip, if needed.
    if (aClip.HasClip()) {
      mContext->Save();
      aClip.ApplyTo(mContext, mAppUnitsPerDevPixel);
      mContext->NewPath();
    }
  }

 private:
  gfxContext* mContext;
  const int32_t mAppUnitsPerDevPixel;
  AutoTArray<DisplayItemClip, 2> mClips;
  bool mDeferredPopClip;
};

/**
 * Returns a clip for the given |aItem|. If the clip can be simplified to not
 * include rounded rects, |aOutClip| is used to store the simplified clip.
 */
static const DisplayItemClip* GetItemClip(const nsDisplayItem* aItem,
                                          DisplayItemClip& aOutClip) {
  const DisplayItemClip& clip = aItem->GetClip();

  if (!clip.HasClip()) {
    return nullptr;
  }

  if (clip.GetRoundedRectCount() > 0 &&
      !clip.IsRectClippedByRoundedCorner(aItem->GetPaintRect())) {
    aOutClip.SetTo(clip.GetClipRect());
    return &aOutClip;
  }

  return &clip;
}

/**
 * Pushes a new opacity group for |aContext| based on |aItem|.
 */
static void PushOpacity(gfxContext* aContext, AssignedDisplayItem& aItem) {
  MOZ_ASSERT(aItem.mType == DisplayItemEntryType::PushOpacity ||
             aItem.mType == DisplayItemEntryType::PushOpacityWithBg);
  MOZ_ASSERT(aItem.mItem->GetType() == DisplayItemType::TYPE_OPACITY);
  nsDisplayOpacity* item = static_cast<nsDisplayOpacity*>(aItem.mItem);

  const float opacity = item->GetOpacity();
  if (aItem.mType == DisplayItemEntryType::PushOpacityWithBg) {
    aContext->PushGroupAndCopyBackground(gfxContentType::COLOR_ALPHA, opacity);
  } else {
    aContext->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
  }
}

/**
 * Pushes the transformation matrix of |aItem| into |aMatrixStack| and sets the
 * accumulated transform as the current transformation matrix for |aContext|.
 */
static void PushTransform(gfxContext* aContext, AssignedDisplayItem& aItem,
                          nsDisplayListBuilder* aBuilder,
                          MatrixStack4x4& aMatrixStack,
                          const Matrix4x4Flagged& aBaseMatrix) {
  MOZ_ASSERT(aItem.mType == DisplayItemEntryType::PushTransform);
  MOZ_ASSERT(aItem.mItem->GetType() == DisplayItemType::TYPE_TRANSFORM);

  nsDisplayTransform* item = static_cast<nsDisplayTransform*>(aItem.mItem);
  if (item->ShouldSkipTransform(aBuilder)) {
    aMatrixStack.Push(Matrix4x4Flagged());
  } else {
    aMatrixStack.Push(item->GetTransformForRendering());
  }

  gfx::Matrix4x4Flagged matrix = aMatrixStack.CurrentMatrix() * aBaseMatrix;
  gfx::Matrix matrix2d;
  DebugOnly<bool> ok = matrix.CanDraw2D(&matrix2d);
  MOZ_ASSERT(ok);

  aContext->SetMatrix(matrix2d);
}

static void UpdateEffectTracking(int& aOpacityLevel, int& aTransformLevel,
                                 const DisplayItemEntryType aType) {
  switch (aType) {
    case DisplayItemEntryType::PushOpacity:
    case DisplayItemEntryType::PushOpacityWithBg:
      aOpacityLevel++;
      break;
    case DisplayItemEntryType::PopOpacity:
      aOpacityLevel--;
      break;
    case DisplayItemEntryType::PushTransform:
      aTransformLevel++;
      break;
    case DisplayItemEntryType::PopTransform:
      aTransformLevel--;
      break;
    default:
      break;
  }

  MOZ_ASSERT(aOpacityLevel >= 0 && aTransformLevel >= 0);
}

void FrameLayerBuilder::PaintItems(std::vector<AssignedDisplayItem>& aItems,
                                   const nsIntRect& aRect, gfxContext* aContext,
                                   nsDisplayListBuilder* aBuilder,
                                   nsPresContext* aPresContext,
                                   const nsIntPoint& aOffset, float aXScale,
                                   float aYScale) {
  DrawTarget& aDrawTarget = *aContext->GetDrawTarget();

  int32_t appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel();
  nsRect boundRect = ToAppUnits(aRect, appUnitsPerDevPixel);
  boundRect.MoveBy(NSIntPixelsToAppUnits(aOffset.x, appUnitsPerDevPixel),
                   NSIntPixelsToAppUnits(aOffset.y, appUnitsPerDevPixel));
  boundRect.ScaleInverseRoundOut(aXScale, aYScale);

  if (boundRect.IsEmpty()) {
    // Hack! This can happen if the conversion of |aRect| to scaled and offset
    // app units overflowed. Ideally the conversion would detect this and handle
    // such situations gracefully. For now, do nothing.
    return;
  }

#ifdef DEBUG
  // Tracks effect nesting level. These are used to track that every effect
  // start marker has a corresponding end marker.
  int opacityLevel = 0;
  int transformLevel = 0;
#endif

  // Tracks effect nesting level for skipping items between effect markers,
  // when the effect display item does not intersect with the invalidated area.
  int emptyEffectLevel = 0;

  // Stores a simplified version of the item clip, if needed.
  DisplayItemClip temporaryClip;

  // Two types of clips are used during PaintItems(): clips for items and clips
  // for effects. Item clips are always the most recent clip set, and they are
  // never nested. The previous item clip is reused, if the next item has the
  // same clip. Item clips are removed when an effect starts or ends.
  ItemClipTracker itemClipTracker(aContext, appUnitsPerDevPixel);

  // Since effects can be nested, the effect clips need to be nested as well.
  // They are pushed for effect start marker, and popped for effect end marker.
  // Effect clips are tracked by |effectClipStack|. If there are consecutive
  // effects with the same clip, |effectClipStack| defers popping the clip for
  // the first end marker, and tries to reuse the previously set clip, when
  // processing the start marker for the next effect.
  ClipStack effectClipStack(aContext, appUnitsPerDevPixel);

  MatrixStack4x4 matrixStack;
  const Matrix4x4Flagged base = Matrix4x4::From2D(aContext->CurrentMatrix());

  for (uint32_t i = 0; i < aItems.size(); ++i) {
    AssignedDisplayItem& cdi = aItems[i];
    nsDisplayItem* item = cdi.mItem;

    const auto NextItemStartsEffect = [&]() {
      const uint32_t next = i + 1;
      return next < aItems.size() && IsEffectStartMarker(aItems[next].mType);
    };

    if (!item) {
      MOZ_ASSERT(cdi.mType == DisplayItemEntryType::Item);
      continue;
    }

    nsRect visibleRect = item->GetPaintRect();

    if (matrixStack.HasTransform()) {
      MOZ_ASSERT(transformLevel > 0);

      if (IsEffectEndMarker(cdi.mType)) {
        // Always process the effect end markers.
        visibleRect = boundRect;
      } else {
        const Matrix4x4Flagged& matrix = matrixStack.CurrentMatrix();
        visibleRect = nsLayoutUtils::MatrixTransformRect(visibleRect, matrix,
                                                         appUnitsPerDevPixel);
      }
    }

    const nsRect paintRect = visibleRect.Intersect(boundRect);

    if (paintRect.IsEmpty() || emptyEffectLevel > 0) {
      // In order for this branch to be hit, either this item has an empty paint
      // rect and nothing would be drawn, or an effect marker before this
      // item had an empty paint rect. In the latter case, the items are skipped
      // until effect POP markers bring |emptyEffectLevel| back to 0.
      UpdateEffectTracking(emptyEffectLevel, emptyEffectLevel, cdi.mType);

      // Sometimes the item that was going to reuse the previous clip is culled.
      // Since |PushClip()| is never called for culled items, pop the clip now.
      effectClipStack.PopDeferredClip();
      continue;
    }

#ifdef MOZ_DUMP_PAINTING
    AUTO_PROFILER_LABEL_DYNAMIC_CSTR_NONSENSITIVE(
        "FrameLayerBuilder::PaintItems", GRAPHICS_Rasterization, item->Name());
#else
    AUTO_PROFILER_LABEL("FrameLayerBuilder::PaintItems",
                        GRAPHICS_Rasterization);
#endif

    MOZ_ASSERT((opacityLevel == 0 && !cdi.HasOpacity()) ||
               (opacityLevel > 0 && cdi.HasOpacity()) ||
               (transformLevel == 0 && !cdi.HasTransform()) ||
               (transformLevel > 0 && cdi.HasTransform()));

    if (cdi.mType != DisplayItemEntryType::Item) {
      // If we are processing an effect marker, remove the current item clip, if
      // there is one.
      itemClipTracker.Restore();
    }

    if (cdi.mType == DisplayItemEntryType::PushOpacity ||
        cdi.mType == DisplayItemEntryType::PushOpacityWithBg) {
      // To avoid pushing large temporary surfaces, it is important to clip
      // opacity group with both the paint rect and the actual opacity clip.
      DisplayItemClip effectClip;
      effectClip.SetTo(item->GetPaintRect());
      effectClip.IntersectWith(item->GetClip());
      effectClipStack.PushClip(effectClip);
      PushOpacity(aContext, cdi);
    }

    if (cdi.mType == DisplayItemEntryType::PopOpacity) {
      MOZ_ASSERT(opacityLevel > 0);
      aContext->PopGroupAndBlend();
    }

    if (cdi.mType == DisplayItemEntryType::PushTransform) {
      effectClipStack.PushClip(item->GetClip());
      aContext->Save();
      PushTransform(aContext, cdi, aBuilder, matrixStack, base);
    }

    if (cdi.mType == DisplayItemEntryType::PopTransform) {
      MOZ_ASSERT(transformLevel > 0);
      matrixStack.Pop();
      aContext->Restore();
    }

    if (IsEffectEndMarker(cdi.mType)) {
      // Pop the clip for the effect.
      MOZ_ASSERT(effectClipStack.HasClips());

      // If the next item starts an effect, defer popping the current clip, and
      // try to reuse it during the next call to |PushClip()|. Trying to reuse
      // clips between nested effects would be difficult, for example due to
      // possibly different coordinate system, so this optimization is limited
      // to consecutive effects.
      effectClipStack.PopClip(NextItemStartsEffect());
    }

    if (cdi.mType != DisplayItemEntryType::Item) {
#ifdef DEBUG
      UpdateEffectTracking(opacityLevel, transformLevel, cdi.mType);
#endif
      // Nothing more to do with effect markers.
      continue;
    }

    const bool paintAsLayer = cdi.mInactiveLayerData.get();
    nsPaintedDisplayItem* paintedItem = item->AsPaintedDisplayItem();
    MOZ_ASSERT(paintAsLayer || paintedItem,
               "The display item does not support painting");

    const DisplayItemClip* itemClip = GetItemClip(item, temporaryClip);
    bool itemPaintsOwnClip = false;

    if (itemClip && !itemClipTracker.HasClip(itemClip)) {
      // The clip has changed. Remove the previous clip.
      itemClipTracker.Restore();

      // Check if the item supports painting with clip.
      itemPaintsOwnClip =
          paintAsLayer ? false : paintedItem->CanPaintWithClip(*itemClip);

      if (!itemPaintsOwnClip) {
        // Item does not support painting with clip, set the clip.
        itemClipTracker.ChangeClipIfNeeded(itemClip);
      }
    }

    if (!itemClip) {
      // Item does not need clipping, remove the clip if there is one.
      itemClipTracker.Restore();
    }

    if (paintAsLayer) {
      bool saved = aDrawTarget.GetPermitSubpixelAA();
      PaintInactiveLayer(aBuilder, cdi.mInactiveLayerData->mLayerManager, item,
                         aContext, aContext);
      aDrawTarget.SetPermitSubpixelAA(saved);
      continue;
    }

    nsIFrame* frame = item->Frame();
    if (aBuilder->IsPaintingToWindow()) {
      frame->AddStateBits(NS_FRAME_PAINTED_THEBES);
    }

#ifdef MOZ_DUMP_PAINTING
    if (gfxEnv::DumpPaintItems()) {
      DebugPaintItem(aDrawTarget, aPresContext, paintedItem, aBuilder);
      continue;
    }
#endif

    if (itemPaintsOwnClip) {
      MOZ_ASSERT(itemClip);
      paintedItem->PaintWithClip(aBuilder, aContext, *itemClip);
    } else {
      paintedItem->Paint(aBuilder, aContext);
    }
  }

  itemClipTracker.Restore();

  MOZ_ASSERT(opacityLevel == 0);
  MOZ_ASSERT(transformLevel == 0);
  MOZ_ASSERT(emptyEffectLevel == 0);
}

/**
 * Returns true if it is preferred to draw the list of display
 * items separately for each rect in the visible region rather
 * than clipping to a complex region.
 */
static bool ShouldDrawRectsSeparately(DrawTarget* aDrawTarget,
                                      DrawRegionClip aClip) {
  if (!StaticPrefs::layout_paint_rects_separately_AtStartup() ||
      aClip == DrawRegionClip::NONE) {
    return false;
  }

  return !aDrawTarget->SupportsRegionClipping();
}

static void DrawForcedBackgroundColor(DrawTarget& aDrawTarget,
                                      const IntRect& aBounds,
                                      nscolor aBackgroundColor) {
  if (NS_GET_A(aBackgroundColor) > 0) {
    ColorPattern color(ToDeviceColor(aBackgroundColor));
    aDrawTarget.FillRect(Rect(aBounds), color);
  }
}

/*
 * A note on residual transforms:
 *
 * In a transformed subtree we sometimes apply the PaintedLayer's
 * "residual transform" when drawing content into the PaintedLayer.
 * This is a translation by components in the range [-0.5,0.5) provided
 * by the layer system; applying the residual transform followed by the
 * transforms used by layer compositing ensures that the subpixel alignment
 * of the content of the PaintedLayer exactly matches what it would be if
 * we used cairo/Thebes to draw directly to the screen without going through
 * retained layer buffers.
 *
 * The visible and valid regions of the PaintedLayer are computed without
 * knowing the residual transform (because we don't know what the residual
 * transform is going to be until we've built the layer tree!). So we have to
 * consider whether content painted in the range [x, xmost) might be painted
 * outside the visible region we computed for that content. The visible region
 * would be [floor(x), ceil(xmost)). The content would be rendered at
 * [x + r, xmost + r), where -0.5 <= r < 0.5. So some half-rendered pixels could
 * indeed fall outside the computed visible region, which is not a big deal;
 * similar issues already arise when we snap cliprects to nearest pixels.
 * Note that if the rendering of the content is snapped to nearest pixels ---
 * which it often is --- then the content is actually rendered at
 * [snap(x + r), snap(xmost + r)). It turns out that floor(x) <= snap(x + r)
 * and ceil(xmost) >= snap(xmost + r), so the rendering of snapped content
 * always falls within the visible region we computed.
 */

/* static */
void FrameLayerBuilder::DrawPaintedLayer(PaintedLayer* aLayer,
                                         gfxContext* aContext,
                                         const nsIntRegion& aRegionToDraw,
                                         const nsIntRegion& aDirtyRegion,
                                         DrawRegionClip aClip,
                                         const nsIntRegion& aRegionToInvalidate,
                                         void* aCallbackData) {
  DrawTarget& aDrawTarget = *aContext->GetDrawTarget();

  AUTO_PROFILER_LABEL("FrameLayerBuilder::DrawPaintedLayer",
                      GRAPHICS_Rasterization);

  nsDisplayListBuilder* builder =
      static_cast<nsDisplayListBuilder*>(aCallbackData);

  FrameLayerBuilder* layerBuilder = aLayer->Manager()->GetLayerBuilder();
  NS_ASSERTION(layerBuilder, "Unexpectedly null layer builder!");

  auto* userData = GetPaintedDisplayItemLayerUserData(aLayer);
  NS_ASSERTION(userData, "where did our user data go?");
  if (!userData->mContainerLayerFrame) {
    return;
  }

  bool shouldDrawRectsSeparately =
      ShouldDrawRectsSeparately(&aDrawTarget, aClip);

  if (!shouldDrawRectsSeparately) {
    if (aClip == DrawRegionClip::DRAW) {
      gfxUtils::ClipToRegion(aContext, aRegionToDraw);
    }

    DrawForcedBackgroundColor(aDrawTarget, aRegionToDraw.GetBounds(),
                              userData->mForcedBackgroundColor);
  }

  // make the origin of the context coincide with the origin of the
  // PaintedLayer
  gfxContextMatrixAutoSaveRestore saveMatrix(aContext);
  nsIntPoint offset = GetTranslationForPaintedLayer(aLayer);
  nsPresContext* presContext = userData->mContainerLayerFrame->PresContext();

  if (!userData->mVisibilityComputedRegion.Contains(aDirtyRegion) &&
      !layerBuilder->GetContainingPaintedLayerData()) {
    // Recompute visibility of items in our PaintedLayer, if required. Note
    // that this recomputes visibility for all descendants of our display
    // items too, so there's no need to do this for the items in inactive
    // PaintedLayers. If aDirtyRegion has not changed since the previous call
    // then we can skip this.
    int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
    RecomputeVisibilityForItems(userData->mItems, builder, aDirtyRegion,
                                userData->mPreviousRecomputeVisibilityRect,
                                offset, appUnitsPerDevPixel, userData->mXScale,
                                userData->mYScale);
    userData->mVisibilityComputedRegion = aDirtyRegion;
  }

  if (shouldDrawRectsSeparately) {
    for (auto iter = aRegionToDraw.RectIter(); !iter.Done(); iter.Next()) {
      const nsIntRect& iterRect = iter.Get();
      gfxContextAutoSaveRestore save(aContext);
      aContext->NewPath();
      aContext->Rectangle(ThebesRect(iterRect));
      aContext->Clip();

      DrawForcedBackgroundColor(aDrawTarget, iterRect,
                                userData->mForcedBackgroundColor);

      // Apply the residual transform if it has been enabled, to ensure that
      // snapping when we draw into aContext exactly matches the ideal
      // transform. See above for why this is OK.
      aContext->SetMatrixDouble(
          aContext->CurrentMatrixDouble()
              .PreTranslate(aLayer->GetResidualTranslation() -
                            gfxPoint(offset.x, offset.y))
              .PreScale(userData->mXScale, userData->mYScale));

      layerBuilder->PaintItems(userData->mItems, iterRect, aContext, builder,
                               presContext, offset, userData->mXScale,
                               userData->mYScale);
      if (StaticPrefs::gfx_logging_painted_pixel_count_enabled()) {
        aLayer->Manager()->AddPaintedPixelCount(iterRect.Area());
      }
    }
  } else {
    // Apply the residual transform if it has been enabled, to ensure that
    // snapping when we draw into aContext exactly matches the ideal transform.
    // See above for why this is OK.
    aContext->SetMatrixDouble(
        aContext->CurrentMatrixDouble()
            .PreTranslate(aLayer->GetResidualTranslation() -
                          gfxPoint(offset.x, offset.y))
            .PreScale(userData->mXScale, userData->mYScale));

    layerBuilder->PaintItems(userData->mItems, aRegionToDraw.GetBounds(),
                             aContext, builder, presContext, offset,
                             userData->mXScale, userData->mYScale);
    if (StaticPrefs::gfx_logging_painted_pixel_count_enabled()) {
      aLayer->Manager()->AddPaintedPixelCount(aRegionToDraw.GetBounds().Area());
    }
  }

  bool isActiveLayerManager = !aLayer->Manager()->IsInactiveLayerManager();

  if (presContext->GetPaintFlashing() && isActiveLayerManager) {
    gfxContextAutoSaveRestore save(aContext);
    if (shouldDrawRectsSeparately) {
      if (aClip == DrawRegionClip::DRAW) {
        gfxUtils::ClipToRegion(aContext, aRegionToDraw);
      }
    }
    FlashPaint(aContext);
  }

  if (presContext->GetDocShell() && isActiveLayerManager) {
    nsDocShell* docShell = static_cast<nsDocShell*>(presContext->GetDocShell());
    RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();

    if (timelines && timelines->HasConsumer(docShell)) {
      timelines->AddMarkerForDocShell(
          docShell, MakeUnique<LayerTimelineMarker>(aRegionToDraw));
    }
  }

  if (!aRegionToInvalidate.IsEmpty()) {
    aLayer->AddInvalidRect(aRegionToInvalidate.GetBounds());
  }
}

/* static */
void FrameLayerBuilder::DumpRetainedLayerTree(LayerManager* aManager,
                                              std::stringstream& aStream,
                                              bool aDumpHtml) {
  aManager->Dump(aStream, "", aDumpHtml);
}

nsDisplayItemGeometry* FrameLayerBuilder::GetMostRecentGeometry(
    nsDisplayItem* aItem) {
  // Retrieve the array of DisplayItemData associated with our frame.

  // Find our display item data, if it exists, and return its geometry.
  // We first check for ones with an inactive manager, since items that
  // create inactive layers will create two DisplayItemData entries,
  // and we want the outer one.
  DisplayItemData* firstMatching = nullptr;
  uint32_t itemPerFrameKey = aItem->GetPerFrameKey();

  for (auto* did : GetDisplayItemDataArray(aItem->Frame())) {
    auto* data = DisplayItemData::AssertDisplayItemData(did);
    if (data->GetDisplayItemKey() == itemPerFrameKey) {
      if (data->InactiveManager()) {
        return data->GetGeometry();
      }
      if (!firstMatching) {
        firstMatching = data;
      }
    }
  }

  if (firstMatching) {
    return firstMatching->GetGeometry();
  }

  if (RefPtr<WebRenderFallbackData> data =
          GetWebRenderUserData<WebRenderFallbackData>(aItem->Frame(),
                                                      itemPerFrameKey)) {
    return data->GetGeometry();
  }

  return nullptr;
}

static gfx::Rect CalculateBounds(
    const nsTArray<DisplayItemClip::RoundedRect>& aRects,
    int32_t aAppUnitsPerDevPixel) {
  nsRect bounds = aRects[0].mRect;
  for (uint32_t i = 1; i < aRects.Length(); ++i) {
    bounds.UnionRect(bounds, aRects[i].mRect);
  }

  return gfx::Rect(bounds.ToNearestPixels(aAppUnitsPerDevPixel));
}

void ContainerState::SetupMaskLayer(Layer* aLayer,
                                    const DisplayItemClip& aClip) {
  // don't build an unnecessary mask
  if (aClip.GetRoundedRectCount() == 0) {
    return;
  }

  RefPtr<Layer> maskLayer = CreateMaskLayer(aLayer, aClip, Nothing());

  if (!maskLayer) {
    return;
  }

  aLayer->SetMaskLayer(maskLayer);
}

static MaskLayerUserData* GetMaskLayerUserData(Layer* aMaskLayer) {
  if (!aMaskLayer) {
    return nullptr;
  }

  return static_cast<MaskLayerUserData*>(
      aMaskLayer->GetUserData(&gMaskLayerUserData));
}

static void SetMaskLayerUserData(Layer* aMaskLayer) {
  MOZ_ASSERT(aMaskLayer);

  aMaskLayer->SetUserData(&gMaskLayerUserData, new MaskLayerUserData());
}

already_AddRefed<Layer> ContainerState::CreateMaskLayer(
    Layer* aLayer, const DisplayItemClip& aClip,
    const Maybe<size_t>& aForAncestorMaskLayer) {
  // aLayer will never be the container layer created by an
  // nsDisplayMasksAndClipPaths because nsDisplayMasksAndClipPaths propagates
  // the DisplayItemClip to its contents and is not clipped itself.
  // This assertion will fail if that ever stops being the case.
  MOZ_ASSERT(!aLayer->GetUserData(&gCSSMaskLayerUserData),
             "A layer contains round clips should not have css-mask on it.");

  // check if we can re-use the mask layer
  RefPtr<ImageLayer> maskLayer = CreateOrRecycleMaskImageLayerFor(
      MaskLayerKey(aLayer, aForAncestorMaskLayer), GetMaskLayerUserData,
      SetMaskLayerUserData);
  MaskLayerUserData* userData = GetMaskLayerUserData(maskLayer.get());

  int32_t A2D = mContainerFrame->PresContext()->AppUnitsPerDevPixel();
  MaskLayerUserData newData(aClip, A2D, mParameters);
  if (*userData == newData) {
    return maskLayer.forget();
  }

  gfx::Rect boundingRect =
      CalculateBounds(newData.mRoundedClipRects, newData.mAppUnitsPerDevPixel);
  boundingRect.Scale(mParameters.mXScale, mParameters.mYScale);
  if (boundingRect.IsEmpty()) {
    // Return early if we know that there is effectively no visible data.
    return nullptr;
  }

  uint32_t maxSize = mManager->GetMaxTextureSize();
  NS_ASSERTION(maxSize > 0, "Invalid max texture size");
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
  // Make mask image width aligned to 4. See Bug 1245552.
  gfx::Size surfaceSize(
      std::min<gfx::Float>(
          GetAlignedStride<4>(NSToIntCeil(boundingRect.Width()), 1), maxSize),
      std::min<gfx::Float>(boundingRect.Height(), maxSize));
#else
  gfx::Size surfaceSize(std::min<gfx::Float>(boundingRect.Width(), maxSize),
                        std::min<gfx::Float>(boundingRect.Height(), maxSize));
#endif

  // maskTransform is applied to the clip when it is painted into the mask (as a
  // component of imageTransform), and its inverse used when the mask is used
  // for masking. It is the transform from the masked layer's space to mask
  // space
  gfx::Matrix maskTransform =
      Matrix::Scaling(surfaceSize.width / boundingRect.Width(),
                      surfaceSize.height / boundingRect.Height());
  if (surfaceSize.IsEmpty()) {
    // Return early if we know that the size of this mask surface is empty.
    return nullptr;
  }

  gfx::Point p = boundingRect.TopLeft();
  maskTransform.PreTranslate(-p.x, -p.y);
  // imageTransform is only used when the clip is painted to the mask
  gfx::Matrix imageTransform = maskTransform;
  imageTransform.PreScale(mParameters.mXScale, mParameters.mYScale);

  UniquePtr<MaskLayerImageCache::MaskLayerImageKey> newKey(
      new MaskLayerImageCache::MaskLayerImageKey());

  // copy and transform the rounded rects
  for (uint32_t i = 0; i < newData.mRoundedClipRects.Length(); ++i) {
    newKey->mRoundedClipRects.AppendElement(
        MaskLayerImageCache::PixelRoundedRect(newData.mRoundedClipRects[i],
                                              mContainerFrame->PresContext()));
    newKey->mRoundedClipRects[i].ScaleAndTranslate(imageTransform);
  }
  newKey->mKnowsCompositor = mManager->AsKnowsCompositor();

  const MaskLayerImageCache::MaskLayerImageKey* lookupKey = newKey.get();

  // check to see if we can reuse a mask image
  RefPtr<ImageContainer> container =
      GetMaskLayerImageCache()->FindImageFor(&lookupKey);

  if (!container) {
    IntSize surfaceSizeInt(NSToIntCeil(surfaceSize.width),
                           NSToIntCeil(surfaceSize.height));
    // no existing mask image, so build a new one
    MaskImageData imageData(surfaceSizeInt, mManager);
    RefPtr<DrawTarget> dt = imageData.CreateDrawTarget();

    // fail if we can't get the right surface
    if (!dt || !dt->IsValid()) {
      NS_WARNING("Could not create DrawTarget for mask layer.");
      return nullptr;
    }

    RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt);
    MOZ_ASSERT(context);  // already checked the draw target above
    context->Multiply(ThebesMatrix(imageTransform));

    // paint the clipping rects with alpha to create the mask
    aClip.FillIntersectionOfRoundedRectClips(
        context, DeviceColor::MaskOpaqueWhite(), newData.mAppUnitsPerDevPixel);

    // build the image and container
    MOZ_ASSERT(aLayer->Manager() == mManager);
    container = imageData.CreateImageAndImageContainer();
    NS_ASSERTION(container, "Could not create image container for mask layer.");

    if (!container) {
      return nullptr;
    }

    GetMaskLayerImageCache()->PutImage(newKey.release(), container);
  }

  maskLayer->SetContainer(container);

  maskTransform.Invert();
  Matrix4x4 matrix = Matrix4x4::From2D(maskTransform);
  matrix.PreTranslate(mParameters.mOffset.x, mParameters.mOffset.y, 0);
  maskLayer->SetBaseTransform(matrix);

  // save the details of the clip in user data
  *userData = std::move(newData);
  userData->mImageKey.Reset(lookupKey);

  return maskLayer.forget();
}

}  // namespace mozilla