Commit aa6cf4b3 authored by Jeff Muizelaar's avatar Jeff Muizelaar
Browse files

Bug 1728246. Remove unused ComputeVisibility infrastructure. r=mattwoodrow 

Differential Revision: https://phabricator.services.mozilla.com/D124109
parent bfc8589c

layout/generic/nsCanvasFrame.h

+0 −4
Original line number Diff line number Diff line
@@ -143,10 +143,6 @@ class nsDisplayCanvasBackgroundColor final : public nsDisplaySolidColorBase { 
                                 nsIFrame* aFrame)

      : nsDisplaySolidColorBase(aBuilder, aFrame, NS_RGBA(0, 0, 0, 0)) {}



  virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                 nsRegion* aVisibleRegion) override {

    return NS_GET_A(mColor) > 0;

  }

  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override {

    nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

layout/painting/nsDisplayList.cpp

+0 −300
Original line number Diff line number Diff line
@@ -2192,14 +2192,6 @@ void nsDisplayListSet::MoveTo(const nsDisplayListSet& aDestination) const { 
  aDestination.Outlines()->AppendToTop(Outlines());

}



static void MoveListTo(nsDisplayList* aList,

                       nsTArray<nsDisplayItem*>* aElements) {

  nsDisplayItem* item;

  while ((item = aList->RemoveBottom()) != nullptr) {

    aElements->AppendElement(item);

  }

}



nsRect nsDisplayList::GetClippedBounds(nsDisplayListBuilder* aBuilder) const {

  nsRect bounds;

  for (nsDisplayItem* i : *this) {
@@ -2235,78 +2227,6 @@ nsRect nsDisplayList::GetBuildingRect() const { 
  return result;

}



bool nsDisplayList::ComputeVisibilityForRoot(nsDisplayListBuilder* aBuilder,

                                             nsRegion* aVisibleRegion) {

  AUTO_PROFILER_LABEL("nsDisplayList::ComputeVisibilityForRoot", GRAPHICS);



  nsRegion r;

  const ActiveScrolledRoot* rootASR = nullptr;

  r.And(*aVisibleRegion, GetClippedBoundsWithRespectToASR(aBuilder, rootASR));

  return ComputeVisibilityForSublist(aBuilder, aVisibleRegion, r.GetBounds());

}



static nsRegion TreatAsOpaque(nsDisplayItem* aItem,

                              nsDisplayListBuilder* aBuilder) {

  bool snap;

  nsRegion opaque = aItem->GetOpaqueRegion(aBuilder, &snap);

  MOZ_ASSERT(

      (aBuilder->IsForEventDelivery() && aBuilder->HitTestIsForVisibility()) ||

      !opaque.IsComplex());

  if (opaque.IsEmpty()) {

    return opaque;

  }

  nsRegion opaqueClipped;

  for (auto iter = opaque.RectIter(); !iter.Done(); iter.Next()) {

    opaqueClipped.Or(opaqueClipped,

                     aItem->GetClip().ApproximateIntersectInward(iter.Get()));

  }

  return opaqueClipped;

}



bool nsDisplayList::ComputeVisibilityForSublist(

    nsDisplayListBuilder* aBuilder, nsRegion* aVisibleRegion,

    const nsRect& aListVisibleBounds) {

#ifdef DEBUG

  nsRegion r;

  r.And(*aVisibleRegion, GetClippedBounds(aBuilder));

  // XXX this fails sometimes:

  NS_WARNING_ASSERTION(r.GetBounds().IsEqualInterior(aListVisibleBounds),

                       "bad aListVisibleBounds");

#endif



  bool anyVisible = false;



  AutoTArray<nsDisplayItem*, 512> elements;

  MoveListTo(this, &elements);



  for (int32_t i = elements.Length() - 1; i >= 0; --i) {

    nsDisplayItem* item = elements[i];



    if (item->ForceNotVisible() && !item->GetSameCoordinateSystemChildren()) {

      NS_ASSERTION(item->GetBuildingRect().IsEmpty(),

                   "invisible items should have empty vis rect");

      item->SetPaintRect(nsRect());

    } else {

      nsRect bounds = item->GetClippedBounds(aBuilder);



      nsRegion itemVisible;

      itemVisible.And(*aVisibleRegion, bounds);

      item->SetPaintRect(itemVisible.GetBounds());

    }



    if (item->ComputeVisibility(aBuilder, aVisibleRegion)) {

      anyVisible = true;



      nsRegion opaque = TreatAsOpaque(item, aBuilder);

      // Subtract opaque item from the visible region

      aBuilder->SubtractFromVisibleRegion(aVisibleRegion, opaque);

    }

    AppendToBottom(item);

  }



  return anyVisible;

}



static void TriggerPendingAnimations(Document& aDoc,

                                     const TimeStamp& aReadyTime) {

  MOZ_ASSERT(!aReadyTime.IsNull(),
@@ -2919,12 +2839,6 @@ bool nsDisplayItem::ForceActiveLayers() { 


int32_t nsDisplayItem::ZIndex() const { return mFrame->ZIndex().valueOr(0); }



bool nsDisplayItem::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                      nsRegion* aVisibleRegion) {

  return !GetPaintRect().IsEmpty() &&

         !IsInvisibleInRect(aVisibleRegion->GetBounds());

}



void nsDisplayItem::SetClipChain(const DisplayItemClipChain* aClipChain,

                                 bool aStore) {

  mClipChain = aClipChain;
@@ -3031,36 +2945,6 @@ bool nsDisplayContainer::CreateWebRenderCommands( 
  return true;

}



/**

 * Like |nsDisplayList::ComputeVisibilityForSublist()|, but restricts

 * |aVisibleRegion| to given |aBounds| of the list.

 */

static bool ComputeClippedVisibilityForSubList(nsDisplayListBuilder* aBuilder,

                                               nsRegion* aVisibleRegion,

                                               nsDisplayList* aList,

                                               const nsRect& aBounds) {

  nsRegion visibleRegion;

  visibleRegion.And(*aVisibleRegion, aBounds);

  nsRegion originalVisibleRegion = visibleRegion;



  const bool anyItemVisible =

      aList->ComputeVisibilityForSublist(aBuilder, &visibleRegion, aBounds);

  nsRegion removed;

  // removed = originalVisibleRegion - visibleRegion

  removed.Sub(originalVisibleRegion, visibleRegion);

  // aVisibleRegion = aVisibleRegion - removed (modulo any simplifications

  // SubtractFromVisibleRegion does)

  aBuilder->SubtractFromVisibleRegion(aVisibleRegion, removed);



  return anyItemVisible;

}



bool nsDisplayContainer::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                           nsRegion* aVisibleRegion) {

  return ComputeClippedVisibilityForSubList(aBuilder, aVisibleRegion,

                                            GetChildren(), GetPaintRect());

}



nsRect nsDisplayContainer::GetBounds(nsDisplayListBuilder* aBuilder,

                                     bool* aSnap) const {

  *aSnap = false;
@@ -3858,18 +3742,6 @@ void nsDisplayBackgroundImage::HitTest(nsDisplayListBuilder* aBuilder, 
  }

}



bool nsDisplayBackgroundImage::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                                 nsRegion* aVisibleRegion) {

  if (!nsDisplayImageContainer::ComputeVisibility(aBuilder, aVisibleRegion)) {

    return false;

  }



  // Return false if the background was propagated away from this

  // frame. We don't want this display item to show up and confuse

  // anything.

  return mBackgroundStyle;

}



static nsRect GetInsideClipRect(const nsDisplayItem* aItem,

                                StyleGeometryBox aClip, const nsRect& aRect,

                                const nsRect& aBackgroundRect) {
@@ -5159,12 +5031,6 @@ nsRect nsDisplayWrapList::GetBounds(nsDisplayListBuilder* aBuilder, 
  return mBounds;

}



bool nsDisplayWrapList::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                          nsRegion* aVisibleRegion) {

  return ComputeClippedVisibilityForSubList(aBuilder, aVisibleRegion,

                                            GetChildren(), GetPaintRect());

}



nsRegion nsDisplayWrapList::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                                            bool* aSnap) const {

  *aSnap = false;
@@ -5532,19 +5398,6 @@ bool nsDisplayOpacity::ShouldFlattenAway(nsDisplayListBuilder* aBuilder) { 
  return ApplyToChildren(aBuilder);

}



bool nsDisplayOpacity::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                         nsRegion* aVisibleRegion) {

  // Our children are translucent so we should not allow them to subtract

  // area from aVisibleRegion. We do need to find out what is visible under

  // our children in the temporary compositing buffer, because if our children

  // paint our entire bounds opaquely then we don't need an alpha channel in

  // the temporary compositing buffer.

  nsRect bounds = GetClippedBounds(aBuilder);

  nsRegion visibleUnderChildren;

  visibleUnderChildren.And(*aVisibleRegion, bounds);

  return nsDisplayWrapList::ComputeVisibility(aBuilder, &visibleUnderChildren);

}



void nsDisplayOpacity::ComputeInvalidationRegion(

    nsDisplayListBuilder* aBuilder, const nsDisplayItemGeometry* aGeometry,

    nsRegion* aInvalidRegion) const {
@@ -5675,19 +5528,6 @@ gfx::CompositionOp nsDisplayBlendMode::BlendMode() { 
  return nsCSSRendering::GetGFXBlendMode(mBlendMode);

}



bool nsDisplayBlendMode::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                           nsRegion* aVisibleRegion) {

  // Our children are need their backdrop so we should not allow them to

  // subtract area from aVisibleRegion. We do need to find out what is visible

  // under our children in the temporary compositing buffer, because if our

  // children paint our entire bounds opaquely then we don't need an alpha

  // channel in the temporary compositing buffer.

  nsRect bounds = GetClippedBounds(aBuilder);

  nsRegion visibleUnderChildren;

  visibleUnderChildren.And(*aVisibleRegion, bounds);

  return nsDisplayWrapList::ComputeVisibility(aBuilder, &visibleUnderChildren);

}



bool nsDisplayBlendMode::CanMerge(const nsDisplayItem* aItem) const {

  // Items for the same content element should be merged into a single

  // compositing group.
@@ -6008,49 +5848,6 @@ nsRect nsDisplaySubDocument::GetBounds(nsDisplayListBuilder* aBuilder, 
  return nsDisplayOwnLayer::GetBounds(aBuilder, aSnap);

}



bool nsDisplaySubDocument::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                             nsRegion* aVisibleRegion) {

  bool usingDisplayPort = UseDisplayPortForViewport(aBuilder, mFrame);



  if (!(mFlags & nsDisplayOwnLayerFlags::GenerateScrollableLayer) ||

      !usingDisplayPort) {

    return nsDisplayWrapList::ComputeVisibility(aBuilder, aVisibleRegion);

  }



  nsRect displayport;

  nsIFrame* rootScrollFrame = mFrame->PresShell()->GetRootScrollFrame();

  MOZ_ASSERT(rootScrollFrame);

  Unused << DisplayPortUtils::GetDisplayPort(

      rootScrollFrame->GetContent(), &displayport,

      DisplayPortOptions().With(DisplayportRelativeTo::ScrollFrame));



  nsRegion childVisibleRegion;

  // The visible region for the children may be much bigger than the hole we

  // are viewing the children from, so that the compositor process has enough

  // content to asynchronously pan while content is being refreshed.

  childVisibleRegion =

      displayport + mFrame->GetOffsetToCrossDoc(ReferenceFrame());



  nsRect boundedRect = childVisibleRegion.GetBounds().Intersect(

      mList.GetClippedBoundsWithRespectToASR(aBuilder, mActiveScrolledRoot));

  bool visible = mList.ComputeVisibilityForSublist(

      aBuilder, &childVisibleRegion, boundedRect);



  // If APZ is enabled then don't allow this computation to influence

  // aVisibleRegion, on the assumption that the layer can be asynchronously

  // scrolled so we'll definitely need all the content under it.

  if (!nsLayoutUtils::UsesAsyncScrolling(mFrame)) {

    bool snap;

    nsRect bounds = GetBounds(aBuilder, &snap);

    nsRegion removed;

    removed.Sub(bounds, childVisibleRegion);



    aBuilder->SubtractFromVisibleRegion(aVisibleRegion, removed);

  }



  return visible;

}



nsRegion nsDisplaySubDocument::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                                               bool* aSnap) const {

  bool usingDisplayPort = UseDisplayPortForViewport(aBuilder, mFrame);
@@ -6610,42 +6407,6 @@ void nsDisplayZoom::HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect, 
  mList.HitTest(aBuilder, rect, aState, aOutFrames);

}



bool nsDisplayZoom::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                      nsRegion* aVisibleRegion) {

  // Convert the passed in visible region to our appunits.

  nsRegion visibleRegion;

  // mVisibleRect has been clipped to GetClippedBounds

  visibleRegion.And(*aVisibleRegion, GetPaintRect());

  visibleRegion = visibleRegion.ScaleToOtherAppUnitsRoundOut(mParentAPD, mAPD);

  nsRegion originalVisibleRegion = visibleRegion;



  nsRect transformedVisibleRect =

      GetPaintRect().ScaleToOtherAppUnitsRoundOut(mParentAPD, mAPD);

  bool retval;

  // If we are to generate a scrollable layer we call

  // nsDisplaySubDocument::ComputeVisibility to make the necessary adjustments

  // for ComputeVisibility, it does all it's calculations in the child APD.

  bool usingDisplayPort = UseDisplayPortForViewport(aBuilder, mFrame);

  if (!(mFlags & nsDisplayOwnLayerFlags::GenerateScrollableLayer) ||

      !usingDisplayPort) {

    retval = mList.ComputeVisibilityForSublist(aBuilder, &visibleRegion,

                                               transformedVisibleRect);

  } else {

    retval = nsDisplaySubDocument::ComputeVisibility(aBuilder, &visibleRegion);

  }



  nsRegion removed;

  // removed = originalVisibleRegion - visibleRegion

  removed.Sub(originalVisibleRegion, visibleRegion);

  // Convert removed region to parent appunits.

  removed = removed.ScaleToOtherAppUnitsRoundIn(mAPD, mParentAPD);

  // aVisibleRegion = aVisibleRegion - removed (modulo any simplifications

  // SubtractFromVisibleRegion does)

  aBuilder->SubtractFromVisibleRegion(aVisibleRegion, removed);



  return retval;

}



nsDisplayAsyncZoom::nsDisplayAsyncZoom(

    nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, nsDisplayList* aList,

    const ActiveScrolledRoot* aActiveScrolledRoot, FrameMetrics::ViewID aViewID)
@@ -7648,35 +7409,6 @@ bool nsDisplayTransform::MayBeAnimated(nsDisplayListBuilder* aBuilder, 
          !(aEnforceMinimumSize && IsItemTooSmallForActiveLayer(mFrame)));

}



