Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 130 insertions, 0 deletions

diff --git a/gfx/layers/ipc/PLayerTransaction.ipdl b/gfx/layers/ipc/PLayerTransaction.ipdl
new file mode 100644
index 0000000000..ddc50216e5
--- /dev/null
+++ b/gfx/layers/ipc/PLayerTransaction.ipdl
@@ -0,0 +1,130 @@
+/* -*- 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 PCompositorBridge;
+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 "mozilla/ipc/IPCCore.h";
+using struct mozilla::null_t from "mozilla/ipc/IPCCore.h";
+using class mozilla::layers::APZTestData from "mozilla/layers/APZTestData.h";
+using mozilla::layers::FrameUniformityData from "mozilla/layers/FrameUniformityData.h";
+using mozilla::layers::ScrollableLayerGuid from "mozilla/layers/ScrollableLayerGuid.h";
+using mozilla::layers::ScrollableLayerGuid::ViewID from "mozilla/layers/ScrollableLayerGuid.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";
+using mozilla::layers::TransactionId 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 {
+
+/**
+ * The PLayerTransaction protocol manages the layer tree for a single "browser".
+ * The "browser" can be a top-level browser window, in which case the PLayer-
+ * TransactionChild exists in the UI process. The "browser" can also be a content
+ * tab, in which case the PLayerTransactionChild exists in the content process.
+ * In either case, the PLayerTransactionParent exists in the GPU process (if
+ * there is one) or the UI process otherwise.
+ */
+sync protocol PLayerTransaction {
+  manager PCompositorBridge;
+
+parent:
+  // The isFirstPaint flag can be used to indicate that this is the first update
+  // for a particular document.
+  async Update(TransactionInfo txn);
+
+  async PaintTime(TransactionId id, TimeDuration paintTime);
+
+  async SetLayersObserverEpoch(LayersObserverEpoch aChildEpoch);
+
+  // Create a new Compositable.
+  async NewCompositable(CompositableHandle handle, TextureInfo info);
+
+  // Release an object that is no longer in use.
+  async ReleaseLayer(LayerHandle layer);
+  async ReleaseCompositable(CompositableHandle compositable);
+
+  // Tell the compositor to notify APZ that a layer has been confirmed for an
+  // input event.
+  async SetConfirmedTargetAPZC(uint64_t aInputBlockId, ScrollableLayerGuid[] aTargets);
+
+  // 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 transform applied to the layer by animation and
+  // APZC.
+  sync GetTransform(LayerHandle layer) returns (Matrix4x4? 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 ScheduleComposite();
+
+  // Get a copy of the compositor-side APZ test data instance for this
+  // layers id.
+  sync GetAPZTestData() returns (APZTestData data);
+
+  // Child requests frame uniformity measurements
+  sync GetFrameUniformity() returns (FrameUniformityData data);
+
+  // Query a named property from the last frame
+  sync RequestProperty(nsString property) returns (float value);
+
+  // Return the TextureFactoryIdentifier for this compositor.
+  sync GetTextureFactoryIdentifier() returns (TextureFactoryIdentifier aIdentifier);
+
+  async RecordPaintTimes(PaintTiming timing);
+
+  async Shutdown();
+  sync ShutdownSync();
+
+child:
+  async __delete__();
+};
+
+} // namespace layers
+} // namespace mozilla