_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q19000 | NewUnregisterArgs | train | func NewUnregisterArgs(scopeURL string) *UnregisterArgs {
args := new(UnregisterArgs)
args.ScopeURL = scopeURL
return args
} | go | {
"resource": ""
} |
q19001 | NewUpdateRegistrationArgs | train | func NewUpdateRegistrationArgs(scopeURL string) *UpdateRegistrationArgs {
args := new(UpdateRegistrationArgs)
args.ScopeURL = scopeURL
return args
} | go | {
"resource": ""
} |
q19002 | GetApplicationCacheForFrame | train | func (d *domainClient) GetApplicationCacheForFrame(ctx context.Context, args *GetApplicationCacheForFrameArgs) (reply *GetApplicationCacheForFrameReply, err error) {
reply = new(GetApplicationCacheForFrameReply)
if args != nil {
err = rpcc.Invoke(ctx, "ApplicationCache.getApplicationCacheForFrame", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "ApplicationCache.getApplicationCacheForFrame", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "ApplicationCache", Op: "GetApplicationCacheForFrame", Err: err}
}
return
} | go | {
"resource": ""
} |
q19003 | GetManifestForFrame | train | func (d *domainClient) GetManifestForFrame(ctx context.Context, args *GetManifestForFrameArgs) (reply *GetManifestForFrameReply, err error) {
reply = new(GetManifestForFrameReply)
if args != nil {
err = rpcc.Invoke(ctx, "ApplicationCache.getManifestForFrame", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "ApplicationCache.getManifestForFrame", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "ApplicationCache", Op: "GetManifestForFrame", Err: err}
}
return
} | go | {
"resource": ""
} |
q19004 | NewClearObjectStoreArgs | train | func NewClearObjectStoreArgs(securityOrigin string, databaseName string, objectStoreName string) *ClearObjectStoreArgs {
args := new(ClearObjectStoreArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
args.ObjectStoreName = objectStoreName
return args
} | go | {
"resource": ""
} |
q19005 | NewDeleteDatabaseArgs | train | func NewDeleteDatabaseArgs(securityOrigin string, databaseName string) *DeleteDatabaseArgs {
args := new(DeleteDatabaseArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
return args
} | go | {
"resource": ""
} |
q19006 | NewDeleteObjectStoreEntriesArgs | train | func NewDeleteObjectStoreEntriesArgs(securityOrigin string, databaseName string, objectStoreName string, keyRange KeyRange) *DeleteObjectStoreEntriesArgs {
args := new(DeleteObjectStoreEntriesArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
args.ObjectStoreName = objectStoreName
args.KeyRange = keyRange
return args
} | go | {
"resource": ""
} |
q19007 | NewRequestDataArgs | train | func NewRequestDataArgs(securityOrigin string, databaseName string, objectStoreName string, indexName string, skipCount int, pageSize int) *RequestDataArgs {
args := new(RequestDataArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
args.ObjectStoreName = objectStoreName
args.IndexName = indexName
args.SkipCount = skipCount
args.PageSize = pageSize
return args
} | go | {
"resource": ""
} |
q19008 | SetKeyRange | train | func (a *RequestDataArgs) SetKeyRange(keyRange KeyRange) *RequestDataArgs {
a.KeyRange = &keyRange
return a
} | go | {
"resource": ""
} |
q19009 | NewGetMetadataArgs | train | func NewGetMetadataArgs(securityOrigin string, databaseName string, objectStoreName string) *GetMetadataArgs {
args := new(GetMetadataArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
args.ObjectStoreName = objectStoreName
return args
} | go | {
"resource": ""
} |
q19010 | NewRequestDatabaseArgs | train | func NewRequestDatabaseArgs(securityOrigin string, databaseName string) *RequestDatabaseArgs {
args := new(RequestDatabaseArgs)
args.SecurityOrigin = securityOrigin
args.DatabaseName = databaseName
return args
} | go | {
"resource": ""
} |
q19011 | NewRequestDatabaseNamesArgs | train | func NewRequestDatabaseNamesArgs(securityOrigin string) *RequestDatabaseNamesArgs {
args := new(RequestDatabaseNamesArgs)
args.SecurityOrigin = securityOrigin
return args
} | go | {
"resource": ""
} |
q19012 | NewCloseArgs | train | func NewCloseArgs(handle StreamHandle) *CloseArgs {
args := new(CloseArgs)
args.Handle = handle
return args
} | go | {
"resource": ""
} |
q19013 | NewReadArgs | train | func NewReadArgs(handle StreamHandle) *ReadArgs {
args := new(ReadArgs)
args.Handle = handle
return args
} | go | {
"resource": ""
} |
q19014 | NewResolveBlobArgs | train | func NewResolveBlobArgs(objectID runtime.RemoteObjectID) *ResolveBlobArgs {
args := new(ResolveBlobArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q19015 | NewContinueInterceptedRequestArgs | train | func NewContinueInterceptedRequestArgs(interceptionID InterceptionID) *ContinueInterceptedRequestArgs {
args := new(ContinueInterceptedRequestArgs)
args.InterceptionID = interceptionID
return args
} | go | {
"resource": ""
} |
q19016 | SetErrorReason | train | func (a *ContinueInterceptedRequestArgs) SetErrorReason(errorReason ErrorReason) *ContinueInterceptedRequestArgs {
a.ErrorReason = errorReason
return a
} | go | {
"resource": ""
} |
q19017 | SetRawResponse | train | func (a *ContinueInterceptedRequestArgs) SetRawResponse(rawResponse string) *ContinueInterceptedRequestArgs {
a.RawResponse = &rawResponse
return a
} | go | {
"resource": ""
} |
q19018 | SetURL | train | func (a *ContinueInterceptedRequestArgs) SetURL(url string) *ContinueInterceptedRequestArgs {
a.URL = &url
return a
} | go | {
"resource": ""
} |
q19019 | SetMethod | train | func (a *ContinueInterceptedRequestArgs) SetMethod(method string) *ContinueInterceptedRequestArgs {
a.Method = &method
return a
} | go | {
"resource": ""
} |
q19020 | SetPostData | train | func (a *ContinueInterceptedRequestArgs) SetPostData(postData string) *ContinueInterceptedRequestArgs {
a.PostData = &postData
return a
} | go | {
"resource": ""
} |
q19021 | SetHeaders | train | func (a *ContinueInterceptedRequestArgs) SetHeaders(headers Headers) *ContinueInterceptedRequestArgs {
a.Headers = headers
return a
} | go | {
"resource": ""
} |
q19022 | SetAuthChallengeResponse | train | func (a *ContinueInterceptedRequestArgs) SetAuthChallengeResponse(authChallengeResponse AuthChallengeResponse) *ContinueInterceptedRequestArgs {
a.AuthChallengeResponse = &authChallengeResponse
return a
} | go | {
"resource": ""
} |
q19023 | NewDeleteCookiesArgs | train | func NewDeleteCookiesArgs(name string) *DeleteCookiesArgs {
args := new(DeleteCookiesArgs)
args.Name = name
return args
} | go | {
"resource": ""
} |
q19024 | SetURL | train | func (a *DeleteCookiesArgs) SetURL(url string) *DeleteCookiesArgs {
a.URL = &url
return a
} | go | {
"resource": ""
} |
q19025 | SetDomain | train | func (a *DeleteCookiesArgs) SetDomain(domain string) *DeleteCookiesArgs {
a.Domain = &domain
return a
} | go | {
"resource": ""
} |
q19026 | SetPath | train | func (a *DeleteCookiesArgs) SetPath(path string) *DeleteCookiesArgs {
a.Path = &path
return a
} | go | {
"resource": ""
} |
q19027 | NewEmulateNetworkConditionsArgs | train | func NewEmulateNetworkConditionsArgs(offline bool, latency float64, downloadThroughput float64, uploadThroughput float64) *EmulateNetworkConditionsArgs {
args := new(EmulateNetworkConditionsArgs)
args.Offline = offline
args.Latency = latency
args.DownloadThroughput = downloadThroughput
args.UploadThroughput = uploadThroughput
return args
} | go | {
"resource": ""
} |
q19028 | SetConnectionType | train | func (a *EmulateNetworkConditionsArgs) SetConnectionType(connectionType ConnectionType) *EmulateNetworkConditionsArgs {
a.ConnectionType = connectionType
return a
} | go | {
"resource": ""
} |
q19029 | NewGetCertificateArgs | train | func NewGetCertificateArgs(origin string) *GetCertificateArgs {
args := new(GetCertificateArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19030 | SetURLs | train | func (a *GetCookiesArgs) SetURLs(urls []string) *GetCookiesArgs {
a.URLs = urls
return a
} | go | {
"resource": ""
} |
q19031 | NewGetResponseBodyArgs | train | func NewGetResponseBodyArgs(requestID RequestID) *GetResponseBodyArgs {
args := new(GetResponseBodyArgs)
args.RequestID = requestID
return args
} | go | {
"resource": ""
} |
q19032 | NewGetRequestPostDataArgs | train | func NewGetRequestPostDataArgs(requestID RequestID) *GetRequestPostDataArgs {
args := new(GetRequestPostDataArgs)
args.RequestID = requestID
return args
} | go | {
"resource": ""
} |
q19033 | NewGetResponseBodyForInterceptionArgs | train | func NewGetResponseBodyForInterceptionArgs(interceptionID InterceptionID) *GetResponseBodyForInterceptionArgs {
args := new(GetResponseBodyForInterceptionArgs)
args.InterceptionID = interceptionID
return args
} | go | {
"resource": ""
} |
q19034 | NewTakeResponseBodyForInterceptionAsStreamArgs | train | func NewTakeResponseBodyForInterceptionAsStreamArgs(interceptionID InterceptionID) *TakeResponseBodyForInterceptionAsStreamArgs {
args := new(TakeResponseBodyForInterceptionAsStreamArgs)
args.InterceptionID = interceptionID
return args
} | go | {
"resource": ""
} |
q19035 | NewReplayXHRArgs | train | func NewReplayXHRArgs(requestID RequestID) *ReplayXHRArgs {
args := new(ReplayXHRArgs)
args.RequestID = requestID
return args
} | go | {
"resource": ""
} |
q19036 | NewSearchInResponseBodyArgs | train | func NewSearchInResponseBodyArgs(requestID RequestID, query string) *SearchInResponseBodyArgs {
args := new(SearchInResponseBodyArgs)
args.RequestID = requestID
args.Query = query
return args
} | go | {
"resource": ""
} |
q19037 | NewSetBlockedURLsArgs | train | func NewSetBlockedURLsArgs(urls []string) *SetBlockedURLsArgs {
args := new(SetBlockedURLsArgs)
args.URLs = urls
return args
} | go | {
"resource": ""
} |
q19038 | NewSetBypassServiceWorkerArgs | train | func NewSetBypassServiceWorkerArgs(bypass bool) *SetBypassServiceWorkerArgs {
args := new(SetBypassServiceWorkerArgs)
args.Bypass = bypass
return args
} | go | {
"resource": ""
} |
q19039 | NewSetCacheDisabledArgs | train | func NewSetCacheDisabledArgs(cacheDisabled bool) *SetCacheDisabledArgs {
args := new(SetCacheDisabledArgs)
args.CacheDisabled = cacheDisabled
return args
} | go | {
"resource": ""
} |
q19040 | NewSetCookieArgs | train | func NewSetCookieArgs(name string, value string) *SetCookieArgs {
args := new(SetCookieArgs)
args.Name = name
args.Value = value
return args
} | go | {
"resource": ""
} |
q19041 | SetURL | train | func (a *SetCookieArgs) SetURL(url string) *SetCookieArgs {
a.URL = &url
return a
} | go | {
"resource": ""
} |
q19042 | SetDomain | train | func (a *SetCookieArgs) SetDomain(domain string) *SetCookieArgs {
a.Domain = &domain
return a
} | go | {
"resource": ""
} |
q19043 | SetPath | train | func (a *SetCookieArgs) SetPath(path string) *SetCookieArgs {
a.Path = &path
return a
} | go | {
"resource": ""
} |
q19044 | SetSecure | train | func (a *SetCookieArgs) SetSecure(secure bool) *SetCookieArgs {
a.Secure = &secure
return a
} | go | {
"resource": ""
} |
q19045 | SetHTTPOnly | train | func (a *SetCookieArgs) SetHTTPOnly(httpOnly bool) *SetCookieArgs {
a.HTTPOnly = &httpOnly
return a
} | go | {
"resource": ""
} |
q19046 | SetSameSite | train | func (a *SetCookieArgs) SetSameSite(sameSite CookieSameSite) *SetCookieArgs {
a.SameSite = sameSite
return a
} | go | {
"resource": ""
} |
q19047 | SetExpires | train | func (a *SetCookieArgs) SetExpires(expires TimeSinceEpoch) *SetCookieArgs {
a.Expires = expires
return a
} | go | {
"resource": ""
} |
q19048 | NewSetCookiesArgs | train | func NewSetCookiesArgs(cookies []CookieParam) *SetCookiesArgs {
args := new(SetCookiesArgs)
args.Cookies = cookies
return args
} | go | {
"resource": ""
} |
q19049 | NewSetExtraHTTPHeadersArgs | train | func NewSetExtraHTTPHeadersArgs(headers Headers) *SetExtraHTTPHeadersArgs {
args := new(SetExtraHTTPHeadersArgs)
args.Headers = headers
return args
} | go | {
"resource": ""
} |
q19050 | NewSetRequestInterceptionArgs | train | func NewSetRequestInterceptionArgs(patterns []RequestPattern) *SetRequestInterceptionArgs {
args := new(SetRequestInterceptionArgs)
args.Patterns = patterns
return args
} | go | {
"resource": ""
} |
q19051 | NewSetSamplingIntervalArgs | train | func NewSetSamplingIntervalArgs(interval int) *SetSamplingIntervalArgs {
args := new(SetSamplingIntervalArgs)
args.Interval = interval
return args
} | go | {
"resource": ""
} |
q19052 | SetCallCount | train | func (a *StartPreciseCoverageArgs) SetCallCount(callCount bool) *StartPreciseCoverageArgs {
a.CallCount = &callCount
return a
} | go | {
"resource": ""
} |
q19053 | SetDetailed | train | func (a *StartPreciseCoverageArgs) SetDetailed(detailed bool) *StartPreciseCoverageArgs {
a.Detailed = &detailed
return a
} | go | {
"resource": ""
} |
q19054 | Name | train | func Name(name string) (should string) {
should = lint.Name(name)
for _, replace := range []struct {
re *regexp.Regexp
to string
}{
{re: reIDs, to: "IDs"},
{re: reURLs, to: "URLs"},
{re: reIDRef, to: "IDRef"},
} {
should = replace.re.ReplaceAllString(should, fmt.Sprintf("${1}%s${2}", replace.to))
}
return should
} | go | {
"resource": ""
} |
q19055 | NewStartObservingArgs | train | func NewStartObservingArgs(service ServiceName) *StartObservingArgs {
args := new(StartObservingArgs)
args.Service = service
return args
} | go | {
"resource": ""
} |
q19056 | NewStopObservingArgs | train | func NewStopObservingArgs(service ServiceName) *StopObservingArgs {
args := new(StopObservingArgs)
args.Service = service
return args
} | go | {
"resource": ""
} |
q19057 | NewSetRecordingArgs | train | func NewSetRecordingArgs(shouldRecord bool, service ServiceName) *SetRecordingArgs {
args := new(SetRecordingArgs)
args.ShouldRecord = shouldRecord
args.Service = service
return args
} | go | {
"resource": ""
} |
q19058 | NewClearEventsArgs | train | func NewClearEventsArgs(service ServiceName) *ClearEventsArgs {
args := new(ClearEventsArgs)
args.Service = service
return args
} | go | {
"resource": ""
} |
q19059 | WithCodec | train | func WithCodec(f func(conn io.ReadWriter) Codec) DialOption {
return func(o *dialOptions) {
o.codec = f
}
} | go | {
"resource": ""
} |
q19060 | WithTLSClientConfig | train | func WithTLSClientConfig(c *tls.Config) DialOption {
return func(o *dialOptions) {
o.wsDialer.TLSClientConfig = c
}
} | go | {
"resource": ""
} |
q19061 | DialContext | train | func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *Conn, err error) {
if ctx == nil {
panic("nil Context")
}
c := &Conn{
pending: make(map[uint64]*rpcCall),
streams: make(map[string]*streamClients),
}
c.ctx, c.cancel = context.WithCancel(context.Background())
defer func() {
select {
case <-ctx.Done():
conn, err = nil, ctx.Err()
default:
}
if err != nil {
c.Close()
}
}()
for _, o := range opts {
o(&c.dialOpts)
}
netDial := c.dialOpts.dialer
if netDial == nil {
netDial = func(ctx context.Context, addr string) (io.ReadWriteCloser, error) {
ws := &c.dialOpts.wsDialer
if ws.WriteBufferSize == 0 {
// Set the default size for use in writeLimiter.
ws.WriteBufferSize = defaultWriteBufferSize
}
// Set NetDial to dial with context, this action will
// override the HandshakeTimeout setting.
ws.NetDial = func(network, addr string) (net.Conn, error) {
conn, err := (&net.Dialer{}).DialContext(ctx, network, addr)
// Use writeLimiter to avoid writing fragmented
// websocket messages. We're not accounting for
// the header length here because it varies, as
// a result we might block some valid writes
// that are a few bytes too large.
return &writeLimiter{
limit: ws.WriteBufferSize,
Conn: conn,
}, err
}
wsConn, _, err := ws.Dial(addr, nil)
if err != nil {
return nil, err
}
if ws.EnableCompression {
c.compressionLevel = wsConn.SetCompressionLevel
}
return &wsReadWriteCloser{wsConn: wsConn}, nil
}
}
c.conn, err = netDial(ctx, target)
if err != nil {
return nil, err
}
newCodec := c.dialOpts.codec
if newCodec == nil {
newCodec = func(conn io.ReadWriter) Codec {
return &jsonCodec{
enc: json.NewEncoder(conn),
dec: json.NewDecoder(conn),
}
}
}
c.codec = newCodec(c.conn)
recvDone := func(err error) {
// When we receive Inspector.detached the remote will close
// the connection afterwards and recvDone will return. Maybe
// we could give the user time to react to the event before
// closing?
// TODO(mafredri): Do we want to close here, like this?
c.close(err)
}
go c.recv(c.notify, recvDone)
return c, nil
} | go | {
"resource": ""
} |
q19062 | recv | train | func (c *Conn) recv(notify func(string, []byte), done func(error)) {
var resp Response
var err error
for {
resp.reset()
if err = c.codec.ReadResponse(&resp); err != nil {
done(err)
return
}
// Check if this is an RPC notification from the server.
if resp.Method != "" {
// Method represents the event that was triggered over the
// Chrome DevTools Protocol. We do not expect to receive
// RPC requests, if this was one, the ID field would be set.
notify(resp.Method, resp.Args)
continue
}
c.mu.Lock()
call := c.pending[resp.ID]
delete(c.pending, resp.ID)
c.mu.Unlock()
switch {
case call == nil:
// No pending call, this could mean there was an error during
// send or the server sent an unexpected response.
if enableDebug {
log.Println("rpcc: no pending call: " + resp.String())
}
case resp.Error != nil:
call.done(resp.Error)
default:
var err error
if call.Reply != nil {
if err = json.Unmarshal(resp.Result, call.Reply); err != nil {
err = fmt.Errorf("rpcc: decoding %s: %s", call.Method, err.Error())
}
}
call.done(err)
}
}
} | go | {
"resource": ""
} |
q19063 | send | train | func (c *Conn) send(ctx context.Context, call *rpcCall) (err error) {
defer func() {
// Give precedence for user cancellation.
select {
case <-ctx.Done():
err = ctx.Err()
default:
}
}()
c.mu.Lock()
if c.closed {
c.mu.Unlock()
return ErrConnClosing
}
c.reqSeq++
reqID := c.reqSeq
c.pending[reqID] = call
c.mu.Unlock()
done := make(chan error, 1)
go func() {
c.reqMu.Lock()
c.req.ID = reqID
c.req.Method = call.Method
c.req.Args = call.Args
err := c.codec.WriteRequest(&c.req)
c.req.Args = nil
c.reqMu.Unlock()
done <- err
}()
// Abort on user or connection cancellation.
select {
case <-ctx.Done():
err = ctx.Err()
case err = <-done:
}
if err != nil {
// Remove reference on error, avoid
// unnecessary work in recv.
c.mu.Lock()
delete(c.pending, reqID)
c.mu.Unlock()
return err
}
return nil
} | go | {
"resource": ""
} |
q19064 | notify | train | func (c *Conn) notify(method string, data []byte) {
c.streamMu.Lock()
stream := c.streams[method]
c.streamMu.Unlock()
if stream != nil {
// Stream writer must be able to handle incoming writes
// even after it has been removed (unsubscribed).
stream.write(method, data)
}
} | go | {
"resource": ""
} |
q19065 | NewSetIgnoreCertificateErrorsArgs | train | func NewSetIgnoreCertificateErrorsArgs(ignore bool) *SetIgnoreCertificateErrorsArgs {
args := new(SetIgnoreCertificateErrorsArgs)
args.Ignore = ignore
return args
} | go | {
"resource": ""
} |
q19066 | NewHandleCertificateErrorArgs | train | func NewHandleCertificateErrorArgs(eventID int, action CertificateErrorAction) *HandleCertificateErrorArgs {
args := new(HandleCertificateErrorArgs)
args.EventID = eventID
args.Action = action
return args
} | go | {
"resource": ""
} |
q19067 | NewSetOverrideCertificateErrorsArgs | train | func NewSetOverrideCertificateErrorsArgs(override bool) *SetOverrideCertificateErrorsArgs {
args := new(SetOverrideCertificateErrorsArgs)
args.Override = override
return args
} | go | {
"resource": ""
} |
q19068 | GetCurrentTime | train | func (d *domainClient) GetCurrentTime(ctx context.Context, args *GetCurrentTimeArgs) (reply *GetCurrentTimeReply, err error) {
reply = new(GetCurrentTimeReply)
if args != nil {
err = rpcc.Invoke(ctx, "Animation.getCurrentTime", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Animation.getCurrentTime", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Animation", Op: "GetCurrentTime", Err: err}
}
return
} | go | {
"resource": ""
} |
q19069 | ResolveAnimation | train | func (d *domainClient) ResolveAnimation(ctx context.Context, args *ResolveAnimationArgs) (reply *ResolveAnimationReply, err error) {
reply = new(ResolveAnimationReply)
if args != nil {
err = rpcc.Invoke(ctx, "Animation.resolveAnimation", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Animation.resolveAnimation", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Animation", Op: "ResolveAnimation", Err: err}
}
return
} | go | {
"resource": ""
} |
q19070 | NewAwaitPromiseArgs | train | func NewAwaitPromiseArgs(promiseObjectID RemoteObjectID) *AwaitPromiseArgs {
args := new(AwaitPromiseArgs)
args.PromiseObjectID = promiseObjectID
return args
} | go | {
"resource": ""
} |
q19071 | NewCallFunctionOnArgs | train | func NewCallFunctionOnArgs(functionDeclaration string) *CallFunctionOnArgs {
args := new(CallFunctionOnArgs)
args.FunctionDeclaration = functionDeclaration
return args
} | go | {
"resource": ""
} |
q19072 | SetObjectID | train | func (a *CallFunctionOnArgs) SetObjectID(objectID RemoteObjectID) *CallFunctionOnArgs {
a.ObjectID = &objectID
return a
} | go | {
"resource": ""
} |
q19073 | SetArguments | train | func (a *CallFunctionOnArgs) SetArguments(arguments []CallArgument) *CallFunctionOnArgs {
a.Arguments = arguments
return a
} | go | {
"resource": ""
} |
q19074 | SetExecutionContextID | train | func (a *CallFunctionOnArgs) SetExecutionContextID(executionContextID ExecutionContextID) *CallFunctionOnArgs {
a.ExecutionContextID = &executionContextID
return a
} | go | {
"resource": ""
} |
q19075 | SetObjectGroup | train | func (a *CallFunctionOnArgs) SetObjectGroup(objectGroup string) *CallFunctionOnArgs {
a.ObjectGroup = &objectGroup
return a
} | go | {
"resource": ""
} |
q19076 | NewCompileScriptArgs | train | func NewCompileScriptArgs(expression string, sourceURL string, persistScript bool) *CompileScriptArgs {
args := new(CompileScriptArgs)
args.Expression = expression
args.SourceURL = sourceURL
args.PersistScript = persistScript
return args
} | go | {
"resource": ""
} |
q19077 | NewEvaluateArgs | train | func NewEvaluateArgs(expression string) *EvaluateArgs {
args := new(EvaluateArgs)
args.Expression = expression
return args
} | go | {
"resource": ""
} |
q19078 | SetContextID | train | func (a *EvaluateArgs) SetContextID(contextID ExecutionContextID) *EvaluateArgs {
a.ContextID = &contextID
return a
} | go | {
"resource": ""
} |
q19079 | NewGetPropertiesArgs | train | func NewGetPropertiesArgs(objectID RemoteObjectID) *GetPropertiesArgs {
args := new(GetPropertiesArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q19080 | SetOwnProperties | train | func (a *GetPropertiesArgs) SetOwnProperties(ownProperties bool) *GetPropertiesArgs {
a.OwnProperties = &ownProperties
return a
} | go | {
"resource": ""
} |
q19081 | SetExecutionContextID | train | func (a *GlobalLexicalScopeNamesArgs) SetExecutionContextID(executionContextID ExecutionContextID) *GlobalLexicalScopeNamesArgs {
a.ExecutionContextID = &executionContextID
return a
} | go | {
"resource": ""
} |
q19082 | NewQueryObjectsArgs | train | func NewQueryObjectsArgs(prototypeObjectID RemoteObjectID) *QueryObjectsArgs {
args := new(QueryObjectsArgs)
args.PrototypeObjectID = prototypeObjectID
return args
} | go | {
"resource": ""
} |
q19083 | SetObjectGroup | train | func (a *QueryObjectsArgs) SetObjectGroup(objectGroup string) *QueryObjectsArgs {
a.ObjectGroup = &objectGroup
return a
} | go | {
"resource": ""
} |
q19084 | NewReleaseObjectArgs | train | func NewReleaseObjectArgs(objectID RemoteObjectID) *ReleaseObjectArgs {
args := new(ReleaseObjectArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q19085 | NewReleaseObjectGroupArgs | train | func NewReleaseObjectGroupArgs(objectGroup string) *ReleaseObjectGroupArgs {
args := new(ReleaseObjectGroupArgs)
args.ObjectGroup = objectGroup
return args
} | go | {
"resource": ""
} |
q19086 | NewRunScriptArgs | train | func NewRunScriptArgs(scriptID ScriptID) *RunScriptArgs {
args := new(RunScriptArgs)
args.ScriptID = scriptID
return args
} | go | {
"resource": ""
} |
q19087 | NewSetCustomObjectFormatterEnabledArgs | train | func NewSetCustomObjectFormatterEnabledArgs(enabled bool) *SetCustomObjectFormatterEnabledArgs {
args := new(SetCustomObjectFormatterEnabledArgs)
args.Enabled = enabled
return args
} | go | {
"resource": ""
} |
q19088 | NewSetMaxCallStackSizeToCaptureArgs | train | func NewSetMaxCallStackSizeToCaptureArgs(size int) *SetMaxCallStackSizeToCaptureArgs {
args := new(SetMaxCallStackSizeToCaptureArgs)
args.Size = size
return args
} | go | {
"resource": ""
} |
q19089 | NewAddBindingArgs | train | func NewAddBindingArgs(name string) *AddBindingArgs {
args := new(AddBindingArgs)
args.Name = name
return args
} | go | {
"resource": ""
} |
q19090 | SetExecutionContextID | train | func (a *AddBindingArgs) SetExecutionContextID(executionContextID ExecutionContextID) *AddBindingArgs {
a.ExecutionContextID = &executionContextID
return a
} | go | {
"resource": ""
} |
q19091 | NewRemoveBindingArgs | train | func NewRemoveBindingArgs(name string) *RemoveBindingArgs {
args := new(RemoveBindingArgs)
args.Name = name
return args
} | go | {
"resource": ""
} |
q19092 | NewStartViolationsReportArgs | train | func NewStartViolationsReportArgs(config []ViolationSetting) *StartViolationsReportArgs {
args := new(StartViolationsReportArgs)
args.Config = config
return args
} | go | {
"resource": ""
} |
q19093 | GetDOMStorageItems | train | func (d *domainClient) GetDOMStorageItems(ctx context.Context, args *GetDOMStorageItemsArgs) (reply *GetDOMStorageItemsReply, err error) {
reply = new(GetDOMStorageItemsReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOMStorage.getDOMStorageItems", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOMStorage.getDOMStorageItems", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOMStorage", Op: "GetDOMStorageItems", Err: err}
}
return
} | go | {
"resource": ""
} |
q19094 | Map | train | func (n Headers) Map() (map[string]string, error) {
m := make(map[string]string)
err := json.Unmarshal(n, &m)
return m, err
} | go | {
"resource": ""
} |
q19095 | WriteRequest | train | func (s *session) WriteRequest(r *rpcc.Request) error {
data, err := json.Marshal(r)
if err != nil {
return err
}
return s.send(data)
} | go | {
"resource": ""
} |
q19096 | ReadResponse | train | func (s *session) ReadResponse(r *rpcc.Response) error {
<-s.init
select {
case m := <-s.recvC:
return json.Unmarshal(m, r)
case <-s.conn.Context().Done():
return s.conn.Context().Err()
}
} | go | {
"resource": ""
} |
q19097 | Write | train | func (s *session) Write(data []byte) error {
select {
case s.recvC <- data:
return nil
case <-s.conn.Context().Done():
return s.conn.Context().Err()
}
} | go | {
"resource": ""
} |
q19098 | SetNoDisplayUpdates | train | func (a *BeginFrameArgs) SetNoDisplayUpdates(noDisplayUpdates bool) *BeginFrameArgs {
a.NoDisplayUpdates = &noDisplayUpdates
return a
} | go | {
"resource": ""
} |
q19099 | SetScreenshot | train | func (a *BeginFrameArgs) SetScreenshot(screenshot ScreenshotParams) *BeginFrameArgs {
a.Screenshot = &screenshot
return a
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.