Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 */
include LayersSurfaces;
include protocol PCompositorBridge;
include protocol PTexture;
include "gfxipc/ShadowLayerUtils.h";
include "mozilla/GfxMessageUtils.h";
include "mozilla/layers/LayersMessageUtils.h";
using mozilla::gfx::Glyph from "mozilla/gfx/2D.h";
using mozilla::gfx::SamplingFilter from "mozilla/gfx/2D.h";
using struct mozilla::gfx::DeviceColor from "mozilla/gfx/2D.h";
using mozilla::gfx::Point from "mozilla/gfx/Point.h";
using mozilla::gfx::Point3D from "mozilla/gfx/Point.h";
using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h";
using mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
using mozilla::SideBits from "mozilla/gfx/Types.h";
using nscolor from "nsColor.h";
using nscoord from "nsCoord.h";
using struct nsRect from "nsRect.h";
using struct nsPoint from "nsPoint.h";
using mozilla::TimeDuration from "mozilla/TimeStamp.h";
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
using mozilla::ScreenRotation from "mozilla/WidgetUtils.h";
using nsCSSPropertyID from "nsCSSPropertyID.h";
using mozilla::hal::ScreenOrientation from "mozilla/HalIPCUtils.h";
using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
using mozilla::CSSCoord from "Units.h";
using mozilla::CSSPoint from "Units.h";
using mozilla::CSSRect from "Units.h";
using mozilla::gfx::IntSize from "mozilla/gfx/2D.h";
using mozilla::LayerMargin from "Units.h";
using mozilla::LayerPoint from "Units.h";
using mozilla::LayerCoord from "Units.h";
using mozilla::LayerSize from "Units.h";
using mozilla::LayerRect from "Units.h";
using mozilla::LayerIntSize from "Units.h";
using mozilla::LayerIntRect from "Units.h";
using mozilla::LayerIntRegion from "Units.h";
using mozilla::layers::TextureFlags from "mozilla/layers/CompositorTypes.h";
using mozilla::ParentLayerIntRect from "Units.h";
using mozilla::ParentLayerRect from "Units.h";
using mozilla::LayoutDeviceIntRect from "Units.h";
using mozilla::LayoutDevicePoint from "Units.h";
using mozilla::LayoutDeviceRect from "Units.h";
using mozilla::layers::ScaleMode 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::ScrollableLayerGuid::ViewID from "mozilla/layers/ScrollableLayerGuid.h";
using mozilla::layers::ScrollDirection from "mozilla/layers/LayersTypes.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::CompositionPayload from "mozilla/layers/LayersTypes.h";
[MoveOnly] using mozilla::CrossProcessSemaphoreHandle from "mozilla/ipc/CrossProcessSemaphore.h";
using struct mozilla::void_t from "mozilla/ipc/IPCCore.h";
using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
using mozilla::layers::RemoteTextureId from "mozilla/layers/LayersTypes.h";
using mozilla::layers::RemoteTextureOwnerId from "mozilla/layers/LayersTypes.h";
using mozilla::layers::TransactionId from "mozilla/layers/LayersTypes.h";
using mozilla::LengthPercentage from "mozilla/ServoStyleConsts.h";
using mozilla::StyleOffsetPath from "mozilla/ServoStyleConsts.h";
using mozilla::StyleOffsetRotate from "mozilla/ServoStyleConsts.h";
using mozilla::StylePositionOrAuto from "mozilla/ServoStyleConsts.h";
using mozilla::StyleOffsetPosition from "mozilla/ServoStyleConsts.h";
using mozilla::StyleRotate from "mozilla/ServoStyleConsts.h";
using mozilla::StyleScale from "mozilla/ServoStyleConsts.h";
using mozilla::StyleTranslate from "mozilla/ServoStyleConsts.h";
using mozilla::StyleTransform from "mozilla/ServoStyleConsts.h";
using mozilla::StyleComputedTimingFunction from "mozilla/ServoStyleConsts.h";
namespace mozilla {
namespace layers {
struct TargetConfig {
IntRect naturalBounds;
ScreenRotation rotation;
ScreenOrientation orientation;
nsIntRegion clearRegion;
struct OpAttachCompositable {
LayerHandle layer;
CompositableHandle compositable;
struct OpAttachAsyncCompositable {
LayerHandle layer;
CompositableHandle compositable;
struct LayerColor { DeviceColor value; };
[Comparable] union Animatable {
struct AnimationSegment {
Animatable startState;
Animatable endState;
float startPortion;
float endPortion;
uint8_t startComposite;
uint8_t endComposite;
StyleComputedTimingFunction? sampleFn;
[Comparable] struct MotionPathData {
// The transform-origin property for motion in css pixels
CSSPoint origin;
// The adjustment for the anchor point of motion path.
CSSPoint anchorAdjustment;
// The coord box of the containing block.
nsRect coordBox;
// The current position of this transfromed box in the coordinate system of
// its containing block.
nsPoint currentPosition;
// The reference length for computing ray(contain) (in css pixels).
CSSCoord rayContainReferenceLength;
// The resolved border-radius of its containing block. If the array size is
// zero, we don't have radius.
nscoord[] coordBoxInsetRadii;
[Comparable] struct PartialPrerenderData {
LayoutDeviceRect rect;
SideBits overflowedSides;
// the scroll id of the nearest scrollable frame of this partial prerender
// data.
ViewID scrollId;
// The clip rectangle of the nearest scrollable frame.
// NOTE: This should be used only for fallback cases where APZ is not enabled.
ParentLayerRect clipRect;
// a transform from the coordinate space of the animated element to a
// coordinate space where the `clipRect` can be applied.
Matrix4x4 transformInClip; // Used only for WebRender.
// the position relative to the reference frame of the animated transform
// element in the element coordinate space.
LayoutDevicePoint position; // Used only for WebRender.
// Transforms need extra information to correctly convert the list of transform
// functions to a Matrix4x4 that can be applied directly to the layer.
[Comparable] struct TransformData {
// the origin of the frame being transformed in app units
nsPoint origin;
// the transform-origin property for the transform in device pixels
Point3D transformOrigin;
nsRect bounds;
int32_t appUnitsPerDevPixel;
MotionPathData? motionPathData;
PartialPrerenderData? partialPrerenderData;
// The scroll timeline information.
struct ScrollTimelineOptions {
// The source of the scroll-timeline.
ViewID source;
// The physical direction.
ScrollDirection axis;
struct Animation {
// The zero time of this Animation's timeline. May be null if isNotPlaying is
// true.
TimeStamp originTime;
// The start time is relative to the originTime. This allows us to represent
// start times in the distant past that cannot be expressed using a TimeStamp.
TimeDuration? startTime;
TimeDuration delay;
TimeDuration endDelay;
// The value of the animation's current time at the moment it was sent to the
// compositor. This value will be used for below cases:
// 1) Animations that are play-pending. Initially these animations will have a
// null |startTime|. Once the animation is ready to start (i.e. painting
// has finished), we calculate an appropriate value of |startTime| such
// that playback begins from |holdTime|.
// 2) Not playing animations (e.g. paused and finished animations). In this
// case the |holdTime| represents the current time the animation will
// maintain.
TimeDuration holdTime;
TimeDuration duration;
// For each frame, the interpolation point is computed based on the
// startTime, the direction, the duration, and the current time.
// The segments must uniquely cover the portion from 0.0 to 1.0
AnimationSegment[] segments;
// Number of times to repeat the animation, including positive infinity.
// Values <= 0 mean the animation will not play (although events are still
// dispatched on the main thread).
float iterations;
float iterationStart;
// This uses the NS_STYLE_ANIMATION_DIRECTION_* constants.
uint8_t direction;
// This uses dom::FillMode.
uint8_t fillMode;
nsCSSPropertyID property;
float playbackRate;
// When performing an asynchronous update to the playbackRate, |playbackRate|
// above is the updated playbackRate while |previousPlaybackRate| is the
// existing playbackRate. This is used by AnimationInfo to update the
// startTime based on the 'readyTime' (timestamp at the end of painting)
// and is not used beyond that point.
// It is set to numeric_limits<float>::quiet_NaN() when no asynchronous update
// to the playbackRate is being performed.
float previousPlaybackRate;
// This is used in the transformed progress calculation.
StyleComputedTimingFunction? easingFunction;
uint8_t iterationComposite;
// True if the animation has a fixed current time (e.g. paused and
// forward-filling animations).
bool isNotPlaying;
// True if this is not an animating property. For some transform-like
// properties, we just send their baseStyles for merging with other animating
// properties. In this case, we don't have animation information on this
// property, and so don't need to do interpolation.
bool isNotAnimating;
// The base style that animations should composite with. This is only set for
// 1. scroll animations with positive delays, or
// 2. animations with a composite mode of additive or accumulate, and only for
// the first animation in the set (i.e. the animation that is lowest in the
// stack).
// In all other cases the value is null_t.
Animatable baseStyle;
// An optional data specific for transform like properies.
TransformData? transformData;
// If this is present, the animation is driven by a ScrollTimeline, and
// this structure contains information about that timeline.
ScrollTimelineOptions? scrollTimelineOptions;
struct CompositorAnimations {
Animation[] animations;
// This id is used to map the layer animations between content
// and compositor side
uint64_t id;
struct ShmemSection {
Shmem shmem;
uint32_t offset;
uint32_t size;
struct CrossProcessSemaphoreDescriptor {
CrossProcessSemaphoreHandle sem;
union ReadLockDescriptor {
* Tells the CompositableHost to remove the corresponding TextureHost
struct OpRemoveTexture {
PTexture texture;
struct TimedTexture {
PTexture texture;
TimeStamp timeStamp;
IntRect picture;
uint32_t frameID;
uint32_t producerID;
bool readLocked;
* Tells the compositor-side which textures to use (for example, as front buffer
* if there are several textures for double buffering).
* This provides a list of textures with timestamps, ordered by timestamp.
* The newest texture whose timestamp is <= the current time is rendered
* (where null is considered less than every other timestamp). If there is no
* such texture, the first texture is rendered.
* The first timestamp value can be null, but the others must not be.
* The list must not be empty.
struct OpUseTexture {
TimedTexture[] textures;
struct OpUseRemoteTexture {
RemoteTextureId textureId;
RemoteTextureOwnerId ownerId;
IntSize size;
TextureFlags textureFlags;
struct OpEnableRemoteTexturePushCallback {
RemoteTextureOwnerId ownerId;
IntSize size;
TextureFlags textureFlags;
struct OpNotifyNotUsed {
uint64_t TextureId;
uint64_t fwdTransactionId;
union CompositableOperationDetail {
struct CompositableOperation {
CompositableHandle compositable;
CompositableOperationDetail detail;
// Operations related to destroying resources, always handled after the other
// operations for safety.
union OpDestroy {
// Replies to operations
struct OpContentBufferSwap {
CompositableHandle compositable;
nsIntRegion frontUpdatedRegion;
* An ImageCompositeNotification is sent the first time a particular
* image is composited by an ImageHost.
struct ImageCompositeNotification {
CompositableHandle compositable;
TimeStamp imageTimeStamp;
TimeStamp firstCompositeTimeStamp;
uint32_t frameID;
uint32_t producerID;
union AsyncParentMessageData {
union OMTAValue {
} // namespace
} // namespace