Backed out 4 changesets (bug 1479234) for build bustage at build/src/gfx/vr/ipc/VRLayerChild.cpp on a CLOSED TREE
authorCoroiu Cristina <ccoroiu@mozilla.com>
Tue, 31 Jul 2018 00:32:04 +0300
changeset 429256 775c7c08f6fd3cb3e9d53a889f7860654cf60c9a
parent 429255 6ecc1666f571b6c97b7c30e2795a91334d09d65f
child 429257 b6b5ba876072c72e6267ce0f9d75dd14c5569a56
push id34358
push usershindli@mozilla.com
push dateTue, 31 Jul 2018 09:52:17 +0000
treeherdermozilla-central@d423ef280609 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1479234
milestone63.0a1
backs out6ecc1666f571b6c97b7c30e2795a91334d09d65f
c3bab1bc97cf21e73699a2b9d2ac114522d19391
c8c2625a33baf37d1122814ee9a04dfcf40cf180
2ffc8e9d5686766189b3d287f086fca8e0d2d8dd
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 4 changesets (bug 1479234) for build bustage at build/src/gfx/vr/ipc/VRLayerChild.cpp on a CLOSED TREE Backed out changeset 6ecc1666f571 (bug 1479234) Backed out changeset c3bab1bc97cf (bug 1479234) Backed out changeset c8c2625a33ba (bug 1479234) Backed out changeset 2ffc8e9d5686 (bug 1479234)
dom/base/nsDOMWindowUtils.cpp
dom/base/nsDOMWindowUtils.h
gfx/layers/AnimationHelper.cpp
gfx/layers/AnimationHelper.h
gfx/layers/composite/CompositableHost.h
gfx/layers/ipc/LayerTransactionParent.cpp
gfx/layers/ipc/LayerTransactionParent.h
gfx/layers/ipc/LayersMessages.ipdlh
gfx/layers/ipc/PLayerTransaction.ipdl
gfx/layers/ipc/PWebRenderBridge.ipdl
gfx/layers/wr/WebRenderBridgeParent.cpp
gfx/layers/wr/WebRenderBridgeParent.h
ipc/ipdl/sync-messages.ini
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -3650,43 +3650,16 @@ GetTargetFrame(const Element* aElement, 
       frame = nsLayoutUtils::GetAfterFrame(aElement);
     } else {
       return Err(NS_ERROR_INVALID_ARG);
     }
   }
   return frame;
 }
 
