tor-browser

WebRenderScrollDataWrapper.h (19030B)

---

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

#ifndef GFX_WEBRENDERSCROLLDATAWRAPPER_H
#define GFX_WEBRENDERSCROLLDATAWRAPPER_H

#include "FrameMetrics.h"
#include "mozilla/layers/APZUpdater.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/layers/WebRenderBridgeParent.h"
#include "mozilla/layers/WebRenderScrollData.h"

namespace mozilla {
namespace layers {

/**
* A wrapper class around a target WebRenderLayerScrollData (henceforth,
* "layer") that allows user code to walk through the ScrollMetadata objects
* on the layer the same way it would walk through a layer tree.
* Consider the following layer tree:
*
*                    +---+
*                    | A |
*                    +---+
*                   /  |  \
*                  /   |   \
*                 /    |    \
*            +---+  +-----+  +---+
*            | B |  |  C  |  | D |
*            +---+  +-----+  +---+
*                   | SMn |
*                   |  .  |
*                   |  .  |
*                   |  .  |
*                   | SM1 |
*                   | SM0 |
*                   +-----+
*                   /     \
*                  /       \
*             +---+         +---+
*             | E |         | F |
*             +---+         +---+
*
* In this layer tree, there are six layers with A being the root and B,D,E,F
* being leaf nodes. Layer C is in the middle and has n+1 ScrollMetadata,
* labelled SM0...SMn. SM0 is the ScrollMetadata you get by calling
* c->GetScrollMetadata(0) and SMn is the ScrollMetadata you can obtain by
* calling c->GetScrollMetadata(c->GetScrollMetadataCount() - 1). This layer
* tree is conceptually equivalent to this one below:
*
*                    +---+
*                    | A |
*                    +---+
*                   /  |  \
*                  /   |   \
*                 /    |    \
*            +---+  +-----+  +---+
*            | B |  | Cn  |  | D |
*            +---+  +-----+  +---+
*                      |
*                      .
*                      .
*                      .
*                      |
*                   +-----+
*                   | C1  |
*                   +-----+
*                      |
*                   +-----+
*                   | C0  |
*                   +-----+
*                   /     \
*                  /       \
*             +---+         +---+
*             | E |         | F |
*             +---+         +---+
*
* In this layer tree, the layer C has been expanded into a stack of layers
* C1...Cn, where C1 has ScrollMetadata SM1 and Cn has ScrollMetdata Fn.
*
* The WebRenderScrollDataWrapper class allows client code to treat the first
* layer tree as though it were the second. That is, instead of client code
* having to iterate through the ScrollMetadata objects directly, it can use a
* WebRenderScrollDataWrapper to encapsulate that aspect of the layer tree and
* just walk the tree as if it were a stack of layers.
*
* The functions on this class do different things depending on which
* simulated layer is being wrapped. For example, if the
* WebRenderScrollDataWrapper is pretending to be C0, the GetPrevSibling()
* function will return null even though the underlying layer C does actually
* have a prev sibling. The WebRenderScrollDataWrapper pretending to be Cn will
* return B as the prev sibling.
*
* Implementation notes:
*
* The AtTopLayer() and AtBottomLayer() functions in this class refer to
* Cn and C0 in the second layer tree above; that is, they are predicates
* to test if the wrapper is simulating the topmost or bottommost layer, as
* those can have special behaviour.
*
* It is possible to wrap a nullptr in a WebRenderScrollDataWrapper, in which
* case the IsValid() function will return false. This is required to allow
* WebRenderScrollDataWrapper to be a MOZ_STACK_CLASS (desirable because it is
* used in loops and recursion).
*
* This class purposely does not expose the wrapped layer directly to avoid
* user code from accidentally calling functions directly on it. Instead
* any necessary functions should be wrapped in this class. It does expose
* the wrapped layer as a void* for printf purposes.
*
* The implementation may look like it special-cases mIndex == 0 and/or
* GetScrollMetadataCount() == 0. This is an artifact of the fact that both
* mIndex and GetScrollMetadataCount() are uint32_t and GetScrollMetadataCount()
* can return 0 but mIndex cannot store -1. This seems better than the
* alternative of making mIndex a int32_t that can store -1, but then having
* to cast to uint32_t all over the place.
*
* Note that WebRenderLayerScrollData objects are owned by WebRenderScrollData,
* which stores them in a flattened representation. The field mData,
* mLayerIndex, and mContainingSubtreeIndex are used to move around the "layers"
* given the flattened representation. The mMetadataIndex is used to move around
* the ScrollMetadata within a single layer.
*
* One important note here is that this class holds a pointer to the "owning"
* WebRenderScrollData. The caller must ensure that this class does not outlive
* the owning WebRenderScrollData, or this may result in use-after-free errors.
* This class being declared a MOZ_STACK_CLASS should help with that.
*/
class MOZ_STACK_CLASS WebRenderScrollDataWrapper final {
public:
 // Basic constructor for external callers. Starts the walker at the root of
 // the tree.
 explicit WebRenderScrollDataWrapper(
     const APZUpdater& aUpdater, const WebRenderScrollData* aData = nullptr)
     : mUpdater(&aUpdater),
       mData(aData),
       mLayerIndex(0),
       mContainingSubtreeLastIndex(0),
       mLayer(nullptr),
       mMetadataIndex(0) {
   if (!mData) {
     return;
   }
   mLayer = mData->GetLayerData(mLayerIndex);
   if (!mLayer) {
     return;
   }

   // sanity check on the data
   MOZ_ASSERT(mData->GetLayerCount() ==
              (size_t)(1 + mLayer->GetDescendantCount()));
   mContainingSubtreeLastIndex = mData->GetLayerCount();

   // See documentation in LayerMetricsWrapper.h about this. mMetadataIndex
   // in this class is equivalent to mIndex in that class.
   mMetadataIndex = mLayer->GetScrollMetadataCount();
   if (mMetadataIndex > 0) {
     mMetadataIndex--;
   }
 }

private:
 // Internal constructor for walking from one WebRenderLayerScrollData to
 // another. In this case we need to recompute the mMetadataIndex to be the
 // "topmost" scroll metadata on the new layer.
 WebRenderScrollDataWrapper(const APZUpdater* aUpdater,
                            const WebRenderScrollData* aData,
                            size_t aLayerIndex,
                            size_t aContainingSubtreeLastIndex)
     : mUpdater(aUpdater),
       mData(aData),
       mLayerIndex(aLayerIndex),
       mContainingSubtreeLastIndex(aContainingSubtreeLastIndex),
       mLayer(nullptr),
       mMetadataIndex(0) {
   MOZ_ASSERT(mData);
   mLayer = mData->GetLayerData(mLayerIndex);
   MOZ_ASSERT(mLayer);

   // See documentation in LayerMetricsWrapper.h about this. mMetadataIndex
   // in this class is equivalent to mIndex in that class.
   mMetadataIndex = mLayer->GetScrollMetadataCount();
   if (mMetadataIndex > 0) {
     mMetadataIndex--;
   }
 }

