1e295eddfb
* Disabled AddOnLoadScript/RemoveOnLoadScript * Updated chromedp-gen fixups for latest timestamp declarations * Updated to latest protocol.json definitions
765 lines
27 KiB
Go
765 lines
27 KiB
Go
// Package network provides the Chrome Debugging Protocol
|
|
// commands, types, and events for the Network domain.
|
|
//
|
|
// Network domain allows tracking network activities of the page. It exposes
|
|
// information about http, file, data and other requests and responses, their
|
|
// headers, bodies, timing, etc.
|
|
//
|
|
// Generated by the chromedp-gen command.
|
|
package network
|
|
|
|
// AUTOGENERATED. DO NOT EDIT.
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
|
|
cdp "github.com/knq/chromedp/cdp"
|
|
)
|
|
|
|
// EnableParams enables network tracking, network events will now be
|
|
// delivered to the client.
|
|
type EnableParams struct {
|
|
MaxTotalBufferSize int64 `json:"maxTotalBufferSize,omitempty"` // Buffer size in bytes to use when preserving network payloads (XHRs, etc).
|
|
MaxResourceBufferSize int64 `json:"maxResourceBufferSize,omitempty"` // Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
|
|
}
|
|
|
|
// Enable enables network tracking, network events will now be delivered to
|
|
// the client.
|
|
//
|
|
// parameters:
|
|
func Enable() *EnableParams {
|
|
return &EnableParams{}
|
|
}
|
|
|
|
// WithMaxTotalBufferSize buffer size in bytes to use when preserving network
|
|
// payloads (XHRs, etc).
|
|
func (p EnableParams) WithMaxTotalBufferSize(maxTotalBufferSize int64) *EnableParams {
|
|
p.MaxTotalBufferSize = maxTotalBufferSize
|
|
return &p
|
|
}
|
|
|
|
// WithMaxResourceBufferSize per-resource buffer size in bytes to use when
|
|
// preserving network payloads (XHRs, etc).
|
|
func (p EnableParams) WithMaxResourceBufferSize(maxResourceBufferSize int64) *EnableParams {
|
|
p.MaxResourceBufferSize = maxResourceBufferSize
|
|
return &p
|
|
}
|
|
|
|
// Do executes Network.enable against the provided context and
|
|
// target handler.
|
|
func (p *EnableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkEnable, p, nil)
|
|
}
|
|
|
|
// DisableParams disables network tracking, prevents network events from
|
|
// being sent to the client.
|
|
type DisableParams struct{}
|
|
|
|
// Disable disables network tracking, prevents network events from being sent
|
|
// to the client.
|
|
func Disable() *DisableParams {
|
|
return &DisableParams{}
|
|
}
|
|
|
|
// Do executes Network.disable against the provided context and
|
|
// target handler.
|
|
func (p *DisableParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkDisable, nil, nil)
|
|
}
|
|
|
|
// SetUserAgentOverrideParams allows overriding user agent with the given
|
|
// string.
|
|
type SetUserAgentOverrideParams struct {
|
|
UserAgent string `json:"userAgent"` // User agent to use.
|
|
}
|
|
|
|
// SetUserAgentOverride allows overriding user agent with the given string.
|
|
//
|
|
// parameters:
|
|
// userAgent - User agent to use.
|
|
func SetUserAgentOverride(userAgent string) *SetUserAgentOverrideParams {
|
|
return &SetUserAgentOverrideParams{
|
|
UserAgent: userAgent,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setUserAgentOverride against the provided context and
|
|
// target handler.
|
|
func (p *SetUserAgentOverrideParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetUserAgentOverride, p, nil)
|
|
}
|
|
|
|
// SetExtraHTTPHeadersParams specifies whether to always send extra HTTP
|
|
// headers with the requests from this page.
|
|
type SetExtraHTTPHeadersParams struct {
|
|
Headers Headers `json:"headers"` // Map with extra HTTP headers.
|
|
}
|
|
|
|
// SetExtraHTTPHeaders specifies whether to always send extra HTTP headers
|
|
// with the requests from this page.
|
|
//
|
|
// parameters:
|
|
// headers - Map with extra HTTP headers.
|
|
func SetExtraHTTPHeaders(headers Headers) *SetExtraHTTPHeadersParams {
|
|
return &SetExtraHTTPHeadersParams{
|
|
Headers: headers,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setExtraHTTPHeaders against the provided context and
|
|
// target handler.
|
|
func (p *SetExtraHTTPHeadersParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetExtraHTTPHeaders, p, nil)
|
|
}
|
|
|
|
// GetResponseBodyParams returns content served for the given request.
|
|
type GetResponseBodyParams struct {
|
|
RequestID RequestID `json:"requestId"` // Identifier of the network request to get content for.
|
|
}
|
|
|
|
// GetResponseBody returns content served for the given request.
|
|
//
|
|
// parameters:
|
|
// requestID - Identifier of the network request to get content for.
|
|
func GetResponseBody(requestID RequestID) *GetResponseBodyParams {
|
|
return &GetResponseBodyParams{
|
|
RequestID: requestID,
|
|
}
|
|
}
|
|
|
|
// GetResponseBodyReturns return values.
|
|
type GetResponseBodyReturns struct {
|
|
Body string `json:"body,omitempty"` // Response body.
|
|
Base64encoded bool `json:"base64Encoded,omitempty"` // True, if content was sent as base64.
|
|
}
|
|
|
|
// Do executes Network.getResponseBody against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// body - Response body.
|
|
func (p *GetResponseBodyParams) Do(ctxt context.Context, h cdp.Handler) (body []byte, err error) {
|
|
// execute
|
|
var res GetResponseBodyReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkGetResponseBody, p, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// decode
|
|
var dec []byte
|
|
if res.Base64encoded {
|
|
dec, err = base64.StdEncoding.DecodeString(res.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
dec = []byte(res.Body)
|
|
}
|
|
return dec, nil
|
|
}
|
|
|
|
// SetBlockedURLSParams blocks URLs from loading.
|
|
type SetBlockedURLSParams struct {
|
|
Urls []string `json:"urls"` // URL patterns to block. Wildcards ('*') are allowed.
|
|
}
|
|
|
|
// SetBlockedURLS blocks URLs from loading.
|
|
//
|
|
// parameters:
|
|
// urls - URL patterns to block. Wildcards ('*') are allowed.
|
|
func SetBlockedURLS(urls []string) *SetBlockedURLSParams {
|
|
return &SetBlockedURLSParams{
|
|
Urls: urls,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setBlockedURLs against the provided context and
|
|
// target handler.
|
|
func (p *SetBlockedURLSParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetBlockedURLS, p, nil)
|
|
}
|
|
|
|
// ReplayXHRParams this method sends a new XMLHttpRequest which is identical
|
|
// to the original one. The following parameters should be identical: method,
|
|
// url, async, request body, extra headers, withCredentials attribute, user,
|
|
// password.
|
|
type ReplayXHRParams struct {
|
|
RequestID RequestID `json:"requestId"` // Identifier of XHR to replay.
|
|
}
|
|
|
|
// ReplayXHR this method sends a new XMLHttpRequest which is identical to the
|
|
// original one. The following parameters should be identical: method, url,
|
|
// async, request body, extra headers, withCredentials attribute, user,
|
|
// password.
|
|
//
|
|
// parameters:
|
|
// requestID - Identifier of XHR to replay.
|
|
func ReplayXHR(requestID RequestID) *ReplayXHRParams {
|
|
return &ReplayXHRParams{
|
|
RequestID: requestID,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.replayXHR against the provided context and
|
|
// target handler.
|
|
func (p *ReplayXHRParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkReplayXHR, p, nil)
|
|
}
|
|
|
|
// CanClearBrowserCacheParams tells whether clearing browser cache is
|
|
// supported.
|
|
type CanClearBrowserCacheParams struct{}
|
|
|
|
// CanClearBrowserCache tells whether clearing browser cache is supported.
|
|
func CanClearBrowserCache() *CanClearBrowserCacheParams {
|
|
return &CanClearBrowserCacheParams{}
|
|
}
|
|
|
|
// CanClearBrowserCacheReturns return values.
|
|
type CanClearBrowserCacheReturns struct {
|
|
Result bool `json:"result,omitempty"` // True if browser cache can be cleared.
|
|
}
|
|
|
|
// Do executes Network.canClearBrowserCache against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// result - True if browser cache can be cleared.
|
|
func (p *CanClearBrowserCacheParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
|
|
// execute
|
|
var res CanClearBrowserCacheReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkCanClearBrowserCache, nil, &res)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return res.Result, nil
|
|
}
|
|
|
|
// ClearBrowserCacheParams clears browser cache.
|
|
type ClearBrowserCacheParams struct{}
|
|
|
|
// ClearBrowserCache clears browser cache.
|
|
func ClearBrowserCache() *ClearBrowserCacheParams {
|
|
return &ClearBrowserCacheParams{}
|
|
}
|
|
|
|
// Do executes Network.clearBrowserCache against the provided context and
|
|
// target handler.
|
|
func (p *ClearBrowserCacheParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkClearBrowserCache, nil, nil)
|
|
}
|
|
|
|
// CanClearBrowserCookiesParams tells whether clearing browser cookies is
|
|
// supported.
|
|
type CanClearBrowserCookiesParams struct{}
|
|
|
|
// CanClearBrowserCookies tells whether clearing browser cookies is
|
|
// supported.
|
|
func CanClearBrowserCookies() *CanClearBrowserCookiesParams {
|
|
return &CanClearBrowserCookiesParams{}
|
|
}
|
|
|
|
// CanClearBrowserCookiesReturns return values.
|
|
type CanClearBrowserCookiesReturns struct {
|
|
Result bool `json:"result,omitempty"` // True if browser cookies can be cleared.
|
|
}
|
|
|
|
// Do executes Network.canClearBrowserCookies against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// result - True if browser cookies can be cleared.
|
|
func (p *CanClearBrowserCookiesParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
|
|
// execute
|
|
var res CanClearBrowserCookiesReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkCanClearBrowserCookies, nil, &res)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return res.Result, nil
|
|
}
|
|
|
|
// ClearBrowserCookiesParams clears browser cookies.
|
|
type ClearBrowserCookiesParams struct{}
|
|
|
|
// ClearBrowserCookies clears browser cookies.
|
|
func ClearBrowserCookies() *ClearBrowserCookiesParams {
|
|
return &ClearBrowserCookiesParams{}
|
|
}
|
|
|
|
// Do executes Network.clearBrowserCookies against the provided context and
|
|
// target handler.
|
|
func (p *ClearBrowserCookiesParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkClearBrowserCookies, nil, nil)
|
|
}
|
|
|
|
// GetCookiesParams returns all browser cookies for the current URL.
|
|
// Depending on the backend support, will return detailed cookie information in
|
|
// the cookies field.
|
|
type GetCookiesParams struct {
|
|
Urls []string `json:"urls,omitempty"` // The list of URLs for which applicable cookies will be fetched
|
|
}
|
|
|
|
// GetCookies returns all browser cookies for the current URL. Depending on
|
|
// the backend support, will return detailed cookie information in the cookies
|
|
// field.
|
|
//
|
|
// parameters:
|
|
func GetCookies() *GetCookiesParams {
|
|
return &GetCookiesParams{}
|
|
}
|
|
|
|
// WithUrls the list of URLs for which applicable cookies will be fetched.
|
|
func (p GetCookiesParams) WithUrls(urls []string) *GetCookiesParams {
|
|
p.Urls = urls
|
|
return &p
|
|
}
|
|
|
|
// GetCookiesReturns return values.
|
|
type GetCookiesReturns struct {
|
|
Cookies []*Cookie `json:"cookies,omitempty"` // Array of cookie objects.
|
|
}
|
|
|
|
// Do executes Network.getCookies against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// cookies - Array of cookie objects.
|
|
func (p *GetCookiesParams) Do(ctxt context.Context, h cdp.Handler) (cookies []*Cookie, err error) {
|
|
// execute
|
|
var res GetCookiesReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkGetCookies, p, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.Cookies, nil
|
|
}
|
|
|
|
// GetAllCookiesParams returns all browser cookies. Depending on the backend
|
|
// support, will return detailed cookie information in the cookies field.
|
|
type GetAllCookiesParams struct{}
|
|
|
|
// GetAllCookies returns all browser cookies. Depending on the backend
|
|
// support, will return detailed cookie information in the cookies field.
|
|
func GetAllCookies() *GetAllCookiesParams {
|
|
return &GetAllCookiesParams{}
|
|
}
|
|
|
|
// GetAllCookiesReturns return values.
|
|
type GetAllCookiesReturns struct {
|
|
Cookies []*Cookie `json:"cookies,omitempty"` // Array of cookie objects.
|
|
}
|
|
|
|
// Do executes Network.getAllCookies against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// cookies - Array of cookie objects.
|
|
func (p *GetAllCookiesParams) Do(ctxt context.Context, h cdp.Handler) (cookies []*Cookie, err error) {
|
|
// execute
|
|
var res GetAllCookiesReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkGetAllCookies, nil, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.Cookies, nil
|
|
}
|
|
|
|
// DeleteCookieParams deletes browser cookie with given name, domain and
|
|
// path.
|
|
type DeleteCookieParams struct {
|
|
CookieName string `json:"cookieName"` // Name of the cookie to remove.
|
|
URL string `json:"url"` // URL to match cooke domain and path.
|
|
}
|
|
|
|
// DeleteCookie deletes browser cookie with given name, domain and path.
|
|
//
|
|
// parameters:
|
|
// cookieName - Name of the cookie to remove.
|
|
// url - URL to match cooke domain and path.
|
|
func DeleteCookie(cookieName string, url string) *DeleteCookieParams {
|
|
return &DeleteCookieParams{
|
|
CookieName: cookieName,
|
|
URL: url,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.deleteCookie against the provided context and
|
|
// target handler.
|
|
func (p *DeleteCookieParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkDeleteCookie, p, nil)
|
|
}
|
|
|
|
// SetCookieParams sets a cookie with the given cookie data; may overwrite
|
|
// equivalent cookies if they exist.
|
|
type SetCookieParams struct {
|
|
URL string `json:"url"` // The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie.
|
|
Name string `json:"name"` // The name of the cookie.
|
|
Value string `json:"value"` // The value of the cookie.
|
|
Domain string `json:"domain,omitempty"` // If omitted, the cookie becomes a host-only cookie.
|
|
Path string `json:"path,omitempty"` // Defaults to the path portion of the url parameter.
|
|
Secure bool `json:"secure,omitempty"` // Defaults ot false.
|
|
HTTPOnly bool `json:"httpOnly,omitempty"` // Defaults to false.
|
|
SameSite CookieSameSite `json:"sameSite,omitempty"` // Defaults to browser default behavior.
|
|
ExpirationDate *cdp.TimeSinceEpoch `json:"expirationDate,omitempty"` // If omitted, the cookie becomes a session cookie.
|
|
}
|
|
|
|
// SetCookie sets a cookie with the given cookie data; may overwrite
|
|
// equivalent cookies if they exist.
|
|
//
|
|
// parameters:
|
|
// url - The request-URI to associate with the setting of the cookie. This value can affect the default domain and path values of the created cookie.
|
|
// name - The name of the cookie.
|
|
// value - The value of the cookie.
|
|
func SetCookie(url string, name string, value string) *SetCookieParams {
|
|
return &SetCookieParams{
|
|
URL: url,
|
|
Name: name,
|
|
Value: value,
|
|
}
|
|
}
|
|
|
|
// WithDomain if omitted, the cookie becomes a host-only cookie.
|
|
func (p SetCookieParams) WithDomain(domain string) *SetCookieParams {
|
|
p.Domain = domain
|
|
return &p
|
|
}
|
|
|
|
// WithPath defaults to the path portion of the url parameter.
|
|
func (p SetCookieParams) WithPath(path string) *SetCookieParams {
|
|
p.Path = path
|
|
return &p
|
|
}
|
|
|
|
// WithSecure defaults ot false.
|
|
func (p SetCookieParams) WithSecure(secure bool) *SetCookieParams {
|
|
p.Secure = secure
|
|
return &p
|
|
}
|
|
|
|
// WithHTTPOnly defaults to false.
|
|
func (p SetCookieParams) WithHTTPOnly(httpOnly bool) *SetCookieParams {
|
|
p.HTTPOnly = httpOnly
|
|
return &p
|
|
}
|
|
|
|
// WithSameSite defaults to browser default behavior.
|
|
func (p SetCookieParams) WithSameSite(sameSite CookieSameSite) *SetCookieParams {
|
|
p.SameSite = sameSite
|
|
return &p
|
|
}
|
|
|
|
// WithExpirationDate if omitted, the cookie becomes a session cookie.
|
|
func (p SetCookieParams) WithExpirationDate(expirationDate *cdp.TimeSinceEpoch) *SetCookieParams {
|
|
p.ExpirationDate = expirationDate
|
|
return &p
|
|
}
|
|
|
|
// SetCookieReturns return values.
|
|
type SetCookieReturns struct {
|
|
Success bool `json:"success,omitempty"` // True if successfully set cookie.
|
|
}
|
|
|
|
// Do executes Network.setCookie against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// success - True if successfully set cookie.
|
|
func (p *SetCookieParams) Do(ctxt context.Context, h cdp.Handler) (success bool, err error) {
|
|
// execute
|
|
var res SetCookieReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkSetCookie, p, &res)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return res.Success, nil
|
|
}
|
|
|
|
// CanEmulateNetworkConditionsParams tells whether emulation of network
|
|
// conditions is supported.
|
|
type CanEmulateNetworkConditionsParams struct{}
|
|
|
|
// CanEmulateNetworkConditions tells whether emulation of network conditions
|
|
// is supported.
|
|
func CanEmulateNetworkConditions() *CanEmulateNetworkConditionsParams {
|
|
return &CanEmulateNetworkConditionsParams{}
|
|
}
|
|
|
|
// CanEmulateNetworkConditionsReturns return values.
|
|
type CanEmulateNetworkConditionsReturns struct {
|
|
Result bool `json:"result,omitempty"` // True if emulation of network conditions is supported.
|
|
}
|
|
|
|
// Do executes Network.canEmulateNetworkConditions against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// result - True if emulation of network conditions is supported.
|
|
func (p *CanEmulateNetworkConditionsParams) Do(ctxt context.Context, h cdp.Handler) (result bool, err error) {
|
|
// execute
|
|
var res CanEmulateNetworkConditionsReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkCanEmulateNetworkConditions, nil, &res)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return res.Result, nil
|
|
}
|
|
|
|
// EmulateNetworkConditionsParams activates emulation of network conditions.
|
|
type EmulateNetworkConditionsParams struct {
|
|
Offline bool `json:"offline"` // True to emulate internet disconnection.
|
|
Latency float64 `json:"latency"` // Additional latency (ms).
|
|
DownloadThroughput float64 `json:"downloadThroughput"` // Maximal aggregated download throughput.
|
|
UploadThroughput float64 `json:"uploadThroughput"` // Maximal aggregated upload throughput.
|
|
ConnectionType ConnectionType `json:"connectionType,omitempty"` // Connection type if known.
|
|
}
|
|
|
|
// EmulateNetworkConditions activates emulation of network conditions.
|
|
//
|
|
// parameters:
|
|
// offline - True to emulate internet disconnection.
|
|
// latency - Additional latency (ms).
|
|
// downloadThroughput - Maximal aggregated download throughput.
|
|
// uploadThroughput - Maximal aggregated upload throughput.
|
|
func EmulateNetworkConditions(offline bool, latency float64, downloadThroughput float64, uploadThroughput float64) *EmulateNetworkConditionsParams {
|
|
return &EmulateNetworkConditionsParams{
|
|
Offline: offline,
|
|
Latency: latency,
|
|
DownloadThroughput: downloadThroughput,
|
|
UploadThroughput: uploadThroughput,
|
|
}
|
|
}
|
|
|
|
// WithConnectionType connection type if known.
|
|
func (p EmulateNetworkConditionsParams) WithConnectionType(connectionType ConnectionType) *EmulateNetworkConditionsParams {
|
|
p.ConnectionType = connectionType
|
|
return &p
|
|
}
|
|
|
|
// Do executes Network.emulateNetworkConditions against the provided context and
|
|
// target handler.
|
|
func (p *EmulateNetworkConditionsParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkEmulateNetworkConditions, p, nil)
|
|
}
|
|
|
|
// SetCacheDisabledParams toggles ignoring cache for each request. If true,
|
|
// cache will not be used.
|
|
type SetCacheDisabledParams struct {
|
|
CacheDisabled bool `json:"cacheDisabled"` // Cache disabled state.
|
|
}
|
|
|
|
// SetCacheDisabled toggles ignoring cache for each request. If true, cache
|
|
// will not be used.
|
|
//
|
|
// parameters:
|
|
// cacheDisabled - Cache disabled state.
|
|
func SetCacheDisabled(cacheDisabled bool) *SetCacheDisabledParams {
|
|
return &SetCacheDisabledParams{
|
|
CacheDisabled: cacheDisabled,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setCacheDisabled against the provided context and
|
|
// target handler.
|
|
func (p *SetCacheDisabledParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetCacheDisabled, p, nil)
|
|
}
|
|
|
|
// SetBypassServiceWorkerParams toggles ignoring of service worker for each
|
|
// request.
|
|
type SetBypassServiceWorkerParams struct {
|
|
Bypass bool `json:"bypass"` // Bypass service worker and load from network.
|
|
}
|
|
|
|
// SetBypassServiceWorker toggles ignoring of service worker for each
|
|
// request.
|
|
//
|
|
// parameters:
|
|
// bypass - Bypass service worker and load from network.
|
|
func SetBypassServiceWorker(bypass bool) *SetBypassServiceWorkerParams {
|
|
return &SetBypassServiceWorkerParams{
|
|
Bypass: bypass,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setBypassServiceWorker against the provided context and
|
|
// target handler.
|
|
func (p *SetBypassServiceWorkerParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetBypassServiceWorker, p, nil)
|
|
}
|
|
|
|
// SetDataSizeLimitsForTestParams for testing.
|
|
type SetDataSizeLimitsForTestParams struct {
|
|
MaxTotalSize int64 `json:"maxTotalSize"` // Maximum total buffer size.
|
|
MaxResourceSize int64 `json:"maxResourceSize"` // Maximum per-resource size.
|
|
}
|
|
|
|
// SetDataSizeLimitsForTest for testing.
|
|
//
|
|
// parameters:
|
|
// maxTotalSize - Maximum total buffer size.
|
|
// maxResourceSize - Maximum per-resource size.
|
|
func SetDataSizeLimitsForTest(maxTotalSize int64, maxResourceSize int64) *SetDataSizeLimitsForTestParams {
|
|
return &SetDataSizeLimitsForTestParams{
|
|
MaxTotalSize: maxTotalSize,
|
|
MaxResourceSize: maxResourceSize,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setDataSizeLimitsForTest against the provided context and
|
|
// target handler.
|
|
func (p *SetDataSizeLimitsForTestParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetDataSizeLimitsForTest, p, nil)
|
|
}
|
|
|
|
// GetCertificateParams returns the DER-encoded certificate.
|
|
type GetCertificateParams struct {
|
|
Origin string `json:"origin"` // Origin to get certificate for.
|
|
}
|
|
|
|
// GetCertificate returns the DER-encoded certificate.
|
|
//
|
|
// parameters:
|
|
// origin - Origin to get certificate for.
|
|
func GetCertificate(origin string) *GetCertificateParams {
|
|
return &GetCertificateParams{
|
|
Origin: origin,
|
|
}
|
|
}
|
|
|
|
// GetCertificateReturns return values.
|
|
type GetCertificateReturns struct {
|
|
TableNames []string `json:"tableNames,omitempty"`
|
|
}
|
|
|
|
// Do executes Network.getCertificate against the provided context and
|
|
// target handler.
|
|
//
|
|
// returns:
|
|
// tableNames
|
|
func (p *GetCertificateParams) Do(ctxt context.Context, h cdp.Handler) (tableNames []string, err error) {
|
|
// execute
|
|
var res GetCertificateReturns
|
|
err = h.Execute(ctxt, cdp.CommandNetworkGetCertificate, p, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.TableNames, nil
|
|
}
|
|
|
|
// SetRequestInterceptionEnabledParams [no description].
|
|
type SetRequestInterceptionEnabledParams struct {
|
|
Enabled bool `json:"enabled"` // Whether or not HTTP requests should be intercepted and Network.requestIntercepted events sent.
|
|
}
|
|
|
|
// SetRequestInterceptionEnabled [no description].
|
|
//
|
|
// parameters:
|
|
// enabled - Whether or not HTTP requests should be intercepted and Network.requestIntercepted events sent.
|
|
func SetRequestInterceptionEnabled(enabled bool) *SetRequestInterceptionEnabledParams {
|
|
return &SetRequestInterceptionEnabledParams{
|
|
Enabled: enabled,
|
|
}
|
|
}
|
|
|
|
// Do executes Network.setRequestInterceptionEnabled against the provided context and
|
|
// target handler.
|
|
func (p *SetRequestInterceptionEnabledParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkSetRequestInterceptionEnabled, p, nil)
|
|
}
|
|
|
|
// ContinueInterceptedRequestParams response to Network.requestIntercepted
|
|
// which either modifies the request to continue with any modifications, or
|
|
// blocks it, or completes it with the provided response bytes. If a network
|
|
// fetch occurs as a result which encounters a redirect an additional
|
|
// Network.requestIntercepted event will be sent with the same InterceptionId.
|
|
type ContinueInterceptedRequestParams struct {
|
|
InterceptionID InterceptionID `json:"interceptionId"`
|
|
ErrorReason ErrorReason `json:"errorReason,omitempty"` // If set this causes the request to fail with the given reason. Must not be set in response to an authChallenge.
|
|
RawResponse string `json:"rawResponse,omitempty"` // If set the requests completes using with the provided base64 encoded raw response, including HTTP status line and headers etc... Must not be set in response to an authChallenge.
|
|
URL string `json:"url,omitempty"` // If set the request url will be modified in a way that's not observable by page. Must not be set in response to an authChallenge.
|
|
Method string `json:"method,omitempty"` // If set this allows the request method to be overridden. Must not be set in response to an authChallenge.
|
|
PostData string `json:"postData,omitempty"` // If set this allows postData to be set. Must not be set in response to an authChallenge.
|
|
Headers Headers `json:"headers,omitempty"` // If set this allows the request headers to be changed. Must not be set in response to an authChallenge.
|
|
AuthChallengeResponse *AuthChallengeResponse `json:"authChallengeResponse,omitempty"` // Response to a requestIntercepted with an authChallenge. Must not be set otherwise.
|
|
}
|
|
|
|
// ContinueInterceptedRequest response to Network.requestIntercepted which
|
|
// either modifies the request to continue with any modifications, or blocks it,
|
|
// or completes it with the provided response bytes. If a network fetch occurs
|
|
// as a result which encounters a redirect an additional
|
|
// Network.requestIntercepted event will be sent with the same InterceptionId.
|
|
//
|
|
// parameters:
|
|
// interceptionID
|
|
func ContinueInterceptedRequest(interceptionID InterceptionID) *ContinueInterceptedRequestParams {
|
|
return &ContinueInterceptedRequestParams{
|
|
InterceptionID: interceptionID,
|
|
}
|
|
}
|
|
|
|
// WithErrorReason if set this causes the request to fail with the given
|
|
// reason. Must not be set in response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithErrorReason(errorReason ErrorReason) *ContinueInterceptedRequestParams {
|
|
p.ErrorReason = errorReason
|
|
return &p
|
|
}
|
|
|
|
// WithRawResponse if set the requests completes using with the provided
|
|
// base64 encoded raw response, including HTTP status line and headers etc...
|
|
// Must not be set in response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithRawResponse(rawResponse string) *ContinueInterceptedRequestParams {
|
|
p.RawResponse = rawResponse
|
|
return &p
|
|
}
|
|
|
|
// WithURL if set the request url will be modified in a way that's not
|
|
// observable by page. Must not be set in response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithURL(url string) *ContinueInterceptedRequestParams {
|
|
p.URL = url
|
|
return &p
|
|
}
|
|
|
|
// WithMethod if set this allows the request method to be overridden. Must
|
|
// not be set in response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithMethod(method string) *ContinueInterceptedRequestParams {
|
|
p.Method = method
|
|
return &p
|
|
}
|
|
|
|
// WithPostData if set this allows postData to be set. Must not be set in
|
|
// response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithPostData(postData string) *ContinueInterceptedRequestParams {
|
|
p.PostData = postData
|
|
return &p
|
|
}
|
|
|
|
// WithHeaders if set this allows the request headers to be changed. Must not
|
|
// be set in response to an authChallenge.
|
|
func (p ContinueInterceptedRequestParams) WithHeaders(headers Headers) *ContinueInterceptedRequestParams {
|
|
p.Headers = headers
|
|
return &p
|
|
}
|
|
|
|
// WithAuthChallengeResponse response to a requestIntercepted with an
|
|
// authChallenge. Must not be set otherwise.
|
|
func (p ContinueInterceptedRequestParams) WithAuthChallengeResponse(authChallengeResponse *AuthChallengeResponse) *ContinueInterceptedRequestParams {
|
|
p.AuthChallengeResponse = authChallengeResponse
|
|
return &p
|
|
}
|
|
|
|
// Do executes Network.continueInterceptedRequest against the provided context and
|
|
// target handler.
|
|
func (p *ContinueInterceptedRequestParams) Do(ctxt context.Context, h cdp.Handler) (err error) {
|
|
return h.Execute(ctxt, cdp.CommandNetworkContinueInterceptedRequest, p, nil)
|
|
}
|