gfx/layers/wr/WebRenderScrollData.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef GFX_WEBRENDERSCROLLDATA_H
   8 #define GFX_WEBRENDERSCROLLDATA_H
   9
  10 #include <map>
  11
  12 #include "chrome/common/ipc_message_utils.h"
  13 #include "FrameMetrics.h"
  14 #include "ipc/IPCMessageUtils.h"
  15 #include "LayersTypes.h"
  16 #include "mozilla/Attributes.h"
  17 #include "mozilla/GfxMessageUtils.h"
  18 #include "mozilla/layers/LayerAttributes.h"
  19 #include "mozilla/layers/LayersMessageUtils.h"
  20 #include "mozilla/layers/FocusTarget.h"
  21 #include "mozilla/layers/WebRenderMessageUtils.h"
  22 #include "mozilla/webrender/WebRenderTypes.h"
  23 #include "mozilla/HashTable.h"
  24 #include "mozilla/Maybe.h"
  25 #include "nsTArrayForwardDeclare.h"
  26
  27 class nsDisplayItem;
  28
  29 namespace mozilla {
  30
  31 struct ActiveScrolledRoot;
  32
  33 namespace layers {
  34
  35 class Layer;
  36 class WebRenderLayerManager;
  37 class WebRenderScrollData;
  38
  39 // Data needed by APZ, per layer. One instance of this class is created for
  40 // each layer in the layer tree and sent over PWebRenderBridge to the APZ code.
  41 // Each WebRenderLayerScrollData is conceptually associated with an "owning"
  42 // WebRenderScrollData.
  43 class WebRenderLayerScrollData final {
  44  public:
  45   WebRenderLayerScrollData();  // needed for IPC purposes
  46   ~WebRenderLayerScrollData();
  47
  48   void InitializeRoot(int32_t aDescendantCount);
  49   void Initialize(WebRenderScrollData& aOwner, nsDisplayItem* aItem,
  50                   int32_t aDescendantCount,
  51                   const ActiveScrolledRoot* aStopAtAsr,
  52                   const Maybe<gfx::Matrix4x4>& aAncestorTransform);
  53
  54   int32_t GetDescendantCount() const;
  55   size_t GetScrollMetadataCount() const;
  56
  57   void AppendScrollMetadata(WebRenderScrollData& aOwner,
  58                             const ScrollMetadata& aData);
  59   // Return the ScrollMetadata object that used to be on the original Layer
  60   // at the given index. Since we deduplicate the ScrollMetadata objects into
  61   // the array in the owning WebRenderScrollData object, we need to be passed
  62   // in a reference to that owner as well.
  63   const ScrollMetadata& GetScrollMetadata(const WebRenderScrollData& aOwner,
  64                                           size_t aIndex) const;
  65
  66   gfx::Matrix4x4 GetAncestorTransform() const { return mAncestorTransform; }
  67   void SetTransform(const gfx::Matrix4x4& aTransform) {
  68     mTransform = aTransform;
  69   }
  70   gfx::Matrix4x4 GetTransform() const { return mTransform; }
  71   CSSTransformMatrix GetTransformTyped() const;
  72   void SetTransformIsPerspective(bool aTransformIsPerspective) {
  73     mTransformIsPerspective = aTransformIsPerspective;
  74   }
  75   bool GetTransformIsPerspective() const { return mTransformIsPerspective; }
  76
  77   EventRegions GetEventRegions() const { return EventRegions(); }
  78   void SetEventRegionsOverride(const EventRegionsOverride& aOverride) {
  79     mEventRegionsOverride = aOverride;
  80   }
  81   EventRegionsOverride GetEventRegionsOverride() const {
  82     return mEventRegionsOverride;
  83   }
  84
  85   void SetVisibleRegion(const LayerIntRegion& aRegion) {
  86     mVisibleRegion = aRegion;
  87   }
  88   const LayerIntRegion& GetVisibleRegion() const { return mVisibleRegion; }
  89   void SetRemoteDocumentSize(const LayerIntSize& aRemoteDocumentSize) {
  90     mRemoteDocumentSize = aRemoteDocumentSize;
  91   }
  92   const LayerIntSize& GetRemoteDocumentSize() const {
  93     return mRemoteDocumentSize;
  94   }
  95   void SetReferentId(LayersId aReferentId) { mReferentId = Some(aReferentId); }
  96   Maybe<LayersId> GetReferentId() const { return mReferentId; }
  97
  98   void SetScrollbarData(const ScrollbarData& aData) { mScrollbarData = aData; }
  99   const ScrollbarData& GetScrollbarData() const { return mScrollbarData; }
 100   void SetScrollbarAnimationId(const uint64_t& aId) {
 101     mScrollbarAnimationId = Some(aId);
 102   }
 103   Maybe<uint64_t> GetScrollbarAnimationId() const {
 104     return mScrollbarAnimationId;
 105   }
 106
 107   void SetFixedPositionAnimationId(const uint64_t& aId) {
 108     mFixedPositionAnimationId = Some(aId);
 109   }
 110   Maybe<uint64_t> GetFixedPositionAnimationId() const {
 111     return mFixedPositionAnimationId;
 112   }
 113
 114   void SetFixedPositionSides(const SideBits& aSideBits) {
 115     mFixedPositionSides = aSideBits;
 116   }
 117   SideBits GetFixedPositionSides() const { return mFixedPositionSides; }
 118
 119   void SetFixedPositionScrollContainerId(ScrollableLayerGuid::ViewID aId) {
 120     mFixedPosScrollContainerId = aId;
 121   }
 122   ScrollableLayerGuid::ViewID GetFixedPositionScrollContainerId() const {
 123     return mFixedPosScrollContainerId;
 124   }
 125
 126   void SetStickyPositionScrollContainerId(ScrollableLayerGuid::ViewID aId) {
 127     mStickyPosScrollContainerId = aId;
 128   }
 129   ScrollableLayerGuid::ViewID GetStickyPositionScrollContainerId() const {
 130     return mStickyPosScrollContainerId;
 131   }
 132
 133   void SetStickyScrollRangeOuter(const LayerRectAbsolute& scrollRange) {
 134     mStickyScrollRangeOuter = scrollRange;
 135   }
 136   const LayerRectAbsolute& GetStickyScrollRangeOuter() const {
 137     return mStickyScrollRangeOuter;
 138   }
 139
 140   void SetStickyScrollRangeInner(const LayerRectAbsolute& scrollRange) {
 141     mStickyScrollRangeInner = scrollRange;
 142   }
 143   const LayerRectAbsolute& GetStickyScrollRangeInner() const {
 144     return mStickyScrollRangeInner;
 145   }
 146
 147   void SetStickyPositionAnimationId(const uint64_t& aId) {
 148     mStickyPositionAnimationId = Some(aId);
 149   }
 150   Maybe<uint64_t> GetStickyPositionAnimationId() const {
 151     return mStickyPositionAnimationId;
 152   }
 153
 154   void SetZoomAnimationId(const uint64_t& aId) { mZoomAnimationId = Some(aId); }
 155   Maybe<uint64_t> GetZoomAnimationId() const { return mZoomAnimationId; }
 156
 157   void SetAsyncZoomContainerId(const ScrollableLayerGuid::ViewID aId) {
 158     mAsyncZoomContainerId = Some(aId);
 159   }
 160   Maybe<ScrollableLayerGuid::ViewID> GetAsyncZoomContainerId() const {
 161     return mAsyncZoomContainerId;
 162   }
 163   bool IsAsyncZoomContainer() const { return mAsyncZoomContainerId.isSome(); }
 164
 165   void Dump(const WebRenderScrollData& aOwner) const;
 166
 167   friend struct IPC::ParamTraits<WebRenderLayerScrollData>;
 168
 169  private:
 170   // The number of descendants this layer has (not including the layer itself).
 171   // This is needed to reconstruct the depth-first layer tree traversal
 172   // efficiently. Leaf layers should always have 0 descendants.
 173   int32_t mDescendantCount;
 174
 175   // Handles to the ScrollMetadata objects that were on this layer. The values
 176   // stored in this array are indices into the owning WebRenderScrollData's
 177   // mScrollMetadatas array. This indirection is used to deduplicate the
 178   // ScrollMetadata objects, since there is usually heavy duplication of them
 179   // within a layer tree.
 180   nsTArray<size_t> mScrollIds;
 181
 182   // Various data that we collect from the Layer in Initialize(), serialize
 183   // over IPC, and use on the parent side in APZ.
 184
 185   gfx::Matrix4x4 mAncestorTransform;
 186   gfx::Matrix4x4 mTransform;
 187   bool mTransformIsPerspective;
 188   LayerIntRegion mVisibleRegion;
 189   // The remote documents only need their size because their origin is always
 190   // (0, 0).
 191   LayerIntSize mRemoteDocumentSize;
 192   Maybe<LayersId> mReferentId;
 193   EventRegionsOverride mEventRegionsOverride;
 194   ScrollbarData mScrollbarData;
 195   Maybe<uint64_t> mScrollbarAnimationId;
 196   Maybe<uint64_t> mFixedPositionAnimationId;
 197   SideBits mFixedPositionSides;
 198   ScrollableLayerGuid::ViewID mFixedPosScrollContainerId;
 199   ScrollableLayerGuid::ViewID mStickyPosScrollContainerId;
 200   LayerRectAbsolute mStickyScrollRangeOuter;
 201   LayerRectAbsolute mStickyScrollRangeInner;
 202   Maybe<uint64_t> mStickyPositionAnimationId;
 203   Maybe<uint64_t> mZoomAnimationId;
 204   Maybe<ScrollableLayerGuid::ViewID> mAsyncZoomContainerId;
 205 };
 206
 207 // Data needed by APZ, for the whole layer tree. One instance of this class
 208 // is created for each transaction sent over PWebRenderBridge. It is populated
 209 // with information from the WebRender layer tree on the client side and the
 210 // information is used by APZ on the parent side.
 211 class WebRenderScrollData final {
 212  public:
 213   WebRenderScrollData();
 214   explicit WebRenderScrollData(WebRenderLayerManager* aManager);
 215
 216   WebRenderLayerManager* GetManager() const;
 217
 218   // Add the given ScrollMetadata if it doesn't already exist. Return an index
 219   // that can be used to look up the metadata later.
 220   size_t AddMetadata(const ScrollMetadata& aMetadata);
 221   // Add the provided WebRenderLayerScrollData and return the index that can
 222   // be used to look it up via GetLayerData.
 223   size_t AddLayerData(const WebRenderLayerScrollData& aData);
 224
 225   size_t GetLayerCount() const;
 226
 227   // Return a pointer to the scroll data at the given index. Use with caution,
 228   // as the pointer may be invalidated if this WebRenderScrollData is mutated.
 229   const WebRenderLayerScrollData* GetLayerData(size_t aIndex) const;
 230
 231   const ScrollMetadata& GetScrollMetadata(size_t aIndex) const;
 232   Maybe<size_t> HasMetadataFor(
 233       const ScrollableLayerGuid::ViewID& aScrollId) const;
 234
 235   void SetIsFirstPaint();
 236   bool IsFirstPaint() const;
 237   void SetPaintSequenceNumber(uint32_t aPaintSequenceNumber);
 238   uint32_t GetPaintSequenceNumber() const;
 239
 240   void ApplyUpdates(ScrollUpdatesMap& aUpdates, uint32_t aPaintSequenceNumber);
 241
 242   friend struct IPC::ParamTraits<WebRenderScrollData>;
 243
 244   void Dump() const;
 245
 246  private:
 247   // This is called by the ParamTraits implementation to rebuild mScrollIdMap
 248   // based on mScrollMetadatas
 249   bool RepopulateMap();
 250
 251  private:
 252   // Pointer back to the layer manager; if this is non-null, it will always be
 253   // valid, because the WebRenderLayerManager that created |this| will
 254   // outlive |this|.
 255   WebRenderLayerManager* MOZ_NON_OWNING_REF mManager;
 256
 257   // Internal data structure used to maintain uniqueness of mScrollMetadatas.
 258   // This is not serialized/deserialized over IPC, but it is rebuilt on the
 259   // parent side when mScrollMetadatas is deserialized. So it should always be
 260   // valid on both the child and parent.
 261   // The key into this map is the scrollId of a ScrollMetadata, and the value is
 262   // an index into the mScrollMetadatas array.
 263   HashMap<ScrollableLayerGuid::ViewID, size_t> mScrollIdMap;
 264
 265   // A list of all the unique ScrollMetadata objects from the layer tree. Each
 266   // ScrollMetadata in this list must have a unique scroll id.
 267   nsTArray<ScrollMetadata> mScrollMetadatas;
 268
 269   // A list of per-layer scroll data objects, generated via a depth-first,
 270   // pre-order, last-to-first traversal of the layer tree (i.e. a recursive
 271   // traversal where a node N first pushes itself, followed by its children in
 272   // last-to-first order). Each layer's scroll data object knows how many
 273   // descendants that layer had, which allows reconstructing the traversal on
 274   // the other side.
 275   nsTArray<WebRenderLayerScrollData> mLayerScrollData;
 276
 277   bool mIsFirstPaint;
 278   uint32_t mPaintSequenceNumber;
 279 };
 280
 281 }  // namespace layers
 282 }  // namespace mozilla
 283
 284 namespace IPC {
 285
 286 template <>
 287 struct ParamTraits<mozilla::layers::WebRenderLayerScrollData> {
 288   typedef mozilla::layers::WebRenderLayerScrollData paramType;
 289
 290   static void Write(Message* aMsg, const paramType& aParam) {
 291     WriteParam(aMsg, aParam.mDescendantCount);
 292     WriteParam(aMsg, aParam.mScrollIds);
 293     WriteParam(aMsg, aParam.mAncestorTransform);
 294     WriteParam(aMsg, aParam.mTransform);
 295     WriteParam(aMsg, aParam.mTransformIsPerspective);
 296     WriteParam(aMsg, aParam.mVisibleRegion);
 297     WriteParam(aMsg, aParam.mRemoteDocumentSize);
 298     WriteParam(aMsg, aParam.mReferentId);
 299     WriteParam(aMsg, aParam.mEventRegionsOverride);
 300     WriteParam(aMsg, aParam.mScrollbarData);
 301     WriteParam(aMsg, aParam.mScrollbarAnimationId);
 302     WriteParam(aMsg, aParam.mFixedPositionAnimationId);
 303     WriteParam(aMsg, aParam.mFixedPositionSides);
 304     WriteParam(aMsg, aParam.mFixedPosScrollContainerId);
 305     WriteParam(aMsg, aParam.mStickyPosScrollContainerId);
 306     WriteParam(aMsg, aParam.mStickyScrollRangeOuter);
 307     WriteParam(aMsg, aParam.mStickyScrollRangeInner);
 308     WriteParam(aMsg, aParam.mStickyPositionAnimationId);
 309     WriteParam(aMsg, aParam.mZoomAnimationId);
 310     WriteParam(aMsg, aParam.mAsyncZoomContainerId);
 311   }
 312
 313   static bool Read(const Message* aMsg, PickleIterator* aIter,
 314                    paramType* aResult) {
 315     return ReadParam(aMsg, aIter, &aResult->mDescendantCount) &&
 316            ReadParam(aMsg, aIter, &aResult->mScrollIds) &&
 317            ReadParam(aMsg, aIter, &aResult->mAncestorTransform) &&
 318            ReadParam(aMsg, aIter, &aResult->mTransform) &&
 319            ReadParam(aMsg, aIter, &aResult->mTransformIsPerspective) &&
 320            ReadParam(aMsg, aIter, &aResult->mVisibleRegion) &&
 321            ReadParam(aMsg, aIter, &aResult->mRemoteDocumentSize) &&
 322            ReadParam(aMsg, aIter, &aResult->mReferentId) &&
 323            ReadParam(aMsg, aIter, &aResult->mEventRegionsOverride) &&
 324            ReadParam(aMsg, aIter, &aResult->mScrollbarData) &&
 325            ReadParam(aMsg, aIter, &aResult->mScrollbarAnimationId) &&
 326            ReadParam(aMsg, aIter, &aResult->mFixedPositionAnimationId) &&
 327            ReadParam(aMsg, aIter, &aResult->mFixedPositionSides) &&
 328            ReadParam(aMsg, aIter, &aResult->mFixedPosScrollContainerId) &&
 329            ReadParam(aMsg, aIter, &aResult->mStickyPosScrollContainerId) &&
 330            ReadParam(aMsg, aIter, &aResult->mStickyScrollRangeOuter) &&
 331            ReadParam(aMsg, aIter, &aResult->mStickyScrollRangeInner) &&
 332            ReadParam(aMsg, aIter, &aResult->mStickyPositionAnimationId) &&
 333            ReadParam(aMsg, aIter, &aResult->mZoomAnimationId) &&
 334            ReadParam(aMsg, aIter, &aResult->mAsyncZoomContainerId);
 335   }
 336 };
 337
 338 template <>
 339 struct ParamTraits<mozilla::layers::WebRenderScrollData> {
 340   typedef mozilla::layers::WebRenderScrollData paramType;
 341
 342   static void Write(Message* aMsg, const paramType& aParam) {
 343     WriteParam(aMsg, aParam.mScrollMetadatas);
 344     WriteParam(aMsg, aParam.mLayerScrollData);
 345     WriteParam(aMsg, aParam.mIsFirstPaint);
 346     WriteParam(aMsg, aParam.mPaintSequenceNumber);
 347   }
 348
 349   static bool Read(const Message* aMsg, PickleIterator* aIter,
 350                    paramType* aResult) {
 351     return ReadParam(aMsg, aIter, &aResult->mScrollMetadatas) &&
 352            ReadParam(aMsg, aIter, &aResult->mLayerScrollData) &&
 353            ReadParam(aMsg, aIter, &aResult->mIsFirstPaint) &&
 354            ReadParam(aMsg, aIter, &aResult->mPaintSequenceNumber) &&
 355            aResult->RepopulateMap();
 356   }
 357 };
 358
 359 }  // namespace IPC
 360
 361 #endif /* GFX_WEBRENDERSCROLLDATA_H */