_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q19200 | NewSynthesizePinchGestureArgs | train | func NewSynthesizePinchGestureArgs(x float64, y float64, scaleFactor float64) *SynthesizePinchGestureArgs {
args := new(SynthesizePinchGestureArgs)
args.X = x
args.Y = y
args.ScaleFactor = scaleFactor
return args
} | go | {
"resource": ""
} |
q19201 | NewSynthesizeScrollGestureArgs | train | func NewSynthesizeScrollGestureArgs(x float64, y float64) *SynthesizeScrollGestureArgs {
args := new(SynthesizeScrollGestureArgs)
args.X = x
args.Y = y
return args
} | go | {
"resource": ""
} |
q19202 | SetXOverscroll | train | func (a *SynthesizeScrollGestureArgs) SetXOverscroll(xOverscroll float64) *SynthesizeScrollGestureArgs {
a.XOverscroll = &xOverscroll
return a
} | go | {
"resource": ""
} |
q19203 | SetYOverscroll | train | func (a *SynthesizeScrollGestureArgs) SetYOverscroll(yOverscroll float64) *SynthesizeScrollGestureArgs {
a.YOverscroll = &yOverscroll
return a
} | go | {
"resource": ""
} |
q19204 | NewSynthesizeTapGestureArgs | train | func NewSynthesizeTapGestureArgs(x float64, y float64) *SynthesizeTapGestureArgs {
args := new(SynthesizeTapGestureArgs)
args.X = x
args.Y = y
return args
} | go | {
"resource": ""
} |
q19205 | Desc | train | func (d Domain) Desc(indent, startOffset int) string {
return cleanDescription(d.Description, indent, startOffset)
} | go | {
"resource": ""
} |
q19206 | Name | train | func (c Command) Name() string {
return lint.Name(strings.Title(c.NameName))
} | go | {
"resource": ""
} |
q19207 | Desc | train | func (c Command) Desc(lineEndComment bool, indent, startOffset int) string {
if lineEndComment {
return cleanDescription(c.Description, indent, startOffset)
}
return lowerFirst(cleanDescription(c.Description, indent, startOffset))
} | go | {
"resource": ""
} |
q19208 | CmdName | train | func (c Command) CmdName(d Domain, export bool) string {
name := d.Name()
if !export {
name = strings.ToLower(d.Name())
}
return name + c.Name() + ""
} | go | {
"resource": ""
} |
q19209 | ReplySignature | train | func (c Command) ReplySignature(d Domain) string {
var args []string
for _, arg := range c.Returns {
name := arg.Name(d)
if name == "range" || name == "type" {
name = name[0 : len(name)-1]
}
typ := arg.GoType("cdp", d)
if arg.Optional && !strings.HasPrefix(typ, "[]") {
typ = "*" + typ
}
args = append(args, name+" "+typ)
}
return strings.Join(args, ", ")
} | go | {
"resource": ""
} |
q19210 | ReplyAssign | train | func (c Command) ReplyAssign(receiver string, d Domain) string {
var args []string
for _, arg := range c.Returns {
name := arg.Name(d)
if name == "range" || name == "type" {
name = name[0 : len(name)-1]
}
args = append(args, name+" = "+receiver+"."+arg.ExportedName(d))
}
return strings.Join(args, "\n")
} | go | {
"resource": ""
} |
q19211 | Name | train | func (e Event) Name() string {
return lint.Name(strings.Title(e.NameName))
} | go | {
"resource": ""
} |
q19212 | EventName | train | func (e Event) EventName(d Domain) string {
return nameInDomain(d, e.Name(), "")
} | go | {
"resource": ""
} |
q19213 | Name | train | func (e Enum) Name() string {
switch e {
case "-Infinity", "-0":
return strings.Replace(string(e), "-", "Negative", 1)
}
s := strings.Replace(string(e), "-", " ", -1)
s = strings.Title(s)
return lint.Name(strings.Replace(s, " ", "", -1))
} | go | {
"resource": ""
} |
q19214 | ExportedName | train | func (at AnyType) ExportedName(d Domain) string {
if at.IDName != "" {
return at.Name(d)
}
return lint.Name(strings.Title(at.NameName))
} | go | {
"resource": ""
} |
q19215 | Name | train | func (at AnyType) Name(d Domain) string {
if at.IDName != "" {
return nameInDomain(d, at.IDName, "")
}
return lint.Name(at.NameName)
} | go | {
"resource": ""
} |
q19216 | Recvr | train | func (at AnyType) Recvr(d Domain) string {
return strings.ToLower(at.Name(d)[0:1])
} | go | {
"resource": ""
} |
q19217 | GoType | train | func (at AnyType) GoType(pkg string, d Domain) string {
switch at.getType() {
case "any":
return "json.RawMessage"
case "boolean":
return "bool"
case "string":
return "string"
case "number":
return "float64"
case "integer":
return "int"
case "object":
return "struct"
case "array":
return "[]" + at.Items.GoType(pkg, d)
case "reference":
return at.refType(d)
case "time":
return "time.Time"
case "enum":
// Enums are handled specially.
return "enum"
case "base64":
// By using a []byte here, Base64-encoded images are
// automatically decoded by json.Unmarshal.
return "[]byte"
case "raw":
// Special []byte, without bas64 decoding.
return "RawMessage"
default:
log.Panicf("unhandled type: %#v", at)
}
panic("unreachable")
} | go | {
"resource": ""
} |
q19218 | GetEncodedResponse | train | func (d *domainClient) GetEncodedResponse(ctx context.Context, args *GetEncodedResponseArgs) (reply *GetEncodedResponseReply, err error) {
reply = new(GetEncodedResponseReply)
if args != nil {
err = rpcc.Invoke(ctx, "Audits.getEncodedResponse", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Audits.getEncodedResponse", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Audits", Op: "GetEncodedResponse", Err: err}
}
return
} | go | {
"resource": ""
} |
q19219 | Sync | train | func Sync(c ...eventClient) error {
var s []rpcc.Stream
for _, cc := range c {
cs, ok := cc.(getStreamer)
if !ok {
return fmt.Errorf("cdp: Sync: bad eventClient type: %T", cc)
}
s = append(s, cs.GetStream())
}
return rpcc.Sync(s...)
} | go | {
"resource": ""
} |
q19220 | SetPresentationURL | train | func (a *EnableArgs) SetPresentationURL(presentationURL string) *EnableArgs {
a.PresentationURL = &presentationURL
return a
} | go | {
"resource": ""
} |
q19221 | NewSetSinkToUseArgs | train | func NewSetSinkToUseArgs(sinkName string) *SetSinkToUseArgs {
args := new(SetSinkToUseArgs)
args.SinkName = sinkName
return args
} | go | {
"resource": ""
} |
q19222 | NewStartTabMirroringArgs | train | func NewStartTabMirroringArgs(sinkName string) *StartTabMirroringArgs {
args := new(StartTabMirroringArgs)
args.SinkName = sinkName
return args
} | go | {
"resource": ""
} |
q19223 | NewStopCastingArgs | train | func NewStopCastingArgs(sinkName string) *StopCastingArgs {
args := new(StopCastingArgs)
args.SinkName = sinkName
return args
} | go | {
"resource": ""
} |
q19224 | SetNodeID | train | func (a *GetPartialAXTreeArgs) SetNodeID(nodeID dom.NodeID) *GetPartialAXTreeArgs {
a.NodeID = &nodeID
return a
} | go | {
"resource": ""
} |
q19225 | SetBackendNodeID | train | func (a *GetPartialAXTreeArgs) SetBackendNodeID(backendNodeID dom.BackendNodeID) *GetPartialAXTreeArgs {
a.BackendNodeID = &backendNodeID
return a
} | go | {
"resource": ""
} |
q19226 | SetObjectID | train | func (a *GetPartialAXTreeArgs) SetObjectID(objectID runtime.RemoteObjectID) *GetPartialAXTreeArgs {
a.ObjectID = &objectID
return a
} | go | {
"resource": ""
} |
q19227 | SetFetchRelatives | train | func (a *GetPartialAXTreeArgs) SetFetchRelatives(fetchRelatives bool) *GetPartialAXTreeArgs {
a.FetchRelatives = &fetchRelatives
return a
} | go | {
"resource": ""
} |
q19228 | NewGrantPermissionsArgs | train | func NewGrantPermissionsArgs(origin string, permissions []PermissionType) *GrantPermissionsArgs {
args := new(GrantPermissionsArgs)
args.Origin = origin
args.Permissions = permissions
return args
} | go | {
"resource": ""
} |
q19229 | SetBrowserContextID | train | func (a *GrantPermissionsArgs) SetBrowserContextID(browserContextID target.BrowserContextID) *GrantPermissionsArgs {
a.BrowserContextID = &browserContextID
return a
} | go | {
"resource": ""
} |
q19230 | SetBrowserContextID | train | func (a *ResetPermissionsArgs) SetBrowserContextID(browserContextID target.BrowserContextID) *ResetPermissionsArgs {
a.BrowserContextID = &browserContextID
return a
} | go | {
"resource": ""
} |
q19231 | SetQuery | train | func (a *GetHistogramsArgs) SetQuery(query string) *GetHistogramsArgs {
a.Query = &query
return a
} | go | {
"resource": ""
} |
q19232 | NewGetHistogramArgs | train | func NewGetHistogramArgs(name string) *GetHistogramArgs {
args := new(GetHistogramArgs)
args.Name = name
return args
} | go | {
"resource": ""
} |
q19233 | NewGetWindowBoundsArgs | train | func NewGetWindowBoundsArgs(windowID WindowID) *GetWindowBoundsArgs {
args := new(GetWindowBoundsArgs)
args.WindowID = windowID
return args
} | go | {
"resource": ""
} |
q19234 | SetTargetID | train | func (a *GetWindowForTargetArgs) SetTargetID(targetID target.ID) *GetWindowForTargetArgs {
a.TargetID = &targetID
return a
} | go | {
"resource": ""
} |
q19235 | NewSetWindowBoundsArgs | train | func NewSetWindowBoundsArgs(windowID WindowID, bounds Bounds) *SetWindowBoundsArgs {
args := new(SetWindowBoundsArgs)
args.WindowID = windowID
args.Bounds = bounds
return args
} | go | {
"resource": ""
} |
q19236 | SetBadgeLabel | train | func (a *SetDockTileArgs) SetBadgeLabel(badgeLabel string) *SetDockTileArgs {
a.BadgeLabel = &badgeLabel
return a
} | go | {
"resource": ""
} |
q19237 | SetImage | train | func (a *SetDockTileArgs) SetImage(image string) *SetDockTileArgs {
a.Image = &image
return a
} | go | {
"resource": ""
} |
q19238 | Read | train | func (d *domainClient) Read(ctx context.Context, args *ReadArgs) (reply *ReadReply, err error) {
reply = new(ReadReply)
if args != nil {
err = rpcc.Invoke(ctx, "IO.read", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IO.read", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IO", Op: "Read", Err: err}
}
return
} | go | {
"resource": ""
} |
q19239 | ResolveBlob | train | func (d *domainClient) ResolveBlob(ctx context.Context, args *ResolveBlobArgs) (reply *ResolveBlobReply, err error) {
reply = new(ResolveBlobReply)
if args != nil {
err = rpcc.Invoke(ctx, "IO.resolveBlob", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "IO.resolveBlob", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "IO", Op: "ResolveBlob", Err: err}
}
return
} | go | {
"resource": ""
} |
q19240 | NewClearDataForOriginArgs | train | func NewClearDataForOriginArgs(origin string, storageTypes string) *ClearDataForOriginArgs {
args := new(ClearDataForOriginArgs)
args.Origin = origin
args.StorageTypes = storageTypes
return args
} | go | {
"resource": ""
} |
q19241 | NewGetUsageAndQuotaArgs | train | func NewGetUsageAndQuotaArgs(origin string) *GetUsageAndQuotaArgs {
args := new(GetUsageAndQuotaArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19242 | NewTrackCacheStorageForOriginArgs | train | func NewTrackCacheStorageForOriginArgs(origin string) *TrackCacheStorageForOriginArgs {
args := new(TrackCacheStorageForOriginArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19243 | NewTrackIndexedDBForOriginArgs | train | func NewTrackIndexedDBForOriginArgs(origin string) *TrackIndexedDBForOriginArgs {
args := new(TrackIndexedDBForOriginArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19244 | NewUntrackCacheStorageForOriginArgs | train | func NewUntrackCacheStorageForOriginArgs(origin string) *UntrackCacheStorageForOriginArgs {
args := new(UntrackCacheStorageForOriginArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19245 | NewUntrackIndexedDBForOriginArgs | train | func NewUntrackIndexedDBForOriginArgs(origin string) *UntrackIndexedDBForOriginArgs {
args := new(UntrackIndexedDBForOriginArgs)
args.Origin = origin
return args
} | go | {
"resource": ""
} |
q19246 | NewSetPressureNotificationsSuppressedArgs | train | func NewSetPressureNotificationsSuppressedArgs(suppressed bool) *SetPressureNotificationsSuppressedArgs {
args := new(SetPressureNotificationsSuppressedArgs)
args.Suppressed = suppressed
return args
} | go | {
"resource": ""
} |
q19247 | NewSimulatePressureNotificationArgs | train | func NewSimulatePressureNotificationArgs(level PressureLevel) *SimulatePressureNotificationArgs {
args := new(SimulatePressureNotificationArgs)
args.Level = level
return args
} | go | {
"resource": ""
} |
q19248 | SetSamplingInterval | train | func (a *StartSamplingArgs) SetSamplingInterval(samplingInterval int) *StartSamplingArgs {
a.SamplingInterval = &samplingInterval
return a
} | go | {
"resource": ""
} |
q19249 | SetSuppressRandomness | train | func (a *StartSamplingArgs) SetSuppressRandomness(suppressRandomness bool) *StartSamplingArgs {
a.SuppressRandomness = &suppressRandomness
return a
} | go | {
"resource": ""
} |
q19250 | write | train | func (s *syncMessageStore) write(m message) {
s.mu.Lock()
defer s.mu.Unlock()
w, ok := s.writers[m.method]
if !ok {
// Exit early if writer has already
// unsubscribed or store is closed.
return
}
m.next = s.load
if s.pending {
s.backlog = append(s.backlog, &m)
return
}
s.pending = true
w.write(m)
} | go | {
"resource": ""
} |
q19251 | load | train | func (s *syncMessageStore) load() {
s.mu.Lock()
defer s.mu.Unlock()
// Keep going until we can write the next message
// or the backlog is empty.
for {
if len(s.backlog) == 0 {
s.pending = false
return
}
m := s.backlog[0]
s.backlog[0] = nil // Remove reference from underlying array.
s.backlog = s.backlog[1:]
// Check if the writer has already unsubscribed.
if w, ok := s.writers[m.method]; ok {
// A write here means that this message must be
// processed (calling m.next) by the recipient.
// Failure to do so will prevent future messages
// from being delivered.
w.write(*m)
return
}
}
} | go | {
"resource": ""
} |
q19252 | Sync | train | func Sync(s ...Stream) (err error) {
if len(s) < 2 {
return errors.New("rpcc: Sync: two or more streams must be provided")
}
set := make(map[Stream]struct{})
for _, ss := range s {
if _, ok := set[ss]; ok {
return errors.New("rpcc: Sync: same instance of stream passed multiple times")
}
set[ss] = struct{}{}
}
store := newSyncMessageStore()
defer func() {
if err != nil {
store.close()
}
}()
var conn *Conn
var swap []func()
for _, ss := range s {
sc, ok := ss.(*streamClient)
if !ok {
return fmt.Errorf("rpcc: Sync: bad Stream type: %T", ss)
}
if conn == nil {
conn = sc.conn
}
if sc.conn != conn {
return errors.New("rpcc: Sync: all Streams must share same Conn")
}
// The Stream lock must be held until the
// swap has been done for all streams.
sc.mu.Lock()
defer sc.mu.Unlock()
if sc.remove == nil {
return errors.New("rpcc: Sync: Stream is closed")
}
// Allow store to manage messages to streamClient.
unsub, err := store.subscribe(sc.method, sc, sc.conn)
if err != nil {
return errors.New("rpcc: Sync: " + err.Error())
}
// Delay listener swap until all Streams have been
// processed so that we can abort on error.
swap = append(swap, func() {
sc.remove() // Prevent direct events from Conn.
sc.remove = func() {
unsub() // Remove from store on Close.
sc.mbuf.clear() // Ensure pending message is processed.
}
// Clear stream messages to prevent sync issues.
sc.mbuf.clear()
})
}
// Perform swap, mutex lock (streamClient.mu) is still active.
for _, s := range swap {
s()
}
return nil
} | go | {
"resource": ""
} |
q19253 | AddScriptToEvaluateOnLoad | train | func (d *domainClient) AddScriptToEvaluateOnLoad(ctx context.Context, args *AddScriptToEvaluateOnLoadArgs) (reply *AddScriptToEvaluateOnLoadReply, err error) {
reply = new(AddScriptToEvaluateOnLoadReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnLoad", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.addScriptToEvaluateOnLoad", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "AddScriptToEvaluateOnLoad", Err: err}
}
return
} | go | {
"resource": ""
} |
q19254 | CaptureScreenshot | train | func (d *domainClient) CaptureScreenshot(ctx context.Context, args *CaptureScreenshotArgs) (reply *CaptureScreenshotReply, err error) {
reply = new(CaptureScreenshotReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.captureScreenshot", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.captureScreenshot", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "CaptureScreenshot", Err: err}
}
return
} | go | {
"resource": ""
} |
q19255 | CreateIsolatedWorld | train | func (d *domainClient) CreateIsolatedWorld(ctx context.Context, args *CreateIsolatedWorldArgs) (reply *CreateIsolatedWorldReply, err error) {
reply = new(CreateIsolatedWorldReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.createIsolatedWorld", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.createIsolatedWorld", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "CreateIsolatedWorld", Err: err}
}
return
} | go | {
"resource": ""
} |
q19256 | GetResourceContent | train | func (d *domainClient) GetResourceContent(ctx context.Context, args *GetResourceContentArgs) (reply *GetResourceContentReply, err error) {
reply = new(GetResourceContentReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.getResourceContent", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.getResourceContent", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "GetResourceContent", Err: err}
}
return
} | go | {
"resource": ""
} |
q19257 | Navigate | train | func (d *domainClient) Navigate(ctx context.Context, args *NavigateArgs) (reply *NavigateReply, err error) {
reply = new(NavigateReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.navigate", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.navigate", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "Navigate", Err: err}
}
return
} | go | {
"resource": ""
} |
q19258 | PrintToPDF | train | func (d *domainClient) PrintToPDF(ctx context.Context, args *PrintToPDFArgs) (reply *PrintToPDFReply, err error) {
reply = new(PrintToPDFReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.printToPDF", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.printToPDF", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "PrintToPDF", Err: err}
}
return
} | go | {
"resource": ""
} |
q19259 | SearchInResource | train | func (d *domainClient) SearchInResource(ctx context.Context, args *SearchInResourceArgs) (reply *SearchInResourceReply, err error) {
reply = new(SearchInResourceReply)
if args != nil {
err = rpcc.Invoke(ctx, "Page.searchInResource", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Page.searchInResource", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Page", Op: "SearchInResource", Err: err}
}
return
} | go | {
"resource": ""
} |
q19260 | WithClient | train | func WithClient(client *http.Client) DevToolsOption {
return func(d *DevTools) {
d.client = client
}
} | go | {
"resource": ""
} |
q19261 | New | train | func New(url string, opts ...DevToolsOption) *DevTools {
devtools := &DevTools{url: url}
for _, o := range opts {
o(devtools)
}
if devtools.client == nil {
devtools.client = &http.Client{}
}
return devtools
} | go | {
"resource": ""
} |
q19262 | Get | train | func (d *DevTools) Get(ctx context.Context, typ Type) (*Target, error) {
list, err := d.List(ctx)
if err != nil {
return nil, err
}
for _, t := range list {
if t.Type == typ {
return t, nil
}
}
return nil, errors.New("devtool: Get: could not find target of type: " + string(typ))
} | go | {
"resource": ""
} |
q19263 | List | train | func (d *DevTools) List(ctx context.Context) ([]*Target, error) {
resp, err := d.httpGet(ctx, "/json/list")
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, parseError("List", resp.Body)
}
var t []*Target
return t, json.NewDecoder(resp.Body).Decode(&t)
} | go | {
"resource": ""
} |
q19264 | Activate | train | func (d *DevTools) Activate(ctx context.Context, t *Target) error {
resp, err := d.httpGet(ctx, "/json/activate/"+t.ID)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return parseError("Activate", resp.Body)
}
return nil
} | go | {
"resource": ""
} |
q19265 | Version | train | func (d *DevTools) Version(ctx context.Context) (*Version, error) {
resp, err := d.httpGet(ctx, "/json/version")
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, parseError("Version", resp.Body)
}
v := new(Version)
return v, json.NewDecoder(resp.Body).Decode(&v)
} | go | {
"resource": ""
} |
q19266 | NewAddRuleArgs | train | func NewAddRuleArgs(styleSheetID StyleSheetID, ruleText string, location SourceRange) *AddRuleArgs {
args := new(AddRuleArgs)
args.StyleSheetID = styleSheetID
args.RuleText = ruleText
args.Location = location
return args
} | go | {
"resource": ""
} |
q19267 | NewCollectClassNamesArgs | train | func NewCollectClassNamesArgs(styleSheetID StyleSheetID) *CollectClassNamesArgs {
args := new(CollectClassNamesArgs)
args.StyleSheetID = styleSheetID
return args
} | go | {
"resource": ""
} |
q19268 | NewCreateStyleSheetArgs | train | func NewCreateStyleSheetArgs(frameID page.FrameID) *CreateStyleSheetArgs {
args := new(CreateStyleSheetArgs)
args.FrameID = frameID
return args
} | go | {
"resource": ""
} |
q19269 | NewForcePseudoStateArgs | train | func NewForcePseudoStateArgs(nodeID dom.NodeID, forcedPseudoClasses []string) *ForcePseudoStateArgs {
args := new(ForcePseudoStateArgs)
args.NodeID = nodeID
args.ForcedPseudoClasses = forcedPseudoClasses
return args
} | go | {
"resource": ""
} |
q19270 | NewGetBackgroundColorsArgs | train | func NewGetBackgroundColorsArgs(nodeID dom.NodeID) *GetBackgroundColorsArgs {
args := new(GetBackgroundColorsArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q19271 | NewGetComputedStyleForNodeArgs | train | func NewGetComputedStyleForNodeArgs(nodeID dom.NodeID) *GetComputedStyleForNodeArgs {
args := new(GetComputedStyleForNodeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q19272 | NewGetInlineStylesForNodeArgs | train | func NewGetInlineStylesForNodeArgs(nodeID dom.NodeID) *GetInlineStylesForNodeArgs {
args := new(GetInlineStylesForNodeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q19273 | NewGetMatchedStylesForNodeArgs | train | func NewGetMatchedStylesForNodeArgs(nodeID dom.NodeID) *GetMatchedStylesForNodeArgs {
args := new(GetMatchedStylesForNodeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q19274 | NewGetPlatformFontsForNodeArgs | train | func NewGetPlatformFontsForNodeArgs(nodeID dom.NodeID) *GetPlatformFontsForNodeArgs {
args := new(GetPlatformFontsForNodeArgs)
args.NodeID = nodeID
return args
} | go | {
"resource": ""
} |
q19275 | NewGetStyleSheetTextArgs | train | func NewGetStyleSheetTextArgs(styleSheetID StyleSheetID) *GetStyleSheetTextArgs {
args := new(GetStyleSheetTextArgs)
args.StyleSheetID = styleSheetID
return args
} | go | {
"resource": ""
} |
q19276 | NewSetEffectivePropertyValueForNodeArgs | train | func NewSetEffectivePropertyValueForNodeArgs(nodeID dom.NodeID, propertyName string, value string) *SetEffectivePropertyValueForNodeArgs {
args := new(SetEffectivePropertyValueForNodeArgs)
args.NodeID = nodeID
args.PropertyName = propertyName
args.Value = value
return args
} | go | {
"resource": ""
} |
q19277 | NewSetKeyframeKeyArgs | train | func NewSetKeyframeKeyArgs(styleSheetID StyleSheetID, rang SourceRange, keyText string) *SetKeyframeKeyArgs {
args := new(SetKeyframeKeyArgs)
args.StyleSheetID = styleSheetID
args.Range = rang
args.KeyText = keyText
return args
} | go | {
"resource": ""
} |
q19278 | NewSetMediaTextArgs | train | func NewSetMediaTextArgs(styleSheetID StyleSheetID, rang SourceRange, text string) *SetMediaTextArgs {
args := new(SetMediaTextArgs)
args.StyleSheetID = styleSheetID
args.Range = rang
args.Text = text
return args
} | go | {
"resource": ""
} |
q19279 | NewSetRuleSelectorArgs | train | func NewSetRuleSelectorArgs(styleSheetID StyleSheetID, rang SourceRange, selector string) *SetRuleSelectorArgs {
args := new(SetRuleSelectorArgs)
args.StyleSheetID = styleSheetID
args.Range = rang
args.Selector = selector
return args
} | go | {
"resource": ""
} |
q19280 | NewSetStyleSheetTextArgs | train | func NewSetStyleSheetTextArgs(styleSheetID StyleSheetID, text string) *SetStyleSheetTextArgs {
args := new(SetStyleSheetTextArgs)
args.StyleSheetID = styleSheetID
args.Text = text
return args
} | go | {
"resource": ""
} |
q19281 | NewSetStyleTextsArgs | train | func NewSetStyleTextsArgs(edits []StyleDeclarationEdit) *SetStyleTextsArgs {
args := new(SetStyleTextsArgs)
args.Edits = edits
return args
} | go | {
"resource": ""
} |
q19282 | GetHistograms | train | func (d *domainClient) GetHistograms(ctx context.Context, args *GetHistogramsArgs) (reply *GetHistogramsReply, err error) {
reply = new(GetHistogramsReply)
if args != nil {
err = rpcc.Invoke(ctx, "Browser.getHistograms", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Browser.getHistograms", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Browser", Op: "GetHistograms", Err: err}
}
return
} | go | {
"resource": ""
} |
q19283 | GetHistogram | train | func (d *domainClient) GetHistogram(ctx context.Context, args *GetHistogramArgs) (reply *GetHistogramReply, err error) {
reply = new(GetHistogramReply)
if args != nil {
err = rpcc.Invoke(ctx, "Browser.getHistogram", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Browser.getHistogram", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Browser", Op: "GetHistogram", Err: err}
}
return
} | go | {
"resource": ""
} |
q19284 | GetWindowBounds | train | func (d *domainClient) GetWindowBounds(ctx context.Context, args *GetWindowBoundsArgs) (reply *GetWindowBoundsReply, err error) {
reply = new(GetWindowBoundsReply)
if args != nil {
err = rpcc.Invoke(ctx, "Browser.getWindowBounds", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Browser.getWindowBounds", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Browser", Op: "GetWindowBounds", Err: err}
}
return
} | go | {
"resource": ""
} |
q19285 | GetWindowForTarget | train | func (d *domainClient) GetWindowForTarget(ctx context.Context, args *GetWindowForTargetArgs) (reply *GetWindowForTargetReply, err error) {
reply = new(GetWindowForTargetReply)
if args != nil {
err = rpcc.Invoke(ctx, "Browser.getWindowForTarget", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Browser.getWindowForTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Browser", Op: "GetWindowForTarget", Err: err}
}
return
} | go | {
"resource": ""
} |
q19286 | NewBindArgs | train | func NewBindArgs(port int) *BindArgs {
args := new(BindArgs)
args.Port = port
return args
} | go | {
"resource": ""
} |
q19287 | NewUnbindArgs | train | func NewUnbindArgs(port int) *UnbindArgs {
args := new(UnbindArgs)
args.Port = port
return args
} | go | {
"resource": ""
} |
q19288 | NewAddInspectedHeapObjectArgs | train | func NewAddInspectedHeapObjectArgs(heapObjectID HeapSnapshotObjectID) *AddInspectedHeapObjectArgs {
args := new(AddInspectedHeapObjectArgs)
args.HeapObjectID = heapObjectID
return args
} | go | {
"resource": ""
} |
q19289 | NewGetHeapObjectIDArgs | train | func NewGetHeapObjectIDArgs(objectID runtime.RemoteObjectID) *GetHeapObjectIDArgs {
args := new(GetHeapObjectIDArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q19290 | NewGetObjectByHeapObjectIDArgs | train | func NewGetObjectByHeapObjectIDArgs(objectID HeapSnapshotObjectID) *GetObjectByHeapObjectIDArgs {
args := new(GetObjectByHeapObjectIDArgs)
args.ObjectID = objectID
return args
} | go | {
"resource": ""
} |
q19291 | SetSamplingInterval | train | func (a *StartSamplingArgs) SetSamplingInterval(samplingInterval float64) *StartSamplingArgs {
a.SamplingInterval = &samplingInterval
return a
} | go | {
"resource": ""
} |
q19292 | SetTrackAllocations | train | func (a *StartTrackingHeapObjectsArgs) SetTrackAllocations(trackAllocations bool) *StartTrackingHeapObjectsArgs {
a.TrackAllocations = &trackAllocations
return a
} | go | {
"resource": ""
} |
q19293 | SetReportProgress | train | func (a *StopTrackingHeapObjectsArgs) SetReportProgress(reportProgress bool) *StopTrackingHeapObjectsArgs {
a.ReportProgress = &reportProgress
return a
} | go | {
"resource": ""
} |
q19294 | SetReportProgress | train | func (a *TakeHeapSnapshotArgs) SetReportProgress(reportProgress bool) *TakeHeapSnapshotArgs {
a.ReportProgress = &reportProgress
return a
} | go | {
"resource": ""
} |
q19295 | NewActivateTargetArgs | train | func NewActivateTargetArgs(targetID ID) *ActivateTargetArgs {
args := new(ActivateTargetArgs)
args.TargetID = targetID
return args
} | go | {
"resource": ""
} |
q19296 | NewAttachToTargetArgs | train | func NewAttachToTargetArgs(targetID ID) *AttachToTargetArgs {
args := new(AttachToTargetArgs)
args.TargetID = targetID
return args
} | go | {
"resource": ""
} |
q19297 | NewCloseTargetArgs | train | func NewCloseTargetArgs(targetID ID) *CloseTargetArgs {
args := new(CloseTargetArgs)
args.TargetID = targetID
return args
} | go | {
"resource": ""
} |
q19298 | NewExposeDevToolsProtocolArgs | train | func NewExposeDevToolsProtocolArgs(targetID ID) *ExposeDevToolsProtocolArgs {
args := new(ExposeDevToolsProtocolArgs)
args.TargetID = targetID
return args
} | go | {
"resource": ""
} |
q19299 | SetBindingName | train | func (a *ExposeDevToolsProtocolArgs) SetBindingName(bindingName string) *ExposeDevToolsProtocolArgs {
a.BindingName = &bindingName
return a
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.