 // Internal constructor for walking from one metadata to another metadata on
 // the same WebRenderLayerScrollData.
 WebRenderScrollDataWrapper(const APZUpdater* aUpdater,
                            const WebRenderScrollData* aData,
                            size_t aLayerIndex,
                            size_t aContainingSubtreeLastIndex,
                            const WebRenderLayerScrollData* aLayer,
                            uint32_t aMetadataIndex)
     : mUpdater(aUpdater),
       mData(aData),
       mLayerIndex(aLayerIndex),
       mContainingSubtreeLastIndex(aContainingSubtreeLastIndex),
       mLayer(aLayer),
       mMetadataIndex(aMetadataIndex) {
   MOZ_ASSERT(mData);
   MOZ_ASSERT(mLayer);
   MOZ_ASSERT(mLayer == mData->GetLayerData(mLayerIndex));
   MOZ_ASSERT(mMetadataIndex == 0 ||
              mMetadataIndex < mLayer->GetScrollMetadataCount());
 }

public:
 bool IsValid() const { return mLayer != nullptr; }

 explicit operator bool() const { return IsValid(); }

 WebRenderScrollDataWrapper GetLastChild() const {
   MOZ_ASSERT(IsValid());

   if (!AtBottomLayer()) {
     // If we're still walking around in the virtual container layers created
     // by the ScrollMetadata array, we just need to update the metadata index
     // and that's it.
     return WebRenderScrollDataWrapper(mUpdater, mData, mLayerIndex,
                                       mContainingSubtreeLastIndex, mLayer,
                                       mMetadataIndex - 1);
   }

   // Otherwise, we need to walk to a different WebRenderLayerScrollData in
   // mData.

   // Since mData contains the layer in depth-first, last-to-first order,
   // the index after mLayerIndex must be mLayerIndex's last child, if it
   // has any children (indicated by GetDescendantCount() > 0). Furthermore
   // we compute the first index outside the subtree rooted at this node
   // (in |subtreeLastIndex|) and pass that in to the child wrapper to use as
   // its mContainingSubtreeLastIndex.
   if (mLayer->GetDescendantCount() > 0) {
     size_t prevSiblingIndex = mLayerIndex + 1 + mLayer->GetDescendantCount();
     // TODO(botond): Replace the min() with just prevSiblingIndex (which
     // should be <= mContainingSubtreeLastIndex).
     MOZ_ASSERT(prevSiblingIndex <= mContainingSubtreeLastIndex);
     size_t subtreeLastIndex =
         std::min(mContainingSubtreeLastIndex, prevSiblingIndex);
     return WebRenderScrollDataWrapper(mUpdater, mData, mLayerIndex + 1,
                                       subtreeLastIndex);
   }

   // We've run out of descendants. But! If the original layer was a RefLayer,
   // then it connects to another layer tree and we need to traverse that too.
   // So return a WebRenderScrollDataWrapper for the root of the child layer
   // tree.
   if (mLayer->GetReferentId()) {
     return WebRenderScrollDataWrapper(
         *mUpdater, mUpdater->GetScrollData(*mLayer->GetReferentId()));
   }

   return WebRenderScrollDataWrapper(*mUpdater);
 }