bool nsDisplayTransform::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                           nsRegion* aVisibleRegion) {

  // nsDisplayTransform::GetBounds() returns an empty rect in nested 3d context.

  // Calling mStoredList.RecomputeVisibility below for such transform causes the

  // child display items to end up with empty visible rect.

  // We avoid this by bailing out always if we are dealing with a 3d context.

  if (mFrame->Extend3DContext() || Combines3DTransformWithAncestors()) {

    return true;

  }



  /* As we do this, we need to be sure to

   * untransform the visible rect, since we want everything that's painting to

   * think that it's painting in its original rectangular coordinate space.

   * If we can't untransform, take the entire overflow rect */

  nsRect untransformedVisibleRect;

  if (!UntransformPaintRect(aBuilder, &untransformedVisibleRect)) {

    untransformedVisibleRect = mFrame->InkOverflowRectRelativeToSelf();

  }



  bool snap;

  const nsRect bounds = GetUntransformedBounds(aBuilder, &snap);

  nsRegion visibleRegion;

  visibleRegion.And(bounds, untransformedVisibleRect);

  GetChildren()->ComputeVisibilityForSublist(aBuilder, &visibleRegion,

                                             visibleRegion.GetBounds());



  return true;

}



nsRect nsDisplayTransform::TransformUntransformedBounds(

    nsDisplayListBuilder* aBuilder, const Matrix4x4Flagged& aMatrix) const {

  bool snap;
@@ -8204,12 +7936,6 @@ bool nsDisplayPerspective::CreateWebRenderCommands( 
  return true;

}



bool nsDisplayPerspective::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                             nsRegion* aVisibleRegion) {

  return mList.ComputeVisibilityForSublist(aBuilder, aVisibleRegion,

                                           GetPaintRect());

}



