1562 lines
36 KiB
Go
1562 lines
36 KiB
Go
// Package page provides the Chrome Debugging Protocol
|
|
// commands, types, and events for the Page domain.
|
|
//
|
|
// Actions and events related to the inspected page belong to the page
|
|
// domain.
|
|
//
|
|
// Generated by the chromedp-gen command.
|
|
package page
|
|
|
|
// AUTOGENERATED. DO NOT EDIT.
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
|
|
cdp "github.com/knq/chromedp/cdp"
|
|
"github.com/knq/chromedp/cdp/debugger"
|
|
"github.com/mailru/easyjson"
|
|
)
|
|
|
|
// EnableParams enables page domain notifications.
|
|
type EnableParams struct{}
|
|
|
|
// Enable enables page domain notifications.
|
|
func Enable() *EnableParams {
|
|
return &EnableParams{}
|
|
}
|
|
|
|
// Do executes Page.enable against the provided context and
|
|
// target handler.
|
|
func (p *EnableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageEnable, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// DisableParams disables page domain notifications.
|
|
type DisableParams struct{}
|
|
|
|
// Disable disables page domain notifications.
|
|
func Disable() *DisableParams {
|
|
return &DisableParams{}
|
|
}
|
|
|
|
// Do executes Page.disable against the provided context and
|
|
// target handler.
|
|
func (p *DisableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageDisable, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// AddScriptToEvaluateOnLoadParams [no description].
|
|
type AddScriptToEvaluateOnLoadParams struct {
|
|
ScriptSource string `json:"scriptSource"`
|
|
}
|
|
|
|
// AddScriptToEvaluateOnLoad [no description].
|
|
//
|
|
// parameters:
|
|
// scriptSource
|
|
func AddScriptToEvaluateOnLoad(scriptSource string) *AddScriptToEvaluateOnLoadParams {
|
|
return &AddScriptToEvaluateOnLoadParams{
|
|
ScriptSource: scriptSource,
|
|
}
|
|
}
|
|
|
|
// AddScriptToEvaluateOnLoadReturns return values.
|
|
type AddScriptToEvaluateOnLoadReturns struct {
|
|
Identifier ScriptIdentifier `json:"identifier,omitempty"` // Identifier of the added script.
|
|
}
|
|
|
|
// Do executes Page.addScriptToEvaluateOnLoad against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// identifier - Identifier of the added script.
|
|
func (p *AddScriptToEvaluateOnLoadParams) Do(ctxt context.Context, h cdp.Handler) (identifier ScriptIdentifier, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageAddScriptToEvaluateOnLoad, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return "", cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r AddScriptToEvaluateOnLoadReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return "", cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.Identifier, nil
|
|
|
|
case error:
|
|
return "", v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return "", ctxt.Err()
|
|
}
|
|
|
|
return "", cdp.ErrUnknownResult
|
|
}
|
|
|
|
// RemoveScriptToEvaluateOnLoadParams [no description].
|
|
type RemoveScriptToEvaluateOnLoadParams struct {
|
|
Identifier ScriptIdentifier `json:"identifier"`
|
|
}
|
|
|
|
// RemoveScriptToEvaluateOnLoad [no description].
|
|
//
|
|
// parameters:
|
|
// identifier
|
|
func RemoveScriptToEvaluateOnLoad(identifier ScriptIdentifier) *RemoveScriptToEvaluateOnLoadParams {
|
|
return &RemoveScriptToEvaluateOnLoadParams{
|
|
Identifier: identifier,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.removeScriptToEvaluateOnLoad against the provided context and
|
|
// target handler.
|
|
func (p *RemoveScriptToEvaluateOnLoadParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageRemoveScriptToEvaluateOnLoad, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// SetAutoAttachToCreatedPagesParams controls whether browser will open a new
|
|
// inspector window for connected pages.
|
|
type SetAutoAttachToCreatedPagesParams struct {
|
|
AutoAttach bool `json:"autoAttach"` // If true, browser will open a new inspector window for every page created from this one.
|
|
}
|
|
|
|
// SetAutoAttachToCreatedPages controls whether browser will open a new
|
|
// inspector window for connected pages.
|
|
//
|
|
// parameters:
|
|
// autoAttach - If true, browser will open a new inspector window for every page created from this one.
|
|
func SetAutoAttachToCreatedPages(autoAttach bool) *SetAutoAttachToCreatedPagesParams {
|
|
return &SetAutoAttachToCreatedPagesParams{
|
|
AutoAttach: autoAttach,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.setAutoAttachToCreatedPages against the provided context and
|
|
// target handler.
|
|
func (p *SetAutoAttachToCreatedPagesParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageSetAutoAttachToCreatedPages, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// ReloadParams reloads given page optionally ignoring the cache.
|
|
type ReloadParams struct {
|
|
IgnoreCache bool `json:"ignoreCache,omitempty"` // If true, browser cache is ignored (as if the user pressed Shift+refresh).
|
|
ScriptToEvaluateOnLoad string `json:"scriptToEvaluateOnLoad,omitempty"` // If set, the script will be injected into all frames of the inspected page after reload.
|
|
}
|
|
|
|
// Reload reloads given page optionally ignoring the cache.
|
|
//
|
|
// parameters:
|
|
func Reload() *ReloadParams {
|
|
return &ReloadParams{}
|
|
}
|
|
|
|
// WithIgnoreCache if true, browser cache is ignored (as if the user pressed
|
|
// Shift+refresh).
|
|
func (p ReloadParams) WithIgnoreCache(ignoreCache bool) *ReloadParams {
|
|
p.IgnoreCache = ignoreCache
|
|
return &p
|
|
}
|
|
|
|
// WithScriptToEvaluateOnLoad if set, the script will be injected into all
|
|
// frames of the inspected page after reload.
|
|
func (p ReloadParams) WithScriptToEvaluateOnLoad(scriptToEvaluateOnLoad string) *ReloadParams {
|
|
p.ScriptToEvaluateOnLoad = scriptToEvaluateOnLoad
|
|
return &p
|
|
}
|
|
|
|
// Do executes Page.reload against the provided context and
|
|
// target handler.
|
|
func (p *ReloadParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageReload, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// NavigateParams navigates current page to the given URL.
|
|
type NavigateParams struct {
|
|
URL string `json:"url"` // URL to navigate the page to.
|
|
}
|
|
|
|
// Navigate navigates current page to the given URL.
|
|
//
|
|
// parameters:
|
|
// url - URL to navigate the page to.
|
|
func Navigate(url string) *NavigateParams {
|
|
return &NavigateParams{
|
|
URL: url,
|
|
}
|
|
}
|
|
|
|
// NavigateReturns return values.
|
|
type NavigateReturns struct {
|
|
FrameID cdp.FrameID `json:"frameId,omitempty"` // Frame id that will be navigated.
|
|
}
|
|
|
|
// Do executes Page.navigate against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// frameID - Frame id that will be navigated.
|
|
func (p *NavigateParams) Do(ctxt context.Context, h cdp.Handler) (frameID cdp.FrameID, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageNavigate, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return "", cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r NavigateReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return "", cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.FrameID, nil
|
|
|
|
case error:
|
|
return "", v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return "", ctxt.Err()
|
|
}
|
|
|
|
return "", cdp.ErrUnknownResult
|
|
}
|
|
|
|
// StopLoadingParams force the page stop all navigations and pending resource
|
|
// fetches.
|
|
type StopLoadingParams struct{}
|
|
|
|
// StopLoading force the page stop all navigations and pending resource
|
|
// fetches.
|
|
func StopLoading() *StopLoadingParams {
|
|
return &StopLoadingParams{}
|
|
}
|
|
|
|
// Do executes Page.stopLoading against the provided context and
|
|
// target handler.
|
|
func (p *StopLoadingParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageStopLoading, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// GetNavigationHistoryParams returns navigation history for the current
|
|
// page.
|
|
type GetNavigationHistoryParams struct{}
|
|
|
|
// GetNavigationHistory returns navigation history for the current page.
|
|
func GetNavigationHistory() *GetNavigationHistoryParams {
|
|
return &GetNavigationHistoryParams{}
|
|
}
|
|
|
|
// GetNavigationHistoryReturns return values.
|
|
type GetNavigationHistoryReturns struct {
|
|
CurrentIndex int64 `json:"currentIndex,omitempty"` // Index of the current navigation history entry.
|
|
Entries []*NavigationEntry `json:"entries,omitempty"` // Array of navigation history entries.
|
|
}
|
|
|
|
// Do executes Page.getNavigationHistory against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// currentIndex - Index of the current navigation history entry.
|
|
// entries - Array of navigation history entries.
|
|
func (p *GetNavigationHistoryParams) Do(ctxt context.Context, h cdp.Handler) (currentIndex int64, entries []*NavigationEntry, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageGetNavigationHistory, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return 0, nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r GetNavigationHistoryReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return 0, nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.CurrentIndex, r.Entries, nil
|
|
|
|
case error:
|
|
return 0, nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return 0, nil, ctxt.Err()
|
|
}
|
|
|
|
return 0, nil, cdp.ErrUnknownResult
|
|
}
|
|
|
|
// NavigateToHistoryEntryParams navigates current page to the given history
|
|
// entry.
|
|
type NavigateToHistoryEntryParams struct {
|
|
EntryID int64 `json:"entryId"` // Unique id of the entry to navigate to.
|
|
}
|
|
|
|
// NavigateToHistoryEntry navigates current page to the given history entry.
|
|
//
|
|
// parameters:
|
|
// entryID - Unique id of the entry to navigate to.
|
|
func NavigateToHistoryEntry(entryID int64) *NavigateToHistoryEntryParams {
|
|
return &NavigateToHistoryEntryParams{
|
|
EntryID: entryID,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.navigateToHistoryEntry against the provided context and
|
|
// target handler.
|
|
func (p *NavigateToHistoryEntryParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageNavigateToHistoryEntry, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// GetResourceTreeParams returns present frame / resource tree structure.
|
|
type GetResourceTreeParams struct{}
|
|
|
|
// GetResourceTree returns present frame / resource tree structure.
|
|
func GetResourceTree() *GetResourceTreeParams {
|
|
return &GetResourceTreeParams{}
|
|
}
|
|
|
|
// GetResourceTreeReturns return values.
|
|
type GetResourceTreeReturns struct {
|
|
FrameTree *FrameResourceTree `json:"frameTree,omitempty"` // Present frame / resource tree structure.
|
|
}
|
|
|
|
// Do executes Page.getResourceTree against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// frameTree - Present frame / resource tree structure.
|
|
func (p *GetResourceTreeParams) Do(ctxt context.Context, h cdp.Handler) (frameTree *FrameResourceTree, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageGetResourceTree, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r GetResourceTreeReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.FrameTree, nil
|
|
|
|
case error:
|
|
return nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return nil, ctxt.Err()
|
|
}
|
|
|
|
return nil, cdp.ErrUnknownResult
|
|
}
|
|
|
|
// GetResourceContentParams returns content of the given resource.
|
|
type GetResourceContentParams struct {
|
|
FrameID cdp.FrameID `json:"frameId"` // Frame id to get resource for.
|
|
URL string `json:"url"` // URL of the resource to get content for.
|
|
}
|
|
|
|
// GetResourceContent returns content of the given resource.
|
|
//
|
|
// parameters:
|
|
// frameID - Frame id to get resource for.
|
|
// url - URL of the resource to get content for.
|
|
func GetResourceContent(frameID cdp.FrameID, url string) *GetResourceContentParams {
|
|
return &GetResourceContentParams{
|
|
FrameID: frameID,
|
|
URL: url,
|
|
}
|
|
}
|
|
|
|
// GetResourceContentReturns return values.
|
|
type GetResourceContentReturns struct {
|
|
Content string `json:"content,omitempty"` // Resource content.
|
|
Base64encoded bool `json:"base64Encoded,omitempty"` // True, if content was served as base64.
|
|
}
|
|
|
|
// Do executes Page.getResourceContent against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// content - Resource content.
|
|
func (p *GetResourceContentParams) Do(ctxt context.Context, h cdp.Handler) (content []byte, 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, cdp.CommandPageGetResourceContent, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r GetResourceContentReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
// decode
|
|
var dec []byte
|
|
if r.Base64encoded {
|
|
dec, err = base64.StdEncoding.DecodeString(r.Content)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
dec = []byte(r.Content)
|
|
}
|
|
|
|
return dec, nil
|
|
|
|
case error:
|
|
return nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return nil, ctxt.Err()
|
|
}
|
|
|
|
return nil, cdp.ErrUnknownResult
|
|
}
|
|
|
|
// SearchInResourceParams searches for given string in resource content.
|
|
type SearchInResourceParams struct {
|
|
FrameID cdp.FrameID `json:"frameId"` // Frame id for resource to search in.
|
|
URL string `json:"url"` // URL of the resource to search in.
|
|
Query string `json:"query"` // String to search for.
|
|
CaseSensitive bool `json:"caseSensitive,omitempty"` // If true, search is case sensitive.
|
|
IsRegex bool `json:"isRegex,omitempty"` // If true, treats string parameter as regex.
|
|
}
|
|
|
|
// SearchInResource searches for given string in resource content.
|
|
//
|
|
// parameters:
|
|
// frameID - Frame id for resource to search in.
|
|
// url - URL of the resource to search in.
|
|
// query - String to search for.
|
|
func SearchInResource(frameID cdp.FrameID, url string, query string) *SearchInResourceParams {
|
|
return &SearchInResourceParams{
|
|
FrameID: frameID,
|
|
URL: url,
|
|
Query: query,
|
|
}
|
|
}
|
|
|
|
// WithCaseSensitive if true, search is case sensitive.
|
|
func (p SearchInResourceParams) WithCaseSensitive(caseSensitive bool) *SearchInResourceParams {
|
|
p.CaseSensitive = caseSensitive
|
|
return &p
|
|
}
|
|
|
|
// WithIsRegex if true, treats string parameter as regex.
|
|
func (p SearchInResourceParams) WithIsRegex(isRegex bool) *SearchInResourceParams {
|
|
p.IsRegex = isRegex
|
|
return &p
|
|
}
|
|
|
|
// SearchInResourceReturns return values.
|
|
type SearchInResourceReturns struct {
|
|
Result []*debugger.SearchMatch `json:"result,omitempty"` // List of search matches.
|
|
}
|
|
|
|
// Do executes Page.searchInResource against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// result - List of search matches.
|
|
func (p *SearchInResourceParams) Do(ctxt context.Context, h cdp.Handler) (result []*debugger.SearchMatch, 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, cdp.CommandPageSearchInResource, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r SearchInResourceReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.Result, nil
|
|
|
|
case error:
|
|
return nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return nil, ctxt.Err()
|
|
}
|
|
|
|
return nil, cdp.ErrUnknownResult
|
|
}
|
|
|
|
// SetDocumentContentParams sets given markup as the document's HTML.
|
|
type SetDocumentContentParams struct {
|
|
FrameID cdp.FrameID `json:"frameId"` // Frame id to set HTML for.
|
|
HTML string `json:"html"` // HTML content to set.
|
|
}
|
|
|
|
// SetDocumentContent sets given markup as the document's HTML.
|
|
//
|
|
// parameters:
|
|
// frameID - Frame id to set HTML for.
|
|
// html - HTML content to set.
|
|
func SetDocumentContent(frameID cdp.FrameID, html string) *SetDocumentContentParams {
|
|
return &SetDocumentContentParams{
|
|
FrameID: frameID,
|
|
HTML: html,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.setDocumentContent against the provided context and
|
|
// target handler.
|
|
func (p *SetDocumentContentParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageSetDocumentContent, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// CaptureScreenshotParams capture page screenshot.
|
|
type CaptureScreenshotParams struct {
|
|
Format CaptureScreenshotFormat `json:"format,omitempty"` // Image compression format (defaults to png).
|
|
Quality int64 `json:"quality,omitempty"` // Compression quality from range [0..100] (jpeg only).
|
|
}
|
|
|
|
// CaptureScreenshot capture page screenshot.
|
|
//
|
|
// parameters:
|
|
func CaptureScreenshot() *CaptureScreenshotParams {
|
|
return &CaptureScreenshotParams{}
|
|
}
|
|
|
|
// WithFormat image compression format (defaults to png).
|
|
func (p CaptureScreenshotParams) WithFormat(format CaptureScreenshotFormat) *CaptureScreenshotParams {
|
|
p.Format = format
|
|
return &p
|
|
}
|
|
|
|
// WithQuality compression quality from range [0..100] (jpeg only).
|
|
func (p CaptureScreenshotParams) WithQuality(quality int64) *CaptureScreenshotParams {
|
|
p.Quality = quality
|
|
return &p
|
|
}
|
|
|
|
// CaptureScreenshotReturns return values.
|
|
type CaptureScreenshotReturns struct {
|
|
Data string `json:"data,omitempty"` // Base64-encoded image data.
|
|
}
|
|
|
|
// Do executes Page.captureScreenshot against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// data - Base64-encoded image data.
|
|
func (p *CaptureScreenshotParams) Do(ctxt context.Context, h cdp.Handler) (data []byte, 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, cdp.CommandPageCaptureScreenshot, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r CaptureScreenshotReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
// decode
|
|
var dec []byte
|
|
dec, err = base64.StdEncoding.DecodeString(r.Data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return dec, nil
|
|
|
|
case error:
|
|
return nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return nil, ctxt.Err()
|
|
}
|
|
|
|
return nil, cdp.ErrUnknownResult
|
|
}
|
|
|
|
// StartScreencastParams starts sending each frame using the screencastFrame
|
|
// event.
|
|
type StartScreencastParams struct {
|
|
Format ScreencastFormat `json:"format,omitempty"` // Image compression format.
|
|
Quality int64 `json:"quality,omitempty"` // Compression quality from range [0..100].
|
|
MaxWidth int64 `json:"maxWidth,omitempty"` // Maximum screenshot width.
|
|
MaxHeight int64 `json:"maxHeight,omitempty"` // Maximum screenshot height.
|
|
EveryNthFrame int64 `json:"everyNthFrame,omitempty"` // Send every n-th frame.
|
|
}
|
|
|
|
// StartScreencast starts sending each frame using the screencastFrame event.
|
|
//
|
|
// parameters:
|
|
func StartScreencast() *StartScreencastParams {
|
|
return &StartScreencastParams{}
|
|
}
|
|
|
|
// WithFormat image compression format.
|
|
func (p StartScreencastParams) WithFormat(format ScreencastFormat) *StartScreencastParams {
|
|
p.Format = format
|
|
return &p
|
|
}
|
|
|
|
// WithQuality compression quality from range [0..100].
|
|
func (p StartScreencastParams) WithQuality(quality int64) *StartScreencastParams {
|
|
p.Quality = quality
|
|
return &p
|
|
}
|
|
|
|
// WithMaxWidth maximum screenshot width.
|
|
func (p StartScreencastParams) WithMaxWidth(maxWidth int64) *StartScreencastParams {
|
|
p.MaxWidth = maxWidth
|
|
return &p
|
|
}
|
|
|
|
// WithMaxHeight maximum screenshot height.
|
|
func (p StartScreencastParams) WithMaxHeight(maxHeight int64) *StartScreencastParams {
|
|
p.MaxHeight = maxHeight
|
|
return &p
|
|
}
|
|
|
|
// WithEveryNthFrame send every n-th frame.
|
|
func (p StartScreencastParams) WithEveryNthFrame(everyNthFrame int64) *StartScreencastParams {
|
|
p.EveryNthFrame = everyNthFrame
|
|
return &p
|
|
}
|
|
|
|
// Do executes Page.startScreencast against the provided context and
|
|
// target handler.
|
|
func (p *StartScreencastParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageStartScreencast, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// StopScreencastParams stops sending each frame in the screencastFrame.
|
|
type StopScreencastParams struct{}
|
|
|
|
// StopScreencast stops sending each frame in the screencastFrame.
|
|
func StopScreencast() *StopScreencastParams {
|
|
return &StopScreencastParams{}
|
|
}
|
|
|
|
// Do executes Page.stopScreencast against the provided context and
|
|
// target handler.
|
|
func (p *StopScreencastParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageStopScreencast, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// ScreencastFrameAckParams acknowledges that a screencast frame has been
|
|
// received by the frontend.
|
|
type ScreencastFrameAckParams struct {
|
|
SessionID int64 `json:"sessionId"` // Frame number.
|
|
}
|
|
|
|
// ScreencastFrameAck acknowledges that a screencast frame has been received
|
|
// by the frontend.
|
|
//
|
|
// parameters:
|
|
// sessionID - Frame number.
|
|
func ScreencastFrameAck(sessionID int64) *ScreencastFrameAckParams {
|
|
return &ScreencastFrameAckParams{
|
|
SessionID: sessionID,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.screencastFrameAck against the provided context and
|
|
// target handler.
|
|
func (p *ScreencastFrameAckParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageScreencastFrameAck, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// HandleJavaScriptDialogParams accepts or dismisses a JavaScript initiated
|
|
// dialog (alert, confirm, prompt, or onbeforeunload).
|
|
type HandleJavaScriptDialogParams struct {
|
|
Accept bool `json:"accept"` // Whether to accept or dismiss the dialog.
|
|
PromptText string `json:"promptText,omitempty"` // The text to enter into the dialog prompt before accepting. Used only if this is a prompt dialog.
|
|
}
|
|
|
|
// HandleJavaScriptDialog accepts or dismisses a JavaScript initiated dialog
|
|
// (alert, confirm, prompt, or onbeforeunload).
|
|
//
|
|
// parameters:
|
|
// accept - Whether to accept or dismiss the dialog.
|
|
func HandleJavaScriptDialog(accept bool) *HandleJavaScriptDialogParams {
|
|
return &HandleJavaScriptDialogParams{
|
|
Accept: accept,
|
|
}
|
|
}
|
|
|
|
// WithPromptText the text to enter into the dialog prompt before accepting.
|
|
// Used only if this is a prompt dialog.
|
|
func (p HandleJavaScriptDialogParams) WithPromptText(promptText string) *HandleJavaScriptDialogParams {
|
|
p.PromptText = promptText
|
|
return &p
|
|
}
|
|
|
|
// Do executes Page.handleJavaScriptDialog against the provided context and
|
|
// target handler.
|
|
func (p *HandleJavaScriptDialogParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageHandleJavaScriptDialog, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// SetColorPickerEnabledParams shows / hides color picker.
|
|
type SetColorPickerEnabledParams struct {
|
|
Enabled bool `json:"enabled"` // Shows / hides color picker
|
|
}
|
|
|
|
// SetColorPickerEnabled shows / hides color picker.
|
|
//
|
|
// parameters:
|
|
// enabled - Shows / hides color picker
|
|
func SetColorPickerEnabled(enabled bool) *SetColorPickerEnabledParams {
|
|
return &SetColorPickerEnabledParams{
|
|
Enabled: enabled,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.setColorPickerEnabled against the provided context and
|
|
// target handler.
|
|
func (p *SetColorPickerEnabledParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageSetColorPickerEnabled, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// ConfigureOverlayParams configures overlay.
|
|
type ConfigureOverlayParams struct {
|
|
Suspended bool `json:"suspended,omitempty"` // Whether overlay should be suspended and not consume any resources.
|
|
Message string `json:"message,omitempty"` // Overlay message to display.
|
|
}
|
|
|
|
// ConfigureOverlay configures overlay.
|
|
//
|
|
// parameters:
|
|
func ConfigureOverlay() *ConfigureOverlayParams {
|
|
return &ConfigureOverlayParams{}
|
|
}
|
|
|
|
// WithSuspended whether overlay should be suspended and not consume any
|
|
// resources.
|
|
func (p ConfigureOverlayParams) WithSuspended(suspended bool) *ConfigureOverlayParams {
|
|
p.Suspended = suspended
|
|
return &p
|
|
}
|
|
|
|
// WithMessage overlay message to display.
|
|
func (p ConfigureOverlayParams) WithMessage(message string) *ConfigureOverlayParams {
|
|
p.Message = message
|
|
return &p
|
|
}
|
|
|
|
// Do executes Page.configureOverlay against the provided context and
|
|
// target handler.
|
|
func (p *ConfigureOverlayParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageConfigureOverlay, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// GetAppManifestParams [no description].
|
|
type GetAppManifestParams struct{}
|
|
|
|
// GetAppManifest [no description].
|
|
func GetAppManifest() *GetAppManifestParams {
|
|
return &GetAppManifestParams{}
|
|
}
|
|
|
|
// GetAppManifestReturns return values.
|
|
type GetAppManifestReturns struct {
|
|
URL string `json:"url,omitempty"` // Manifest location.
|
|
Errors []*AppManifestError `json:"errors,omitempty"`
|
|
Data string `json:"data,omitempty"` // Manifest content.
|
|
}
|
|
|
|
// Do executes Page.getAppManifest against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// url - Manifest location.
|
|
// errors
|
|
// data - Manifest content.
|
|
func (p *GetAppManifestParams) Do(ctxt context.Context, h cdp.Handler) (url string, errors []*AppManifestError, data string, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageGetAppManifest, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return "", nil, "", cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r GetAppManifestReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return "", nil, "", cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.URL, r.Errors, r.Data, nil
|
|
|
|
case error:
|
|
return "", nil, "", v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return "", nil, "", ctxt.Err()
|
|
}
|
|
|
|
return "", nil, "", cdp.ErrUnknownResult
|
|
}
|
|
|
|
// RequestAppBannerParams [no description].
|
|
type RequestAppBannerParams struct{}
|
|
|
|
// RequestAppBanner [no description].
|
|
func RequestAppBanner() *RequestAppBannerParams {
|
|
return &RequestAppBannerParams{}
|
|
}
|
|
|
|
// Do executes Page.requestAppBanner against the provided context and
|
|
// target handler.
|
|
func (p *RequestAppBannerParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageRequestAppBanner, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// SetControlNavigationsParams toggles navigation throttling which allows
|
|
// programatic control over navigation and redirect response.
|
|
type SetControlNavigationsParams struct {
|
|
Enabled bool `json:"enabled"`
|
|
}
|
|
|
|
// SetControlNavigations toggles navigation throttling which allows
|
|
// programatic control over navigation and redirect response.
|
|
//
|
|
// parameters:
|
|
// enabled
|
|
func SetControlNavigations(enabled bool) *SetControlNavigationsParams {
|
|
return &SetControlNavigationsParams{
|
|
Enabled: enabled,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.setControlNavigations against the provided context and
|
|
// target handler.
|
|
func (p *SetControlNavigationsParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageSetControlNavigations, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// ProcessNavigationParams should be sent in response to a
|
|
// navigationRequested or a redirectRequested event, telling the browser how to
|
|
// handle the navigation.
|
|
type ProcessNavigationParams struct {
|
|
Response NavigationResponse `json:"response"`
|
|
NavigationID int64 `json:"navigationId"`
|
|
}
|
|
|
|
// ProcessNavigation should be sent in response to a navigationRequested or a
|
|
// redirectRequested event, telling the browser how to handle the navigation.
|
|
//
|
|
// parameters:
|
|
// response
|
|
// navigationID
|
|
func ProcessNavigation(response NavigationResponse, navigationID int64) *ProcessNavigationParams {
|
|
return &ProcessNavigationParams{
|
|
Response: response,
|
|
NavigationID: navigationID,
|
|
}
|
|
}
|
|
|
|
// Do executes Page.processNavigation against the provided context and
|
|
// target handler.
|
|
func (p *ProcessNavigationParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// marshal
|
|
buf, err := easyjson.Marshal(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageProcessNavigation, easyjson.RawMessage(buf))
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
return nil
|
|
|
|
case error:
|
|
return v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return ctxt.Err()
|
|
}
|
|
|
|
return cdp.ErrUnknownResult
|
|
}
|
|
|
|
// GetLayoutMetricsParams returns metrics relating to the layouting of the
|
|
// page, such as viewport bounds/scale.
|
|
type GetLayoutMetricsParams struct{}
|
|
|
|
// GetLayoutMetrics returns metrics relating to the layouting of the page,
|
|
// such as viewport bounds/scale.
|
|
func GetLayoutMetrics() *GetLayoutMetricsParams {
|
|
return &GetLayoutMetricsParams{}
|
|
}
|
|
|
|
// GetLayoutMetricsReturns return values.
|
|
type GetLayoutMetricsReturns struct {
|
|
LayoutViewport *LayoutViewport `json:"layoutViewport,omitempty"` // Metrics relating to the layout viewport.
|
|
VisualViewport *VisualViewport `json:"visualViewport,omitempty"` // Metrics relating to the visual viewport.
|
|
}
|
|
|
|
// Do executes Page.getLayoutMetrics against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// layoutViewport - Metrics relating to the layout viewport.
|
|
// visualViewport - Metrics relating to the visual viewport.
|
|
func (p *GetLayoutMetricsParams) Do(ctxt context.Context, h cdp.Handler) (layoutViewport *LayoutViewport, visualViewport *VisualViewport, err error) {
|
|
if ctxt == nil {
|
|
ctxt = context.Background()
|
|
}
|
|
|
|
// execute
|
|
ch := h.Execute(ctxt, cdp.CommandPageGetLayoutMetrics, cdp.Empty)
|
|
|
|
// read response
|
|
select {
|
|
case res := <-ch:
|
|
if res == nil {
|
|
return nil, nil, cdp.ErrChannelClosed
|
|
}
|
|
|
|
switch v := res.(type) {
|
|
case easyjson.RawMessage:
|
|
// unmarshal
|
|
var r GetLayoutMetricsReturns
|
|
err = easyjson.Unmarshal(v, &r)
|
|
if err != nil {
|
|
return nil, nil, cdp.ErrInvalidResult
|
|
}
|
|
|
|
return r.LayoutViewport, r.VisualViewport, nil
|
|
|
|
case error:
|
|
return nil, nil, v
|
|
}
|
|
|
|
case <-ctxt.Done():
|
|
return nil, nil, ctxt.Err()
|
|
}
|
|
|
|
return nil, nil, cdp.ErrUnknownResult
|
|
}
|