The Tor Browser / file 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 http://mozilla.org/MPL/2.0/. */

 include LayersSurfaces;

 include protocol PCompositable;

 include protocol PCompositor;

 include protocol PGrallocBuffer;

 include protocol PLayer;

 include protocol PRenderFrame;

 include protocol PTexture;

 include "gfxipc/ShadowLayerUtils.h";

 include "mozilla/GfxMessageUtils.h";

 include "ImageLayers.h";

 using mozilla::GraphicsFilterType from "mozilla/GfxMessageUtils.h";

 using struct gfxRGBA from "gfxColor.h";

 using struct gfxPoint3D from "gfxPoint3D.h";

 using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";

 using class gfx3DMatrix from "gfx3DMatrix.h";

 using nscoord from "nsCoord.h";

 using struct nsIntPoint from "nsPoint.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 nsCSSProperty from "nsCSSProperty.h";

 using mozilla::dom::ScreenOrientation from "mozilla/dom/ScreenOrientation.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::LayerRect from "Units.h";

 using mozilla::layers::ScaleMode from "mozilla/layers/LayersTypes.h";

 using mozilla::layers::EventRegions from "mozilla/layers/LayersTypes.h";

 using mozilla::layers::DiagnosticTypes from "mozilla/layers/CompositorTypes.h";

 using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";

 using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";

 using struct mozilla::layers::FenceHandle from "mozilla/layers/FenceUtils.h";

 namespace mozilla {

 namespace layers {

 struct TargetConfig {

   nsIntRect naturalBounds;

   ScreenRotation rotation;

   nsIntRect clientBounds;

   ScreenOrientation orientation;

   nsIntRegion clearRegion;

 };

 // Create a shadow layer for |layer|

 struct OpCreateThebesLayer     { PLayer layer; };

 struct OpCreateContainerLayer  { PLayer layer; };

 struct OpCreateImageLayer      { PLayer layer; };

 struct OpCreateColorLayer      { PLayer layer; };

 struct OpCreateCanvasLayer     { PLayer layer; };

 struct OpCreateRefLayer        { PLayer layer; };

 struct OpAttachCompositable {

   PLayer layer;

   PCompositable compositable;

 };

 struct OpAttachAsyncCompositable {

   PLayer layer;

   uint64_t containerID;

 };

 struct ThebesBufferData {

   nsIntRect rect;

   nsIntPoint rotation;

 };

 struct CubicBezierFunction {

   float x1;

   float y1;

   float x2;

   float y2;

 };

 struct StepFunction {

   int steps;

   // 1 = nsTimingFunction::StepStart, 2 = nsTimingFunction::StepEnd

   int type;

 };

 union TimingFunction {

   CubicBezierFunction;

   StepFunction;

 };

 struct LayerColor { gfxRGBA value; };

 struct Perspective { float value; };

 struct RotationX { float radians; };

 struct RotationY { float radians; };

 struct RotationZ { float radians; };

 struct Rotation { float radians; };

 struct Rotation3D {

   float x;

   float y;

   float z;

   float radians;

 };

 struct Scale {

   float x;

   float y;

   float z;

 };

 struct Skew { float x; float y; };

 struct SkewX { float x; };

 struct SkewY { float y; };

 struct TransformMatrix { Matrix4x4 value; };

 struct Translation {

   float x;

   float y;

   float z;

 };

 union TransformFunction {

   Perspective;

   RotationX;

   RotationY;

   RotationZ;

   Rotation;

   Rotation3D;

   Scale;

   Skew;

   SkewX;

   SkewY;

   Translation;

   TransformMatrix;

 };

 union Animatable {

   float;

   TransformFunction[];

 };

 struct AnimationSegment {

   Animatable startState;

   Animatable endState;

   float startPortion;

   float endPortion;

   TimingFunction sampleFn;

 };

 // Transforms need extra information to correctly convert the list of transform

 // functions to a gfx3DMatrix 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 css pixels

   gfxPoint3D transformOrigin;

   // the perspective-origin property for the transform in css pixels

   gfxPoint3D perspectiveOrigin;

   nsRect bounds;

   nscoord perspective;

   int32_t appUnitsPerDevPixel;

 };

 union AnimationData {

   null_t;

   TransformData;

 };

 struct Animation {

   // Unlike in nsAnimationManager, this start time is at the end of the

   // delay.  If the delay is changed dynamically, the layer's data will

   // be updated.

   TimeStamp startTime;

   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;

   // How many times to repeat the animation.  -1 means "forever".

   float numIterations;

   // This uses the NS_STYLE_ANIMATION_DIRECTION_* constants.

   int32_t direction;

   nsCSSProperty property;

   AnimationData data;

 };

 // Change a layer's attributes

 struct CommonLayerAttributes {

   nsIntRegion visibleRegion;

   EventRegions eventRegions;

   TransformMatrix transform;

   float postXScale;

   float postYScale;

   uint32_t contentFlags;

   float opacity;

   bool useClipRect;

   nsIntRect clipRect;

   bool isFixedPosition;

   LayerPoint fixedPositionAnchor;

   LayerMargin fixedPositionMargin;

   bool isStickyPosition;

   uint64_t stickyScrollContainerId;

   LayerRect stickyScrollRangeOuter;

   LayerRect stickyScrollRangeInner;

   uint64_t scrollbarTargetContainerId;

   uint32_t scrollbarDirection;

   nullable PLayer maskLayer;

   // Animated colors will only honored for ColorLayers.

   Animation[] animations;

   nsIntRegion invalidRegion;

 };

 struct ThebesLayerAttributes {

   nsIntRegion validRegion;

 };

 struct ContainerLayerAttributes {

   FrameMetrics metrics;

   ViewID scrollParentId;

   float preXScale;

   float preYScale;

   float inheritedXScale;

   float inheritedYScale;

 };

 struct ColorLayerAttributes     { LayerColor color; nsIntRect bounds; };

 struct CanvasLayerAttributes    { GraphicsFilterType filter; nsIntRect bounds; };

 struct RefLayerAttributes       { int64_t id; };

 struct ImageLayerAttributes     { GraphicsFilterType filter; IntSize scaleToSize; ScaleMode scaleMode; };

 union SpecificLayerAttributes {

   null_t;

   ThebesLayerAttributes;

   ContainerLayerAttributes;

   ColorLayerAttributes;

   CanvasLayerAttributes;

   RefLayerAttributes;

   ImageLayerAttributes;

 };

 struct LayerAttributes {

   CommonLayerAttributes common;

   SpecificLayerAttributes specific;

 };

 struct OpSetLayerAttributes {

   PLayer layer;

   LayerAttributes attrs;

 };

 // Monkey with the tree structure

 struct OpSetRoot          { PLayer root; };

 struct OpInsertAfter      { PLayer container; PLayer childLayer; PLayer after; };

 struct OpPrependChild     { PLayer container; PLayer childLayer; };

 struct OpRemoveChild      { PLayer container; PLayer childLayer; };

 struct OpRepositionChild  { PLayer container; PLayer childLayer; PLayer after; };

 struct OpRaiseToTopChild  { PLayer container; PLayer childLayer; };

 struct OpSetDiagnosticTypes { DiagnosticTypes diagnostics; };

 struct ShmemSection {

   Shmem shmem;

   uint32_t offset;

   size_t size;

 };

 union TileLock {

   ShmemSection;

   uintptr_t;

 };

 struct TexturedTileDescriptor {

   PTexture texture;

   TileLock sharedLock;

 };

 struct PlaceholderTileDescriptor {

 };

 union TileDescriptor {

   TexturedTileDescriptor;

   PlaceholderTileDescriptor;

 };

 struct SurfaceDescriptorTiles {

   nsIntRegion validRegion;

   nsIntRegion paintedRegion;

   TileDescriptor[] tiles;

   int         retainedWidth;

   int         retainedHeight;

   float       resolution;

   float       frameResolution;

 };

 struct OpUseTiledLayerBuffer {

   PCompositable compositable;

   SurfaceDescriptorTiles tileLayerDescriptor;

 };

 struct OpCreatedIncrementalTexture {

   PCompositable compositable;

   TextureInfo textureInfo;

   nsIntRect bufferRect;

 };

 struct OpPaintTextureRegion {

   PCompositable compositable;

   ThebesBufferData bufferData;

   nsIntRegion updatedRegion;

 };

 struct OpPaintTextureIncremental {

   PCompositable compositable;

   uint32_t textureId;

   SurfaceDescriptor image;

   nsIntRegion updatedRegion;

   nsIntRect bufferRect;

   nsIntPoint bufferRotation;

 };

 struct OpUpdatePictureRect {

   PCompositable compositable;

   nsIntRect picture;

 };

 /**

  * Tells the CompositableHost to remove the corresponding TextureHost

  */

 struct OpRemoveTexture {

   PCompositable compositable;

   PTexture texture;

 };

 /**

  * Tells the compositor-side which texture to use (for example, as front buffer

  * if there is several textures for double buffering)

  */

 struct OpUseTexture {

   PCompositable compositable;

   PTexture texture;

 };

 struct OpUseComponentAlphaTextures {

   PCompositable compositable;

   PTexture textureOnBlack;

   PTexture textureOnWhite;

 };

 union MaybeRegion {

   nsIntRegion;

   null_t;

 };

 struct OpUpdateTexture {

   PCompositable compositable;

   PTexture texture;

   MaybeRegion region;

 };

 union CompositableOperation {

   OpUpdatePictureRect;

   OpCreatedIncrementalTexture;

   OpPaintTextureRegion;

   OpPaintTextureIncremental;

   OpUseTiledLayerBuffer;

   OpRemoveTexture;

   OpUpdateTexture;

   OpUseTexture;

   OpUseComponentAlphaTextures;

 };

 // A unit of a changeset; a set of these comprise a changeset

 union Edit {

   OpCreateThebesLayer;

   OpCreateContainerLayer;

   OpCreateImageLayer;

   OpCreateColorLayer;

   OpCreateCanvasLayer;

   OpCreateRefLayer;

   OpSetLayerAttributes;

   OpSetDiagnosticTypes;

   OpSetRoot;

   OpInsertAfter;

   OpPrependChild;

   OpRemoveChild;

   OpRepositionChild;

   OpRaiseToTopChild;

   OpAttachCompositable;

   OpAttachAsyncCompositable;

   CompositableOperation;

 };

 // Replies to operations

 struct OpContentBufferSwap {

   PCompositable compositable;

   nsIntRegion frontUpdatedRegion;

 };

 struct OpTextureSwap {

   PCompositable compositable;

   uint32_t textureId;

   SurfaceDescriptor image;

 };

 struct ReturnReleaseFence {

   PCompositable compositable;

   PTexture texture;

   FenceHandle fence;

 };

 // Unit of a "changeset reply".  This is a weird abstraction, probably

 // only to be used for buffer swapping.

 union EditReply {

   OpContentBufferSwap;

   OpTextureSwap;

   ReturnReleaseFence;

 };

 } // namespace

 } // namespace