nsDisplayText::nsDisplayText(nsDisplayListBuilder* aBuilder,

                             nsTextFrame* aFrame)

    : nsPaintedDisplayItem(aBuilder, aFrame),
@@ -8718,16 +8444,6 @@ bool nsDisplayMasksAndClipPaths::CanPaintOnMaskLayer(LayerManager* aManager) { 
  return true;

}



bool nsDisplayMasksAndClipPaths::ComputeVisibility(

    nsDisplayListBuilder* aBuilder, nsRegion* aVisibleRegion) {

  // Our children may be made translucent or arbitrarily deformed so we should

  // not allow them to subtract area from aVisibleRegion.

  nsRegion childrenVisible(GetPaintRect());

  nsRect r = GetPaintRect().Intersect(mList.GetClippedBounds(aBuilder));

  mList.ComputeVisibilityForSublist(aBuilder, &childrenVisible, r);

  return true;

}



void nsDisplayMasksAndClipPaths::ComputeInvalidationRegion(

    nsDisplayListBuilder* aBuilder, const nsDisplayItemGeometry* aGeometry,

    nsRegion* aInvalidRegion) const {
@@ -9151,22 +8867,6 @@ void nsDisplayFilters::Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) { 
  });

}



bool nsDisplayFilters::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                         nsRegion* aVisibleRegion) {

  nsPoint offset = ToReferenceFrame();

  nsRect dirtyRect = SVGIntegrationUtils::GetRequiredSourceForInvalidArea(

                         mFrame, GetPaintRect() - offset) +

                     offset;



  // Our children may be made translucent or arbitrarily deformed so we should

  // not allow them to subtract area from aVisibleRegion.

  nsRegion childrenVisible(dirtyRect);

  nsRect r = dirtyRect.Intersect(

      mList.GetClippedBoundsWithRespectToASR(aBuilder, mActiveScrolledRoot));

  mList.ComputeVisibilityForSublist(aBuilder, &childrenVisible, r);

  return true;

}



