layertree

Documentation

Overview

Package layertree implements the LayerTree domain.

Index

• func NewClient(conn *rpcc.Conn) *domainClient
• type CompositingReasonsArgs
  • func NewCompositingReasonsArgs(layerID LayerID) *CompositingReasonsArgs
• type CompositingReasonsReply
• type DidChangeClient
• type DidChangeReply
• type Layer
• type LayerID
• type LayerPaintedClient
• type LayerPaintedReply
• type LoadSnapshotArgs
  • func NewLoadSnapshotArgs(tiles []PictureTile) *LoadSnapshotArgs
• type LoadSnapshotReply
• type MakeSnapshotArgs
  • func NewMakeSnapshotArgs(layerID LayerID) *MakeSnapshotArgs
• type MakeSnapshotReply
• type PaintProfile
• type PictureTile
• type ProfileSnapshotArgs
  • func NewProfileSnapshotArgs(snapshotID SnapshotID) *ProfileSnapshotArgs
  • func (a *ProfileSnapshotArgs) SetClipRect(clipRect dom.Rect) *ProfileSnapshotArgs
  • func (a *ProfileSnapshotArgs) SetMinDuration(minDuration float64) *ProfileSnapshotArgs
  • func (a *ProfileSnapshotArgs) SetMinRepeatCount(minRepeatCount int) *ProfileSnapshotArgs
• type ProfileSnapshotReply
• type ReleaseSnapshotArgs
  • func NewReleaseSnapshotArgs(snapshotID SnapshotID) *ReleaseSnapshotArgs
• type ReplaySnapshotArgs
  • func NewReplaySnapshotArgs(snapshotID SnapshotID) *ReplaySnapshotArgs
  • func (a *ReplaySnapshotArgs) SetFromStep(fromStep int) *ReplaySnapshotArgs
  • func (a *ReplaySnapshotArgs) SetScale(scale float64) *ReplaySnapshotArgs
  • func (a *ReplaySnapshotArgs) SetToStep(toStep int) *ReplaySnapshotArgs
• type ReplaySnapshotReply
• type ScrollRect
• type SnapshotCommandLogArgs
  • func NewSnapshotCommandLogArgs(snapshotID SnapshotID) *SnapshotCommandLogArgs
• type SnapshotCommandLogReply
• type SnapshotID

Functions

func NewClient

func NewClient(conn *rpcc.Conn) *domainClient

NewClient returns a client for the LayerTree domain with the connection set to conn.

Types

type CompositingReasonsArgs

type CompositingReasonsArgs struct {
	LayerID LayerID `json:"layerId"` // The id of the layer for which we want to get the reasons it was composited.
}

CompositingReasonsArgs represents the arguments for CompositingReasons in the LayerTree domain.

func NewCompositingReasonsArgs

func NewCompositingReasonsArgs(layerID LayerID) *CompositingReasonsArgs

NewCompositingReasonsArgs initializes CompositingReasonsArgs with the required arguments.

type CompositingReasonsReply

type CompositingReasonsReply struct {
	CompositingReasons []string `json:"compositingReasons"` // A list of strings specifying reasons for the given layer to become composited.
}

CompositingReasonsReply represents the return values for CompositingReasons in the LayerTree domain.

type DidChangeClient

type DidChangeClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*DidChangeReply, error)
	rpcc.Stream
}

DidChangeClient is a client for LayerTreeDidChange events.

type DidChangeReply

type DidChangeReply struct {
	Layers []Layer `json:"layers,omitempty"` // Layer tree, absent if not in the comspositing mode.
}

DidChangeReply is the reply for LayerTreeDidChange events.

type Layer

