cdpevent

package
v0.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 18, 2017 License: MIT Imports: 3 Imported by: 0

Documentation

Overview

Package cdpevent defines the event clients and replies for CDP events.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AnimationCanceledClient 

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

AnimationCanceledClient receives AnimationCanceled events.

type AnimationCanceledReply 

type AnimationCanceledReply struct {
	ID string `json:"id"` // Id of the animation that was canceled.
}

AnimationCanceledReply event for when an animation has been canceled.

type AnimationCreatedClient 

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

AnimationCreatedClient receives AnimationCreated events.

type AnimationCreatedReply 

type AnimationCreatedReply struct {
	ID string `json:"id"` // Id of the animation that was created.
}

AnimationCreatedReply event for each animation that has been created.

type AnimationStartedClient 

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

AnimationStartedClient receives AnimationStarted events.

type AnimationStartedReply 

type AnimationStartedReply struct {
	Animation cdptype.Animation `json:"animation"` // Animation that was started.
}

AnimationStartedReply event for animation that has been started.

type ApplicationCacheNetworkStateUpdatedClient 

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

ApplicationCacheNetworkStateUpdatedClient receives NetworkStateUpdated events.

type ApplicationCacheNetworkStateUpdatedReply 

type ApplicationCacheNetworkStateUpdatedReply struct {
	IsNowOnline bool `json:"isNowOnline"` //
}

ApplicationCacheNetworkStateUpdatedReply

type ApplicationCacheStatusUpdatedClient 

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

ApplicationCacheStatusUpdatedClient receives ApplicationCacheStatusUpdated events.

type ApplicationCacheStatusUpdatedReply 

type ApplicationCacheStatusUpdatedReply struct {
	FrameID     cdptype.PageFrameID `json:"frameId"`     // Identifier of the frame containing document whose application cache updated status.
	ManifestURL string              `json:"manifestURL"` // Manifest URL.
	Status      int                 `json:"status"`      // Updated application cache status.
}

ApplicationCacheStatusUpdatedReply

type CSSFontsUpdatedClient 

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

CSSFontsUpdatedClient receives FontsUpdated events.

type CSSFontsUpdatedReply 

type CSSFontsUpdatedReply struct{}

CSSFontsUpdatedReply fires whenever a web font gets loaded.

type CSSMediaQueryResultChangedClient 

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

CSSMediaQueryResultChangedClient receives MediaQueryResultChanged events.

type CSSMediaQueryResultChangedReply 

type CSSMediaQueryResultChangedReply struct{}

CSSMediaQueryResultChangedReply fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features.

type CSSStyleSheetAddedClient 

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

CSSStyleSheetAddedClient receives StyleSheetAdded events.

type CSSStyleSheetAddedReply 

type CSSStyleSheetAddedReply struct {
	Header cdptype.CSSStyleSheetHeader `json:"header"` // Added stylesheet metainfo.
}

CSSStyleSheetAddedReply fired whenever an active document stylesheet is added.

type CSSStyleSheetChangedClient 

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

CSSStyleSheetChangedClient receives StyleSheetChanged events.

type CSSStyleSheetChangedReply 

type CSSStyleSheetChangedReply struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` //
}

CSSStyleSheetChangedReply fired whenever a stylesheet is changed as a result of the client operation.

type CSSStyleSheetRemovedClient 

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

CSSStyleSheetRemovedClient receives StyleSheetRemoved events.

type CSSStyleSheetRemovedReply 

type CSSStyleSheetRemovedReply struct {
	StyleSheetID cdptype.CSSStyleSheetID `json:"styleSheetId"` // Identifier of the removed stylesheet.
}

CSSStyleSheetRemovedReply fired whenever an active document stylesheet is removed.

type ConsoleMessageAddedClient 

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

ConsoleMessageAddedClient receives MessageAdded events.

type ConsoleMessageAddedReply 

type ConsoleMessageAddedReply struct {
	Message cdptype.ConsoleMessage `json:"message"` // Console message that has been added.
}

ConsoleMessageAddedReply issued when new console message is added.

type DOMAttributeModifiedClient 

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

DOMAttributeModifiedClient receives AttributeModified events.

type DOMAttributeModifiedReply 

type DOMAttributeModifiedReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node that has changed.
	Name   string            `json:"name"`   // Attribute name.
	Value  string            `json:"value"`  // Attribute value.
}

DOMAttributeModifiedReply fired when Element's attribute is modified.

type DOMAttributeRemovedClient 

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

DOMAttributeRemovedClient receives AttributeRemoved events.

type DOMAttributeRemovedReply 

type DOMAttributeRemovedReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` // Id of the node that has changed.
	Name   string            `json:"name"`   // A ttribute name.
}

DOMAttributeRemovedReply fired when Element's attribute is removed.

type DOMCharacterDataModifiedClient 

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

DOMCharacterDataModifiedClient receives CharacterDataModified events.

type DOMCharacterDataModifiedReply 

type DOMCharacterDataModifiedReply struct {
	NodeID        cdptype.DOMNodeID `json:"nodeId"`        // Id of the node that has changed.
	CharacterData string            `json:"characterData"` // New text value.
}

DOMCharacterDataModifiedReply mirrors DOMCharacterDataModified event.

type DOMChildNodeCountUpdatedClient 

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

DOMChildNodeCountUpdatedClient receives ChildNodeCountUpdated events.

type DOMChildNodeCountUpdatedReply 

type DOMChildNodeCountUpdatedReply struct {
	NodeID         cdptype.DOMNodeID `json:"nodeId"`         // Id of the node that has changed.
	ChildNodeCount int               `json:"childNodeCount"` // New node count.
}

DOMChildNodeCountUpdatedReply fired when Container's child node count has changed.

type DOMChildNodeInsertedClient 

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

DOMChildNodeInsertedClient receives ChildNodeInserted events.

type DOMChildNodeInsertedReply 

type DOMChildNodeInsertedReply struct {
	ParentNodeID   cdptype.DOMNodeID `json:"parentNodeId"`   // Id of the node that has changed.
	PreviousNodeID cdptype.DOMNodeID `json:"previousNodeId"` // If of the previous siblint.
	Node           cdptype.DOMNode   `json:"node"`           // Inserted node data.
}

DOMChildNodeInsertedReply mirrors DOMNodeInserted event.

type DOMChildNodeRemovedClient 

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

DOMChildNodeRemovedClient receives ChildNodeRemoved events.

type DOMChildNodeRemovedReply 

type DOMChildNodeRemovedReply struct {
	ParentNodeID cdptype.DOMNodeID `json:"parentNodeId"` // Parent id.
	NodeID       cdptype.DOMNodeID `json:"nodeId"`       // Id of the node that has been removed.
}

DOMChildNodeRemovedReply mirrors DOMNodeRemoved event.

type DOMDistributedNodesUpdatedClient 

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

DOMDistributedNodesUpdatedClient receives DistributedNodesUpdated events.

type DOMDistributedNodesUpdatedReply 

type DOMDistributedNodesUpdatedReply struct {
	InsertionPointID cdptype.DOMNodeID        `json:"insertionPointId"` // Insertion point where distributed nodes were updated.
	DistributedNodes []cdptype.DOMBackendNode `json:"distributedNodes"` // Distributed nodes for given insertion point.
}

DOMDistributedNodesUpdatedReply called when distribution is changed.

type DOMDocumentUpdatedClient 

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

DOMDocumentUpdatedClient receives DocumentUpdated events.

type DOMDocumentUpdatedReply 

