chromedp/cdp/target/target.go

// Package target provides the Chrome Debugging Protocol
// commands, types, and events for the Chrome Target domain.
//
// Supports additional targets discovery and allows to attach to them.
//
// Generated by the chromedp-gen command.
package target

// AUTOGENERATED. DO NOT EDIT.

import (
	"context"

	. "github.com/knq/chromedp/cdp"
	"github.com/mailru/easyjson"
)

var (
	_ BackendNode
	_ BackendNodeID
	_ ComputedProperty
	_ ErrorType
	_ Frame
	_ FrameID
	_ LoaderID
	_ Message
	_ MessageError
	_ MethodType
	_ Node
	_ NodeID
	_ NodeType
	_ PseudoType
	_ RGBA
	_ ShadowRootType
	_ Timestamp
)

// SetDiscoverTargetsParams controls whether to discover available targets
// and notify via targetCreated/targetDestroyed events.
type SetDiscoverTargetsParams struct {
	Discover bool `json:"discover"` // Whether to discover available targets.
}

// SetDiscoverTargets controls whether to discover available targets and
// notify via targetCreated/targetDestroyed events.
//
// parameters:
//   discover - Whether to discover available targets.
func SetDiscoverTargets(discover bool) *SetDiscoverTargetsParams {
	return &SetDiscoverTargetsParams{
		Discover: discover,
	}
}

// Do executes Target.setDiscoverTargets.
func (p *SetDiscoverTargetsParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetSetDiscoverTargets, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// SetAutoAttachParams controls whether to automatically attach to new
// targets which are considered to be related to this one. When turned on,
// attaches to all existing related targets as well. When turned off,
// automatically detaches from all currently attached targets.
type SetAutoAttachParams struct {
	AutoAttach             bool `json:"autoAttach"`             // Whether to auto-attach to related targets.
	WaitForDebuggerOnStart bool `json:"waitForDebuggerOnStart"` // Whether to pause new targets when attaching to them. Use Runtime.runIfWaitingForDebugger to run paused targets.
}

// SetAutoAttach controls whether to automatically attach to new targets
// which are considered to be related to this one. When turned on, attaches to
// all existing related targets as well. When turned off, automatically detaches
// from all currently attached targets.
//
// parameters:
//   autoAttach - Whether to auto-attach to related targets.
//   waitForDebuggerOnStart - Whether to pause new targets when attaching to them. Use Runtime.runIfWaitingForDebugger to run paused targets.
func SetAutoAttach(autoAttach bool, waitForDebuggerOnStart bool) *SetAutoAttachParams {
	return &SetAutoAttachParams{
		AutoAttach:             autoAttach,
		WaitForDebuggerOnStart: waitForDebuggerOnStart,
	}
}

// Do executes Target.setAutoAttach.
func (p *SetAutoAttachParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetSetAutoAttach, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

type SetAttachToFramesParams struct {
	Value bool `json:"value"` // Whether to attach to frames.
}

// parameters:
//   value - Whether to attach to frames.
func SetAttachToFrames(value bool) *SetAttachToFramesParams {
	return &SetAttachToFramesParams{
		Value: value,
	}
}

// Do executes Target.setAttachToFrames.
func (p *SetAttachToFramesParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetSetAttachToFrames, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// SetRemoteLocationsParams enables target discovery for the specified
// locations, when setDiscoverTargets was set to true.
type SetRemoteLocationsParams struct {
	Locations []*RemoteLocation `json:"locations"` // List of remote locations.
}

// SetRemoteLocations enables target discovery for the specified locations,
// when setDiscoverTargets was set to true.
//
// parameters:
//   locations - List of remote locations.
func SetRemoteLocations(locations []*RemoteLocation) *SetRemoteLocationsParams {
	return &SetRemoteLocationsParams{
		Locations: locations,
	}
}

// Do executes Target.setRemoteLocations.
func (p *SetRemoteLocationsParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetSetRemoteLocations, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// SendMessageToTargetParams sends protocol message to the target with given
// id.
type SendMessageToTargetParams struct {
	TargetID string `json:"targetId"`
	Message  string `json:"message"`
}

// SendMessageToTarget sends protocol message to the target with given id.
//
// parameters:
//   targetId
//   message
func SendMessageToTarget(targetId string, message string) *SendMessageToTargetParams {
	return &SendMessageToTargetParams{
		TargetID: targetId,
		Message:  message,
	}
}

// Do executes Target.sendMessageToTarget.
func (p *SendMessageToTargetParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetSendMessageToTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// GetTargetInfoParams returns information about a target.
type GetTargetInfoParams struct {
	TargetID TargetID `json:"targetId"`
}

// GetTargetInfo returns information about a target.
//
// parameters:
//   targetId
func GetTargetInfo(targetId TargetID) *GetTargetInfoParams {
	return &GetTargetInfoParams{
		TargetID: targetId,
	}
}

// GetTargetInfoReturns return values.
type GetTargetInfoReturns struct {
	TargetInfo *TargetInfo `json:"targetInfo,omitempty"`
}

// Do executes Target.getTargetInfo.
//
// returns:
//   targetInfo
func (p *GetTargetInfoParams) Do(ctxt context.Context, h FrameHandler) (targetInfo *TargetInfo, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return nil, err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetGetTargetInfo, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return nil, ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r GetTargetInfoReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return nil, ErrInvalidResult
			}

			return r.TargetInfo, nil

		case error:
			return nil, v
		}

	case <-ctxt.Done():
		return nil, ErrContextDone
	}

	return nil, ErrUnknownResult
}

// ActivateTargetParams activates (focuses) the target.
type ActivateTargetParams struct {
	TargetID TargetID `json:"targetId"`
}

// ActivateTarget activates (focuses) the target.
//
// parameters:
//   targetId
func ActivateTarget(targetId TargetID) *ActivateTargetParams {
	return &ActivateTargetParams{
		TargetID: targetId,
	}
}

// Do executes Target.activateTarget.
func (p *ActivateTargetParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetActivateTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// CloseTargetParams closes the target. If the target is a page that gets
// closed too.
type CloseTargetParams struct {
	TargetID TargetID `json:"targetId"`
}

// CloseTarget closes the target. If the target is a page that gets closed
// too.
//
// parameters:
//   targetId
func CloseTarget(targetId TargetID) *CloseTargetParams {
	return &CloseTargetParams{
		TargetID: targetId,
	}
}

// CloseTargetReturns return values.
type CloseTargetReturns struct {
	Success bool `json:"success,omitempty"`
}

// Do executes Target.closeTarget.
//
// returns:
//   success
func (p *CloseTargetParams) Do(ctxt context.Context, h FrameHandler) (success bool, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return false, err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetCloseTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return false, ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r CloseTargetReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return false, ErrInvalidResult
			}

			return r.Success, nil

		case error:
			return false, v
		}

	case <-ctxt.Done():
		return false, ErrContextDone
	}

	return false, ErrUnknownResult
}