type Layer struct {
	LayerID       LayerID            `json:"layerId"`                 // The unique id for this layer.
	ParentLayerID *LayerID           `json:"parentLayerId,omitempty"` // The id of parent (not present for root).
	BackendNodeID *dom.BackendNodeID `json:"backendNodeId,omitempty"` // The backend id for the node associated with this layer.
	OffsetX       float64            `json:"offsetX"`                 // Offset from parent layer, X coordinate.
	OffsetY       float64            `json:"offsetY"`                 // Offset from parent layer, Y coordinate.
	Width         float64            `json:"width"`                   // Layer width.
	Height        float64            `json:"height"`                  // Layer height.
	Transform     []float64          `json:"transform,omitempty"`     // Transformation matrix for layer, default is identity matrix
	AnchorX       *float64           `json:"anchorX,omitempty"`       // Transform anchor point X, absent if no transform specified
	AnchorY       *float64           `json:"anchorY,omitempty"`       // Transform anchor point Y, absent if no transform specified
	AnchorZ       *float64           `json:"anchorZ,omitempty"`       // Transform anchor point Z, absent if no transform specified
	PaintCount    int                `json:"paintCount"`              // Indicates how many time this layer has painted.
	DrawsContent  bool               `json:"drawsContent"`            // Indicates whether this layer hosts any content, rather than being used for transform/scrolling purposes only.
	Invisible     *bool              `json:"invisible,omitempty"`     // Set if layer is not visible.
	ScrollRects   []ScrollRect       `json:"scrollRects,omitempty"`   // Rectangles scrolling on main thread only.
}

Layer Information about a compositing layer.

type LayerID

type LayerID string

LayerID Unique Layer identifier.

type LayerPaintedClient

type LayerPaintedClient interface {
	// Recv calls RecvMsg on rpcc.Stream, blocks until the event is
	// triggered, context canceled or connection closed.
	Recv() (*LayerPaintedReply, error)
	rpcc.Stream
}

LayerPaintedClient is a client for LayerPainted events.

type LayerPaintedReply

type LayerPaintedReply struct {
	LayerID LayerID  `json:"layerId"` // The id of the painted layer.
	Clip    dom.Rect `json:"clip"`    // Clip rectangle.
}

LayerPaintedReply is the reply for LayerPainted events.

type LoadSnapshotArgs

type LoadSnapshotArgs struct {
	Tiles []PictureTile `json:"tiles"` // An array of tiles composing the snapshot.
}

LoadSnapshotArgs represents the arguments for LoadSnapshot in the LayerTree domain.

func NewLoadSnapshotArgs

func NewLoadSnapshotArgs(tiles []PictureTile) *LoadSnapshotArgs

NewLoadSnapshotArgs initializes LoadSnapshotArgs with the required arguments.

type LoadSnapshotReply

type LoadSnapshotReply struct {
	SnapshotID SnapshotID `json:"snapshotId"` // The id of the snapshot.
}

LoadSnapshotReply represents the return values for LoadSnapshot in the LayerTree domain.

type MakeSnapshotArgs

type MakeSnapshotArgs struct {
	LayerID LayerID `json:"layerId"` // The id of the layer.
}

MakeSnapshotArgs represents the arguments for MakeSnapshot in the LayerTree domain.

func NewMakeSnapshotArgs

func NewMakeSnapshotArgs(layerID LayerID) *MakeSnapshotArgs

NewMakeSnapshotArgs initializes MakeSnapshotArgs with the required arguments.

type MakeSnapshotReply