type DOMDocumentUpdatedReply struct{}

DOMDocumentUpdatedReply fired when Document has been totally updated. Node ids are no longer valid.

type DOMInlineStyleInvalidatedClient 

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

DOMInlineStyleInvalidatedClient receives InlineStyleInvalidated events.

type DOMInlineStyleInvalidatedReply 

type DOMInlineStyleInvalidatedReply struct {
	NodeIDs []cdptype.DOMNodeID `json:"nodeIds"` // Ids of the nodes for which the inline styles have been invalidated.
}

DOMInlineStyleInvalidatedReply fired when Element's inline style is modified via a CSS property modification.

type DOMPseudoElementAddedClient 

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

DOMPseudoElementAddedClient receives PseudoElementAdded events.

type DOMPseudoElementAddedReply 

type DOMPseudoElementAddedReply struct {
	ParentID      cdptype.DOMNodeID `json:"parentId"`      // Pseudo element's parent element id.
	PseudoElement cdptype.DOMNode   `json:"pseudoElement"` // The added pseudo element.
}

DOMPseudoElementAddedReply called when a pseudo element is added to an element.

type DOMPseudoElementRemovedClient 

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

DOMPseudoElementRemovedClient receives PseudoElementRemoved events.

type DOMPseudoElementRemovedReply 

type DOMPseudoElementRemovedReply struct {
	ParentID        cdptype.DOMNodeID `json:"parentId"`        // Pseudo element's parent element id.
	PseudoElementID cdptype.DOMNodeID `json:"pseudoElementId"` // The removed pseudo element id.
}

DOMPseudoElementRemovedReply called when a pseudo element is removed from an element.

type DOMSetChildNodesClient 

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

DOMSetChildNodesClient receives SetChildNodes events.

type DOMSetChildNodesReply 

type DOMSetChildNodesReply struct {
	ParentID cdptype.DOMNodeID `json:"parentId"` // Parent node id to populate with children.
	Nodes    []cdptype.DOMNode `json:"nodes"`    // Child nodes array.
}

DOMSetChildNodesReply fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.

type DOMShadowRootPoppedClient 

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

DOMShadowRootPoppedClient receives ShadowRootPopped events.

type DOMShadowRootPoppedReply 

type DOMShadowRootPoppedReply struct {
	HostID cdptype.DOMNodeID `json:"hostId"` // Host element id.
	RootID cdptype.DOMNodeID `json:"rootId"` // Shadow root id.
}

DOMShadowRootPoppedReply called when shadow root is popped from the element.

type DOMShadowRootPushedClient 

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

DOMShadowRootPushedClient receives ShadowRootPushed events.

type DOMShadowRootPushedReply 

type DOMShadowRootPushedReply struct {
	HostID cdptype.DOMNodeID `json:"hostId"` // Host element id.
	Root   cdptype.DOMNode   `json:"root"`   // Shadow root.
}

DOMShadowRootPushedReply called when shadow root is pushed into the element.

type DOMStorageItemAddedClient 

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

DOMStorageItemAddedClient receives DOMStorageItemAdded events.

type DOMStorageItemAddedReply 

type DOMStorageItemAddedReply struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
	Key       string                      `json:"key"`       //
	NewValue  string                      `json:"newValue"`  //
}

DOMStorageItemAddedReply

type DOMStorageItemRemovedClient 

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

DOMStorageItemRemovedClient receives DOMStorageItemRemoved events.

type DOMStorageItemRemovedReply 

type DOMStorageItemRemovedReply struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
	Key       string                      `json:"key"`       //
}

DOMStorageItemRemovedReply

type DOMStorageItemUpdatedClient 

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

DOMStorageItemUpdatedClient receives DOMStorageItemUpdated events.

type DOMStorageItemUpdatedReply 

type DOMStorageItemUpdatedReply struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
	Key       string                      `json:"key"`       //
	OldValue  string                      `json:"oldValue"`  //
	NewValue  string                      `json:"newValue"`  //
}

DOMStorageItemUpdatedReply

type DOMStorageItemsClearedClient 

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

DOMStorageItemsClearedClient receives DOMStorageItemsCleared events.

type DOMStorageItemsClearedReply 

type DOMStorageItemsClearedReply struct {
	StorageID cdptype.DOMStorageStorageID `json:"storageId"` //
}

DOMStorageItemsClearedReply

type DatabaseAddDatabaseClient 

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

DatabaseAddDatabaseClient receives AddDatabase events.

type DatabaseAddDatabaseReply 

type DatabaseAddDatabaseReply struct {
	Database cdptype.Database `json:"database"` //
}

DatabaseAddDatabaseReply

type DebuggerBreakpointResolvedClient 

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

DebuggerBreakpointResolvedClient receives BreakpointResolved events.

type DebuggerBreakpointResolvedReply 

type DebuggerBreakpointResolvedReply struct {
	BreakpointID cdptype.DebuggerBreakpointID `json:"breakpointId"` // Breakpoint unique identifier.
	Location     cdptype.DebuggerLocation     `json:"location"`     // Actual breakpoint location.
}

DebuggerBreakpointResolvedReply fired when breakpoint is resolved to an actual script and location.

type DebuggerPausedClient 

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

DebuggerPausedClient receives Paused events.

type DebuggerPausedReply 

type DebuggerPausedReply struct {
	CallFrames      []cdptype.DebuggerCallFrame `json:"callFrames"`                // Call stack the virtual machine stopped on.
	Reason          string                      `json:"reason"`                    // Pause reason.
	Data            json.RawMessage             `json:"data,omitempty"`            // Object containing break-specific auxiliary properties.
	HitBreakpoints  []string                    `json:"hitBreakpoints,omitempty"`  // Hit breakpoints IDs
	AsyncStackTrace *cdptype.RuntimeStackTrace  `json:"asyncStackTrace,omitempty"` // Async stack trace, if any.
}

DebuggerPausedReply fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

type DebuggerResumedClient 

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

DebuggerResumedClient receives Resumed events.

type DebuggerResumedReply 

type DebuggerResumedReply struct{}

DebuggerResumedReply fired when the virtual machine resumed execution.

type DebuggerScriptFailedToParseClient 

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

DebuggerScriptFailedToParseClient receives ScriptFailedToParse events.

type DebuggerScriptFailedToParseReply 

type DebuggerScriptFailedToParseReply struct {
	ScriptID                cdptype.RuntimeScriptID           `json:"scriptId"`                          // Identifier of the script parsed.
	URL                     string                            `json:"url"`                               // URL or name of the script parsed (if any).
	StartLine               int                               `json:"startLine"`                         // Line offset of the script within the resource with given URL (for script tags).
	StartColumn             int                               `json:"startColumn"`                       // Column offset of the script within the resource with given URL.
	EndLine                 int                               `json:"endLine"`                           // Last line of the script.
	EndColumn               int                               `json:"endColumn"`                         // Length of the last line of the script.
	ExecutionContextID      cdptype.RuntimeExecutionContextID `json:"executionContextId"`                // Specifies script creation context.
	Hash                    string                            `json:"hash"`                              // Content hash of the script.
	ExecutionContextAuxData json.RawMessage                   `json:"executionContextAuxData,omitempty"` // Embedder-specific auxiliary data.
	SourceMapURL            *string                           `json:"sourceMapURL,omitempty"`            // URL of source map associated with script (if any).
	HasSourceURL            *bool                             `json:"hasSourceURL,omitempty"`            // True, if this script has sourceURL.
	IsModule                *bool                             `json:"isModule,omitempty"`                // True, if this script is ES6 module.
	Length                  *int                              `json:"length,omitempty"`                  // This script length.
	StackTrace              *cdptype.RuntimeStackTrace        `json:"stackTrace,omitempty"`              // JavaScript top stack frame of where the script parsed event was triggered if available.
}

