author Hiroyuki Ikezoe <>
Wed, 28 Nov 2018 00:58:46 +0000
changeset 504896 d99d8f275d8bfa954671ea2663bbe37a561d7583
parent 504687 20898bcaaa0069be066b088fde0262169fc71261
child 504897 a30f77050399cefc43236e7c552760ce6a68275a
permissions -rw-r--r--
Bug 1504065 - Run background-color animations on the compositor. r=birtles Changes for nsIDOMWindowUtils.getOMTAValue is in the next commit with come test cases. Differential Revision:

/* -*- 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 "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 nscolor from "nsColor.h";
using nscoord from "nsCoord.h";
using struct nsRect from "nsRect.h";
using struct nsPoint from "nsPoint.h";
using class 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 hal::ScreenOrientation from "mozilla/HalScreenConfiguration.h";
using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.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::LayerIntRegion from "Units.h";
using mozilla::ParentLayerIntRect from "Units.h";
using mozilla::LayoutDeviceIntRect from "Units.h";
using mozilla::layers::ScaleMode from "mozilla/layers/LayersTypes.h";
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::ScrollableLayerGuid::ViewID from "mozilla/layers/ScrollableLayerGuid.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::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";

namespace mozilla {
namespace layers {

struct TargetConfig {
  IntRect naturalBounds;
  ScreenRotation rotation;
  ScreenOrientation orientation;
  nsIntRegion clearRegion;

// Create a shadow layer for |layer|
struct OpCreatePaintedLayer    { LayerHandle layer; };
struct OpCreateContainerLayer  { LayerHandle layer; };
struct OpCreateImageLayer      { LayerHandle layer; };
struct OpCreateColorLayer      { LayerHandle layer; };
struct OpCreateCanvasLayer     { LayerHandle layer; };
struct OpCreateRefLayer        { LayerHandle layer; };

struct OpAttachCompositable {
  LayerHandle layer;
  CompositableHandle compositable;

struct OpAttachAsyncCompositable {
  LayerHandle layer;
  CompositableHandle compositable;

struct ThebesBufferData {
  IntRect rect;
  IntPoint rotation;

struct CubicBezierFunction {
  float x1;
  float y1;
  float x2;
  float y2;

struct StepFunction {
  int steps;
  uint8_t type; // Converted from StyleStepPosition.

union TimingFunction {

// Send the angle with units rather than sending all angles in radians
// to avoid having floating point error introduced by unit switching.
struct CSSAngle {
  float value;
  int unit; // an nsCSSUnit that is valid for angles

struct LayerColor { Color value; };
struct Perspective { float value; };
struct RotationX { CSSAngle angle; };
struct RotationY { CSSAngle angle; };
struct RotationZ { CSSAngle angle; };
struct Rotation { CSSAngle angle; };
struct Rotation3D {
  float x;
  float y;
  float z;
  CSSAngle angle;
struct Scale {
  float x;
  float y;
  float z;
struct Skew { CSSAngle x; CSSAngle y; };
struct SkewX { CSSAngle x; };
struct SkewY { CSSAngle y; };
struct TransformMatrix { Matrix4x4 value; };
struct Translation {
  float x;
  float y;
  float z;

union TransformFunction {

union MaybeTimeDuration {

union Animatable {

struct AnimationSegment {
  Animatable startState;
  Animatable endState;
  float startPortion;
  float endPortion;
  uint8_t startComposite;
  uint8_t endComposite;
  TimingFunction sampleFn;

// Transforms need extra information to correctly convert the list of transform
// functions to a Matrix4x4 that can be applied directly to the layer.
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;
  // The resolution scale inherited from the parent
  float inheritedXScale;
  float inheritedYScale;
  // True if the parent has perspective transform
  bool hasPerspectiveParent;

union AnimationData {

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.
  MaybeTimeDuration 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;
  AnimationData data;
  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.
  TimingFunction easingFunction;
  uint8_t iterationComposite;
  // True if the animation has a fixed current time (e.g. paused and
  // forward-filling animations).
  bool isNotPlaying;
  // The base style that animations should composite with. This is only set for
  // 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;

struct CompositorAnimations {
  Animation[] animations;
  // This id is used to map the layer animations between content
  // and compositor side
  uint64_t id;

// Change a layer's attributes
struct CommonLayerAttributes {
  LayerIntRegion visibleRegion;
  EventRegions eventRegions;
  bool useClipRect;
  ParentLayerIntRect clipRect;
  LayerHandle maskLayer;
  LayerHandle[] ancestorMaskLayers;
  // Animated colors will only honored for ColorLayers.
  CompositorAnimations compositorAnimations;
  nsIntRegion invalidRegion;
  ScrollMetadata[] scrollMetadata;
  nsCString displayListLog;

struct PaintedLayerAttributes {
  nsIntRegion validRegion;
struct ContainerLayerAttributes {
  float preXScale;
  float preYScale;
  float inheritedXScale;
  float inheritedYScale;
  float presShellResolution;
  bool scaleToResolution;

struct GlyphArray
  LayerColor color;
  Glyph[] glyphs;

struct ColorLayerAttributes     { LayerColor color; IntRect bounds; };
struct CanvasLayerAttributes    { SamplingFilter samplingFilter; IntRect bounds; };
struct RefLayerAttributes {
  LayersId id;
  EventRegionsOverride eventRegionsOverride;
struct ImageLayerAttributes     { SamplingFilter samplingFilter; IntSize scaleToSize; ScaleMode scaleMode; };

union SpecificLayerAttributes {

struct LayerAttributes {
  CommonLayerAttributes common;
  SpecificLayerAttributes specific;

// See nsIWidget Configurations
struct PluginWindowData {
  uintptr_t windowId;
  LayoutDeviceIntRect[] clip;
  LayoutDeviceIntRect bounds;
  bool visible;

struct OpSetSimpleLayerAttributes {
  LayerHandle layer;
  SimpleLayerAttributes attrs;

struct OpSetLayerAttributes {
  LayerHandle layer;
  LayerAttributes attrs;

// Monkey with the tree structure
struct OpSetRoot          { LayerHandle root; };
struct OpInsertAfter      { LayerHandle container; LayerHandle childLayer; LayerHandle after; };
struct OpPrependChild     { LayerHandle container; LayerHandle childLayer; };
struct OpRemoveChild      { LayerHandle container; LayerHandle childLayer; };
struct OpRepositionChild  { LayerHandle container; LayerHandle childLayer; LayerHandle after; };
struct OpRaiseToTopChild  { LayerHandle container; LayerHandle childLayer; };

struct OpSetDiagnosticTypes { DiagnosticTypes diagnostics; };
struct OpWindowOverlayChanged { };

struct ShmemSection {
  Shmem shmem;
  uint32_t offset;
  size_t size;

struct CrossProcessSemaphoreDescriptor {
  CrossProcessSemaphoreHandle sem;

union ReadLockDescriptor {

union MaybeTexture {

struct TexturedTileDescriptor {
  PTexture texture;
  MaybeTexture textureOnWhite;
  IntRect updateRect;
  bool readLocked;
  bool readLockedOnWhite;
  bool wasPlaceholder;

struct PlaceholderTileDescriptor {

union TileDescriptor {

struct SurfaceDescriptorTiles {
  nsIntRegion validRegion;
  TileDescriptor[] tiles;
  IntPoint    tileOrigin;
  IntSize     tileSize;
  int         firstTileX;
  int         firstTileY;
  int         retainedWidth;
  int         retainedHeight;
  float       resolution;
  float       frameXResolution;
  float       frameYResolution;
  bool        isProgressive;

struct OpUseTiledLayerBuffer {
  SurfaceDescriptorTiles tileLayerDescriptor;

struct OpPaintTextureRegion {
  ThebesBufferData bufferData;
  nsIntRegion updatedRegion;

 * 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 OpUseComponentAlphaTextures {
  PTexture textureOnBlack;
  PTexture textureOnWhite;
  bool readLockedBlack;
  bool readLockedWhite;

union MaybeRegion {

struct OpNotifyNotUsed {
  uint64_t TextureId;
  uint64_t fwdTransactionId;

union CompositableOperationDetail {




struct CompositableOperation {
  CompositableHandle compositable;
  CompositableOperationDetail detail;

// A unit of a changeset; a set of these comprise a changeset
// If adding a new edit type that requires the hit testing tree to be updated,
// set the updateHitTestingTree flag to true in RecvUpdate()
union Edit {





// 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 {

struct PaintTiming {
  float serializeMs;
  float sendMs;
  float dlMs;
  float dl2Ms;
  float flbMs;
  float rasterMs;

struct TransactionInfo
  Edit[] cset;
  OpSetSimpleLayerAttributes[] setSimpleAttrs;
  OpSetLayerAttributes[] setAttrs;
  CompositableOperation[] paints;
  OpDestroy[] toDestroy;
  uint64_t fwdTransactionId;
  TransactionId id;
  TargetConfig targetConfig;
  PluginWindowData[] plugins;
  bool isFirstPaint;
  FocusTarget focusTarget;
  bool scheduleComposite;
  uint32_t paintSequenceNumber;
  bool isRepeatTransaction;
  TimeStamp refreshStart;
  TimeStamp transactionStart;
  nsCString url;
  TimeStamp fwdTime;

union MaybeTransform {

union OMTAValue {

} // namespace
} // namespace