зеркало из https://github.com/mozilla/gecko-dev.git
136 строки
5.3 KiB
Plaintext
136 строки
5.3 KiB
Plaintext
/* -*- 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 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 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";
|
|
|
|
/**
|
|
* 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:
|
|
// Creates a set of mappings between TextureReadLocks and an associated
|
|
// ReadLockHandle that can be used in Update, and persist until the
|
|
// next Update call.
|
|
async InitReadLocks(ReadLockInit[] locks);
|
|
|
|
// The isFirstPaint flag can be used to indicate that this is the first update
|
|
// for a particular document.
|
|
async Update(TransactionInfo txn);
|
|
|
|
async PaintTime(uint64_t id, TimeDuration paintTime);
|
|
|
|
async SetLayerObserverEpoch(uint64_t layerObserverEpoch);
|
|
|
|
// 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 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);
|
|
|
|
// 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);
|
|
|
|
// 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
|