1 files changed, 503 insertions, 0 deletions

diff --git a/gfx/layers/wr/ClipManager.cpp b/gfx/layers/wr/ClipManager.cpp
new file mode 100644
index 0000000000..930ad8d07d
--- /dev/null
+++ b/gfx/layers/wr/ClipManager.cpp
@@ -0,0 +1,503 @@
+/* -*- 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 "mozilla/layers/ClipManager.h"
+
+#include "DisplayItemClipChain.h"
+#include "FrameMetrics.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsDisplayList.h"
+#include "nsRefreshDriver.h"
+#include "nsStyleStructInlines.h"
+#include "UnitTransforms.h"
+
+static mozilla::LazyLogModule sClipLog("wr.clip");
+#define CLIP_LOG(...) MOZ_LOG(sClipLog, LogLevel::Debug, (__VA_ARGS__))
+
+namespace mozilla {
+namespace layers {
+
+ClipManager::ClipManager() : mManager(nullptr), mBuilder(nullptr) {}
+
+void ClipManager::BeginBuild(WebRenderLayerManager* aManager,
+                             wr::DisplayListBuilder& aBuilder) {
+  MOZ_ASSERT(!mManager);
+  mManager = aManager;
+  MOZ_ASSERT(!mBuilder);
+  mBuilder = &aBuilder;
+  MOZ_ASSERT(mCacheStack.empty());
+  mCacheStack.emplace();
+  MOZ_ASSERT(mASROverride.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+void ClipManager::EndBuild() {
+  mBuilder = nullptr;
+  mManager = nullptr;
+  mCacheStack.pop();
+  MOZ_ASSERT(mCacheStack.empty());
+  MOZ_ASSERT(mASROverride.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+void ClipManager::BeginList(const StackingContextHelper& aStackingContext) {
+  CLIP_LOG("begin list %p affects = %d, ref-frame = %d\n", &aStackingContext,
+           aStackingContext.AffectsClipPositioning(),
+           aStackingContext.ReferenceFrameId().isSome());
+
+  ItemClips clips(nullptr, nullptr, 0, false);
+  if (!mItemClipStack.empty()) {
+    clips = mItemClipStack.top();
+  }
+
+  if (aStackingContext.AffectsClipPositioning()) {
+    if (auto referenceFrameId = aStackingContext.ReferenceFrameId()) {
+      PushOverrideForASR(clips.mASR, *referenceFrameId);
+      clips.mScrollId = *referenceFrameId;
+    } else {
+      // Start a new cache
+      mCacheStack.emplace();
+    }
+    if (clips.mChain) {
+      clips.mClipChainId =
+          DefineClipChain(clips.mChain, clips.mAppUnitsPerDevPixel);
+    }
+  }
+
+  CLIP_LOG("  push: clip: %p, asr: %p, scroll =%" PRIuPTR ", clip =%" PRIu64
+           "\n",
+           clips.mChain, clips.mASR, clips.mScrollId.id,
+           clips.mClipChainId.valueOr(wr::WrClipChainId{0}).id);
+
+  mItemClipStack.push(clips);
+}
+
+void ClipManager::EndList(const StackingContextHelper& aStackingContext) {
+  MOZ_ASSERT(!mItemClipStack.empty());
+
+  CLIP_LOG("end list %p\n", &aStackingContext);
+
+  mBuilder->SetClipChainLeaf(Nothing());
+  mItemClipStack.pop();
+
+  if (aStackingContext.AffectsClipPositioning()) {
+    if (aStackingContext.ReferenceFrameId()) {
+      PopOverrideForASR(mItemClipStack.empty() ? nullptr
+                                               : mItemClipStack.top().mASR);
+    } else {
+      MOZ_ASSERT(!mCacheStack.empty());
+      mCacheStack.pop();
+    }
+  }
+}
+
+void ClipManager::PushOverrideForASR(const ActiveScrolledRoot* aASR,
+                                     const wr::WrSpatialId& aSpatialId) {
+  wr::WrSpatialId space = GetScrollLayer(aASR);
+
+  CLIP_LOG("Pushing %p override %zu -> %zu\n", aASR, space.id, aSpatialId.id);
+  auto it = mASROverride.insert({space, std::stack<wr::WrSpatialId>()});
+  it.first->second.push(aSpatialId);
+
+  // Start a new cache
+  mCacheStack.emplace();
+
+  // Fix up our cached item clip if needed.
+  if (!mItemClipStack.empty()) {
+    auto& top = mItemClipStack.top();
+    if (top.mASR == aASR) {
+      top.mScrollId = aSpatialId;
+      if (top.mChain) {
+        top.mClipChainId =
+            DefineClipChain(top.mChain, top.mAppUnitsPerDevPixel);
+      }
+    }
+  }
+}
+
+void ClipManager::PopOverrideForASR(const ActiveScrolledRoot* aASR) {
+  MOZ_ASSERT(!mCacheStack.empty());
+  mCacheStack.pop();
+
+  wr::WrSpatialId space = GetScrollLayer(aASR);
+  auto it = mASROverride.find(space);
+  if (it == mASROverride.end()) {
+    MOZ_ASSERT_UNREACHABLE("Push/PopOverrideForASR should be balanced");
+  } else {
+    CLIP_LOG("Popping %p override %zu -> %zu\n", aASR, space.id,
+             it->second.top().id);
+    it->second.pop();
+  }
+
+  if (!mItemClipStack.empty()) {
+    auto& top = mItemClipStack.top();
+    if (top.mASR == aASR) {
+      top.mScrollId = (it == mASROverride.end() || it->second.empty())
+                          ? space
+                          : it->second.top();
+      if (top.mChain) {
+        top.mClipChainId =
+            DefineClipChain(top.mChain, top.mAppUnitsPerDevPixel);
+      }
+    }
+  }
+
+  if (it != mASROverride.end() && it->second.empty()) {
+    mASROverride.erase(it);
+  }
+}
+
+wr::WrSpatialId ClipManager::SpatialIdAfterOverride(
+    const wr::WrSpatialId& aSpatialId) {
+  auto it = mASROverride.find(aSpatialId);
+  if (it == mASROverride.end()) {
+    return aSpatialId;
+  }
+  MOZ_ASSERT(!it->second.empty());
+  CLIP_LOG("Overriding %zu with %zu\n", aSpatialId.id, it->second.top().id);
+  return it->second.top();
+}
+
+wr::WrSpaceAndClipChain ClipManager::SwitchItem(nsDisplayListBuilder* aBuilder,
+                                                nsDisplayItem* aItem) {
+  const DisplayItemClipChain* clip = aItem->GetClipChain();
+  const DisplayItemClipChain* inheritedClipChain =
+      mBuilder->GetInheritedClipChain();
+  if (inheritedClipChain && inheritedClipChain != clip) {
+    if (!clip) {
+      clip = mBuilder->GetInheritedClipChain();
+    } else {
+      clip = aBuilder->CreateClipChainIntersection(
+          mBuilder->GetInheritedClipChain(), clip);
+    }
+  }
+  const ActiveScrolledRoot* asr = aItem->GetActiveScrolledRoot();
+  DisplayItemType type = aItem->GetType();
+  if (type == DisplayItemType::TYPE_STICKY_POSITION) {
+    // For sticky position items, the ASR is computed differently depending on
+    // whether the item has a fixed descendant or not. But for WebRender
+    // purposes we always want to use the ASR that would have been used if it
+    // didn't have fixed descendants, which is stored as the "container ASR" on
+    // the sticky item.
+    auto* sticky = static_cast<nsDisplayStickyPosition*>(aItem);
+    asr = sticky->GetContainerASR();
+
+    // If the leafmost clip for the sticky item is just the displayport clip,
+    // then skip it. This allows sticky items to remain visible even if the
+    // rest of the content in the enclosing scrollframe is checkerboarding.
+    if (sticky->IsClippedToDisplayPort() && clip && clip->mASR == asr) {
+      clip = clip->mParent;
+    }
+  }
+
+  CLIP_LOG("processing item %p (%s) asr %p clip %p, inherited = %p\n", aItem,
+           DisplayItemTypeName(aItem->GetType()), asr, clip,
+           inheritedClipChain);
+
+  // In most cases we can combine the leaf of the clip chain with the clip rect
+  // of the display item. This reduces the number of clip items, which avoids
+  // some overhead further down the pipeline.
+  bool separateLeaf = false;
+  if (clip && clip->mASR == asr && clip->mClip.GetRoundedRectCount() == 0) {
+    // Container display items are not currently supported because the clip
+    // rect of a stacking context is not handled the same as normal display
+    // items.
+    separateLeaf = !aItem->GetChildren();
+  }
+
+  // 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.
+  const int32_t auPerDevPixel = [&] {
+    if (type == DisplayItemType::TYPE_ZOOM) {
+      return static_cast<nsDisplayZoom*>(aItem)->GetParentAppUnitsPerDevPixel();
+    }
+    return aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+  }();
+
+  ItemClips clips(asr, clip, auPerDevPixel, separateLeaf);
+  MOZ_ASSERT(!mItemClipStack.empty());
+  if (clips.HasSameInputs(mItemClipStack.top())) {
+    // Early-exit because if the clips are the same as aItem's previous sibling,
+    // then we don't need to do do the work of popping the old stuff and then
+    // pushing it right back on for the new item. Note that if aItem doesn't
+    // have a previous sibling, that means BeginList would have been called
+    // just before this, which will have pushed a ItemClips(nullptr, nullptr)
+    // onto mItemClipStack, so the HasSameInputs check should return false.
+    CLIP_LOG("\tearly-exit for %p\n", aItem);
+    return mItemClipStack.top().GetSpaceAndClipChain();
+  }
+
+  // Pop aItem's previous sibling's stuff from mBuilder in preparation for
+  // pushing aItem's stuff.
+  mItemClipStack.pop();
+
+  // If the leaf of the clip chain is going to be merged with the display item's
+  // clip rect, then we should create a clip chain id from the leaf's parent.
+  if (separateLeaf) {
+    CLIP_LOG("\tseparate leaf detected, ignoring the last clip\n");
+    clip = clip->mParent;
+  }
+
+  // There are two ASR chains here that we need to be fully defined. One is the
+  // ASR chain pointed to by |asr|. The other is the
+  // ASR chain pointed to by clip->mASR. We pick the leafmost
+  // of these two chains because that one will include the other. Calling
+  // DefineScrollLayers with this leafmost ASR will recursively define all the
+  // ASRs that we care about for this item, but will not actually push
+  // anything onto the WR stack.
+  const ActiveScrolledRoot* leafmostASR = asr;
+  if (clip) {
+    leafmostASR = ActiveScrolledRoot::PickDescendant(leafmostASR, clip->mASR);
+  }
+  Maybe<wr::WrSpatialId> leafmostId = DefineScrollLayers(leafmostASR, aItem);
+  Unused << leafmostId;
+
+  // Define all the clips in the item's clip chain, and obtain a clip chain id
+  // for it.
+  clips.mClipChainId = DefineClipChain(clip, auPerDevPixel);
+
+  wr::WrSpatialId space = GetScrollLayer(asr);
+  clips.mScrollId = SpatialIdAfterOverride(space);
+  CLIP_LOG("\tassigning %d -> %d\n", (int)space.id, (int)clips.mScrollId.id);
+
+  // Now that we have the scroll id and a clip id for the item, push it onto
+  // the WR stack.
+  clips.UpdateSeparateLeaf(*mBuilder, auPerDevPixel);
+  auto spaceAndClipChain = clips.GetSpaceAndClipChain();
+
+  CLIP_LOG("  push: clip: %p, asr: %p, scroll = %" PRIuPTR ", clip = %" PRIu64
+           "\n",
+           clips.mChain, clips.mASR, clips.mScrollId.id,
+           clips.mClipChainId.valueOr(wr::WrClipChainId{0}).id);
+
+  mItemClipStack.push(clips);
+
+  CLIP_LOG("done setup for %p\n", aItem);
+  return spaceAndClipChain;
+}
+
+wr::WrSpatialId ClipManager::GetScrollLayer(const ActiveScrolledRoot* aASR) {
+  for (const ActiveScrolledRoot* asr = aASR; asr; asr = asr->mParent) {
+    Maybe<wr::WrSpatialId> space =
+        mBuilder->GetScrollIdForDefinedScrollLayer(asr->GetViewId());
+    if (space) {
+      return *space;
+    }
+
+    // If this ASR doesn't have a scroll ID, then we should check its ancestor.
+    // There may not be one defined because the ASR may not be scrollable or we
+    // failed to get the scroll metadata.
+  }
+
+  Maybe<wr::WrSpatialId> space = mBuilder->GetScrollIdForDefinedScrollLayer(
+      ScrollableLayerGuid::NULL_SCROLL_ID);
+  MOZ_ASSERT(space.isSome());
+  return *space;
+}
+
+Maybe<wr::WrSpatialId> ClipManager::DefineScrollLayers(
+    const ActiveScrolledRoot* aASR, nsDisplayItem* aItem) {
+  if (!aASR) {
+    // Recursion base case
+    return Nothing();
+  }
+  ScrollableLayerGuid::ViewID viewId = aASR->GetViewId();
+  Maybe<wr::WrSpatialId> space =
+      mBuilder->GetScrollIdForDefinedScrollLayer(viewId);
+  if (space) {
+    // If we've already defined this scroll layer before, we can early-exit
+    return space;
+  }
+  // Recurse to define the ancestors
+  Maybe<wr::WrSpatialId> ancestorSpace =
+      DefineScrollLayers(aASR->mParent, aItem);
+
+  Maybe<ScrollMetadata> metadata =
+      aASR->mScrollableFrame->ComputeScrollMetadata(mManager, aItem->Frame(),
+                                                    aItem->ToReferenceFrame());
+  if (!metadata) {
+    MOZ_ASSERT_UNREACHABLE("Expected scroll metadata to be available!");
+    return ancestorSpace;
+  }
+
+  FrameMetrics& metrics = metadata->GetMetrics();
+  if (!metrics.IsScrollable()) {
+    // This item is a scrolling no-op, skip over it in the ASR chain.
+    return ancestorSpace;
+  }
+
+  nsIScrollableFrame* scrollableFrame = aASR->mScrollableFrame;
+  nsIFrame* scrollFrame = do_QueryFrame(scrollableFrame);
+  nsPoint offset = scrollFrame->GetOffsetToCrossDoc(aItem->Frame()) +
+                   aItem->ToReferenceFrame();
+  int32_t auPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+  nsRect scrollPort = scrollableFrame->GetScrollPortRect() + offset;
+  LayoutDeviceRect clipBounds =
+      LayoutDeviceRect::FromAppUnits(scrollPort, auPerDevPixel);
+
+  // The content rect that we hand to PushScrollLayer should be relative to
+  // the same origin as the clipBounds that we hand to PushScrollLayer -
+  // that is, both of them should be relative to the stacking context `aSc`.
+  // However, when we get the scrollable rect from the FrameMetrics, the
+  // origin has nothing to do with the position of the frame but instead
+  // represents the minimum allowed scroll offset of the scrollable content.
+  // While APZ uses this to clamp the scroll position, we don't need to send
+  // this to WebRender at all. Instead, we take the position from the
+  // composition bounds.
+  LayoutDeviceRect contentRect =
+      metrics.GetExpandedScrollableRect() * metrics.GetDevPixelsPerCSSPixel();
+  contentRect.MoveTo(clipBounds.TopLeft());
+
+  Maybe<wr::WrSpatialId> parent = ancestorSpace;
+  if (parent) {
+    *parent = SpatialIdAfterOverride(*parent);
+  }
+  // The external scroll offset is accumulated into the local space positions of
+  // display items inside WR, so that the elements hash (intern) to the same
+  // content ID for quick comparisons. To avoid invalidations when the
+  // auPerDevPixel is not a round value, round here directly from app units.
+  // This guarantees we won't introduce any inaccuracy in the external scroll
+  // offset passed to WR.
+  const bool useRoundedOffset =
+      StaticPrefs::apz_rounded_external_scroll_offset();
+  LayoutDevicePoint scrollOffset =
+      useRoundedOffset
+          ? LayoutDevicePoint::FromAppUnitsRounded(
+                scrollableFrame->GetScrollPosition(), auPerDevPixel)
+          : LayoutDevicePoint::FromAppUnits(
+                scrollableFrame->GetScrollPosition(), auPerDevPixel);
+
+  // Currently we track scroll-linked effects at the granularity of documents,
+  // not scroll frames, so we consider a scroll frame to have a scroll-linked
+  // effect whenever its containing document does.
+  nsPresContext* presContext = aItem->Frame()->PresContext();
+  const bool hasScrollLinkedEffect =
+      !StaticPrefs::apz_disable_for_scroll_linked_effects() &&
+      presContext->Document()->HasScrollLinkedEffect();
+
+  return Some(mBuilder->DefineScrollLayer(
+      viewId, parent, wr::ToLayoutRect(contentRect),
+      wr::ToLayoutRect(clipBounds), wr::ToLayoutVector2D(scrollOffset),
+      wr::ToWrAPZScrollGeneration(scrollableFrame->ScrollGenerationOnApz()),
+      wr::ToWrHasScrollLinkedEffect(hasScrollLinkedEffect),
+      wr::SpatialKey(uint64_t(scrollFrame), 0, wr::SpatialKeyKind::Scroll)));
+}
+
+Maybe<wr::WrClipChainId> ClipManager::DefineClipChain(
+    const DisplayItemClipChain* aChain, int32_t aAppUnitsPerDevPixel) {
+  MOZ_ASSERT(!mCacheStack.empty());
+  AutoTArray<wr::WrClipId, 6> allClipIds;
+  ClipIdMap& cache = mCacheStack.top();
+  // Iterate through the clips in the current item's clip chain, define them
+  // in WR, and put their IDs into |clipIds|.
+  for (const DisplayItemClipChain* chain = aChain; chain;
+       chain = chain->mParent) {
+    MOZ_DIAGNOSTIC_ASSERT(chain->mOnStack || !chain->mASR ||
+                          chain->mASR->mScrollableFrame);
+
+    if (!chain->mClip.HasClip()) {
+      // This item in the chain is a no-op, skip over it
+      continue;
+    }
+
+    auto emplaceResult = cache.try_emplace(chain);
+    auto& chainClipIds = emplaceResult.first->second;
+    if (!emplaceResult.second) {
+      // Found it in the currently-active cache, so just use the id we have for
+      // it.
+      CLIP_LOG("cache[%p] => hit\n", chain);
+      allClipIds.AppendElements(chainClipIds);
+      continue;
+    }
+
+    LayoutDeviceRect clip = LayoutDeviceRect::FromAppUnits(
+        chain->mClip.GetClipRect(), aAppUnitsPerDevPixel);
+    AutoTArray<wr::ComplexClipRegion, 6> wrRoundedRects;
+    chain->mClip.ToComplexClipRegions(aAppUnitsPerDevPixel, wrRoundedRects);
+
+    wr::WrSpatialId space = GetScrollLayer(chain->mASR);
+    // Define the clip
+    space = SpatialIdAfterOverride(space);
+
+    auto rectClipId =
+        mBuilder->DefineRectClip(Some(space), wr::ToLayoutRect(clip));
+    CLIP_LOG("cache[%p] <= %zu\n", chain, rectClipId.id);
+    chainClipIds.AppendElement(rectClipId);
+
+    for (const auto& complexClip : wrRoundedRects) {
+      auto complexClipId =
+          mBuilder->DefineRoundedRectClip(Some(space), complexClip);
+      CLIP_LOG("cache[%p] <= %zu\n", chain, complexClipId.id);
+      chainClipIds.AppendElement(complexClipId);
+    }
+
+    allClipIds.AppendElements(chainClipIds);
+  }
+
+  if (allClipIds.IsEmpty()) {
+    return Nothing();
+  }
+
+  return Some(mBuilder->DefineClipChain(allClipIds));
+}
+
+ClipManager::~ClipManager() {
+  MOZ_ASSERT(!mBuilder);
+  MOZ_ASSERT(mCacheStack.empty());
+  MOZ_ASSERT(mItemClipStack.empty());
+}
+
+ClipManager::ItemClips::ItemClips(const ActiveScrolledRoot* aASR,
+                                  const DisplayItemClipChain* aChain,
+                                  int32_t aAppUnitsPerDevPixel,
+                                  bool aSeparateLeaf)
+    : mASR(aASR),
+      mChain(aChain),
+      mAppUnitsPerDevPixel(aAppUnitsPerDevPixel),
+      mSeparateLeaf(aSeparateLeaf) {
+  mScrollId = wr::wr_root_scroll_node_id();
+}
+
+void ClipManager::ItemClips::UpdateSeparateLeaf(
+    wr::DisplayListBuilder& aBuilder, int32_t aAppUnitsPerDevPixel) {
+  Maybe<wr::LayoutRect> clipLeaf;
+  if (mSeparateLeaf) {
+    MOZ_ASSERT(mChain);
+    clipLeaf.emplace(wr::ToLayoutRect(LayoutDeviceRect::FromAppUnits(
+        mChain->mClip.GetClipRect(), aAppUnitsPerDevPixel)));
+  }
+
+  aBuilder.SetClipChainLeaf(clipLeaf);
+}
+
+bool ClipManager::ItemClips::HasSameInputs(const ItemClips& aOther) {
+  if (mASR != aOther.mASR || mChain != aOther.mChain ||
+      mSeparateLeaf != aOther.mSeparateLeaf) {
+    return false;
+  }
+  // AUPDP only matters if we have a clip chain, since it's only used to compute
+  // the device space clip rect.
+  if (mChain && mAppUnitsPerDevPixel != aOther.mAppUnitsPerDevPixel) {
+    return false;
+  }
+  return true;
+}
+
+wr::WrSpaceAndClipChain ClipManager::ItemClips::GetSpaceAndClipChain() const {
+  auto spaceAndClipChain = wr::RootScrollNodeWithChain();
+  spaceAndClipChain.space = mScrollId;
+  if (mClipChainId) {
+    spaceAndClipChain.clip_chain = mClipChainId->id;
+  }
+  return spaceAndClipChain;
+}
+
+}  // namespace layers
+}  // namespace mozilla