void nsDisplayFilters::ComputeInvalidationRegion(

    nsDisplayListBuilder* aBuilder, const nsDisplayItemGeometry* aGeometry,

    nsRegion* aInvalidRegion) const {

layout/painting/nsDisplayList.h

+1 −82
Original line number Diff line number Diff line
@@ -2756,26 +2756,6 @@ class nsDisplayItem : public nsDisplayItemLink { 
    return false;

  }



  /**

   * On entry, aVisibleRegion contains the region (relative to ReferenceFrame())

   * which may be visible. If the display item opaquely covers an area, it

   * can remove that area from aVisibleRegion before returning.

   * nsDisplayList::ComputeVisibility automatically subtracts the region

   * returned by GetOpaqueRegion, and automatically removes items whose bounds

   * do not intersect the visible area, so implementations of

   * nsDisplayItem::ComputeVisibility do not need to do these things.

   * nsDisplayList::ComputeVisibility will already have set mVisibleRect on

   * this item to the intersection of *aVisibleRegion and this item's bounds.

   * We rely on that, so this should only be called by

   * nsDisplayList::ComputeVisibility or nsDisplayItem::RecomputeVisibility.

   * This method needs to be idempotent.

   *

   * @return true if the item is visible, false if no part of the item

   * is visible.

   */

  virtual bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                 nsRegion* aVisibleRegion);



  /**

   * Returns true if this item needs to have its geometry updated, despite

   * returning empty invalidation region.
@@ -3023,9 +3003,6 @@ class nsDisplayItem : public nsDisplayItemLink { 
  // rect to decide which items to construct.

  nsRect mBuildingRect;



  // nsDisplayList::ComputeVisibility sets this to the visible region

  // of the item by intersecting the visible region with the bounds

  // of the item. Paint implementations can use this to limit their drawing.

  // Guaranteed to be contained in GetBounds().

  nsRect mPaintRect;
@@ -3165,7 +3142,7 @@ class nsPaintedDisplayItem : public nsDisplayItem { 
 *

 * Stepping upward through this list is very fast. Stepping downward is very

 * slow so we don't support it. The methods that need to step downward

 * (HitTest(), ComputeVisibility()) internally build a temporary array of all

 * (HitTest()) internally build a temporary array of all

 * the items while they do the downward traversal, so overall they're still

 * linear time. We have optimized for efficient AppendToTop() of both

 * items and lists, with minimal codesize. AppendToBottom() is efficient too.
@@ -3456,39 +3433,6 @@ class nsDisplayList { 
    }

  }



  /**

   * Compute visiblity for the items in the list.

   * We put this logic here so it can be shared by top-level

   * painting and also display items that maintain child lists.

   * This is also a good place to put ComputeVisibility-related logic

   * that must be applied to every display item. In particular, this

   * sets mVisibleRect on each display item.

   * This does not remove any items from the list, so we can recompute

   * visiblity with different regions later (see

   * FrameLayerBuilder::DrawPaintedLayer).

   * This method needs to be idempotent.

   *

   * @param aVisibleRegion the area that is visible, relative to the

   * reference frame; on return, this contains the area visible under the list.

   * I.e., opaque contents of this list are subtracted from aVisibleRegion.

   * @param aListVisibleBounds must be equal to the bounds of the intersection

   * of aVisibleRegion and GetBounds() for this list.

   * @return true if any item in the list is visible.

   */

  bool ComputeVisibilityForSublist(nsDisplayListBuilder* aBuilder,

                                   nsRegion* aVisibleRegion,

                                   const nsRect& aListVisibleBounds);



  /**

   * As ComputeVisibilityForSublist, but computes visibility for a root

   * list (a list that does not belong to an nsDisplayItem).

   * This method needs to be idempotent.

   *

   * @param aVisibleRegion the area that is visible

   */

  bool ComputeVisibilityForRoot(nsDisplayListBuilder* aBuilder,

                                nsRegion* aVisibleRegion);



  /**

   * Returns true if any display item requires the surface to be transparent.

   */
