Commit 623ddc7d authored by Kartikaya Gupta's avatar Kartikaya Gupta
Browse files

Bug 1389138 - Push scroll layers in layers-free WR. r=mstange 

This patch takes the existing code (which allows recursively pushing the necessary
part of a clip chain) and folds it into another recursive function that
operates on the ASR chain. Now the ASR recursion is the primary one, and
clips are pushed for each ASR as needed.

This code was partly modelled after the code in
ContainerState::SetupScrollingMetadata, which also iterates over the
ASRs and clips.

MozReview-Commit-ID: 1qaFPY7Ja7

--HG--
extra : rebase_source : 0c1879531e77998254d2ccaf87479154b179545a
parent 0f4e8945

gfx/layers/wr/ScrollingLayersHelper.cpp

+98 −3
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ ScrollingLayersHelper::ScrollingLayersHelper(WebRenderLayer* aLayer, 
  : mLayer(aLayer)

  , mBuilder(&aBuilder)

  , mPushedLayerLocalClip(false)

  , mPushedClipAndScroll(false)

{

  if (!mLayer->WrManager()->AsyncPanZoomEnabled()) {

    // If APZ is disabled then we don't need to push the scrolling clips. We
@@ -92,9 +93,96 @@ ScrollingLayersHelper::ScrollingLayersHelper(nsDisplayItem* aItem, 
  : mLayer(nullptr)

  , mBuilder(&aBuilder)

  , mPushedLayerLocalClip(false)

  , mPushedClipAndScroll(false)

{

  int32_t auPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();



  // There are two ASR chains here that we need to be fully defined. One is the

  // ASR chain pointed to by aItem->GetActiveScrolledRoot(). The other is the

  // ASR chain pointed to by aItem->GetClipChain()->mASR. We pick the leafmost

  // of these two chains because that one will include the other. And then we

  // call DefineAndPushScrollLayers with it, which will recursively push all

  // the necessary clips and scroll layer items for that ASR chain.

  const ActiveScrolledRoot* leafmostASR = aItem->GetActiveScrolledRoot();

  if (aItem->GetClipChain()) {

    leafmostASR = ActiveScrolledRoot::PickDescendant(leafmostASR,

        aItem->GetClipChain()->mASR);

  }

  DefineAndPushScrollLayers(aItem, leafmostASR,

      aItem->GetClipChain(), aBuilder, auPerDevPixel, aStackingContext, aCache);



  // Next, we push the leaf part of the clip chain that is scrolled by the

  // leafmost ASR. All the clips outside the leafmost ASR were already pushed

  // in the above call. This call may be a no-op if the item's ASR got picked

  // as the leaftmostASR previously, because that means these clips were pushed

  // already as being "outside" leafmostASR.

  DefineAndPushChain(aItem->GetClipChain(), aBuilder, aStackingContext,

      aItem->Frame()->PresContext()->AppUnitsPerDevPixel(), aCache);

      auPerDevPixel, aCache);



  // Finally, if clip chain's ASR was the leafmost ASR, then the top of the

  // scroll id stack right now will point to that, rather than the item's ASR

  // which is what we want. So we override that by doing a PushClipAndScrollInfo

  // call. This should generally only happen for fixed-pos type items, but we

  // use code generic enough to handle other cases.

  FrameMetrics::ViewID scrollId = aItem->GetActiveScrolledRoot()

      ? nsLayoutUtils::ViewIDForASR(aItem->GetActiveScrolledRoot())

      : FrameMetrics::NULL_SCROLL_ID;

  if (aBuilder.TopmostScrollId() != Some(scrollId)) {

    Maybe<wr::WrClipId> clipId = mBuilder->TopmostClipId();

    mBuilder->PushClipAndScrollInfo(scrollId, clipId.ptrOr(nullptr));

    mPushedClipAndScroll = true;

  }

}



void

ScrollingLayersHelper::DefineAndPushScrollLayers(nsDisplayItem* aItem,

                                                 const ActiveScrolledRoot* aAsr,

                                                 const DisplayItemClipChain* aChain,

                                                 wr::DisplayListBuilder& aBuilder,

                                                 int32_t aAppUnitsPerDevPixel,

                                                 const StackingContextHelper& aStackingContext,

                                                 WebRenderLayerManager::ClipIdMap& aCache)

{

  if (!aAsr) {

    return;

  }

  Maybe<ScrollMetadata> metadata = aAsr->mScrollableFrame->ComputeScrollMetadata(

      nullptr, aItem->ReferenceFrame(), ContainerLayerParameters(), nullptr);

  MOZ_ASSERT(metadata);

  FrameMetrics::ViewID scrollId = metadata->GetMetrics().GetScrollId();

  if (aBuilder.TopmostScrollId() == Some(scrollId)) {

    // it's already been pushed, so we don't need to recurse any further.

    return;

  }



  // Find the first clip up the chain that's "outside" aAsr. Any clips

  // that are "inside" aAsr (i.e. that are scrolled by aAsr) will need to be

  // pushed onto the stack after aAsr has been pushed. On the recursive call

  // we need to skip up the clip chain past these clips.

  const DisplayItemClipChain* asrClippedBy = aChain;

  while (asrClippedBy &&

         ActiveScrolledRoot::PickAncestor(asrClippedBy->mASR, aAsr) == aAsr) {

    asrClippedBy = asrClippedBy->mParent;

  }



  // Recurse up the ASR chain to make sure all ancestor scroll layers and their

  // enclosing clips are defined and pushed onto the WR stack.

  DefineAndPushScrollLayers(aItem, aAsr->mParent, asrClippedBy, aBuilder,

      aAppUnitsPerDevPixel, aStackingContext, aCache);



  // Once the ancestors are dealt with, we want to make sure all the clips

  // enclosing aAsr are pushed. All the clips enclosing aAsr->mParent were

  // already taken care of in the recursive call, so DefineAndPushChain will

  // push exactly what we want.

  DefineAndPushChain(asrClippedBy, aBuilder, aStackingContext,

      aAppUnitsPerDevPixel, aCache);

  // Finally, push the ASR itself as a scroll layer. Note that the

  // implementation of wr_push_scroll_layer in bindings.rs makes sure the

  // scroll layer doesn't get defined multiple times so we don't need to worry

  // about that here.

  if (PushScrollLayer(metadata->GetMetrics(), aStackingContext)) {

    mPushedClips.push_back(wr::ScrollOrClipId(scrollId));

  }

}



void
@@ -212,10 +300,17 @@ ScrollingLayersHelper::~ScrollingLayersHelper() 
{

  if (!mLayer) {

    // For layers-free mode.

    if (mPushedClipAndScroll) {

      mBuilder->PopClipAndScrollInfo();

    }

    while (!mPushedClips.empty()) {

      wr::ScrollOrClipId id = mPushedClips.back();

      MOZ_ASSERT(id.is<wr::WrClipId>());

      if (id.is<wr::WrClipId>()) {

        mBuilder->PopClip();

      } else {

        MOZ_ASSERT(id.is<FrameMetrics::ViewID>());

        mBuilder->PopScrollLayer();

      }

      mPushedClips.pop_back();

    }

    return;

gfx/layers/wr/ScrollingLayersHelper.h

+8 −0
Original line number Diff line number Diff line
@@ -37,6 +37,13 @@ public: 
  ~ScrollingLayersHelper();



private:

  void DefineAndPushScrollLayers(nsDisplayItem* aItem,

                                 const ActiveScrolledRoot* aAsr,

                                 const DisplayItemClipChain* aChain,

                                 wr::DisplayListBuilder& aBuilder,

                                 int32_t aAppUnitsPerDevPixel,

                                 const StackingContextHelper& aStackingContext,

                                 WebRenderLayerManager::ClipIdMap& aCache);

  void DefineAndPushChain(const DisplayItemClipChain* aChain,

                          wr::DisplayListBuilder& aBuilder,

                          const StackingContextHelper& aStackingContext,
@@ -51,6 +58,7 @@ private: 
  WebRenderLayer* mLayer;

  wr::DisplayListBuilder* mBuilder;

  bool mPushedLayerLocalClip;

  bool mPushedClipAndScroll;

  std::vector<wr::ScrollOrClipId> mPushedClips;

};