 WebRenderScrollDataWrapper GetPrevSibling() const {
   MOZ_ASSERT(IsValid());

   if (!AtTopLayer()) {
     // The virtual container layers don't have siblings
     return WebRenderScrollDataWrapper(*mUpdater);
   }

   // Skip past the descendants to get to the previous sibling. However, we
   // might be at the last sibling already.
   size_t prevSiblingIndex = mLayerIndex + 1 + mLayer->GetDescendantCount();
   if (prevSiblingIndex < mContainingSubtreeLastIndex) {
     return WebRenderScrollDataWrapper(mUpdater, mData, prevSiblingIndex,
                                       mContainingSubtreeLastIndex);
   }
   return WebRenderScrollDataWrapper(*mUpdater);
 }

 const ScrollMetadata& Metadata() const {
   MOZ_ASSERT(IsValid());

   if (mMetadataIndex >= mLayer->GetScrollMetadataCount()) {
     return *ScrollMetadata::sNullMetadata;
   }
   return mLayer->GetScrollMetadata(*mData, mMetadataIndex);
 }

 const FrameMetrics& Metrics() const { return Metadata().GetMetrics(); }

 AsyncPanZoomController* GetApzc() const { return nullptr; }

 void SetApzc(AsyncPanZoomController* aApzc) const {}

 const char* Name() const { return "WebRenderScrollDataWrapper"; }

 gfx::Matrix4x4 GetTransform() const {
   MOZ_ASSERT(IsValid());

   // See WebRenderLayerScrollData::Initialize for more context.
   //  * The ancestor transform is associated with whichever layer has scroll
   //    id matching GetAncestorTransformId().
   //  * The transform is associated with the "bottommost" layer.
   // Multiple transforms may apply to the same layer (e.g. if there is only
   // one scrollmetadata on the layer, then it is both "topmost" and
   // "bottommost"), so we may need to combine the transforms.

   gfx::Matrix4x4 transform;
   // The ancestor transform is usually emitted at the layer with the
   // matching scroll id. However, sometimes the transform ends up on
   // a node with no scroll metadata at all. In such cases we generate
   // a single layer, and the ancestor transform needs to be on that layer,
   // otherwise it will be lost.
   bool emitAncestorTransform =
       !Metrics().IsScrollable() ||
       Metrics().GetScrollId() == mLayer->GetAncestorTransformId();
   if (emitAncestorTransform) {
     transform = mLayer->GetAncestorTransform();
   }
   if (AtBottomLayer()) {
     transform = mLayer->GetTransform() * transform;
   }
   return transform;
 }

 CSSTransformMatrix GetTransformTyped() const {
   return ViewAs<CSSTransformMatrix>(GetTransform());
 }

 bool TransformIsPerspective() const {
   MOZ_ASSERT(IsValid());

   // mLayer->GetTransformIsPerspective() tells us whether
   // mLayer->GetTransform() is a perspective transform. Since
   // mLayer->GetTransform() is only used at the bottom layer, we only
   // need to check GetTransformIsPerspective() at the bottom layer too.
   if (AtBottomLayer()) {
     return mLayer->GetTransformIsPerspective();
   }
   return false;
 }

 LayerIntRect GetVisibleRect() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetVisibleRect();
   }

   return ViewAs<LayerPixel>(
       TransformBy(mLayer->GetTransformTyped(), mLayer->GetVisibleRect()),
       PixelCastJustification::MovingDownToChildren);
 }

 LayerIntSize GetRemoteDocumentSize() const {
   MOZ_ASSERT(IsValid());

   if (mLayer->GetReferentId().isNothing()) {
     return LayerIntSize();
   }

   if (AtBottomLayer()) {
     return mLayer->GetRemoteDocumentSize();
   }

   return ViewAs<LayerPixel>(mLayer->GetRemoteDocumentSize(),
                             PixelCastJustification::MovingDownToChildren);
 }

