--- a/gfx/layers/wr/WebRenderScrollData.cpp
+++ b/gfx/layers/wr/WebRenderScrollData.cpp
@@ -27,16 +27,34 @@ WebRenderLayerScrollData::Initialize(Web
   MOZ_ASSERT(aDescendantCount >= 0); // Ensure value is valid
   MOZ_ASSERT(mDescendantCount == -1); // Don't allow re-setting an already set value
   mDescendantCount = aDescendantCount;
 
   MOZ_ASSERT(aLayer);
   for (uint32_t i = 0; i < aLayer->GetScrollMetadataCount(); i++) {
     mScrollIds.AppendElement(aOwner.AddMetadata(aLayer->GetScrollMetadata(i)));
   }
+
+  mIsScrollInfoLayer = aLayer->AsContainerLayer() && !aLayer->GetFirstChild();
+  mTransform = aLayer->GetTransform();
+  mTransformIsPerspective = aLayer->GetTransformIsPerspective();
+  mEventRegions = aLayer->GetEventRegions();
+  mReferentId = aLayer->AsRefLayer()
+      ? Some(aLayer->AsRefLayer()->GetReferentId())
+      : Nothing();
+  mEventRegionsOverride = aLayer->AsContainerLayer()
+      ? aLayer->AsContainerLayer()->GetEventRegionsOverride()
+      : EventRegionsOverride::NoOverride;
+  mScrollbarDirection = aLayer->GetScrollbarDirection();
+  mScrollbarTargetContainerId = aLayer->GetScrollbarTargetContainerId();
+  mScrollThumbLength = mScrollbarDirection == ScrollDirection::VERTICAL
+      ? aLayer->GetVisibleRegion().GetBounds().height
+      : aLayer->GetVisibleRegion().GetBounds().width;
+  mIsScrollbarContainer = aLayer->IsScrollbarContainer();
+  mFixedPosScrollContainerId = aLayer->GetFixedPositionScrollContainerId();
 }
 
 int32_t
 WebRenderLayerScrollData::GetDescendantCount() const
 {
   MOZ_ASSERT(mDescendantCount >= 0); // check that it was set
   return mDescendantCount;
 }

--- a/gfx/layers/wr/WebRenderScrollData.h
+++ b/gfx/layers/wr/WebRenderScrollData.h
@@ -5,16 +5,17 @@
 
 #ifndef GFX_WEBRENDERSCROLLDATA_H
 #define GFX_WEBRENDERSCROLLDATA_H
 
 #include <map>
 
 #include "chrome/common/ipc_message_utils.h"
 #include "FrameMetrics.h"