// AttachToTargetParams attaches to the target with given id.
type AttachToTargetParams struct {
	TargetID TargetID `json:"targetId"`
}

// AttachToTarget attaches to the target with given id.
//
// parameters:
//   targetId
func AttachToTarget(targetId TargetID) *AttachToTargetParams {
	return &AttachToTargetParams{
		TargetID: targetId,
	}
}

// AttachToTargetReturns return values.
type AttachToTargetReturns struct {
	Success bool `json:"success,omitempty"` // Whether attach succeeded.
}

// Do executes Target.attachToTarget.
//
// returns:
//   success - Whether attach succeeded.
func (p *AttachToTargetParams) Do(ctxt context.Context, h FrameHandler) (success bool, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return false, err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetAttachToTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return false, ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r AttachToTargetReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return false, ErrInvalidResult
			}

			return r.Success, nil

		case error:
			return false, v
		}

	case <-ctxt.Done():
		return false, ErrContextDone
	}

	return false, ErrUnknownResult
}

// DetachFromTargetParams detaches from the target with given id.
type DetachFromTargetParams struct {
	TargetID TargetID `json:"targetId"`
}

// DetachFromTarget detaches from the target with given id.
//
// parameters:
//   targetId
func DetachFromTarget(targetId TargetID) *DetachFromTargetParams {
	return &DetachFromTargetParams{
		TargetID: targetId,
	}
}

// Do executes Target.detachFromTarget.
func (p *DetachFromTargetParams) Do(ctxt context.Context, h FrameHandler) (err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetDetachFromTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			return nil

		case error:
			return v
		}

	case <-ctxt.Done():
		return ErrContextDone
	}

	return ErrUnknownResult
}

// CreateBrowserContextParams creates a new empty BrowserContext. Similar to
// an incognito profile but you can have more than one.
type CreateBrowserContextParams struct{}

// CreateBrowserContext creates a new empty BrowserContext. Similar to an
// incognito profile but you can have more than one.
func CreateBrowserContext() *CreateBrowserContextParams {
	return &CreateBrowserContextParams{}
}

// CreateBrowserContextReturns return values.
type CreateBrowserContextReturns struct {
	BrowserContextID BrowserContextID `json:"browserContextId,omitempty"` // The id of the context created.
}

// Do executes Target.createBrowserContext.
//
// returns:
//   browserContextId - The id of the context created.
func (p *CreateBrowserContextParams) Do(ctxt context.Context, h FrameHandler) (browserContextId BrowserContextID, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetCreateBrowserContext, Empty)

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return "", ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r CreateBrowserContextReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return "", ErrInvalidResult
			}

			return r.BrowserContextID, nil

		case error:
			return "", v
		}

	case <-ctxt.Done():
		return "", ErrContextDone
	}

	return "", ErrUnknownResult
}