DebuggerScriptFailedToParseReply fired when virtual machine fails to parse the script.

type DebuggerScriptParsedClient 

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

DebuggerScriptParsedClient receives ScriptParsed events.

type DebuggerScriptParsedReply 

type DebuggerScriptParsedReply struct {
	ScriptID                cdptype.RuntimeScriptID           `json:"scriptId"`                          // Identifier of the script parsed.
	URL                     string                            `json:"url"`                               // URL or name of the script parsed (if any).
	StartLine               int                               `json:"startLine"`                         // Line offset of the script within the resource with given URL (for script tags).
	StartColumn             int                               `json:"startColumn"`                       // Column offset of the script within the resource with given URL.
	EndLine                 int                               `json:"endLine"`                           // Last line of the script.
	EndColumn               int                               `json:"endColumn"`                         // Length of the last line of the script.
	ExecutionContextID      cdptype.RuntimeExecutionContextID `json:"executionContextId"`                // Specifies script creation context.
	Hash                    string                            `json:"hash"`                              // Content hash of the script.
	ExecutionContextAuxData json.RawMessage                   `json:"executionContextAuxData,omitempty"` // Embedder-specific auxiliary data.
	IsLiveEdit              *bool                             `json:"isLiveEdit,omitempty"`              // True, if this script is generated as a result of the live edit operation.
	SourceMapURL            *string                           `json:"sourceMapURL,omitempty"`            // URL of source map associated with script (if any).
	HasSourceURL            *bool                             `json:"hasSourceURL,omitempty"`            // True, if this script has sourceURL.
	IsModule                *bool                             `json:"isModule,omitempty"`                // True, if this script is ES6 module.
	Length                  *int                              `json:"length,omitempty"`                  // This script length.
	StackTrace              *cdptype.RuntimeStackTrace        `json:"stackTrace,omitempty"`              // JavaScript top stack frame of where the script parsed event was triggered if available.
}

DebuggerScriptParsedReply fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

type EmulationVirtualTimeBudgetExpiredClient 

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

EmulationVirtualTimeBudgetExpiredClient receives VirtualTimeBudgetExpired events.

type EmulationVirtualTimeBudgetExpiredReply 

type EmulationVirtualTimeBudgetExpiredReply struct{}

EmulationVirtualTimeBudgetExpiredReply notification sent after the virual time budget for the current VirtualTimePolicy has run out.

type EventType 

type EventType string

EventType is the type for CDP event names. 

const (
	AnimationCreated                          EventType = "Animation.animationCreated"
	AnimationStarted                          EventType = "Animation.animationStarted"
	AnimationCanceled                         EventType = "Animation.animationCanceled"
	ApplicationCacheStatusUpdated             EventType = "ApplicationCache.applicationCacheStatusUpdated"
	ApplicationCacheNetworkStateUpdated       EventType = "ApplicationCache.networkStateUpdated"
	CSSMediaQueryResultChanged                EventType = "CSS.mediaQueryResultChanged"
	CSSFontsUpdated                           EventType = "CSS.fontsUpdated"
	CSSStyleSheetChanged                      EventType = "CSS.styleSheetChanged"
	CSSStyleSheetAdded                        EventType = "CSS.styleSheetAdded"
	CSSStyleSheetRemoved                      EventType = "CSS.styleSheetRemoved"
	ConsoleMessageAdded                       EventType = "Console.messageAdded"
	DOMDocumentUpdated                        EventType = "DOM.documentUpdated"
	DOMSetChildNodes                          EventType = "DOM.setChildNodes"
	DOMAttributeModified                      EventType = "DOM.attributeModified"
	DOMAttributeRemoved                       EventType = "DOM.attributeRemoved"
	DOMInlineStyleInvalidated                 EventType = "DOM.inlineStyleInvalidated"
	DOMCharacterDataModified                  EventType = "DOM.characterDataModified"
	DOMChildNodeCountUpdated                  EventType = "DOM.childNodeCountUpdated"
	DOMChildNodeInserted                      EventType = "DOM.childNodeInserted"
	DOMChildNodeRemoved                       EventType = "DOM.childNodeRemoved"
	DOMShadowRootPushed                       EventType = "DOM.shadowRootPushed"
	DOMShadowRootPopped                       EventType = "DOM.shadowRootPopped"
	DOMPseudoElementAdded                     EventType = "DOM.pseudoElementAdded"
	DOMPseudoElementRemoved                   EventType = "DOM.pseudoElementRemoved"
	DOMDistributedNodesUpdated                EventType = "DOM.distributedNodesUpdated"
	DOMStorageItemsCleared                    EventType = "DOMStorage.domStorageItemsCleared"
	DOMStorageItemRemoved                     EventType = "DOMStorage.domStorageItemRemoved"
	DOMStorageItemAdded                       EventType = "DOMStorage.domStorageItemAdded"
	DOMStorageItemUpdated                     EventType = "DOMStorage.domStorageItemUpdated"
	DatabaseAddDatabase                       EventType = "Database.addDatabase"
	DebuggerScriptParsed                      EventType = "Debugger.scriptParsed"
	DebuggerScriptFailedToParse               EventType = "Debugger.scriptFailedToParse"
	DebuggerBreakpointResolved                EventType = "Debugger.breakpointResolved"
	DebuggerPaused                            EventType = "Debugger.paused"
	DebuggerResumed                           EventType = "Debugger.resumed"
	EmulationVirtualTimeBudgetExpired         EventType = "Emulation.virtualTimeBudgetExpired"
	HeapProfilerAddHeapSnapshotChunk          EventType = "HeapProfiler.addHeapSnapshotChunk"
	HeapProfilerResetProfiles                 EventType = "HeapProfiler.resetProfiles"
	HeapProfilerReportHeapSnapshotProgress    EventType = "HeapProfiler.reportHeapSnapshotProgress"
	HeapProfilerLastSeenObjectID              EventType = "HeapProfiler.lastSeenObjectId"
	HeapProfilerHeapStatsUpdate               EventType = "HeapProfiler.heapStatsUpdate"
	InspectorDetached                         EventType = "Inspector.detached"
	InspectorTargetCrashed                    EventType = "Inspector.targetCrashed"
	LayerTreeDidChange                        EventType = "LayerTree.layerTreeDidChange"
	LayerTreeLayerPainted                     EventType = "LayerTree.layerPainted"
	LogEntryAdded                             EventType = "Log.entryAdded"
	NetworkResourceChangedPriority            EventType = "Network.resourceChangedPriority"
	NetworkRequestWillBeSent                  EventType = "Network.requestWillBeSent"
	NetworkRequestServedFromCache             EventType = "Network.requestServedFromCache"
	NetworkResponseReceived                   EventType = "Network.responseReceived"
	NetworkDataReceived                       EventType = "Network.dataReceived"
	NetworkLoadingFinished                    EventType = "Network.loadingFinished"
	NetworkLoadingFailed                      EventType = "Network.loadingFailed"
	NetworkWebSocketWillSendHandshakeRequest  EventType = "Network.webSocketWillSendHandshakeRequest"
	NetworkWebSocketHandshakeResponseReceived EventType = "Network.webSocketHandshakeResponseReceived"
	NetworkWebSocketCreated                   EventType = "Network.webSocketCreated"
	NetworkWebSocketClosed                    EventType = "Network.webSocketClosed"
	NetworkWebSocketFrameReceived             EventType = "Network.webSocketFrameReceived"
	NetworkWebSocketFrameError                EventType = "Network.webSocketFrameError"
	NetworkWebSocketFrameSent                 EventType = "Network.webSocketFrameSent"
	NetworkEventSourceMessageReceived         EventType = "Network.eventSourceMessageReceived"
	NetworkRequestIntercepted                 EventType = "Network.requestIntercepted"
	OverlayNodeHighlightRequested             EventType = "Overlay.nodeHighlightRequested"
	OverlayInspectNodeRequested               EventType = "Overlay.inspectNodeRequested"
	PageDOMContentEventFired                  EventType = "Page.domContentEventFired"
	PageLoadEventFired                        EventType = "Page.loadEventFired"
	PageFrameAttached                         EventType = "Page.frameAttached"
	PageFrameNavigated                        EventType = "Page.frameNavigated"
	PageFrameDetached                         EventType = "Page.frameDetached"
	PageFrameStartedLoading                   EventType = "Page.frameStartedLoading"
	PageFrameStoppedLoading                   EventType = "Page.frameStoppedLoading"
	PageFrameScheduledNavigation              EventType = "Page.frameScheduledNavigation"
	PageFrameClearedScheduledNavigation       EventType = "Page.frameClearedScheduledNavigation"
	PageFrameResized                          EventType = "Page.frameResized"
	PageJavascriptDialogOpening               EventType = "Page.javascriptDialogOpening"
	PageJavascriptDialogClosed                EventType = "Page.javascriptDialogClosed"
	PageScreencastFrame                       EventType = "Page.screencastFrame"
	PageScreencastVisibilityChanged           EventType = "Page.screencastVisibilityChanged"
	PageInterstitialShown                     EventType = "Page.interstitialShown"
	PageInterstitialHidden                    EventType = "Page.interstitialHidden"
	PageNavigationRequested                   EventType = "Page.navigationRequested"
	ProfilerConsoleProfileStarted             EventType = "Profiler.consoleProfileStarted"
	ProfilerConsoleProfileFinished            EventType = "Profiler.consoleProfileFinished"
	RuntimeExecutionContextCreated            EventType = "Runtime.executionContextCreated"
	RuntimeExecutionContextDestroyed          EventType = "Runtime.executionContextDestroyed"
	RuntimeExecutionContextsCleared           EventType = "Runtime.executionContextsCleared"
	RuntimeExceptionThrown                    EventType = "Runtime.exceptionThrown"
	RuntimeExceptionRevoked                   EventType = "Runtime.exceptionRevoked"
	RuntimeConsoleAPICalled                   EventType = "Runtime.consoleAPICalled"
	RuntimeInspectRequested                   EventType = "Runtime.inspectRequested"
	SecurityStateChanged                      EventType = "Security.securityStateChanged"
	SecurityCertificateError                  EventType = "Security.certificateError"
	ServiceWorkerWorkerRegistrationUpdated    EventType = "ServiceWorker.workerRegistrationUpdated"
	ServiceWorkerWorkerVersionUpdated         EventType = "ServiceWorker.workerVersionUpdated"
	ServiceWorkerWorkerErrorReported          EventType = "ServiceWorker.workerErrorReported"
	TargetCreated                             EventType = "Target.targetCreated"
	TargetInfoChanged                         EventType = "Target.targetInfoChanged"
	TargetDestroyed                           EventType = "Target.targetDestroyed"
	TargetAttachedToTarget                    EventType = "Target.attachedToTarget"
	TargetDetachedFromTarget                  EventType = "Target.detachedFromTarget"
	TargetReceivedMessageFromTarget           EventType = "Target.receivedMessageFromTarget"
	TetheringAccepted                         EventType = "Tethering.accepted"
	TracingDataCollected                      EventType = "Tracing.dataCollected"
	TracingComplete                           EventType = "Tracing.tracingComplete"
	TracingBufferUsage                        EventType = "Tracing.bufferUsage"
)

