_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q18800 | NewSearchInContentArgs | train | func NewSearchInContentArgs(scriptID runtime.ScriptID, query string) *SearchInContentArgs {
args := new(SearchInContentArgs)
args.ScriptID = scriptID
args.Query = query
return args
} | go | {
"resource": ""
} |
q18801 | NewSetAsyncCallStackDepthArgs | train | func NewSetAsyncCallStackDepthArgs(maxDepth int) *SetAsyncCallStackDepthArgs {
args := new(SetAsyncCallStackDepthArgs)
args.MaxDepth = maxDepth
return args
} | go | {
"resource": ""
} |
q18802 | NewSetBlackboxPatternsArgs | train | func NewSetBlackboxPatternsArgs(patterns []string) *SetBlackboxPatternsArgs {
args := new(SetBlackboxPatternsArgs)
args.Patterns = patterns
return args
} | go | {
"resource": ""
} |
q18803 | NewSetBlackboxedRangesArgs | train | func NewSetBlackboxedRangesArgs(scriptID runtime.ScriptID, positions []ScriptPosition) *SetBlackboxedRangesArgs {
args := new(SetBlackboxedRangesArgs)
args.ScriptID = scriptID
args.Positions = positions
return args
} | go | {
"resource": ""
} |
q18804 | NewSetBreakpointArgs | train | func NewSetBreakpointArgs(location Location) *SetBreakpointArgs {
args := new(SetBreakpointArgs)
args.Location = location
return args
} | go | {
"resource": ""
} |
q18805 | NewSetBreakpointByURLArgs | train | func NewSetBreakpointByURLArgs(lineNumber int) *SetBreakpointByURLArgs {
args := new(SetBreakpointByURLArgs)
args.LineNumber = lineNumber
return args
} | go | {
"resource": ""
} |
q18806 | SetURL | train | func (a *SetBreakpointByURLArgs) SetURL(url string) *SetBreakpointByURLArgs {
a.URL = &url
return a
} | go | {
"resource": ""
} |
q18807 | SetURLRegex | train | func (a *SetBreakpointByURLArgs) SetURLRegex(urlRegex string) *SetBreakpointByURLArgs {
a.URLRegex = &urlRegex
return a
} | go | {
"resource": ""
} |
q18808 | SetScriptHash | train | func (a *SetBreakpointByURLArgs) SetScriptHash(scriptHash string) *SetBreakpointByURLArgs {
a.ScriptHash = &scriptHash
return a
} | go | {
"resource": ""
} |
q18809 | SetColumnNumber | train | func (a *SetBreakpointByURLArgs) SetColumnNumber(columnNumber int) *SetBreakpointByURLArgs {
a.ColumnNumber = &columnNumber
return a
} | go | {
"resource": ""
} |
q18810 | NewSetBreakpointOnFunctionCallArgs | train | func NewSetBreakpointOnFunctionCallArgs(objectID runtime.RemoteObjectID) *SetBreakpointOnFunctionCallArgs {
args := new(SetBreakpointOnFunctionCallArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q18811 | SetCondition | train | func (a *SetBreakpointOnFunctionCallArgs) SetCondition(condition string) *SetBreakpointOnFunctionCallArgs {
a.Condition = &condition
return a
} | go | {
"resource": ""
} |
q18812 | NewSetBreakpointsActiveArgs | train | func NewSetBreakpointsActiveArgs(active bool) *SetBreakpointsActiveArgs {
args := new(SetBreakpointsActiveArgs)
args.Active = active
return args
} | go | {
"resource": ""
} |
q18813 | NewSetPauseOnExceptionsArgs | train | func NewSetPauseOnExceptionsArgs(state string) *SetPauseOnExceptionsArgs {
args := new(SetPauseOnExceptionsArgs)
args.State = state
return args
} | go | {
"resource": ""
} |
q18814 | NewSetReturnValueArgs | train | func NewSetReturnValueArgs(newValue runtime.CallArgument) *SetReturnValueArgs {
args := new(SetReturnValueArgs)
args.NewValue = newValue
return args
} | go | {
"resource": ""
} |
q18815 | NewSetScriptSourceArgs | train | func NewSetScriptSourceArgs(scriptID runtime.ScriptID, scriptSource string) *SetScriptSourceArgs {
args := new(SetScriptSourceArgs)
args.ScriptID = scriptID
args.ScriptSource = scriptSource
return args
} | go | {
"resource": ""
} |
q18816 | SetDryRun | train | func (a *SetScriptSourceArgs) SetDryRun(dryRun bool) *SetScriptSourceArgs {
a.DryRun = &dryRun
return a
} | go | {
"resource": ""
} |
q18817 | NewSetSkipAllPausesArgs | train | func NewSetSkipAllPausesArgs(skip bool) *SetSkipAllPausesArgs {
args := new(SetSkipAllPausesArgs)
args.Skip = skip
return args
} | go | {
"resource": ""
} |
q18818 | NewSetVariableValueArgs | train | func NewSetVariableValueArgs(scopeNumber int, variableName string, newValue runtime.CallArgument, callFrameID CallFrameID) *SetVariableValueArgs {
args := new(SetVariableValueArgs)
args.ScopeNumber = scopeNumber
args.VariableName = variableName
args.NewValue = newValue
args.CallFrameID = callFrameID
return args
} | go | {
"resource": ""
} |
q18819 | NewGetSnapshotArgs | train | func NewGetSnapshotArgs(computedStyleWhitelist []string) *GetSnapshotArgs {
args := new(GetSnapshotArgs)
args.ComputedStyleWhitelist = computedStyleWhitelist
return args
} | go | {
"resource": ""
} |
q18820 | NewCaptureSnapshotArgs | train | func NewCaptureSnapshotArgs(computedStyles []string) *CaptureSnapshotArgs {
args := new(CaptureSnapshotArgs)
args.ComputedStyles = computedStyles
return args
} | go | {
"resource": ""
} |
q18821 | NewGetEncodedResponseArgs | train | func NewGetEncodedResponseArgs(requestID network.RequestID, encoding string) *GetEncodedResponseArgs {
args := new(GetEncodedResponseArgs)
args.RequestID = requestID
args.Encoding = encoding
return args
} | go | {
"resource": ""
} |
q18822 | RequestCacheNames | train | func (d *domainClient) RequestCacheNames(ctx context.Context, args *RequestCacheNamesArgs) (reply *RequestCacheNamesReply, err error) {
reply = new(RequestCacheNamesReply)
if args != nil {
err = rpcc.Invoke(ctx, "CacheStorage.requestCacheNames", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "CacheStorage.requestCacheNames", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "CacheStorage", Op: "RequestCacheNames", Err: err}
}
return
} | go | {
"resource": ""
} |
q18823 | RequestCachedResponse | train | func (d *domainClient) RequestCachedResponse(ctx context.Context, args *RequestCachedResponseArgs) (reply *RequestCachedResponseReply, err error) {
reply = new(RequestCachedResponseReply)
if args != nil {
err = rpcc.Invoke(ctx, "CacheStorage.requestCachedResponse", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "CacheStorage.requestCachedResponse", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "CacheStorage", Op: "RequestCachedResponse", Err: err}
}
return
} | go | {
"resource": ""
} |
q18824 | RequestEntries | train | func (d *domainClient) RequestEntries(ctx context.Context, args *RequestEntriesArgs) (reply *RequestEntriesReply, err error) {
reply = new(RequestEntriesReply)
if args != nil {
err = rpcc.Invoke(ctx, "CacheStorage.requestEntries", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "CacheStorage.requestEntries", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "CacheStorage", Op: "RequestEntries", Err: err}
}
return
} | go | {
"resource": ""
} |
q18825 | NewRecordClockSyncMarkerArgs | train | func NewRecordClockSyncMarkerArgs(syncID string) *RecordClockSyncMarkerArgs {
args := new(RecordClockSyncMarkerArgs)
args.SyncID = syncID
return args
} | go | {
"resource": ""
} |
q18826 | SetBufferUsageReportingInterval | train | func (a *StartArgs) SetBufferUsageReportingInterval(bufferUsageReportingInterval float64) *StartArgs {
a.BufferUsageReportingInterval = &bufferUsageReportingInterval
return a
} | go | {
"resource": ""
} |
q18827 | SetTraceConfig | train | func (a *StartArgs) SetTraceConfig(traceConfig TraceConfig) *StartArgs {
a.TraceConfig = &traceConfig
return a
} | go | {
"resource": ""
} |
q18828 | RequestData | train | func (d *domainClient) RequestData(ctx context.Context, args *RequestDataArgs) (reply *RequestDataReply, err error) {
reply = new(RequestDataReply)
if args != nil {
err = rpcc.Invoke(ctx, "IndexedDB.requestData", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IndexedDB.requestData", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IndexedDB", Op: "RequestData", Err: err}
}
return
} | go | {
"resource": ""
} |
q18829 | GetMetadata | train | func (d *domainClient) GetMetadata(ctx context.Context, args *GetMetadataArgs) (reply *GetMetadataReply, err error) {
reply = new(GetMetadataReply)
if args != nil {
err = rpcc.Invoke(ctx, "IndexedDB.getMetadata", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IndexedDB.getMetadata", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IndexedDB", Op: "GetMetadata", Err: err}
}
return
} | go | {
"resource": ""
} |
q18830 | RequestDatabase | train | func (d *domainClient) RequestDatabase(ctx context.Context, args *RequestDatabaseArgs) (reply *RequestDatabaseReply, err error) {
reply = new(RequestDatabaseReply)
if args != nil {
err = rpcc.Invoke(ctx, "IndexedDB.requestDatabase", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IndexedDB.requestDatabase", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IndexedDB", Op: "RequestDatabase", Err: err}
}
return
} | go | {
"resource": ""
} |
q18831 | RequestDatabaseNames | train | func (d *domainClient) RequestDatabaseNames(ctx context.Context, args *RequestDatabaseNamesArgs) (reply *RequestDatabaseNamesReply, err error) {
reply = new(RequestDatabaseNamesReply)
if args != nil {
err = rpcc.Invoke(ctx, "IndexedDB.requestDatabaseNames", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IndexedDB.requestDatabaseNames", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IndexedDB", Op: "RequestDatabaseNames", Err: err}
}
return
} | go | {
"resource": ""
} |
q18832 | Printf | train | func (g *Generator) Printf(format string, args ...interface{}) {
fmt.Fprintf(&g.buf, format, args...)
} | go | {
"resource": ""
} |
q18833 | CdpClient | train | func (g *Generator) CdpClient(domains []proto.Domain) {
g.hasContent = true
var fields, newFields Generator
for _, d := range domains {
fields.Printf("\t%s %s\n", d.Name(), d.Type())
newFields.Printf("\t\t%s: %s.NewClient(conn),\n", d.Name(), strings.ToLower(d.Name()))
}
g.Printf(`
// Client represents a Chrome DevTools Protocol client that can be used to
// invoke methods or listen to events in every CDP domain. The Client consumes
// a rpcc connection, used to invoke the methods.
type Client struct {
%s
}
// NewClient returns a new Client that uses conn
// for communication with the debugging target.
func NewClient(conn *rpcc.Conn) *Client {
return &Client{
%s
}
}
`, fields.buf.Bytes(), newFields.buf.Bytes())
} | go | {
"resource": ""
} |
q18834 | PackageHeader | train | func (g *Generator) PackageHeader(comment string) {
if g.hasHeader {
return
}
g.hasHeader = true
g.Printf(`// Code generated by cdpgen. DO NOT EDIT.
%s
package %s
import (
"context"
"encoding/json"
"fmt"
%s
)
`, comment, g.pkg, quotedImports(g.imports))
} | go | {
"resource": ""
} |
q18835 | DomainInterface | train | func (g *Generator) DomainInterface(d proto.Domain) {
g.hasContent = true
comment := "The " + d.Name() + " domain. "
desc := d.Desc(0, len(comment))
if d.Deprecated {
desc = "\n//\n// Deprecated: " + desc
}
if d.Experimental {
desc += "\n//\n// Note: This domain is experimental."
}
g.Printf(`
// %[1]s%[2]s
type %[3]s interface{`, comment, desc, d.Name())
for _, c := range d.Commands {
if c.Redirect != "" {
continue
}
request := ""
reply := "error"
if len(c.Parameters) > 0 {
request = ", *" + strings.ToLower(d.Name()) + "." + c.ArgsName(d)
}
if len(c.Returns) > 0 {
reply = fmt.Sprintf("(*%s.%s, error)", strings.ToLower(d.Name()), c.ReplyName(d))
}
desc := c.Desc(true, 8, 0)
if c.Deprecated {
desc = strings.Replace(c.Desc(true, 8, 12), "Deprecated, ", "", 1)
desc = "Deprecated: " + strings.ToUpper(desc[0:1]) + desc[1:]
}
if desc != "" {
desc = "\n\t//\n\t// " + desc
}
if c.Experimental {
desc += "\n\t//\n\t// Note: This command is experimental."
}
g.Printf("\n\t// Command %s%s\n\t%s(context.Context%s) %s\n", c.Name(), desc, c.Name(), request, reply)
}
for _, e := range d.Events {
eventClient := fmt.Sprintf("%sClient", e.EventName(d))
desc := e.Desc(true, 8, 0)
if e.Deprecated {
desc = strings.Replace(e.Desc(true, 8, 12), "Deprecated, ", "", 1)
desc = "Deprecated: " + strings.ToUpper(desc[0:1]) + desc[1:]
}
if desc != "" {
desc = "\n\t//\n\t// " + desc
}
if e.Experimental {
desc += "\n//\n// Note: This event is experimental."
}
g.Printf("\n\t// Event %s%s\n\t%s(context.Context) (%s.%s, error)\n", e.Name(), desc, e.Name(), strings.ToLower(d.Name()), eventClient)
}
g.Printf("}\n")
} | go | {
"resource": ""
} |
q18836 | DomainType | train | func (g *Generator) DomainType(d proto.Domain, t proto.AnyType) {
g.hasContent = true
var comment string
if d.Name() == "Page" && (t.Name(d) == "FrameID") {
comment = "//"
g.Printf(`
// %[1]s %[2]s
//
// Provided as an alias to prevent circular dependencies.
type %[1]s = internal.Page%[1]s
`, t.Name(d), t.Desc(0, len(t.Name(d))+1))
}
desc := t.Desc(0, len(t.Name(d))+1)
if t.Deprecated {
desc = "\n//\n// Deprecated: " + t.Desc(0, 12)
}
if t.Experimental {
desc = desc + "\n//\n// Note: This type is experimental."
}
g.Printf(`
// %[1]s %[2]s
%[3]stype %[1]s `, t.Name(d), desc, comment)
typ := t.GoType(g.pkg, d)
switch typ {
case "struct":
g.domainTypeStruct(d, t)
case "enum":
g.domainTypeEnum(d, t)
case "time.Time":
g.domainTypeTime(d, t)
case "RawMessage":
g.domainTypeRawMessage(d, t)
default:
g.Printf(typ)
}
g.Printf("\n\n")
} | go | {
"resource": ""
} |
q18837 | CmdType | train | func (g *Generator) CmdType(doms []proto.Domain) {
g.hasContent = true
g.Printf(`
// CmdType is the type for CDP methods names.
type CmdType string
func (c CmdType) String() string {
return string(c)
}
// Cmd methods.
const (`)
for _, d := range doms {
for _, c := range d.Commands {
g.Printf("\n\t%s CmdType = %q", c.CmdName(d, true), d.Domain+"."+c.NameName)
}
}
g.Printf("\n)\n")
} | go | {
"resource": ""
} |
q18838 | DomainCmd | train | func (g *Generator) DomainCmd(d proto.Domain, c proto.Command) {
if len(c.Parameters) > 0 {
g.hasContent = true
g.domainCmdArgs(d, c)
}
if len(c.Returns) > 0 {
g.hasContent = true
g.domainCmdReply(d, c)
}
} | go | {
"resource": ""
} |
q18839 | EventType | train | func (g *Generator) EventType(doms []proto.Domain) {
g.hasContent = true
g.Printf(`
// EventType is the type for CDP event names.
type EventType string
func (e EventType) String() string {
return string(e)
}
// Event methods.
const (`)
for _, d := range doms {
for _, e := range d.Events {
g.Printf("\n\t%s EventType = %q", e.EventName(d), d.Domain+"."+e.NameName)
}
}
g.Printf("\n)\n")
} | go | {
"resource": ""
} |
q18840 | DomainEvent | train | func (g *Generator) DomainEvent(d proto.Domain, e proto.Event) {
g.hasContent = true
g.domainEventClient(d, e)
g.domainEventReply(d, e)
} | go | {
"resource": ""
} |
q18841 | CompositingReasons | train | func (d *domainClient) CompositingReasons(ctx context.Context, args *CompositingReasonsArgs) (reply *CompositingReasonsReply, err error) {
reply = new(CompositingReasonsReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.compositingReasons", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.compositingReasons", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "CompositingReasons", Err: err}
}
return
} | go | {
"resource": ""
} |
q18842 | LoadSnapshot | train | func (d *domainClient) LoadSnapshot(ctx context.Context, args *LoadSnapshotArgs) (reply *LoadSnapshotReply, err error) {
reply = new(LoadSnapshotReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.loadSnapshot", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.loadSnapshot", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "LoadSnapshot", Err: err}
}
return
} | go | {
"resource": ""
} |
q18843 | MakeSnapshot | train | func (d *domainClient) MakeSnapshot(ctx context.Context, args *MakeSnapshotArgs) (reply *MakeSnapshotReply, err error) {
reply = new(MakeSnapshotReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.makeSnapshot", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.makeSnapshot", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "MakeSnapshot", Err: err}
}
return
} | go | {
"resource": ""
} |
q18844 | ProfileSnapshot | train | func (d *domainClient) ProfileSnapshot(ctx context.Context, args *ProfileSnapshotArgs) (reply *ProfileSnapshotReply, err error) {
reply = new(ProfileSnapshotReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.profileSnapshot", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.profileSnapshot", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "ProfileSnapshot", Err: err}
}
return
} | go | {
"resource": ""
} |
q18845 | ReplaySnapshot | train | func (d *domainClient) ReplaySnapshot(ctx context.Context, args *ReplaySnapshotArgs) (reply *ReplaySnapshotReply, err error) {
reply = new(ReplaySnapshotReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.replaySnapshot", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.replaySnapshot", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "ReplaySnapshot", Err: err}
}
return
} | go | {
"resource": ""
} |
q18846 | SnapshotCommandLog | train | func (d *domainClient) SnapshotCommandLog(ctx context.Context, args *SnapshotCommandLogArgs) (reply *SnapshotCommandLogReply, err error) {
reply = new(SnapshotCommandLogReply)
if args != nil {
err = rpcc.Invoke(ctx, "LayerTree.snapshotCommandLog", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "LayerTree.snapshotCommandLog", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "LayerTree", Op: "SnapshotCommandLog", Err: err}
}
return
} | go | {
"resource": ""
} |
q18847 | NewGetApplicationCacheForFrameArgs | train | func NewGetApplicationCacheForFrameArgs(frameID page.FrameID) *GetApplicationCacheForFrameArgs {
args := new(GetApplicationCacheForFrameArgs)
args.FrameID = frameID
return args
} | go | {
"resource": ""
} |
q18848 | NewGetManifestForFrameArgs | train | func NewGetManifestForFrameArgs(frameID page.FrameID) *GetManifestForFrameArgs {
args := new(GetManifestForFrameArgs)
args.FrameID = frameID
return args
} | go | {
"resource": ""
} |
q18849 | CollectClassNamesFromSubtree | train | func (d *domainClient) CollectClassNamesFromSubtree(ctx context.Context, args *CollectClassNamesFromSubtreeArgs) (reply *CollectClassNamesFromSubtreeReply, err error) {
reply = new(CollectClassNamesFromSubtreeReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.collectClassNamesFromSubtree", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.collectClassNamesFromSubtree", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "CollectClassNamesFromSubtree", Err: err}
}
return
} | go | {
"resource": ""
} |
q18850 | CopyTo | train | func (d *domainClient) CopyTo(ctx context.Context, args *CopyToArgs) (reply *CopyToReply, err error) {
reply = new(CopyToReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.copyTo", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.copyTo", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "CopyTo", Err: err}
}
return
} | go | {
"resource": ""
} |
q18851 | DescribeNode | train | func (d *domainClient) DescribeNode(ctx context.Context, args *DescribeNodeArgs) (reply *DescribeNodeReply, err error) {
reply = new(DescribeNodeReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.describeNode", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.describeNode", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "DescribeNode", Err: err}
}
return
} | go | {
"resource": ""
} |
q18852 | GetAttributes | train | func (d *domainClient) GetAttributes(ctx context.Context, args *GetAttributesArgs) (reply *GetAttributesReply, err error) {
reply = new(GetAttributesReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getAttributes", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getAttributes", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetAttributes", Err: err}
}
return
} | go | {
"resource": ""
} |
q18853 | GetBoxModel | train | func (d *domainClient) GetBoxModel(ctx context.Context, args *GetBoxModelArgs) (reply *GetBoxModelReply, err error) {
reply = new(GetBoxModelReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getBoxModel", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getBoxModel", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetBoxModel", Err: err}
}
return
} | go | {
"resource": ""
} |
q18854 | GetContentQuads | train | func (d *domainClient) GetContentQuads(ctx context.Context, args *GetContentQuadsArgs) (reply *GetContentQuadsReply, err error) {
reply = new(GetContentQuadsReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getContentQuads", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getContentQuads", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetContentQuads", Err: err}
}
return
} | go | {
"resource": ""
} |
q18855 | GetNodeForLocation | train | func (d *domainClient) GetNodeForLocation(ctx context.Context, args *GetNodeForLocationArgs) (reply *GetNodeForLocationReply, err error) {
reply = new(GetNodeForLocationReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getNodeForLocation", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getNodeForLocation", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetNodeForLocation", Err: err}
}
return
} | go | {
"resource": ""
} |
q18856 | GetOuterHTML | train | func (d *domainClient) GetOuterHTML(ctx context.Context, args *GetOuterHTMLArgs) (reply *GetOuterHTMLReply, err error) {
reply = new(GetOuterHTMLReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getOuterHTML", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getOuterHTML", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetOuterHTML", Err: err}
}
return
} | go | {
"resource": ""
} |
q18857 | GetRelayoutBoundary | train | func (d *domainClient) GetRelayoutBoundary(ctx context.Context, args *GetRelayoutBoundaryArgs) (reply *GetRelayoutBoundaryReply, err error) {
reply = new(GetRelayoutBoundaryReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getRelayoutBoundary", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getRelayoutBoundary", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetRelayoutBoundary", Err: err}
}
return
} | go | {
"resource": ""
} |
q18858 | GetSearchResults | train | func (d *domainClient) GetSearchResults(ctx context.Context, args *GetSearchResultsArgs) (reply *GetSearchResultsReply, err error) {
reply = new(GetSearchResultsReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getSearchResults", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getSearchResults", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetSearchResults", Err: err}
}
return
} | go | {
"resource": ""
} |
q18859 | MoveTo | train | func (d *domainClient) MoveTo(ctx context.Context, args *MoveToArgs) (reply *MoveToReply, err error) {
reply = new(MoveToReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.moveTo", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.moveTo", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "MoveTo", Err: err}
}
return
} | go | {
"resource": ""
} |
q18860 | PerformSearch | train | func (d *domainClient) PerformSearch(ctx context.Context, args *PerformSearchArgs) (reply *PerformSearchReply, err error) {
reply = new(PerformSearchReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.performSearch", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.performSearch", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "PerformSearch", Err: err}
}
return
} | go | {
"resource": ""
} |
q18861 | PushNodesByBackendIDsToFrontend | train | func (d *domainClient) PushNodesByBackendIDsToFrontend(ctx context.Context, args *PushNodesByBackendIDsToFrontendArgs) (reply *PushNodesByBackendIDsToFrontendReply, err error) {
reply = new(PushNodesByBackendIDsToFrontendReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.pushNodesByBackendIdsToFrontend", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.pushNodesByBackendIdsToFrontend", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "PushNodesByBackendIDsToFrontend", Err: err}
}
return
} | go | {
"resource": ""
} |
q18862 | QuerySelector | train | func (d *domainClient) QuerySelector(ctx context.Context, args *QuerySelectorArgs) (reply *QuerySelectorReply, err error) {
reply = new(QuerySelectorReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.querySelector", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.querySelector", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "QuerySelector", Err: err}
}
return
} | go | {
"resource": ""
} |
q18863 | QuerySelectorAll | train | func (d *domainClient) QuerySelectorAll(ctx context.Context, args *QuerySelectorAllArgs) (reply *QuerySelectorAllReply, err error) {
reply = new(QuerySelectorAllReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.querySelectorAll", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.querySelectorAll", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "QuerySelectorAll", Err: err}
}
return
} | go | {
"resource": ""
} |
q18864 | RequestNode | train | func (d *domainClient) RequestNode(ctx context.Context, args *RequestNodeArgs) (reply *RequestNodeReply, err error) {
reply = new(RequestNodeReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.requestNode", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.requestNode", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "RequestNode", Err: err}
}
return
} | go | {
"resource": ""
} |
q18865 | ResolveNode | train | func (d *domainClient) ResolveNode(ctx context.Context, args *ResolveNodeArgs) (reply *ResolveNodeReply, err error) {
reply = new(ResolveNodeReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.resolveNode", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.resolveNode", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "ResolveNode", Err: err}
}
return
} | go | {
"resource": ""
} |
q18866 | GetFileInfo | train | func (d *domainClient) GetFileInfo(ctx context.Context, args *GetFileInfoArgs) (reply *GetFileInfoReply, err error) {
reply = new(GetFileInfoReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getFileInfo", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getFileInfo", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetFileInfo", Err: err}
}
return
} | go | {
"resource": ""
} |
q18867 | SetNodeName | train | func (d *domainClient) SetNodeName(ctx context.Context, args *SetNodeNameArgs) (reply *SetNodeNameReply, err error) {
reply = new(SetNodeNameReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.setNodeName", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.setNodeName", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "SetNodeName", Err: err}
}
return
} | go | {
"resource": ""
} |
q18868 | GetFrameOwner | train | func (d *domainClient) GetFrameOwner(ctx context.Context, args *GetFrameOwnerArgs) (reply *GetFrameOwnerReply, err error) {
reply = new(GetFrameOwnerReply)
if args != nil {
err = rpcc.Invoke(ctx, "DOM.getFrameOwner", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "DOM.getFrameOwner", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOM", Op: "GetFrameOwner", Err: err}
}
return
} | go | {
"resource": ""
} |
q18869 | Read | train | func (cw *wsReadWriteCloser) Read(p []byte) (n int, err error) {
if cw.r != nil {
// Check if previous reader still has data in the buffer.
// Otherwise pass on to next reader.
n, err = cw.r.Read(p)
if err != io.EOF {
return n, err
}
}
_, r, err := cw.wsConn.NextReader()
if err != nil {
return 0, err
}
cw.r = r // Store reader for next call to Read.
n, err = r.Read(p)
return n, err
} | go | {
"resource": ""
} |
q18870 | Write | train | func (cw *wsReadWriteCloser) Write(p []byte) (n int, err error) {
w, err := cw.wsConn.NextWriter(websocket.TextMessage)
if err != nil {
return 0, err
}
if n, err = w.Write(p); err != nil {
return n, err
}
err = w.Close()
return n, err
} | go | {
"resource": ""
} |
q18871 | Errorf | train | func Errorf(format string, a ...interface{}) error {
return New(fmt.Sprintf(format, a...))
} | go | {
"resource": ""
} |
q18872 | Wrapf | train | func Wrapf(err error, format string, a ...interface{}) error {
if err == nil {
return nil
}
return &wrapped{
err: err,
msg: fmt.Sprintf(format, a...),
}
} | go | {
"resource": ""
} |
q18873 | Merge | train | func Merge(err ...error) error {
var errs []error
for _, e := range err {
if e != nil {
errs = append(errs, e)
}
}
if len(errs) == 0 {
return nil
}
return &merged{s: err}
} | go | {
"resource": ""
} |
q18874 | NewCollectClassNamesFromSubtreeArgs | train | func NewCollectClassNamesFromSubtreeArgs(nodeID NodeID) *CollectClassNamesFromSubtreeArgs {
args := new(CollectClassNamesFromSubtreeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q18875 | NewCopyToArgs | train | func NewCopyToArgs(nodeID NodeID, targetNodeID NodeID) *CopyToArgs {
args := new(CopyToArgs)
args.NodeID = nodeID
args.TargetNodeID = targetNodeID
return args
} | go | {
"resource": ""
} |
q18876 | NewDiscardSearchResultsArgs | train | func NewDiscardSearchResultsArgs(searchID string) *DiscardSearchResultsArgs {
args := new(DiscardSearchResultsArgs)
args.SearchID = searchID
return args
} | go | {
"resource": ""
} |
q18877 | NewGetAttributesArgs | train | func NewGetAttributesArgs(nodeID NodeID) *GetAttributesArgs {
args := new(GetAttributesArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q18878 | NewGetNodeForLocationArgs | train | func NewGetNodeForLocationArgs(x int, y int) *GetNodeForLocationArgs {
args := new(GetNodeForLocationArgs)
args.X = x
args.Y = y
return args
} | go | {
"resource": ""
} |
q18879 | NewGetRelayoutBoundaryArgs | train | func NewGetRelayoutBoundaryArgs(nodeID NodeID) *GetRelayoutBoundaryArgs {
args := new(GetRelayoutBoundaryArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q18880 | NewGetSearchResultsArgs | train | func NewGetSearchResultsArgs(searchID string, fromIndex int, toIndex int) *GetSearchResultsArgs {
args := new(GetSearchResultsArgs)
args.SearchID = searchID
args.FromIndex = fromIndex
args.ToIndex = toIndex
return args
} | go | {
"resource": ""
} |
q18881 | NewMoveToArgs | train | func NewMoveToArgs(nodeID NodeID, targetNodeID NodeID) *MoveToArgs {
args := new(MoveToArgs)
args.NodeID = nodeID
args.TargetNodeID = targetNodeID
return args
} | go | {
"resource": ""
} |
q18882 | NewPerformSearchArgs | train | func NewPerformSearchArgs(query string) *PerformSearchArgs {
args := new(PerformSearchArgs)
args.Query = query
return args
} | go | {
"resource": ""
} |
q18883 | SetIncludeUserAgentShadowDOM | train | func (a *PerformSearchArgs) SetIncludeUserAgentShadowDOM(includeUserAgentShadowDOM bool) *PerformSearchArgs {
a.IncludeUserAgentShadowDOM = &includeUserAgentShadowDOM
return a
} | go | {
"resource": ""
} |
q18884 | NewPushNodeByPathToFrontendArgs | train | func NewPushNodeByPathToFrontendArgs(path string) *PushNodeByPathToFrontendArgs {
args := new(PushNodeByPathToFrontendArgs)
args.Path = path
return args
} | go | {
"resource": ""
} |
q18885 | NewPushNodesByBackendIDsToFrontendArgs | train | func NewPushNodesByBackendIDsToFrontendArgs(backendNodeIDs []BackendNodeID) *PushNodesByBackendIDsToFrontendArgs {
args := new(PushNodesByBackendIDsToFrontendArgs)
args.BackendNodeIDs = backendNodeIDs
return args
} | go | {
"resource": ""
} |
q18886 | NewQuerySelectorArgs | train | func NewQuerySelectorArgs(nodeID NodeID, selector string) *QuerySelectorArgs {
args := new(QuerySelectorArgs)
args.NodeID = nodeID
args.Selector = selector
return args
} | go | {
"resource": ""
} |
q18887 | NewQuerySelectorAllArgs | train | func NewQuerySelectorAllArgs(nodeID NodeID, selector string) *QuerySelectorAllArgs {
args := new(QuerySelectorAllArgs)
args.NodeID = nodeID
args.Selector = selector
return args
} | go | {
"resource": ""
} |
q18888 | NewRemoveAttributeArgs | train | func NewRemoveAttributeArgs(nodeID NodeID, name string) *RemoveAttributeArgs {
args := new(RemoveAttributeArgs)
args.NodeID = nodeID
args.Name = name
return args
} | go | {
"resource": ""
} |
q18889 | NewRemoveNodeArgs | train | func NewRemoveNodeArgs(nodeID NodeID) *RemoveNodeArgs {
args := new(RemoveNodeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q18890 | NewRequestChildNodesArgs | train | func NewRequestChildNodesArgs(nodeID NodeID) *RequestChildNodesArgs {
args := new(RequestChildNodesArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q18891 | NewRequestNodeArgs | train | func NewRequestNodeArgs(objectID runtime.RemoteObjectID) *RequestNodeArgs {
args := new(RequestNodeArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q18892 | SetNodeID | train | func (a *ResolveNodeArgs) SetNodeID(nodeID NodeID) *ResolveNodeArgs {
a.NodeID = &nodeID
return a
} | go | {
"resource": ""
} |
q18893 | SetBackendNodeID | train | func (a *ResolveNodeArgs) SetBackendNodeID(backendNodeID BackendNodeID) *ResolveNodeArgs {
a.BackendNodeID = &backendNodeID
return a
} | go | {
"resource": ""
} |
q18894 | SetExecutionContextID | train | func (a *ResolveNodeArgs) SetExecutionContextID(executionContextID runtime.ExecutionContextID) *ResolveNodeArgs {
a.ExecutionContextID = &executionContextID
return a
} | go | {
"resource": ""
} |
q18895 | NewSetAttributeValueArgs | train | func NewSetAttributeValueArgs(nodeID NodeID, name string, value string) *SetAttributeValueArgs {
args := new(SetAttributeValueArgs)
args.NodeID = nodeID
args.Name = name
args.Value = value
return args
} | go | {
"resource": ""
} |
q18896 | NewSetAttributesAsTextArgs | train | func NewSetAttributesAsTextArgs(nodeID NodeID, text string) *SetAttributesAsTextArgs {
args := new(SetAttributesAsTextArgs)
args.NodeID = nodeID
args.Text = text
return args
} | go | {
"resource": ""
} |
q18897 | SetName | train | func (a *SetAttributesAsTextArgs) SetName(name string) *SetAttributesAsTextArgs {
a.Name = &name
return a
} | go | {
"resource": ""
} |
q18898 | NewSetFileInputFilesArgs | train | func NewSetFileInputFilesArgs(files []string) *SetFileInputFilesArgs {
args := new(SetFileInputFilesArgs)
args.Files = files
return args
} | go | {
"resource": ""
} |
q18899 | NewGetFileInfoArgs | train | func NewGetFileInfoArgs(objectID runtime.RemoteObjectID) *GetFileInfoArgs {
args := new(GetFileInfoArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.