// DisposeBrowserContextParams deletes a BrowserContext, will fail of any
// open page uses it.
type DisposeBrowserContextParams struct {
	BrowserContextID BrowserContextID `json:"browserContextId"`
}

// DisposeBrowserContext deletes a BrowserContext, will fail of any open page
// uses it.
//
// parameters:
//   browserContextId
func DisposeBrowserContext(browserContextId BrowserContextID) *DisposeBrowserContextParams {
	return &DisposeBrowserContextParams{
		BrowserContextID: browserContextId,
	}
}

// DisposeBrowserContextReturns return values.
type DisposeBrowserContextReturns struct {
	Success bool `json:"success,omitempty"`
}

// Do executes Target.disposeBrowserContext.
//
// returns:
//   success
func (p *DisposeBrowserContextParams) Do(ctxt context.Context, h FrameHandler) (success bool, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return false, err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetDisposeBrowserContext, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return false, ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r DisposeBrowserContextReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return false, ErrInvalidResult
			}

			return r.Success, nil

		case error:
			return false, v
		}

	case <-ctxt.Done():
		return false, ErrContextDone
	}

	return false, ErrUnknownResult
}

// CreateTargetParams creates a new page.
type CreateTargetParams struct {
	URL              string           `json:"url"`                        // The initial URL the page will be navigated to.
	Width            int64            `json:"width,omitempty"`            // Frame width in DIP (headless chrome only).
	Height           int64            `json:"height,omitempty"`           // Frame height in DIP (headless chrome only).
	BrowserContextID BrowserContextID `json:"browserContextId,omitempty"` // The browser context to create the page in (headless chrome only).
}

// CreateTarget creates a new page.
//
// parameters:
//   url - The initial URL the page will be navigated to.
func CreateTarget(url string) *CreateTargetParams {
	return &CreateTargetParams{
		URL: url,
	}
}

// WithWidth frame width in DIP (headless chrome only).
func (p CreateTargetParams) WithWidth(width int64) *CreateTargetParams {
	p.Width = width
	return &p
}

// WithHeight frame height in DIP (headless chrome only).
func (p CreateTargetParams) WithHeight(height int64) *CreateTargetParams {
	p.Height = height
	return &p
}

// WithBrowserContextID the browser context to create the page in (headless
// chrome only).
func (p CreateTargetParams) WithBrowserContextID(browserContextId BrowserContextID) *CreateTargetParams {
	p.BrowserContextID = browserContextId
	return &p
}

// CreateTargetReturns return values.
type CreateTargetReturns struct {
	TargetID TargetID `json:"targetId,omitempty"` // The id of the page opened.
}

// Do executes Target.createTarget.
//
// returns:
//   targetId - The id of the page opened.
func (p *CreateTargetParams) Do(ctxt context.Context, h FrameHandler) (targetId TargetID, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// marshal
	buf, err := easyjson.Marshal(p)
	if err != nil {
		return "", err
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetCreateTarget, easyjson.RawMessage(buf))

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return "", ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r CreateTargetReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return "", ErrInvalidResult
			}

			return r.TargetID, nil

		case error:
			return "", v
		}

	case <-ctxt.Done():
		return "", ErrContextDone
	}

	return "", ErrUnknownResult
}

// GetTargetsParams retrieves a list of available targets.
type GetTargetsParams struct{}

// GetTargets retrieves a list of available targets.
func GetTargets() *GetTargetsParams {
	return &GetTargetsParams{}
}

// GetTargetsReturns return values.
type GetTargetsReturns struct {
	TargetInfos []*TargetInfo `json:"targetInfos,omitempty"` // The list of targets.
}

// Do executes Target.getTargets.
//
// returns:
//   targetInfos - The list of targets.
func (p *GetTargetsParams) Do(ctxt context.Context, h FrameHandler) (targetInfos []*TargetInfo, err error) {
	if ctxt == nil {
		ctxt = context.Background()
	}

	// execute
	ch := h.Execute(ctxt, CommandTargetGetTargets, Empty)

	// read response
	select {
	case res := <-ch:
		if res == nil {
			return nil, ErrChannelClosed
		}

		switch v := res.(type) {
		case easyjson.RawMessage:
			// unmarshal
			var r GetTargetsReturns
			err = easyjson.Unmarshal(v, &r)
			if err != nil {
				return nil, ErrInvalidResult
			}

			return r.TargetInfos, nil

		case error:
			return nil, v
		}

	case <-ctxt.Done():
		return nil, ErrContextDone
	}

	return nil, ErrUnknownResult
}