Event methods.

func (EventType) String 

func (e EventType) String() string

type HeapProfilerAddHeapSnapshotChunkClient 

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

HeapProfilerAddHeapSnapshotChunkClient receives AddHeapSnapshotChunk events.

type HeapProfilerAddHeapSnapshotChunkReply 

type HeapProfilerAddHeapSnapshotChunkReply struct {
	Chunk string `json:"chunk"` //
}

HeapProfilerAddHeapSnapshotChunkReply

type HeapProfilerHeapStatsUpdateClient 

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

HeapProfilerHeapStatsUpdateClient receives HeapStatsUpdate events.

type HeapProfilerHeapStatsUpdateReply 

type HeapProfilerHeapStatsUpdateReply struct {
	StatsUpdate []int `json:"statsUpdate"` // An array of triplets. Each triplet describes a fragment. The first integer is the fragment index, the second integer is a total count of objects for the fragment, the third integer is a total size of the objects for the fragment.
}

HeapProfilerHeapStatsUpdateReply if heap objects tracking has been started then backend may send update for one or more fragments

type HeapProfilerLastSeenObjectIDClient 

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

HeapProfilerLastSeenObjectIDClient receives LastSeenObjectID events.

type HeapProfilerLastSeenObjectIDReply 

type HeapProfilerLastSeenObjectIDReply struct {
	LastSeenObjectID int               `json:"lastSeenObjectId"` //
	Timestamp        cdptype.Timestamp `json:"timestamp"`        //
}

HeapProfilerLastSeenObjectIDReply if heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.

type HeapProfilerReportHeapSnapshotProgressClient 

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

HeapProfilerReportHeapSnapshotProgressClient receives ReportHeapSnapshotProgress events.

type HeapProfilerReportHeapSnapshotProgressReply 

type HeapProfilerReportHeapSnapshotProgressReply struct {
	Done     int   `json:"done"`               //
	Total    int   `json:"total"`              //
	Finished *bool `json:"finished,omitempty"` //
}

HeapProfilerReportHeapSnapshotProgressReply

type HeapProfilerResetProfilesClient 

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

HeapProfilerResetProfilesClient receives ResetProfiles events.

type HeapProfilerResetProfilesReply 

type HeapProfilerResetProfilesReply struct{}

HeapProfilerResetProfilesReply

type InspectorDetachedClient 

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

InspectorDetachedClient receives Detached events.

type InspectorDetachedReply 

type InspectorDetachedReply struct {
	Reason string `json:"reason"` // The reason why connection has been terminated.
}

InspectorDetachedReply fired when remote debugging connection is about to be terminated. Contains detach reason.

type InspectorTargetCrashedClient 

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

InspectorTargetCrashedClient receives TargetCrashed events.

type InspectorTargetCrashedReply 

type InspectorTargetCrashedReply struct{}

InspectorTargetCrashedReply fired when debugging target has crashed

type LayerTreeDidChangeClient 

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

LayerTreeDidChangeClient receives LayerTreeDidChange events.

type LayerTreeDidChangeReply 

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

LayerTreeDidChangeReply

type LayerTreeLayerPaintedClient 

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

LayerTreeLayerPaintedClient receives LayerPainted events.

type LayerTreeLayerPaintedReply 

type LayerTreeLayerPaintedReply struct {
	LayerID cdptype.LayerTreeLayerID `json:"layerId"` // The id of the painted layer.
	Clip    cdptype.DOMRect          `json:"clip"`    // Clip rectangle.
}