-OMTAValue
-nsDOMWindowUtils::GetOMTAValue(nsIFrame* aFrame,
-                               DisplayItemType aDisplayItemKey)
-{
-  OMTAValue value = mozilla::null_t();
-
-  Layer* layer =
-    FrameLayerBuilder::GetDedicatedLayer(aFrame, aDisplayItemKey);
-  if (layer) {
-    ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
-    if (forwarder && forwarder->HasShadowManager()) {
-      forwarder->GetShadowManager()->
-        SendGetAnimationValue(layer->GetCompositorAnimationsId(), &value);
-    }
-  } else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
-    RefPtr<WebRenderAnimationData> animationData =
-      GetWebRenderUserData<WebRenderAnimationData>(aFrame,
-                                                   (uint32_t)aDisplayItemKey);
-    if (animationData) {
-      wrbc->SendGetAnimationValue(
-        animationData->GetAnimationInfo().GetCompositorAnimationsId(),
-        &value);
-    }
-  }
-  return value;
-}
-
 NS_IMETHODIMP
 nsDOMWindowUtils::GetOMTAStyle(Element* aElement,
                                const nsAString& aProperty,
                                const nsAString& aPseudoElement,
                                nsAString& aResult)
 {
   if (!aElement) {
     return NS_ERROR_INVALID_ARG;
@@ -3701,25 +3674,66 @@ nsDOMWindowUtils::GetOMTAStyle(Element* 
   RefPtr<nsROCSSPrimitiveValue> cssValue = nullptr;
   if (frame && nsLayoutUtils::AreAsyncAnimationsEnabled()) {
     RefPtr<LayerManager> widgetLayerManager;
     if (nsIWidget* widget = GetWidget()) {
       widgetLayerManager = widget->GetLayerManager();
     }
 
     if (aProperty.EqualsLiteral("opacity")) {
-      OMTAValue value = GetOMTAValue(frame, DisplayItemType::TYPE_OPACITY);
-      if (value.type() == OMTAValue::Tfloat) {
+      float value = 0;
+      bool hadAnimatedOpacity = false;
+
+      Layer* layer =
+        FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_OPACITY);
+      if (layer) {
+        ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
+        if (forwarder && forwarder->HasShadowManager()) {
+          forwarder->GetShadowManager()->
+            SendGetAnimationOpacity(layer->GetCompositorAnimationsId(),
+                                    &value,
+                                    &hadAnimatedOpacity);
+        }
+      } else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
+        RefPtr<WebRenderAnimationData> animationData =
+            GetWebRenderUserData<WebRenderAnimationData>(frame, (uint32_t)DisplayItemType::TYPE_OPACITY);
+        if (animationData) {
+          wrbc->SendGetAnimationOpacity(
+              animationData->GetAnimationInfo().GetCompositorAnimationsId(),
+              &value,
+              &hadAnimatedOpacity);
+        }
+      }
+      if (hadAnimatedOpacity) {
         cssValue = new nsROCSSPrimitiveValue;
-        cssValue->SetNumber(value.get_float());
+        cssValue->SetNumber(value);
       }
     } else if (aProperty.EqualsLiteral("transform")) {
-      OMTAValue value = GetOMTAValue(frame, DisplayItemType::TYPE_TRANSFORM);
-      if (value.type() == OMTAValue::TMatrix4x4) {
-        cssValue = nsComputedDOMStyle::MatrixToCSSValue(value.get_Matrix4x4());
+      MaybeTransform transform;
+
+      Layer* layer =
+        FrameLayerBuilder::GetDedicatedLayer(frame, DisplayItemType::TYPE_TRANSFORM);
+      if (layer) {
+        ShadowLayerForwarder* forwarder = layer->Manager()->AsShadowForwarder();
+        if (forwarder && forwarder->HasShadowManager()) {
+          forwarder->GetShadowManager()->
+            SendGetAnimationTransform(layer->GetCompositorAnimationsId(), &transform);
+        }
+      } else if (WebRenderBridgeChild* wrbc = GetWebRenderBridge()) {
+        RefPtr<WebRenderAnimationData> animationData =
+            GetWebRenderUserData<WebRenderAnimationData>(frame, (uint32_t)DisplayItemType::TYPE_TRANSFORM);
+        if (animationData) {
+          wrbc->SendGetAnimationTransform(
+              animationData->GetAnimationInfo().GetCompositorAnimationsId(),
+              &transform);
+        }
+      }
+      if (transform.type() == MaybeTransform::TMatrix4x4) {
+        Matrix4x4 matrix = transform.get_Matrix4x4();
+        cssValue = nsComputedDOMStyle::MatrixToCSSValue(matrix);
       }
     }
   }
 
   if (cssValue) {
     nsString text;
     ErrorResult rv;
     cssValue->GetCssText(text, rv);
--- a/dom/base/nsDOMWindowUtils.h
+++ b/dom/base/nsDOMWindowUtils.h
@@ -5,23 +5,20 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsDOMWindowUtils_h_
 #define nsDOMWindowUtils_h_
 
 #include "nsWeakReference.h"
 
 #include "nsIDOMWindowUtils.h"
-#include "nsDisplayItemTypes.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/BasicEvents.h"
-#include "mozilla/layers/LayersMessages.h" // For OMTAValue
 
 class nsGlobalWindowOuter;
-class nsIFrame;
 class nsIPresShell;
 class nsIWidget;
 class nsPresContext;
 class nsIDocument;
 class nsView;
 struct nsPoint;
 
 namespace mozilla {
@@ -116,14 +113,11 @@ protected:
                                   uint32_t* aRys,
                                   float* aRotationAngles,
                                   float* aForces,
                                   uint32_t aCount,
                                   int32_t aModifiers,
                                   bool aIgnoreRootScrollFrame,
                                   bool aToWindow,
                                   bool* aPreventDefault);
-
-  mozilla::layers::OMTAValue GetOMTAValue(nsIFrame* aFrame,
-                                          DisplayItemType aDisplayItemKey);
 };
 
 #endif
--- a/gfx/layers/AnimationHelper.cpp
+++ b/gfx/layers/AnimationHelper.cpp
@@ -40,55 +40,54 @@ CompositorAnimationStorage::ClearById(co
 
 AnimatedValue*
 CompositorAnimationStorage::GetAnimatedValue(const uint64_t& aId) const
 {
   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
   return mAnimatedValues.Get(aId);
 }
 
-OMTAValue
-CompositorAnimationStorage::GetOMTAValue(const uint64_t& aId) const
+Maybe<float>
+CompositorAnimationStorage::GetAnimationOpacity(const uint64_t& aId) const
 {
-  OMTAValue omtaValue = mozilla::null_t();
-  auto animatedValue = GetAnimatedValue(aId);
-  if (!animatedValue) {
-    return omtaValue;
+  auto value = GetAnimatedValue(aId);
+  if (!value || value->mType != AnimatedValue::OPACITY) {
+    return Nothing();
+  }
+
+  return Some(value->mOpacity);
+}
+
+Maybe<gfx::Matrix4x4>
+CompositorAnimationStorage::GetAnimationTransform(const uint64_t& aId) const
+{
+  auto value = GetAnimatedValue(aId);
+  if (!value || value->mType != AnimatedValue::TRANSFORM) {
+    return Nothing();
   }
 
-  switch (animatedValue->mType) {
-    case AnimatedValue::OPACITY:
-      omtaValue = animatedValue->mOpacity;
-      break;
-    case AnimatedValue::TRANSFORM: {
-      gfx::Matrix4x4 transform = animatedValue->mTransform.mFrameTransform;
-      const TransformData& data = animatedValue->mTransform.mData;
-      float scale = data.appUnitsPerDevPixel();
-      gfx::Point3D transformOrigin = data.transformOrigin();
+  gfx::Matrix4x4 transform = value->mTransform.mFrameTransform;
+  const TransformData& data = value->mTransform.mData;
+  float scale = data.appUnitsPerDevPixel();
+  gfx::Point3D transformOrigin = data.transformOrigin();
 
-      // Undo the rebasing applied by
-      // nsDisplayTransform::GetResultingTransformMatrixInternal
-      transform.ChangeBasis(-transformOrigin);
+  // Undo the rebasing applied by
+  // nsDisplayTransform::GetResultingTransformMatrixInternal
+  transform.ChangeBasis(-transformOrigin);
 
-      // Convert to CSS pixels (this undoes the operations performed by
-      // nsStyleTransformMatrix::ProcessTranslatePart which is called from
-      // nsDisplayTransform::GetResultingTransformMatrix)
-      double devPerCss =
-        double(scale) / double(nsDeviceContext::AppUnitsPerCSSPixel());
-      transform._41 *= devPerCss;
-      transform._42 *= devPerCss;
-      transform._43 *= devPerCss;
-      omtaValue = transform;
-      break;
-    }
-    case AnimatedValue::NONE:
-      break;
-  }
+  // Convert to CSS pixels (this undoes the operations performed by
+  // nsStyleTransformMatrix::ProcessTranslatePart which is called from
+  // nsDisplayTransform::GetResultingTransformMatrix)
+  double devPerCss =
+    double(scale) / double(nsDeviceContext::AppUnitsPerCSSPixel());
+  transform._41 *= devPerCss;
+  transform._42 *= devPerCss;
+  transform._43 *= devPerCss;
 
-  return omtaValue;
+  return Some(transform);
 }
 
 void
 CompositorAnimationStorage::SetAnimatedValue(uint64_t aId,
                                              gfx::Matrix4x4&& aTransformInDevSpace,
                                              gfx::Matrix4x4&& aFrameTransform,
                                              const TransformData& aData)
 {
--- a/gfx/layers/AnimationHelper.h
+++ b/gfx/layers/AnimationHelper.h
@@ -127,17 +127,29 @@ public:
    */
   void SetAnimatedValue(uint64_t aId, const float& aOpacity);
 
   /**
    * Return the animated value if a given id can map to its animated value
    */
   AnimatedValue* GetAnimatedValue(const uint64_t& aId) const;
 
-  OMTAValue GetOMTAValue(const uint64_t& aId) const;
+  /**
+   * Like GetAnimatedValue(), but ensures the value is an opacity and returns
+   * the float value if possible, or Nothing() otherwise.
+   */
+  Maybe<float> GetAnimationOpacity(const uint64_t& aId) const;
+
+  /**
+   * Like GetAnimatedValue(), but ensures the value is a transform and returns
+   * the transform matrix if possible, or Nothing() otherwise. It also does
+   * some post-processing on the transform matrix as well. See the comments
+   * inside the function for details.
+   */
+  Maybe<gfx::Matrix4x4> GetAnimationTransform(const uint64_t& aId) const;
 
   /**
    * Return the iterator of animated value table
    */
   AnimatedValueTable::Iterator ConstAnimatedValueTableIter() const
   {
     return mAnimatedValues.ConstIter();
   }
--- a/gfx/layers/composite/CompositableHost.h
+++ b/gfx/layers/composite/CompositableHost.h
@@ -43,17 +43,16 @@ class LayerComposite;
 class ImageHost;
 class Compositor;
 class ThebesBufferData;
 class TiledContentHost;
 class CompositableParentManager;
 class WebRenderImageHost;
 class ContentHost;
 class ContentHostTexture;
-class HostLayerManager;
 struct EffectChain;
 
 struct ImageCompositeNotificationInfo {
   base::ProcessId mImageBridgeProcessId;
   ImageCompositeNotification mNotification;
 };
 
 struct AsyncCompositableRef
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -676,35 +676,65 @@ LayerTransactionParent::RecvSetTestSampl
 mozilla::ipc::IPCResult
 LayerTransactionParent::RecvLeaveTestMode()
 {
   mCompositorBridge->LeaveTestMode(GetId());
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
-LayerTransactionParent::RecvGetAnimationValue(const uint64_t& aCompositorAnimationsId,
-                                              OMTAValue* aValue)
+LayerTransactionParent::RecvGetAnimationOpacity(const uint64_t& aCompositorAnimationsId,
+                                                float* aOpacity,
+                                                bool* aHasAnimationOpacity)
+{
+  *aHasAnimationOpacity = false;
+  if (mDestroyed || !mLayerManager || mLayerManager->IsDestroyed()) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  mCompositorBridge->ApplyAsyncProperties(
+    this, CompositorBridgeParentBase::TransformsToSkip::APZ);
+
+  if (!mAnimStorage) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  Maybe<float> opacity = mAnimStorage->GetAnimationOpacity(aCompositorAnimationsId);
+  if (opacity) {
+    *aOpacity = *opacity;
+    *aHasAnimationOpacity = true;
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+LayerTransactionParent::RecvGetAnimationTransform(const uint64_t& aCompositorAnimationsId,
+                                                  MaybeTransform* aTransform)
 {
   if (mDestroyed || !mLayerManager || mLayerManager->IsDestroyed()) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   // Make sure we apply the latest animation style or else we can end up with
   // a race between when we temporarily clear the animation transform (in
   // CompositorBridgeParent::SetShadowProperties) and when animation recalculates
   // the value.
   mCompositorBridge->ApplyAsyncProperties(
     this, CompositorBridgeParentBase::TransformsToSkip::APZ);
 
   if (!mAnimStorage) {
     return IPC_FAIL_NO_REASON(this);
   }
 
-  *aValue = mAnimStorage->GetOMTAValue(aCompositorAnimationsId);
+  Maybe<Matrix4x4> transform = mAnimStorage->GetAnimationTransform(aCompositorAnimationsId);
+  if (transform) {
+    *aTransform = *transform;
+  } else {
+    *aTransform = mozilla::void_t();
+  }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 LayerTransactionParent::RecvGetTransform(const LayerHandle& aLayerHandle,
                                          MaybeTransform* aTransform)
 {
   if (mDestroyed || !mLayerManager || mLayerManager->IsDestroyed()) {
--- a/gfx/layers/ipc/LayerTransactionParent.h
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -120,18 +120,21 @@ protected:
                                               const TextureInfo& aInfo) override;
   mozilla::ipc::IPCResult RecvReleaseLayer(const LayerHandle& aHandle) override;
   mozilla::ipc::IPCResult RecvReleaseCompositable(const CompositableHandle& aHandle) override;
 
   mozilla::ipc::IPCResult RecvClearCachedResources() override;
   mozilla::ipc::IPCResult RecvScheduleComposite() override;
   mozilla::ipc::IPCResult RecvSetTestSampleTime(const TimeStamp& aTime) override;
   mozilla::ipc::IPCResult RecvLeaveTestMode() override;
-  mozilla::ipc::IPCResult RecvGetAnimationValue(const uint64_t& aCompositorAnimationsId,
-                                                OMTAValue* aValue) override;
+  mozilla::ipc::IPCResult RecvGetAnimationOpacity(const uint64_t& aCompositorAnimationsId,
+                                                  float* aOpacity,
+                                                  bool* aHasAnimationOpacity) override;
+  mozilla::ipc::IPCResult RecvGetAnimationTransform(const uint64_t& aCompositorAnimationsId,
+                                                    MaybeTransform* aTransform) override;
   mozilla::ipc::IPCResult RecvGetTransform(const LayerHandle& aHandle,
                                            MaybeTransform* aTransform) override;
   mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(const FrameMetrics::ViewID& aId,
                                                    const float& aX, const float& aY) override;
   mozilla::ipc::IPCResult RecvSetAsyncZoom(const FrameMetrics::ViewID& aId,
                                            const float& aValue) override;
   mozilla::ipc::IPCResult RecvFlushApzRepaints() override;
   mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* aOutData) override;
--- a/gfx/layers/ipc/LayersMessages.ipdlh
+++ b/gfx/layers/ipc/LayersMessages.ipdlh
@@ -9,17 +9,16 @@ include LayersSurfaces;
 include protocol PCompositorBridge;
 include protocol PRenderFrame;
 include protocol PTexture;
 
 include "gfxipc/ShadowLayerUtils.h";
 include "mozilla/GfxMessageUtils.h";
 include "ImageLayers.h";
 
-using mozilla::gfx::Glyph from "mozilla/gfx/2D.h";
 using mozilla::gfx::SamplingFilter from "mozilla/gfx/2D.h";
 using struct mozilla::gfx::Color from "mozilla/gfx/2D.h";
 using struct mozilla::gfx::Point3D from "mozilla/gfx/Point.h";
 using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h";
 using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
 using nscoord from "nsCoord.h";
 using struct nsRect from "nsRect.h";
 using struct nsPoint from "nsPoint.h";
@@ -41,16 +40,17 @@ using mozilla::layers::ScaleMode from "m
 using mozilla::layers::EventRegions from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::EventRegionsOverride from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::DiagnosticTypes from "mozilla/layers/CompositorTypes.h";
 using mozilla::layers::FocusTarget from "mozilla/layers/FocusTarget.h";
 using struct mozilla::layers::ScrollMetadata from "FrameMetrics.h";
 using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
 using mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::MaybeLayerClip from "FrameMetrics.h";
+using mozilla::gfx::Glyph from "Layers.h";
 using mozilla::layers::LayerHandle from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::CompositableHandle from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::SimpleLayerAttributes from "mozilla/layers/LayerAttributes.h";
 using mozilla::CrossProcessSemaphoreHandle from "mozilla/ipc/CrossProcessSemaphore.h";
 using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
 using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::TransactionId from "mozilla/layers/LayersTypes.h";
 
@@ -565,16 +565,10 @@ struct TransactionInfo
   TimeStamp fwdTime;
 };
 
 union MaybeTransform {
   Matrix4x4;
   void_t;
 };
 
-union OMTAValue {
-  null_t;
-  float;
-  Matrix4x4;
-};
-
 } // namespace
 } // namespace
--- a/gfx/layers/ipc/PLayerTransaction.ipdl
+++ b/gfx/layers/ipc/PLayerTransaction.ipdl
@@ -11,17 +11,16 @@ include protocol PCompositorBridge;
 include protocol PRenderFrame;
 include protocol PTexture;
 
 include "mozilla/GfxMessageUtils.h";
 include "mozilla/layers/LayersMessageUtils.h";
 
 using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
 using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
-using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
 using class mozilla::layers::APZTestData from "mozilla/layers/APZTestData.h";
 using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
 using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
 using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
 using mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::LayerHandle from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::CompositableHandle from "mozilla/layers/LayersTypes.h";
 using mozilla::layers::LayersObserverEpoch from "mozilla/layers/LayersTypes.h";
@@ -72,18 +71,28 @@ parent:
   // Testing APIs
 
   // Enter test mode, set the sample time to sampleTime, and resample
   // animations. sampleTime must not be null.
   sync SetTestSampleTime(TimeStamp sampleTime);
   // Leave test mode and resume normal compositing
   sync LeaveTestMode();
 
-  // Returns |OMTAValue| applied to the layer.
-  sync GetAnimationValue(uint64_t aCompositorAnimationId) returns (OMTAValue value);
+  // Returns the value of the opacity applied to the layer by animation.
+  // |hasAnimationOpacity| is true if the layer has an opacity value
+  // specified by animation. If it's false, |opacity| value is indefinite.
+  sync GetAnimationOpacity(uint64_t aCompositorAnimationsId) returns (float opacity,
+                                                  bool hasAnimationOpacity);
+
+  // Returns the value of the transform applied to the layer by animation after
+  // factoring out translation components introduced to account for the offset
+  // of the corresponding frame and transform origin and after converting to CSS
+  // pixels. If the layer is not transformed by animation, the return value will
+  // be void_t.
+  sync GetAnimationTransform(uint64_t aCompositorAnimationId) returns (MaybeTransform transform);
 
   // Returns the value of the transform applied to the layer by animation and
   // APZC.
   sync GetTransform(LayerHandle layer) returns (MaybeTransform transform);
 
   // The next time the layer tree is composited, add this async scroll offset in
   // CSS pixels for the given ViewID.
   // Useful for testing rendering of async scrolling.
--- a/gfx/layers/ipc/PWebRenderBridge.ipdl
+++ b/gfx/layers/ipc/PWebRenderBridge.ipdl
@@ -65,17 +65,19 @@ parent:
   sync SyncWithCompositor();
 
   // These correspond exactly to the equivalent APIs in PLayerTransaction -
   // see those for documentation.
   async SetConfirmedTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
   // More copied from PLayerTransaction, but these are only used for testing.
   sync SetTestSampleTime(TimeStamp sampleTime);
   sync LeaveTestMode();
-  sync GetAnimationValue(uint64_t aCompositorAnimationsId) returns (OMTAValue value);
+  sync GetAnimationOpacity(uint64_t aCompositorAnimationsId) returns (float opacity,
+                                                  bool hasAnimationOpacity);
+  sync GetAnimationTransform(uint64_t aCompositorAnimationId) returns (MaybeTransform transform);
   sync SetAsyncScrollOffset(ViewID scrollId, float x, float y);
   sync SetAsyncZoom(ViewID scrollId, float zoom);
   async FlushApzRepaints();
   sync GetAPZTestData() returns (APZTestData data);
 
   async Shutdown();
   sync ShutdownSync();
 child:
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -1356,31 +1356,62 @@ WebRenderBridgeParent::RecvSetTestSample
 mozilla::ipc::IPCResult
 WebRenderBridgeParent::RecvLeaveTestMode()
 {
   mCompositorBridge->LeaveTestMode(GetLayersId());
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
-WebRenderBridgeParent::RecvGetAnimationValue(const uint64_t& aCompositorAnimationsId,
-                                             OMTAValue* aValue)
+WebRenderBridgeParent::RecvGetAnimationOpacity(const uint64_t& aCompositorAnimationsId,
+                                               float* aOpacity,
+                                               bool* aHasAnimationOpacity)
 {
   if (mDestroyed) {
     return IPC_FAIL_NO_REASON(this);
   }
 
   MOZ_ASSERT(mAnimStorage);
   if (RefPtr<WebRenderBridgeParent> root = GetRootWebRenderBridgeParent()) {
     root->AdvanceAnimations();
   } else {
     AdvanceAnimations();
   }
 
-  *aValue = mAnimStorage->GetOMTAValue(aCompositorAnimationsId);
+  Maybe<float> opacity = mAnimStorage->GetAnimationOpacity(aCompositorAnimationsId);
+  if (opacity) {
+    *aOpacity = *opacity;
+    *aHasAnimationOpacity = true;
+  } else {
+    *aHasAnimationOpacity = false;
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
+WebRenderBridgeParent::RecvGetAnimationTransform(const uint64_t& aCompositorAnimationsId,
+                                                 MaybeTransform* aTransform)
+{
+  if (mDestroyed) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+
+  MOZ_ASSERT(mAnimStorage);
+  if (RefPtr<WebRenderBridgeParent> root = GetRootWebRenderBridgeParent()) {
+    root->AdvanceAnimations();
+  } else {
+    AdvanceAnimations();
+  }
+
+  Maybe<Matrix4x4> transform = mAnimStorage->GetAnimationTransform(aCompositorAnimationsId);
+  if (transform) {
+    *aTransform = *transform;
+  } else {
+    *aTransform = mozilla::void_t();
+  }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 WebRenderBridgeParent::RecvSetAsyncScrollOffset(const FrameMetrics::ViewID& aScrollId,
                                                 const float& aX,
                                                 const float& aY)
 {
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -113,18 +113,21 @@ public:
   mozilla::ipc::IPCResult RecvCapture() override;
   mozilla::ipc::IPCResult RecvSyncWithCompositor() override;
 
   mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC(const uint64_t& aBlockId,
                                                      nsTArray<ScrollableLayerGuid>&& aTargets) override;
 
   mozilla::ipc::IPCResult RecvSetTestSampleTime(const TimeStamp& aTime) override;
   mozilla::ipc::IPCResult RecvLeaveTestMode() override;
-  mozilla::ipc::IPCResult RecvGetAnimationValue(const uint64_t& aCompositorAnimationsId,
-                                                OMTAValue* aValue) override;
+  mozilla::ipc::IPCResult RecvGetAnimationOpacity(const uint64_t& aCompositorAnimationsId,
+                                                  float* aOpacity,
+                                                  bool* aHasAnimationOpacity) override;
+  mozilla::ipc::IPCResult RecvGetAnimationTransform(const uint64_t& aCompositorAnimationsId,
+                                                    MaybeTransform* aTransform) override;
   mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(const FrameMetrics::ViewID& aScrollId,
                                                    const float& aX,
                                                    const float& aY) override;
   mozilla::ipc::IPCResult RecvSetAsyncZoom(const FrameMetrics::ViewID& aScrollId,
                                            const float& aZoom) override;
   mozilla::ipc::IPCResult RecvFlushApzRepaints() override;
   mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* data) override;
 
--- a/ipc/ipdl/sync-messages.ini
+++ b/ipc/ipdl/sync-messages.ini
@@ -990,18 +990,20 @@ platform = win
 [PImageBridge::WillClose]
 description =
 [PImageBridge::NewCompositable]
 description =
 [PLayerTransaction::SetTestSampleTime]
 description =
 [PLayerTransaction::LeaveTestMode]
 description =
-[PLayerTransaction::GetAnimationValue]
-description = test only
+[PLayerTransaction::GetAnimationOpacity]
+description =
+[PLayerTransaction::GetAnimationTransform]
+description =
 [PLayerTransaction::GetTransform]
 description = test only
 [PLayerTransaction::SetAsyncScrollOffset]
 description =
 [PLayerTransaction::SetAsyncZoom]
 description =
 [PLayerTransaction::GetAPZTestData]
 description =
@@ -1018,17 +1020,19 @@ description =
 [PWebRenderBridge::Create]
 description =
 [PWebRenderBridge::GetSnapshot]
 description =
 [PWebRenderBridge::SetTestSampleTime]
 description = test only
 [PWebRenderBridge::LeaveTestMode]
 description = test only
-[PWebRenderBridge::GetAnimationValue]
+[PWebRenderBridge::GetAnimationOpacity]
+description = test only
+[PWebRenderBridge::GetAnimationTransform]
 description = test only
 [PWebRenderBridge::SetAsyncScrollOffset]
 description = test only
 [PWebRenderBridge::SetAsyncZoom]
 description = test only
 [PWebRenderBridge::GetAPZTestData]
 description = test only
 [PWebRenderBridge::ShutdownSync]