import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

gfx/layers/ipc/PLayerTransaction.ipdl

@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* 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/. */
+
+include LayersSurfaces;
+include LayersMessages;
+include protocol PCompositable;
+include protocol PCompositorBridge;
+include protocol PLayer;
+include protocol PRenderFrame;
+include protocol PTexture;
+
+include "mozilla/GfxMessageUtils.h";
+
+using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
+using struct mozilla::void_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 mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";
+
+/**
+ * The layers protocol is spoken between thread contexts that manage
+ * layer (sub)trees.  The protocol comprises atomically publishing
+ * layer subtrees to a "shadow" thread context (which grafts the
+ * subtree into its own tree), and atomically updating a published
+ * subtree.  ("Atomic" in this sense is wrt painting.)
+ */
+
+namespace mozilla {
+namespace layers {
+
+union MaybeTransform {
+  Matrix4x4;
+  void_t;
+};
+
+sync protocol PLayerTransaction {
+  manager PCompositorBridge;
+  manages PLayer;
+  manages PCompositable;
+
+parent:
+  async PLayer();
+  async PCompositable(TextureInfo aTextureInfo);
+
+  // The isFirstPaint flag can be used to indicate that this is the first update
+  // for a particular document.
+  sync Update(Edit[] cset, OpDestroy[] toDestroy,
+              uint64_t fwdTransactionId,
+              uint64_t id, TargetConfig targetConfig,
+              PluginWindowData[] plugins, bool isFirstPaint,
+              bool scheduleComposite, uint32_t paintSequenceNumber,
+              bool isRepeatTransaction, TimeStamp transactionStart,
+              int32_t paintSyncId)
+    returns (EditReply[] reply);
+
+  async PaintTime(uint64_t id, TimeDuration paintTime);
+
+  // We don't need to send a sync transaction if
+  // no transaction operate require a swap.
+  async UpdateNoSwap(Edit[] cset, OpDestroy[] toDestroy,
+                     uint64_t fwdTransactionId,
+                     uint64_t id, TargetConfig targetConfig,
+                     PluginWindowData[] plugins, bool isFirstPaint,
+                     bool scheduleComposite, uint32_t paintSequenceNumber,
+                     bool isRepeatTransaction, TimeStamp transactionStart,
+                     int32_t paintSyncId);
+
+  async SetLayerObserverEpoch(uint64_t layerObserverEpoch);
+
+  // 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 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(PLayer layer) 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(PLayer 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.
+  sync SetAsyncScrollOffset(ViewID id, float x, float y);
+
+  // The next time the layer tree is composited, include this async zoom in
+  // for the given ViewID.
+  // Useful for testing rendering of async zooming.
+  sync SetAsyncZoom(ViewID id, float zoom);
+
+  // Flush any pending APZ repaints to the main thread.
+  async FlushApzRepaints();
+
+  // Drop any front buffers that might be retained on the compositor
+  // side.
+  async ClearCachedResources();
+
+  // Schedule a composite if one isn't already scheduled.
+  async ForceComposite();
+
+  // Get a copy of the compositor-side APZ test data instance for this
+  // layers id.
+  sync GetAPZTestData() returns (APZTestData data);
+
+  // Query a named property from the last frame
+  sync RequestProperty(nsString property) returns (float value);
+
+  // Tell the compositor to notify APZ that a layer has been confirmed for an
+  // input event.
+  async SetConfirmedTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
+
+  async Shutdown();
+child:
+  async __delete__();
+};
+
+} // namespace layers
+} // namespace mozilla