LayerTreeLayerPaintedReply

type LogEntryAddedClient 

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

LogEntryAddedClient receives EntryAdded events.

type LogEntryAddedReply 

type LogEntryAddedReply struct {
	Entry cdptype.LogEntry `json:"entry"` // The entry.
}

LogEntryAddedReply issued when new message was logged.

type NetworkDataReceivedClient 

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

NetworkDataReceivedClient receives DataReceived events.

type NetworkDataReceivedReply 

type NetworkDataReceivedReply struct {
	RequestID         cdptype.NetworkRequestID `json:"requestId"`         // Request identifier.
	Timestamp         cdptype.NetworkTimestamp `json:"timestamp"`         // Timestamp.
	DataLength        int                      `json:"dataLength"`        // Data chunk length.
	EncodedDataLength int                      `json:"encodedDataLength"` // Actual bytes received (might be less than dataLength for compressed encodings).
}

NetworkDataReceivedReply fired when data chunk was received over the network.

type NetworkEventSourceMessageReceivedClient 

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

NetworkEventSourceMessageReceivedClient receives EventSourceMessageReceived events.

type NetworkEventSourceMessageReceivedReply 

type NetworkEventSourceMessageReceivedReply struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp `json:"timestamp"` // Timestamp.
	EventName string                   `json:"eventName"` // Message type.
	EventID   string                   `json:"eventId"`   // Message identifier.
	Data      string                   `json:"data"`      // Message content.
}

NetworkEventSourceMessageReceivedReply fired when EventSource message is received.

type NetworkLoadingFailedClient 

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

NetworkLoadingFailedClient receives LoadingFailed events.

type NetworkLoadingFailedReply 

type NetworkLoadingFailedReply struct {
	RequestID     cdptype.NetworkRequestID     `json:"requestId"`               // Request identifier.
	Timestamp     cdptype.NetworkTimestamp     `json:"timestamp"`               // Timestamp.
	Type          cdptype.PageResourceType     `json:"type"`                    // Resource type.
	ErrorText     string                       `json:"errorText"`               // User friendly error message.
	Canceled      *bool                        `json:"canceled,omitempty"`      // True if loading was canceled.
	BlockedReason cdptype.NetworkBlockedReason `json:"blockedReason,omitempty"` // The reason why loading was blocked, if any.
}

NetworkLoadingFailedReply fired when HTTP request has failed to load.

type NetworkLoadingFinishedClient 

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

NetworkLoadingFinishedClient receives LoadingFinished events.

type NetworkLoadingFinishedReply 

type NetworkLoadingFinishedReply struct {
	RequestID         cdptype.NetworkRequestID `json:"requestId"`         // Request identifier.
	Timestamp         cdptype.NetworkTimestamp `json:"timestamp"`         // Timestamp.
	EncodedDataLength float64                  `json:"encodedDataLength"` // Total number of bytes received for this request.
}

NetworkLoadingFinishedReply fired when HTTP request has finished loading.

type NetworkRequestInterceptedClient 

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

NetworkRequestInterceptedClient receives RequestIntercepted events.

type NetworkRequestInterceptedReply 

type NetworkRequestInterceptedReply struct {
	InterceptionID     cdptype.NetworkInterceptionID `json:"interceptionId"`               // Each request the page makes will have a unique id, however if any redirects are encountered while processing that fetch, they will be reported with the same id as the original fetch. Likewise if HTTP authentication is needed then the same fetch id will be used.
	Request            cdptype.NetworkRequest        `json:"request"`                      //
	ResourceType       cdptype.PageResourceType      `json:"resourceType"`                 // How the requested resource will be used.
	RedirectHeaders    cdptype.NetworkHeaders        `json:"redirectHeaders,omitempty"`    // HTTP response headers, only sent if a redirect was intercepted.
	RedirectStatusCode *int                          `json:"redirectStatusCode,omitempty"` // HTTP response code, only sent if a redirect was intercepted.
	RedirectURL        *string                       `json:"redirectUrl,omitempty"`        // Redirect location, only sent if a redirect was intercepted.
	AuthChallenge      *cdptype.NetworkAuthChallenge `json:"authChallenge,omitempty"`      // Details of the Authorization Challenge encountered. If this is set then continueInterceptedRequest must contain an authChallengeResponse.
}

NetworkRequestInterceptedReply details of an intercepted HTTP request, which must be either allowed, blocked, modified or mocked.

type NetworkRequestServedFromCacheClient 

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

NetworkRequestServedFromCacheClient receives RequestServedFromCache events.

type NetworkRequestServedFromCacheReply 

type NetworkRequestServedFromCacheReply struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Request identifier.
}

NetworkRequestServedFromCacheReply fired if request ended up loading from cache.

type NetworkRequestWillBeSentClient 

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

NetworkRequestWillBeSentClient receives RequestWillBeSent events.

type NetworkRequestWillBeSentReply 

type NetworkRequestWillBeSentReply struct {
	RequestID        cdptype.NetworkRequestID `json:"requestId"`                  // Request identifier.
	FrameID          cdptype.PageFrameID      `json:"frameId"`                    // Frame identifier.
	LoaderID         cdptype.NetworkLoaderID  `json:"loaderId"`                   // Loader identifier.
	DocumentURL      string                   `json:"documentURL"`                // URL of the document this request is loaded for.
	Request          cdptype.NetworkRequest   `json:"request"`                    // Request data.
	Timestamp        cdptype.NetworkTimestamp `json:"timestamp"`                  // Timestamp.
	WallTime         cdptype.NetworkTimestamp `json:"wallTime"`                   // UTC Timestamp.
	Initiator        cdptype.NetworkInitiator `json:"initiator"`                  // Request initiator.
	RedirectResponse *cdptype.NetworkResponse `json:"redirectResponse,omitempty"` // Redirect response data.
	Type             cdptype.PageResourceType `json:"type,omitempty"`             // Type of this resource.
}

NetworkRequestWillBeSentReply fired when page is about to send HTTP request.

type NetworkResourceChangedPriorityClient 

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

NetworkResourceChangedPriorityClient receives ResourceChangedPriority events.

type NetworkResourceChangedPriorityReply 

type NetworkResourceChangedPriorityReply struct {
	RequestID   cdptype.NetworkRequestID        `json:"requestId"`   // Request identifier.
	NewPriority cdptype.NetworkResourcePriority `json:"newPriority"` // New priority
	Timestamp   cdptype.NetworkTimestamp        `json:"timestamp"`   // Timestamp.
}

NetworkResourceChangedPriorityReply fired when resource loading priority is changed

type NetworkResponseReceivedClient 

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

NetworkResponseReceivedClient receives ResponseReceived events.

type NetworkResponseReceivedReply 

type NetworkResponseReceivedReply struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Request identifier.
	FrameID   cdptype.PageFrameID      `json:"frameId"`   // Frame identifier.
	LoaderID  cdptype.NetworkLoaderID  `json:"loaderId"`  // Loader identifier.
	Timestamp cdptype.NetworkTimestamp `json:"timestamp"` // Timestamp.
	Type      cdptype.PageResourceType `json:"type"`      // Resource type.
	Response  cdptype.NetworkResponse  `json:"response"`  // Response data.
}

NetworkResponseReceivedReply fired when HTTP response is available.

type NetworkWebSocketClosedClient 

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

NetworkWebSocketClosedClient receives WebSocketClosed events.

type NetworkWebSocketClosedReply 