+#include "LayersTypes.h"
 #include "mozilla/Maybe.h"
 #include "nsTArrayForwardDeclare.h"
 
 namespace mozilla {
 namespace layers {
 
 class Layer;
 class WebRenderScrollData;
@@ -41,30 +42,57 @@ public:
 
   // Return the ScrollMetadata object that used to be on the original Layer
   // at the given index. Since we deduplicate the ScrollMetadata objects into
   // the array in the owning WebRenderScrollData object, we need to be passed
   // in a reference to that owner as well.
   const ScrollMetadata& GetScrollMetadata(const WebRenderScrollData& aOwner,
                                           size_t aIndex) const;
 
+  bool IsScrollInfoLayer() const { return mIsScrollInfoLayer; }
+  gfx::Matrix4x4 GetTransform() const { return mTransform; }
+  bool GetTransformIsPerspective() const { return mTransformIsPerspective; }
+  EventRegions GetEventRegions() const { return mEventRegions; }
+  Maybe<uint64_t> GetReferentId() const { return mReferentId; }
+  EventRegionsOverride GetEventRegionsOverride() const { return mEventRegionsOverride; }
+  ScrollDirection GetScrollbarDirection() const { return mScrollbarDirection; }
+  FrameMetrics::ViewID GetScrollbarTargetContainerId() const { return mScrollbarTargetContainerId; }
+  int32_t GetScrollThumbLength() const { return mScrollThumbLength; }
+  bool IsScrollbarContainer() const { return mIsScrollbarContainer; }
+  FrameMetrics::ViewID GetFixedPositionScrollContainerId() const { return mFixedPosScrollContainerId; }
+
   friend struct IPC::ParamTraits<WebRenderLayerScrollData>;
 
 private:
   // The number of descendants this layer had (not including the layer itself).
   // This is needed to reconstruct the depth-first layer tree traversal
   // efficiently. Leaf layers should always have 0 descendants.
   int32_t mDescendantCount;
 
   // Handles to the ScrollMetadata objects that were on this layer. The values
   // stored in this array are indices into the owning WebRenderScrollData's
   // mScrollMetadatas array. This indirection is used to deduplicate the
   // ScrollMetadata objects, since there is usually heavy duplication of them
   // within a layer tree.
   nsTArray<size_t> mScrollIds;
+
+  // Various data that we collect from the Layer in Initialize(), serialize
+  // over IPC, and use on the parent side in APZ.
+
+  bool mIsScrollInfoLayer;
+  gfx::Matrix4x4 mTransform;
+  bool mTransformIsPerspective;
+  EventRegions mEventRegions;
+  Maybe<uint64_t> mReferentId;
+  EventRegionsOverride mEventRegionsOverride;
+  ScrollDirection mScrollbarDirection;
+  FrameMetrics::ViewID mScrollbarTargetContainerId;
+  int32_t mScrollThumbLength;
+  bool mIsScrollbarContainer;
+  FrameMetrics::ViewID mFixedPosScrollContainerId;
 };
 
 // Data needed by APZ, for the whole layer tree. One instance of this class
 // is created for each transaction sent over PWebRenderBridge. It is populated
 // with information from the WebRender layer tree on the client side and the
 // information is used by APZ on the parent side.
 class WebRenderScrollData
 {
@@ -122,23 +150,45 @@ struct ParamTraits<mozilla::layers::WebR
 {
   typedef mozilla::layers::WebRenderLayerScrollData paramType;
 
   static void
   Write(Message* aMsg, const paramType& aParam)
   {
     WriteParam(aMsg, aParam.mDescendantCount);
     WriteParam(aMsg, aParam.mScrollIds);
+    WriteParam(aMsg, aParam.mIsScrollInfoLayer);
+    WriteParam(aMsg, aParam.mTransform);
+    WriteParam(aMsg, aParam.mTransformIsPerspective);
+    WriteParam(aMsg, aParam.mEventRegions);
+    WriteParam(aMsg, aParam.mReferentId);
+    WriteParam(aMsg, aParam.mEventRegionsOverride);
+    WriteParam(aMsg, aParam.mScrollbarDirection);
+    WriteParam(aMsg, aParam.mScrollbarTargetContainerId);
+    WriteParam(aMsg, aParam.mScrollThumbLength);
+    WriteParam(aMsg, aParam.mIsScrollbarContainer);
+    WriteParam(aMsg, aParam.mFixedPosScrollContainerId);
   }
 
   static bool
   Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
     return ReadParam(aMsg, aIter, &aResult->mDescendantCount)
-        && ReadParam(aMsg, aIter, &aResult->mScrollIds);
+        && ReadParam(aMsg, aIter, &aResult->mScrollIds)
+        && ReadParam(aMsg, aIter, &aResult->mIsScrollInfoLayer)
+        && ReadParam(aMsg, aIter, &aResult->mTransform)
+        && ReadParam(aMsg, aIter, &aResult->mTransformIsPerspective)
+        && ReadParam(aMsg, aIter, &aResult->mEventRegions)
+        && ReadParam(aMsg, aIter, &aResult->mReferentId)
+        && ReadParam(aMsg, aIter, &aResult->mEventRegionsOverride)
+        && ReadParam(aMsg, aIter, &aResult->mScrollbarDirection)
+        && ReadParam(aMsg, aIter, &aResult->mScrollbarTargetContainerId)
+        && ReadParam(aMsg, aIter, &aResult->mScrollThumbLength)
+        && ReadParam(aMsg, aIter, &aResult->mIsScrollbarContainer)
+        && ReadParam(aMsg, aIter, &aResult->mFixedPosScrollContainerId);
   }
 };
 
 template<>
 struct ParamTraits<mozilla::layers::WebRenderScrollData>
 {
   typedef mozilla::layers::WebRenderScrollData paramType;
 

--- a/gfx/layers/wr/WebRenderScrollDataWrapper.h
+++ b/gfx/layers/wr/WebRenderScrollDataWrapper.h
@@ -120,18 +120,20 @@ public:
 
   explicit operator bool() const
   {
     return IsValid();
   }
 
   bool IsScrollInfoLayer() const
   {
-    // TODO
-    return false;
+    MOZ_ASSERT(IsValid());
+
+    return Metrics().IsScrollable()
+        && mLayer->IsScrollInfoLayer();
   }
 
   WebRenderScrollDataWrapper GetLastChild() const
   {
     MOZ_ASSERT(IsValid());
 
     if (!AtBottomLayer()) {
       // If we're still walking around in the virtual container layers created
@@ -188,106 +190,119 @@ public:
 
   const FrameMetrics& Metrics() const
   {
     return Metadata().GetMetrics();
   }
 
   AsyncPanZoomController* GetApzc() const
   {
-    // TODO
     return nullptr;
   }
 
   void SetApzc(AsyncPanZoomController* aApzc) const
   {
-    // TODO
   }
 
   const char* Name() const
   {
-    // TODO
-    return nullptr;
+    return "WebRenderScrollDataWrapper";
   }
 
   gfx::Matrix4x4 GetTransform() const
   {
-    // TODO
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetTransform();
+    }
     return gfx::Matrix4x4();
   }
 
   CSSTransformMatrix GetTransformTyped() const
   {
     return ViewAs<CSSTransformMatrix>(GetTransform());
   }
 
   bool TransformIsPerspective() const
   {
-    // TODO
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetTransformIsPerspective();
+    }
     return false;
   }
 
   EventRegions GetEventRegions() const
   {
-    // TODO
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetEventRegions();
+    }
     return EventRegions();
   }
 
   Maybe<uint64_t> GetReferentId() const
   {
-    // TODO
+    MOZ_ASSERT(IsValid());
+
+    if (AtBottomLayer()) {
+      return mLayer->GetReferentId();
+    }
     return Nothing();
   }
 
   Maybe<ParentLayerIntRect> GetClipRect() const
   {
     // TODO
     return Nothing();
   }
 
   EventRegionsOverride GetEventRegionsOverride() const
   {
-    // TODO
-    return EventRegionsOverride::NoOverride;
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetEventRegionsOverride();
   }
 
   ScrollDirection GetScrollbarDirection() const
   {
-    // TODO
-    return ScrollDirection::NONE;
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetScrollbarDirection();
   }
 
   FrameMetrics::ViewID GetScrollbarTargetContainerId() const
   {
-    // TODO
-    return 0;
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetScrollbarTargetContainerId();
   }
 
   int32_t GetScrollThumbLength() const
   {
-    // TODO
-    return 0;
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetScrollThumbLength();
   }
 
   bool IsScrollbarContainer() const
   {
-    // TODO
-    return false;
+    MOZ_ASSERT(IsValid());
+    return mLayer->IsScrollbarContainer();
   }
 
   FrameMetrics::ViewID GetFixedPositionScrollContainerId() const
   {
-    // TODO
-    return 0;
+    MOZ_ASSERT(IsValid());
+    return mLayer->GetFixedPositionScrollContainerId();
   }
 
   const void* GetLayer() const
   {
-    // TODO
-    return nullptr;
+    MOZ_ASSERT(IsValid());
+    return mLayer;
   }
 
 private:
   bool AtBottomLayer() const
   {
     return mMetadataIndex == 0;
   }