type MakeSnapshotReply struct {
	SnapshotID SnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

MakeSnapshotReply represents the return values for MakeSnapshot in the LayerTree domain.

type PaintProfile

type PaintProfile []float64

PaintProfile Array of timings, one per paint step.

type PictureTile

type PictureTile struct {
	X       float64 `json:"x"`       // Offset from owning layer left boundary
	Y       float64 `json:"y"`       // Offset from owning layer top boundary
	Picture []byte  `json:"picture"` // Base64-encoded snapshot data.
}

PictureTile Serialized fragment of layer picture along with its offset within the layer.

type ProfileSnapshotArgs

type ProfileSnapshotArgs struct {
	SnapshotID     SnapshotID `json:"snapshotId"`               // The id of the layer snapshot.
	MinRepeatCount *int       `json:"minRepeatCount,omitempty"` // The maximum number of times to replay the snapshot (1, if not specified).
	MinDuration    *float64   `json:"minDuration,omitempty"`    // The minimum duration (in seconds) to replay the snapshot.
	ClipRect       *dom.Rect  `json:"clipRect,omitempty"`       // The clip rectangle to apply when replaying the snapshot.
}

ProfileSnapshotArgs represents the arguments for ProfileSnapshot in the LayerTree domain.

func NewProfileSnapshotArgs

func NewProfileSnapshotArgs(snapshotID SnapshotID) *ProfileSnapshotArgs

NewProfileSnapshotArgs initializes ProfileSnapshotArgs with the required arguments.

func (*ProfileSnapshotArgs) SetClipRect

func (a *ProfileSnapshotArgs) SetClipRect(clipRect dom.Rect) *ProfileSnapshotArgs

SetClipRect sets the ClipRect optional argument. The clip rectangle to apply when replaying the snapshot.

func (*ProfileSnapshotArgs) SetMinDuration

func (a *ProfileSnapshotArgs) SetMinDuration(minDuration float64) *ProfileSnapshotArgs

SetMinDuration sets the MinDuration optional argument. The minimum duration (in seconds) to replay the snapshot.

func (*ProfileSnapshotArgs) SetMinRepeatCount

func (a *ProfileSnapshotArgs) SetMinRepeatCount(minRepeatCount int) *ProfileSnapshotArgs

SetMinRepeatCount sets the MinRepeatCount optional argument. The maximum number of times to replay the snapshot (1, if not specified).

type ProfileSnapshotReply

type ProfileSnapshotReply struct {
	Timings []PaintProfile `json:"timings"` // The array of paint profiles, one per run.
}

ProfileSnapshotReply represents the return values for ProfileSnapshot in the LayerTree domain.

type ReleaseSnapshotArgs

type ReleaseSnapshotArgs struct {
	SnapshotID SnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

ReleaseSnapshotArgs represents the arguments for ReleaseSnapshot in the LayerTree domain.

func NewReleaseSnapshotArgs

func NewReleaseSnapshotArgs(snapshotID SnapshotID) *ReleaseSnapshotArgs

NewReleaseSnapshotArgs initializes ReleaseSnapshotArgs with the required arguments.

type ReplaySnapshotArgs

type ReplaySnapshotArgs struct {
	SnapshotID SnapshotID `json:"snapshotId"`         // The id of the layer snapshot.
	FromStep   *int       `json:"fromStep,omitempty"` // The first step to replay from (replay from the very start if not specified).
	ToStep     *int       `json:"toStep,omitempty"`   // The last step to replay to (replay till the end if not specified).
	Scale      *float64   `json:"scale,omitempty"`    // The scale to apply while replaying (defaults to 1).
}

ReplaySnapshotArgs represents the arguments for ReplaySnapshot in the LayerTree domain.

func NewReplaySnapshotArgs

func NewReplaySnapshotArgs(snapshotID SnapshotID) *ReplaySnapshotArgs

NewReplaySnapshotArgs initializes ReplaySnapshotArgs with the required arguments.

func (*ReplaySnapshotArgs) SetFromStep

func (a *ReplaySnapshotArgs) SetFromStep(fromStep int) *ReplaySnapshotArgs

SetFromStep sets the FromStep optional argument. The first step to replay from (replay from the very start if not specified).

func (*ReplaySnapshotArgs) SetScale

func (a *ReplaySnapshotArgs) SetScale(scale float64) *ReplaySnapshotArgs

SetScale sets the Scale optional argument. The scale to apply while replaying (defaults to 1).

func (*ReplaySnapshotArgs) SetToStep

func (a *ReplaySnapshotArgs) SetToStep(toStep int) *ReplaySnapshotArgs

SetToStep sets the ToStep optional argument. The last step to replay to (replay till the end if not specified).

type ReplaySnapshotReply

type ReplaySnapshotReply struct {
	DataURL string `json:"dataURL"` // A data: URL for resulting image.
}

ReplaySnapshotReply represents the return values for ReplaySnapshot in the LayerTree domain.

type ScrollRect

type ScrollRect struct {
	Rect dom.Rect `json:"rect"` // Rectangle itself.
	Type string   `json:"type"` // Reason for rectangle to force scrolling on the main thread
}

ScrollRect Rectangle where scrolling happens on the main thread.

type SnapshotCommandLogArgs

type SnapshotCommandLogArgs struct {
	SnapshotID SnapshotID `json:"snapshotId"` // The id of the layer snapshot.
}

SnapshotCommandLogArgs represents the arguments for SnapshotCommandLog in the LayerTree domain.

func NewSnapshotCommandLogArgs

func NewSnapshotCommandLogArgs(snapshotID SnapshotID) *SnapshotCommandLogArgs

NewSnapshotCommandLogArgs initializes SnapshotCommandLogArgs with the required arguments.

type SnapshotCommandLogReply

type SnapshotCommandLogReply struct {
	CommandLog []json.RawMessage `json:"commandLog"` // The array of canvas function calls.
}

SnapshotCommandLogReply represents the return values for SnapshotCommandLog in the LayerTree domain.

type SnapshotID

type SnapshotID string

SnapshotID Unique snapshot identifier.