type NetworkWebSocketClosedReply struct {
	RequestID cdptype.NetworkRequestID `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp `json:"timestamp"` // Timestamp.
}

NetworkWebSocketClosedReply fired when WebSocket is closed.

type NetworkWebSocketCreatedClient 

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

NetworkWebSocketCreatedClient receives WebSocketCreated events.

type NetworkWebSocketCreatedReply 

type NetworkWebSocketCreatedReply struct {
	RequestID cdptype.NetworkRequestID  `json:"requestId"`           // Request identifier.
	URL       string                    `json:"url"`                 // WebSocket request URL.
	Initiator *cdptype.NetworkInitiator `json:"initiator,omitempty"` // Request initiator.
}

NetworkWebSocketCreatedReply fired upon WebSocket creation.

type NetworkWebSocketFrameErrorClient 

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

NetworkWebSocketFrameErrorClient receives WebSocketFrameError events.

type NetworkWebSocketFrameErrorReply 

type NetworkWebSocketFrameErrorReply struct {
	RequestID    cdptype.NetworkRequestID `json:"requestId"`    // Request identifier.
	Timestamp    cdptype.NetworkTimestamp `json:"timestamp"`    // Timestamp.
	ErrorMessage string                   `json:"errorMessage"` // WebSocket frame error message.
}

NetworkWebSocketFrameErrorReply fired when WebSocket frame error occurs.

type NetworkWebSocketFrameReceivedClient 

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

NetworkWebSocketFrameReceivedClient receives WebSocketFrameReceived events.

type NetworkWebSocketFrameReceivedReply 

type NetworkWebSocketFrameReceivedReply struct {
	RequestID cdptype.NetworkRequestID      `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp      `json:"timestamp"` // Timestamp.
	Response  cdptype.NetworkWebSocketFrame `json:"response"`  // WebSocket response data.
}

NetworkWebSocketFrameReceivedReply fired when WebSocket frame is received.

type NetworkWebSocketFrameSentClient 

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

NetworkWebSocketFrameSentClient receives WebSocketFrameSent events.

type NetworkWebSocketFrameSentReply 

type NetworkWebSocketFrameSentReply struct {
	RequestID cdptype.NetworkRequestID      `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp      `json:"timestamp"` // Timestamp.
	Response  cdptype.NetworkWebSocketFrame `json:"response"`  // WebSocket response data.
}

NetworkWebSocketFrameSentReply fired when WebSocket frame is sent.

type NetworkWebSocketHandshakeResponseReceivedClient 

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

NetworkWebSocketHandshakeResponseReceivedClient receives WebSocketHandshakeResponseReceived events.

type NetworkWebSocketHandshakeResponseReceivedReply 

type NetworkWebSocketHandshakeResponseReceivedReply struct {
	RequestID cdptype.NetworkRequestID         `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp         `json:"timestamp"` // Timestamp.
	Response  cdptype.NetworkWebSocketResponse `json:"response"`  // WebSocket response data.
}

NetworkWebSocketHandshakeResponseReceivedReply fired when WebSocket handshake response becomes available.

type NetworkWebSocketWillSendHandshakeRequestClient 

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

NetworkWebSocketWillSendHandshakeRequestClient receives WebSocketWillSendHandshakeRequest events.

type NetworkWebSocketWillSendHandshakeRequestReply 

type NetworkWebSocketWillSendHandshakeRequestReply struct {
	RequestID cdptype.NetworkRequestID        `json:"requestId"` // Request identifier.
	Timestamp cdptype.NetworkTimestamp        `json:"timestamp"` // Timestamp.
	WallTime  cdptype.NetworkTimestamp        `json:"wallTime"`  // UTC Timestamp.
	Request   cdptype.NetworkWebSocketRequest `json:"request"`   // WebSocket request data.
}

NetworkWebSocketWillSendHandshakeRequestReply fired when WebSocket is about to initiate handshake.

type OverlayInspectNodeRequestedClient 

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

OverlayInspectNodeRequestedClient receives InspectNodeRequested events.

type OverlayInspectNodeRequestedReply 

type OverlayInspectNodeRequestedReply struct {
	BackendNodeID cdptype.DOMBackendNodeID `json:"backendNodeId"` // Id of the node to inspect.
}

OverlayInspectNodeRequestedReply fired when the node should be inspected. This happens after call to setInspectMode or when user manually inspects an element.

type OverlayNodeHighlightRequestedClient 

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

OverlayNodeHighlightRequestedClient receives NodeHighlightRequested events.

type OverlayNodeHighlightRequestedReply 

type OverlayNodeHighlightRequestedReply struct {
	NodeID cdptype.DOMNodeID `json:"nodeId"` //
}

OverlayNodeHighlightRequestedReply fired when the node should be highlighted. This happens after call to setInspectMode.

type PageDOMContentEventFiredClient 

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

PageDOMContentEventFiredClient receives DOMContentEventFired events.

type PageDOMContentEventFiredReply 

type PageDOMContentEventFiredReply struct {
	Timestamp cdptype.Timestamp `json:"timestamp"` //
}

PageDOMContentEventFiredReply

type PageFrameAttachedClient 

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

PageFrameAttachedClient receives FrameAttached events.

type PageFrameAttachedReply 

type PageFrameAttachedReply struct {
	FrameID       cdptype.PageFrameID        `json:"frameId"`         // Id of the frame that has been attached.
	ParentFrameID cdptype.PageFrameID        `json:"parentFrameId"`   // Parent frame identifier.
	Stack         *cdptype.RuntimeStackTrace `json:"stack,omitempty"` // JavaScript stack trace of when frame was attached, only set if frame initiated from script.
}

PageFrameAttachedReply fired when frame has been attached to its parent.

type PageFrameClearedScheduledNavigationClient 

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

PageFrameClearedScheduledNavigationClient receives FrameClearedScheduledNavigation events.

type PageFrameClearedScheduledNavigationReply 

type PageFrameClearedScheduledNavigationReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Id of the frame that has cleared its scheduled navigation.
}

PageFrameClearedScheduledNavigationReply fired when frame no longer has a scheduled navigation.

type PageFrameDetachedClient 

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

PageFrameDetachedClient receives FrameDetached events.

type PageFrameDetachedReply 

type PageFrameDetachedReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Id of the frame that has been detached.
}

PageFrameDetachedReply fired when frame has been detached from its parent.

type PageFrameNavigatedClient 

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

PageFrameNavigatedClient receives FrameNavigated events.

type PageFrameNavigatedReply 

type PageFrameNavigatedReply struct {
	Frame cdptype.PageFrame `json:"frame"` // Frame object.
}

PageFrameNavigatedReply fired once navigation of the frame has completed. Frame is now associated with the new loader.

type PageFrameResizedClient 

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

PageFrameResizedClient receives FrameResized events.

type PageFrameResizedReply 

type PageFrameResizedReply struct{}

PageFrameResizedReply

type PageFrameScheduledNavigationClient 

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

PageFrameScheduledNavigationClient receives FrameScheduledNavigation events.

type PageFrameScheduledNavigationReply 

type PageFrameScheduledNavigationReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Id of the frame that has scheduled a navigation.
	Delay   float64             `json:"delay"`   // Delay (in seconds) until the navigation is scheduled to begin. The navigation is not guaranteed to start.
}

PageFrameScheduledNavigationReply fired when frame schedules a potential navigation.

type PageFrameStartedLoadingClient 

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

PageFrameStartedLoadingClient receives FrameStartedLoading events.

type PageFrameStartedLoadingReply 

type PageFrameStartedLoadingReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Id of the frame that has started loading.
}

PageFrameStartedLoadingReply fired when frame has started loading.

type PageFrameStoppedLoadingClient 

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

PageFrameStoppedLoadingClient receives FrameStoppedLoading events.

type PageFrameStoppedLoadingReply 

type PageFrameStoppedLoadingReply struct {
	FrameID cdptype.PageFrameID `json:"frameId"` // Id of the frame that has stopped loading.
}

PageFrameStoppedLoadingReply fired when frame has stopped loading.

type PageInterstitialHiddenClient 

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

PageInterstitialHiddenClient receives InterstitialHidden events.

type PageInterstitialHiddenReply 

type PageInterstitialHiddenReply struct{}

PageInterstitialHiddenReply fired when interstitial page was hidden

type PageInterstitialShownClient 

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

PageInterstitialShownClient receives InterstitialShown events.

type PageInterstitialShownReply 

type PageInterstitialShownReply struct{}

PageInterstitialShownReply fired when interstitial page was shown

type PageJavascriptDialogClosedClient 

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

PageJavascriptDialogClosedClient receives JavascriptDialogClosed events.

type PageJavascriptDialogClosedReply 

type PageJavascriptDialogClosedReply struct {
	Result bool `json:"result"` // Whether dialog was confirmed.
}

PageJavascriptDialogClosedReply fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed.

type PageJavascriptDialogOpeningClient 

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

PageJavascriptDialogOpeningClient receives JavascriptDialogOpening events.

type PageJavascriptDialogOpeningReply 

type PageJavascriptDialogOpeningReply struct {
	Message string                 `json:"message"` // Message that will be displayed by the dialog.
	Type    cdptype.PageDialogType `json:"type"`    // Dialog type.
}

PageJavascriptDialogOpeningReply fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open.

type PageLoadEventFiredClient 

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

PageLoadEventFiredClient receives LoadEventFired events.

type PageLoadEventFiredReply 

type PageLoadEventFiredReply struct {
	Timestamp cdptype.Timestamp `json:"timestamp"` //
}

PageLoadEventFiredReply 

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

PageNavigationRequestedClient receives NavigationRequested events. 

type PageNavigationRequestedReply struct {
	IsInMainFrame bool   `json:"isInMainFrame"` // Whether the navigation is taking place in the main frame or in a subframe.
	IsRedirect    bool   `json:"isRedirect"`    // Whether the navigation has encountered a server redirect or not.
	NavigationID  int    `json:"navigationId"`  //
	URL           string `json:"url"`           // URL of requested navigation.
}

PageNavigationRequestedReply fired when a navigation is started if navigation throttles are enabled. The navigation will be deferred until processNavigation is called.

type PageScreencastFrameClient 

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

PageScreencastFrameClient receives ScreencastFrame events.

type PageScreencastFrameReply 

type PageScreencastFrameReply struct {
	Data      []byte                              `json:"data"`      // Base64-encoded compressed image.
	Metadata  cdptype.PageScreencastFrameMetadata `json:"metadata"`  // Screencast frame metadata.
	SessionID int                                 `json:"sessionId"` // Frame number.
}

PageScreencastFrameReply compressed image data requested by the startScreencast.

type PageScreencastVisibilityChangedClient 

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

PageScreencastVisibilityChangedClient receives ScreencastVisibilityChanged events.

type PageScreencastVisibilityChangedReply 

type PageScreencastVisibilityChangedReply struct {
	Visible bool `json:"visible"` // True if the page is visible.
}

PageScreencastVisibilityChangedReply fired when the page with currently enabled screencast was shown or hidden .

type ProfilerConsoleProfileFinishedClient 

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

ProfilerConsoleProfileFinishedClient receives ConsoleProfileFinished events.

type ProfilerConsoleProfileFinishedReply 

type ProfilerConsoleProfileFinishedReply struct {
	ID       string                   `json:"id"`              //
	Location cdptype.DebuggerLocation `json:"location"`        // Location of console.profileEnd().
	Profile  cdptype.ProfilerProfile  `json:"profile"`         //
	Title    *string                  `json:"title,omitempty"` // Profile title passed as an argument to console.profile().
}

ProfilerConsoleProfileFinishedReply

type ProfilerConsoleProfileStartedClient 

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

ProfilerConsoleProfileStartedClient receives ConsoleProfileStarted events.

type ProfilerConsoleProfileStartedReply 

type ProfilerConsoleProfileStartedReply struct {
	ID       string                   `json:"id"`              //
	Location cdptype.DebuggerLocation `json:"location"`        // Location of console.profile().
	Title    *string                  `json:"title,omitempty"` // Profile title passed as an argument to console.profile().
}

ProfilerConsoleProfileStartedReply sent when new profile recording is started using console.profile() call.

type RuntimeConsoleAPICalledClient 

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

RuntimeConsoleAPICalledClient receives ConsoleAPICalled events.

type RuntimeConsoleAPICalledReply 

type RuntimeConsoleAPICalledReply struct {
	Type               string                            `json:"type"`                 // Type of the call.
	Args               []cdptype.RuntimeRemoteObject     `json:"args"`                 // Call arguments.
	ExecutionContextID cdptype.RuntimeExecutionContextID `json:"executionContextId"`   // Identifier of the context where the call was made.
	Timestamp          cdptype.RuntimeTimestamp          `json:"timestamp"`            // Call timestamp.
	StackTrace         *cdptype.RuntimeStackTrace        `json:"stackTrace,omitempty"` // Stack trace captured when the call was made.
	Context            *string                           `json:"context,omitempty"`    // Console context descriptor for calls on non-default console context (not console.*): 'anonymous#unique-logger-id' for call on unnamed context, 'name#unique-logger-id' for call on named context.
}

RuntimeConsoleAPICalledReply issued when console API was called.

type RuntimeExceptionRevokedClient 

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

RuntimeExceptionRevokedClient receives ExceptionRevoked events.

type RuntimeExceptionRevokedReply 

type RuntimeExceptionRevokedReply struct {
	Reason      string `json:"reason"`      // Reason describing why exception was revoked.
	ExceptionID int    `json:"exceptionId"` // The id of revoked exception, as reported in exceptionUnhandled.
}

RuntimeExceptionRevokedReply issued when unhandled exception was revoked.

type RuntimeExceptionThrownClient 

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

RuntimeExceptionThrownClient receives ExceptionThrown events.

type RuntimeExceptionThrownReply 

type RuntimeExceptionThrownReply struct {
	Timestamp        cdptype.RuntimeTimestamp        `json:"timestamp"`        // Timestamp of the exception.
	ExceptionDetails cdptype.RuntimeExceptionDetails `json:"exceptionDetails"` //
}

RuntimeExceptionThrownReply issued when exception was thrown and unhandled.

type RuntimeExecutionContextCreatedClient 

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

RuntimeExecutionContextCreatedClient receives ExecutionContextCreated events.

type RuntimeExecutionContextCreatedReply 

type RuntimeExecutionContextCreatedReply struct {
	Context cdptype.RuntimeExecutionContextDescription `json:"context"` // A newly created execution context.
}

RuntimeExecutionContextCreatedReply issued when new execution context is created.

type RuntimeExecutionContextDestroyedClient 

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

RuntimeExecutionContextDestroyedClient receives ExecutionContextDestroyed events.

type RuntimeExecutionContextDestroyedReply 