 Maybe<LayersId> GetReferentId() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetReferentId();
   }
   return Nothing();
 }

 EventRegionsOverride GetEventRegionsOverride() const {
   MOZ_ASSERT(IsValid());
   // Only ref layers can have an event regions override.
   if (GetReferentId()) {
     return mLayer->GetEventRegionsOverride();
   }
   return EventRegionsOverride::NoOverride;
 }

 const ScrollbarData& GetScrollbarData() const {
   MOZ_ASSERT(IsValid());
   return mLayer->GetScrollbarData();
 }

 Maybe<uint64_t> GetScrollbarAnimationId() const {
   MOZ_ASSERT(IsValid());
   return mLayer->GetScrollbarAnimationId();
 }

 Maybe<uint64_t> GetFixedPositionAnimationId() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetFixedPositionAnimationId();
   }
   return Nothing();
 }

 ScrollableLayerGuid::ViewID GetFixedPositionScrollContainerId() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetFixedPositionScrollContainerId();
   }
   return ScrollableLayerGuid::NULL_SCROLL_ID;
 }

 SideBits GetFixedPositionSides() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetFixedPositionSides();
   }
   return SideBits::eNone;
 }

 ScrollableLayerGuid::ViewID GetStickyScrollContainerId() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetStickyPositionScrollContainerId();
   }
   return ScrollableLayerGuid::NULL_SCROLL_ID;
 }

 const LayerRectAbsolute& GetStickyScrollRangeOuter() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetStickyScrollRangeOuter();
   }

   static const LayerRectAbsolute empty;
   return empty;
 }

 const LayerRectAbsolute& GetStickyScrollRangeInner() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetStickyScrollRangeInner();
   }

   static const LayerRectAbsolute empty;
   return empty;
 }

 Maybe<uint64_t> GetStickyPositionAnimationId() const {
   MOZ_ASSERT(IsValid());

   if (AtBottomLayer()) {
     return mLayer->GetStickyPositionAnimationId();
   }
   return Nothing();
 }

 Maybe<uint64_t> GetZoomAnimationId() const {
   MOZ_ASSERT(IsValid());
   return mLayer->GetZoomAnimationId();
 }

 Maybe<ScrollableLayerGuid::ViewID> GetAsyncZoomContainerId() const {
   MOZ_ASSERT(IsValid());
   return mLayer->GetAsyncZoomContainerId();
 }

 // Expose an opaque pointer to the layer. Mostly used for printf
 // purposes. This is not intended to be a general-purpose accessor
 // for the underlying layer.
 const void* GetLayer() const {
   MOZ_ASSERT(IsValid());
   return mLayer;
 }

 template <int Level>
 size_t Dump(gfx::TreeLog<Level>& aOut) const {
   std::string result = "(invalid)";
   if (!IsValid()) {
     aOut << result;
     return result.length();
   }
   if (AtBottomLayer()) {
     if (mData != nullptr) {
       const WebRenderLayerScrollData* layerData =
           mData->GetLayerData(mLayerIndex);
       if (layerData != nullptr) {
         std::stringstream ss;
         layerData->Dump(ss, *mData);
         result = ss.str();
         aOut << result;
         return result.length();
       }
     }
   }
   return 0;
 }

 bool IsFirstPaint() const { return mData ? mData->IsFirstPaint() : false; }

private:
 bool AtBottomLayer() const { return mMetadataIndex == 0; }

 bool AtTopLayer() const {
   return mLayer->GetScrollMetadataCount() == 0 ||
          mMetadataIndex == mLayer->GetScrollMetadataCount() - 1;
 }

private:
 const APZUpdater* mUpdater;
 const WebRenderScrollData* mData;
 // The index (in mData->mLayerScrollData) of the WebRenderLayerScrollData this
 // wrapper is pointing to.
 size_t mLayerIndex;
 // The upper bound on the set of valid indices inside the subtree rooted at
 // the parent of this "layer". That is, any layer index |i| in the range
 // mLayerIndex <= i < mContainingSubtreeLastIndex is guaranteed to point to
 // a layer that is a descendant of "parent", where "parent" is the parent
 // layer of the layer at mLayerIndex. This is needed in order to implement
 // GetPrevSibling() correctly.
 size_t mContainingSubtreeLastIndex;
 // The WebRenderLayerScrollData this wrapper is pointing to.
 const WebRenderLayerScrollData* mLayer;
 // The index of the scroll metadata within mLayer that this wrapper is
 // pointing to.
 uint32_t mMetadataIndex;
};

}  // namespace layers
}  // namespace mozilla

#endif /* GFX_WEBRENDERSCROLLDATAWRAPPER_H */