@@ -3815,9 +3759,6 @@ class nsDisplayContainer final : public nsDisplayItem { 
    nsDisplayItem::Destroy(aBuilder);

  }



  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  bool CreateWebRenderCommands(

      wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,

      const StackingContextHelper& aSc,
@@ -4375,8 +4316,6 @@ class nsDisplayBackgroundImage : public nsDisplayImageContainer { 
      nsDisplayListBuilder* aDisplayListBuilder) override;

  void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,

               HitTestState* aState, nsTArray<nsIFrame*>* aOutFrames) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;

  nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override;

  Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) const override;
@@ -5147,8 +5086,6 @@ class nsDisplayWrapList : public nsPaintedDisplayItem { 
  nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override;

  Maybe<nscolor> IsUniform(nsDisplayListBuilder* aBuilder) const override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  /**

   * Checks if the given display item can be merged with this item.
@@ -5368,8 +5305,6 @@ class nsDisplayOpacity : public nsDisplayWrapList { 
  nsRegion GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override;

  void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  bool CanMerge(const nsDisplayItem* aItem) const override {

    // items for the same content element should be merged into a single
@@ -5492,8 +5427,6 @@ class nsDisplayBlendMode : public nsDisplayWrapList { 
      layers::RenderRootStateManager* aManager,

      nsDisplayListBuilder* aDisplayListBuilder) override;

  void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  bool CanMerge(const nsDisplayItem* aItem) const override;
@@ -5790,8 +5723,6 @@ class nsDisplaySubDocument : public nsDisplayOwnLayer { 


  virtual nsSubDocumentFrame* SubDocumentFrame() { return mSubDocFrame; }



  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;

  bool ShouldFlattenAway(nsDisplayListBuilder* aBuilder) override {

    return mShouldFlatten;

  }
@@ -6062,8 +5993,6 @@ class nsDisplayZoom : public nsDisplaySubDocument { 
  nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override;

  void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,

               HitTestState* aState, nsTArray<nsIFrame*>* aOutFrames) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;

  // Get the app units per dev pixel ratio of the child document.

  int32_t GetChildAppUnitsPerDevPixel() { return mAPD; }

  // Get the app units per dev pixel ratio of the parent document.
@@ -6209,8 +6138,6 @@ class nsDisplayMasksAndClipPaths : public nsDisplayEffectsBase { 
  }



  void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  nsDisplayItemGeometry* AllocateGeometry(

      nsDisplayListBuilder* aBuilder) override {
@@ -6371,9 +6298,6 @@ class nsDisplayFilters : public nsDisplayEffectsBase { 
    return mEffectsBounds + ToReferenceFrame();

  }



  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  nsDisplayItemGeometry* AllocateGeometry(

      nsDisplayListBuilder* aBuilder) override {

    return new nsDisplayFiltersGeometry(this, aBuilder);
@@ -6504,8 +6428,6 @@ class nsDisplayTransform : public nsPaintedDisplayItem { 
      nsDisplayListBuilder* aDisplayListBuilder) override;

  bool UpdateScrollData(layers::WebRenderScrollData* aData,

                        layers::WebRenderLayerScrollData* aLayerData) override;

  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  nsDisplayItemGeometry* AllocateGeometry(

      nsDisplayListBuilder* aBuilder) override {
@@ -6831,9 +6753,6 @@ class nsDisplayPerspective : public nsPaintedDisplayItem { 
                                                           mActiveScrolledRoot);

  }



  bool ComputeVisibility(nsDisplayListBuilder* aBuilder,

                         nsRegion* aVisibleRegion) override;



  void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                 const nsDisplayItemGeometry* aGeometry,

                                 nsRegion* aInvalidRegion) const override {}