type RuntimeExecutionContextDestroyedReply struct {
	ExecutionContextID cdptype.RuntimeExecutionContextID `json:"executionContextId"` // Id of the destroyed context
}

RuntimeExecutionContextDestroyedReply issued when execution context is destroyed.

type RuntimeExecutionContextsClearedClient 

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

RuntimeExecutionContextsClearedClient receives ExecutionContextsCleared events.

type RuntimeExecutionContextsClearedReply 

type RuntimeExecutionContextsClearedReply struct{}

RuntimeExecutionContextsClearedReply issued when all executionContexts were cleared in browser

type RuntimeInspectRequestedClient 

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

RuntimeInspectRequestedClient receives InspectRequested events.

type RuntimeInspectRequestedReply 

type RuntimeInspectRequestedReply struct {
	Object cdptype.RuntimeRemoteObject `json:"object"` //
	Hints  json.RawMessage             `json:"hints"`  //
}

RuntimeInspectRequestedReply issued when object should be inspected (for example, as a result of inspect() command line API call).

type SecurityCertificateErrorClient 

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

SecurityCertificateErrorClient receives CertificateError events.

type SecurityCertificateErrorReply 

type SecurityCertificateErrorReply struct {
	EventID    int    `json:"eventId"`    // The ID of the event.
	ErrorType  string `json:"errorType"`  // The type of the error.
	RequestURL string `json:"requestURL"` // The url that was requested.
}

SecurityCertificateErrorReply there is a certificate error. If overriding certificate errors is enabled, then it should be handled with the handleCertificateError command. Note: this event does not fire if the certificate error has been allowed internally.

type SecurityStateChangedClient 

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

SecurityStateChangedClient receives SecurityStateChanged events.

type SecurityStateChangedReply 

type SecurityStateChangedReply struct {
	SecurityState         cdptype.SecurityState                 `json:"securityState"`         // Security state.
	SchemeIsCryptographic bool                                  `json:"schemeIsCryptographic"` // True if the page was loaded over cryptographic transport such as HTTPS.
	Explanations          []cdptype.SecurityStateExplanation    `json:"explanations"`          // List of explanations for the security state. If the overall security state is `insecure` or `warning`, at least one corresponding explanation should be included.
	InsecureContentStatus cdptype.SecurityInsecureContentStatus `json:"insecureContentStatus"` // Information about insecure content on the page.
	Summary               *string                               `json:"summary,omitempty"`     // Overrides user-visible description of the state.
}

SecurityStateChangedReply the security state of the page changed.

type ServiceWorkerWorkerErrorReportedClient 

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

ServiceWorkerWorkerErrorReportedClient receives WorkerErrorReported events.

type ServiceWorkerWorkerErrorReportedReply 

type ServiceWorkerWorkerErrorReportedReply struct {
	ErrorMessage cdptype.ServiceWorkerErrorMessage `json:"errorMessage"` //
}

ServiceWorkerWorkerErrorReportedReply

type ServiceWorkerWorkerRegistrationUpdatedClient 

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

ServiceWorkerWorkerRegistrationUpdatedClient receives WorkerRegistrationUpdated events.

type ServiceWorkerWorkerRegistrationUpdatedReply 

type ServiceWorkerWorkerRegistrationUpdatedReply struct {
	Registrations []cdptype.ServiceWorkerRegistration `json:"registrations"` //
}

ServiceWorkerWorkerRegistrationUpdatedReply

type ServiceWorkerWorkerVersionUpdatedClient 

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

ServiceWorkerWorkerVersionUpdatedClient receives WorkerVersionUpdated events.

type ServiceWorkerWorkerVersionUpdatedReply 

type ServiceWorkerWorkerVersionUpdatedReply struct {
	Versions []cdptype.ServiceWorkerVersion `json:"versions"` //
}

ServiceWorkerWorkerVersionUpdatedReply

type TargetAttachedToTargetClient 

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

TargetAttachedToTargetClient receives AttachedToTarget events.

type TargetAttachedToTargetReply 

type TargetAttachedToTargetReply struct {
	TargetInfo         cdptype.TargetInfo `json:"targetInfo"`         //
	WaitingForDebugger bool               `json:"waitingForDebugger"` //
}

TargetAttachedToTargetReply issued when attached to target because of auto-attach or attachToTarget command.

type TargetCreatedClient 

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

TargetCreatedClient receives TargetCreated events.

type TargetCreatedReply 

type TargetCreatedReply struct {
	TargetInfo cdptype.TargetInfo `json:"targetInfo"` //
}

TargetCreatedReply issued when a possible inspection target is created.

type TargetDestroyedClient 

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

TargetDestroyedClient receives TargetDestroyed events.

type TargetDestroyedReply 

type TargetDestroyedReply struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetDestroyedReply issued when a target is destroyed.

type TargetDetachedFromTargetClient 

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

TargetDetachedFromTargetClient receives DetachedFromTarget events.

type TargetDetachedFromTargetReply 

type TargetDetachedFromTargetReply struct {
	TargetID cdptype.TargetID `json:"targetId"` //
}

TargetDetachedFromTargetReply issued when detached from target for any reason (including detachFromTarget command).

type TargetInfoChangedClient 

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

TargetInfoChangedClient receives TargetInfoChanged events.

type TargetInfoChangedReply 

type TargetInfoChangedReply struct {
	TargetInfo cdptype.TargetInfo `json:"targetInfo"` //
}

TargetInfoChangedReply issued when some information about a target has changed. This only happens between targetCreated and targetDestroyed.

type TargetReceivedMessageFromTargetClient 

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

TargetReceivedMessageFromTargetClient receives ReceivedMessageFromTarget events.

type TargetReceivedMessageFromTargetReply 

type TargetReceivedMessageFromTargetReply struct {
	TargetID cdptype.TargetID `json:"targetId"` //
	Message  string           `json:"message"`  //
}

TargetReceivedMessageFromTargetReply notifies about new protocol message from attached target.

type TetheringAcceptedClient 

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

TetheringAcceptedClient receives Accepted events.

type TetheringAcceptedReply 

type TetheringAcceptedReply struct {
	Port         int    `json:"port"`         // Port number that was successfully bound.
	ConnectionID string `json:"connectionId"` // Connection id to be used.
}

TetheringAcceptedReply informs that port was successfully bound and got a specified connection id.

type TracingBufferUsageClient 

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

TracingBufferUsageClient receives BufferUsage events.

type TracingBufferUsageReply 

type TracingBufferUsageReply struct {
	PercentFull *float64 `json:"percentFull,omitempty"` // A number in range [0..1] that indicates the used size of event buffer as a fraction of its total size.
	EventCount  *float64 `json:"eventCount,omitempty"`  // An approximate number of events in the trace log.
	Value       *float64 `json:"value,omitempty"`       // A number in range [0..1] that indicates the used size of event buffer as a fraction of its total size.
}

TracingBufferUsageReply

type TracingCompleteClient 

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

TracingCompleteClient receives TracingComplete events.

type TracingCompleteReply 

type TracingCompleteReply struct {
	Stream *cdptype.IOStreamHandle `json:"stream,omitempty"` // A handle of the stream that holds resulting trace data.
}

TracingCompleteReply signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.

type TracingDataCollectedClient 

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

TracingDataCollectedClient receives DataCollected events.

type TracingDataCollectedReply 

type TracingDataCollectedReply struct {
	Value []json.RawMessage `json:"value"` //
}

TracingDataCollectedReply contains an bucket of collected trace events. When tracing is stopped collected events will be send as a sequence of dataCollected events followed by tracingComplete event.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.