browser_protocol/domdebugger/
mod.rs

1//! DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript
2//! execution will stop on these operations as if there was a regular breakpoint set.
3
4
5use serde::{Serialize, Deserialize};
6use serde_json::Value as JsonValue;
7use std::borrow::Cow;
8
9/// DOM breakpoint type.
10
11#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
12pub enum DOMBreakpointType {
13    #[default]
14    #[serde(rename = "subtree-modified")]
15    SubtreeModified,
16    #[serde(rename = "attribute-modified")]
17    AttributeModified,
18    #[serde(rename = "node-removed")]
19    NodeRemoved,
20}
21
22/// CSP Violation type.
23
24#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
25pub enum CSPViolationType {
26    #[default]
27    #[serde(rename = "trustedtype-sink-violation")]
28    TrustedtypeSinkViolation,
29    #[serde(rename = "trustedtype-policy-violation")]
30    TrustedtypePolicyViolation,
31}
32
33/// Object event listener.
34
35#[derive(Debug, Clone, Serialize, Deserialize, Default)]
36#[serde(rename_all = "camelCase")]
37pub struct EventListener<'a> {
38    /// 'EventListener''s type.
39    #[serde(rename = "type")]
40    type_: Cow<'a, str>,
41    /// 'EventListener''s useCapture.
42    #[serde(rename = "useCapture")]
43    use_capture: bool,
44    /// 'EventListener''s passive flag.
45    passive: bool,
46    /// 'EventListener''s once flag.
47    once: bool,
48    /// Script id of the handler code.
49    #[serde(rename = "scriptId")]
50    script_id: crate::runtime::ScriptId<'a>,
51    /// Line number in the script (0-based).
52    #[serde(rename = "lineNumber")]
53    line_number: i64,
54    /// Column number in the script (0-based).
55    #[serde(rename = "columnNumber")]
56    column_number: i64,
57    /// Event handler function value.
58    #[serde(skip_serializing_if = "Option::is_none")]
59    handler: Option<crate::runtime::RemoteObject>,
60    /// Event original handler function value.
61    #[serde(skip_serializing_if = "Option::is_none", rename = "originalHandler")]
62    original_handler: Option<crate::runtime::RemoteObject>,
63    /// Node the listener is added to (if any).
64    #[serde(skip_serializing_if = "Option::is_none", rename = "backendNodeId")]
65    backend_node_id: Option<crate::dom::BackendNodeId>,
66}
67
68impl<'a> EventListener<'a> {
69    /// Creates a builder for this type with the required parameters:
70    /// * `type_`: `EventListener`'s type.
71    /// * `use_capture`: `EventListener`'s useCapture.
72    /// * `passive`: `EventListener`'s passive flag.
73    /// * `once`: `EventListener`'s once flag.
74    /// * `script_id`: Script id of the handler code.
75    /// * `line_number`: Line number in the script (0-based).
76    /// * `column_number`: Column number in the script (0-based).
77    pub fn builder(type_: impl Into<Cow<'a, str>>, use_capture: bool, passive: bool, once: bool, script_id: crate::runtime::ScriptId<'a>, line_number: i64, column_number: i64) -> EventListenerBuilder<'a> {
78        EventListenerBuilder {
79            type_: type_.into(),
80            use_capture: use_capture,
81            passive: passive,
82            once: once,
83            script_id: script_id,
84            line_number: line_number,
85            column_number: column_number,
86            handler: None,
87            original_handler: None,
88            backend_node_id: None,
89        }
90    }
91    /// 'EventListener''s type.
92    pub fn type_(&self) -> &str { self.type_.as_ref() }
93    /// 'EventListener''s useCapture.
94    pub fn use_capture(&self) -> bool { self.use_capture }
95    /// 'EventListener''s passive flag.
96    pub fn passive(&self) -> bool { self.passive }
97    /// 'EventListener''s once flag.
98    pub fn once(&self) -> bool { self.once }
99    /// Script id of the handler code.
100    pub fn script_id(&self) -> &crate::runtime::ScriptId<'a> { &self.script_id }
101    /// Line number in the script (0-based).
102    pub fn line_number(&self) -> i64 { self.line_number }
103    /// Column number in the script (0-based).
104    pub fn column_number(&self) -> i64 { self.column_number }
105    /// Event handler function value.
106    pub fn handler(&self) -> Option<&crate::runtime::RemoteObject> { self.handler.as_ref() }
107    /// Event original handler function value.
108    pub fn original_handler(&self) -> Option<&crate::runtime::RemoteObject> { self.original_handler.as_ref() }
109    /// Node the listener is added to (if any).
110    pub fn backend_node_id(&self) -> Option<&crate::dom::BackendNodeId> { self.backend_node_id.as_ref() }
111}
112
113
114pub struct EventListenerBuilder<'a> {
115    type_: Cow<'a, str>,
116    use_capture: bool,
117    passive: bool,
118    once: bool,
119    script_id: crate::runtime::ScriptId<'a>,
120    line_number: i64,
121    column_number: i64,
122    handler: Option<crate::runtime::RemoteObject>,
123    original_handler: Option<crate::runtime::RemoteObject>,
124    backend_node_id: Option<crate::dom::BackendNodeId>,
125}
126
127impl<'a> EventListenerBuilder<'a> {
128    /// Event handler function value.
129    pub fn handler(mut self, handler: crate::runtime::RemoteObject) -> Self { self.handler = Some(handler); self }
130    /// Event original handler function value.
131    pub fn original_handler(mut self, original_handler: crate::runtime::RemoteObject) -> Self { self.original_handler = Some(original_handler); self }
132    /// Node the listener is added to (if any).
133    pub fn backend_node_id(mut self, backend_node_id: crate::dom::BackendNodeId) -> Self { self.backend_node_id = Some(backend_node_id); self }
134    pub fn build(self) -> EventListener<'a> {
135        EventListener {
136            type_: self.type_,
137            use_capture: self.use_capture,
138            passive: self.passive,
139            once: self.once,
140            script_id: self.script_id,
141            line_number: self.line_number,
142            column_number: self.column_number,
143            handler: self.handler,
144            original_handler: self.original_handler,
145            backend_node_id: self.backend_node_id,
146        }
147    }
148}
149
150/// Returns event listeners of the given object.
151
152#[derive(Debug, Clone, Serialize, Deserialize, Default)]
153#[serde(rename_all = "camelCase")]
154pub struct GetEventListenersParams<'a> {
155    /// Identifier of the object to return listeners for.
156    #[serde(rename = "objectId")]
157    object_id: crate::runtime::RemoteObjectId<'a>,
158    /// The maximum depth at which Node children should be retrieved, defaults to 1. Use -1 for the
159    /// entire subtree or provide an integer larger than 0.
160    #[serde(skip_serializing_if = "Option::is_none")]
161    depth: Option<i64>,
162    /// Whether or not iframes and shadow roots should be traversed when returning the subtree
163    /// (default is false). Reports listeners for all contexts if pierce is enabled.
164    #[serde(skip_serializing_if = "Option::is_none")]
165    pierce: Option<bool>,
166}
167
168impl<'a> GetEventListenersParams<'a> {
169    /// Creates a builder for this type with the required parameters:
170    /// * `object_id`: Identifier of the object to return listeners for.
171    pub fn builder(object_id: crate::runtime::RemoteObjectId<'a>) -> GetEventListenersParamsBuilder<'a> {
172        GetEventListenersParamsBuilder {
173            object_id: object_id,
174            depth: None,
175            pierce: None,
176        }
177    }
178    /// Identifier of the object to return listeners for.
179    pub fn object_id(&self) -> &crate::runtime::RemoteObjectId<'a> { &self.object_id }
180    /// The maximum depth at which Node children should be retrieved, defaults to 1. Use -1 for the
181    /// entire subtree or provide an integer larger than 0.
182    pub fn depth(&self) -> Option<i64> { self.depth }
183    /// Whether or not iframes and shadow roots should be traversed when returning the subtree
184    /// (default is false). Reports listeners for all contexts if pierce is enabled.
185    pub fn pierce(&self) -> Option<bool> { self.pierce }
186}
187
188
189pub struct GetEventListenersParamsBuilder<'a> {
190    object_id: crate::runtime::RemoteObjectId<'a>,
191    depth: Option<i64>,
192    pierce: Option<bool>,
193}
194
195impl<'a> GetEventListenersParamsBuilder<'a> {
196    /// The maximum depth at which Node children should be retrieved, defaults to 1. Use -1 for the
197    /// entire subtree or provide an integer larger than 0.
198    pub fn depth(mut self, depth: i64) -> Self { self.depth = Some(depth); self }
199    /// Whether or not iframes and shadow roots should be traversed when returning the subtree
200    /// (default is false). Reports listeners for all contexts if pierce is enabled.
201    pub fn pierce(mut self, pierce: bool) -> Self { self.pierce = Some(pierce); self }
202    pub fn build(self) -> GetEventListenersParams<'a> {
203        GetEventListenersParams {
204            object_id: self.object_id,
205            depth: self.depth,
206            pierce: self.pierce,
207        }
208    }
209}
210
211/// Returns event listeners of the given object.
212
213#[derive(Debug, Clone, Serialize, Deserialize, Default)]
214#[serde(rename_all = "camelCase")]
215pub struct GetEventListenersReturns<'a> {
216    /// Array of relevant listeners.
217    listeners: Vec<EventListener<'a>>,
218}
219
220impl<'a> GetEventListenersReturns<'a> {
221    /// Creates a builder for this type with the required parameters:
222    /// * `listeners`: Array of relevant listeners.
223    pub fn builder(listeners: Vec<EventListener<'a>>) -> GetEventListenersReturnsBuilder<'a> {
224        GetEventListenersReturnsBuilder {
225            listeners: listeners,
226        }
227    }
228    /// Array of relevant listeners.
229    pub fn listeners(&self) -> &[EventListener<'a>] { &self.listeners }
230}
231
232
233pub struct GetEventListenersReturnsBuilder<'a> {
234    listeners: Vec<EventListener<'a>>,
235}
236
237impl<'a> GetEventListenersReturnsBuilder<'a> {
238    pub fn build(self) -> GetEventListenersReturns<'a> {
239        GetEventListenersReturns {
240            listeners: self.listeners,
241        }
242    }
243}
244
245impl<'a> GetEventListenersParams<'a> { pub const METHOD: &'static str = "DOMDebugger.getEventListeners"; }
246
247impl<'a> crate::CdpCommand<'a> for GetEventListenersParams<'a> {
248    const METHOD: &'static str = "DOMDebugger.getEventListeners";
249    type Response = GetEventListenersReturns<'a>;
250}
251
252/// Removes DOM breakpoint that was set using 'setDOMBreakpoint'.
253
254#[derive(Debug, Clone, Serialize, Deserialize, Default)]
255#[serde(rename_all = "camelCase")]
256pub struct RemoveDOMBreakpointParams {
257    /// Identifier of the node to remove breakpoint from.
258    #[serde(rename = "nodeId")]
259    node_id: crate::dom::NodeId,
260    /// Type of the breakpoint to remove.
261    #[serde(rename = "type")]
262    type_: DOMBreakpointType,
263}
264
265impl RemoveDOMBreakpointParams {
266    /// Creates a builder for this type with the required parameters:
267    /// * `node_id`: Identifier of the node to remove breakpoint from.
268    /// * `type_`: Type of the breakpoint to remove.
269    pub fn builder(node_id: crate::dom::NodeId, type_: impl Into<DOMBreakpointType>) -> RemoveDOMBreakpointParamsBuilder {
270        RemoveDOMBreakpointParamsBuilder {
271            node_id: node_id,
272            type_: type_.into(),
273        }
274    }
275    /// Identifier of the node to remove breakpoint from.
276    pub fn node_id(&self) -> &crate::dom::NodeId { &self.node_id }
277    /// Type of the breakpoint to remove.
278    pub fn type_(&self) -> &DOMBreakpointType { &self.type_ }
279}
280
281
282pub struct RemoveDOMBreakpointParamsBuilder {
283    node_id: crate::dom::NodeId,
284    type_: DOMBreakpointType,
285}
286
287impl RemoveDOMBreakpointParamsBuilder {
288    pub fn build(self) -> RemoveDOMBreakpointParams {
289        RemoveDOMBreakpointParams {
290            node_id: self.node_id,
291            type_: self.type_,
292        }
293    }
294}
295
296impl RemoveDOMBreakpointParams { pub const METHOD: &'static str = "DOMDebugger.removeDOMBreakpoint"; }
297
298impl<'a> crate::CdpCommand<'a> for RemoveDOMBreakpointParams {
299    const METHOD: &'static str = "DOMDebugger.removeDOMBreakpoint";
300    type Response = crate::EmptyReturns;
301}
302
303/// Removes breakpoint on particular DOM event.
304
305#[derive(Debug, Clone, Serialize, Deserialize, Default)]
306#[serde(rename_all = "camelCase")]
307pub struct RemoveEventListenerBreakpointParams<'a> {
308    /// Event name.
309    #[serde(rename = "eventName")]
310    event_name: Cow<'a, str>,
311    /// EventTarget interface name.
312    #[serde(skip_serializing_if = "Option::is_none", rename = "targetName")]
313    target_name: Option<Cow<'a, str>>,
314}
315
316impl<'a> RemoveEventListenerBreakpointParams<'a> {
317    /// Creates a builder for this type with the required parameters:
318    /// * `event_name`: Event name.
319    pub fn builder(event_name: impl Into<Cow<'a, str>>) -> RemoveEventListenerBreakpointParamsBuilder<'a> {
320        RemoveEventListenerBreakpointParamsBuilder {
321            event_name: event_name.into(),
322            target_name: None,
323        }
324    }
325    /// Event name.
326    pub fn event_name(&self) -> &str { self.event_name.as_ref() }
327    /// EventTarget interface name.
328    pub fn target_name(&self) -> Option<&str> { self.target_name.as_deref() }
329}
330
331
332pub struct RemoveEventListenerBreakpointParamsBuilder<'a> {
333    event_name: Cow<'a, str>,
334    target_name: Option<Cow<'a, str>>,
335}
336
337impl<'a> RemoveEventListenerBreakpointParamsBuilder<'a> {
338    /// EventTarget interface name.
339    pub fn target_name(mut self, target_name: impl Into<Cow<'a, str>>) -> Self { self.target_name = Some(target_name.into()); self }
340    pub fn build(self) -> RemoveEventListenerBreakpointParams<'a> {
341        RemoveEventListenerBreakpointParams {
342            event_name: self.event_name,
343            target_name: self.target_name,
344        }
345    }
346}
347
348impl<'a> RemoveEventListenerBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.removeEventListenerBreakpoint"; }
349
350impl<'a> crate::CdpCommand<'a> for RemoveEventListenerBreakpointParams<'a> {
351    const METHOD: &'static str = "DOMDebugger.removeEventListenerBreakpoint";
352    type Response = crate::EmptyReturns;
353}
354
355/// Removes breakpoint on particular native event.
356
357#[derive(Debug, Clone, Serialize, Deserialize, Default)]
358#[serde(rename_all = "camelCase")]
359pub struct RemoveInstrumentationBreakpointParams<'a> {
360    /// Instrumentation name to stop on.
361    #[serde(rename = "eventName")]
362    event_name: Cow<'a, str>,
363}
364
365impl<'a> RemoveInstrumentationBreakpointParams<'a> {
366    /// Creates a builder for this type with the required parameters:
367    /// * `event_name`: Instrumentation name to stop on.
368    pub fn builder(event_name: impl Into<Cow<'a, str>>) -> RemoveInstrumentationBreakpointParamsBuilder<'a> {
369        RemoveInstrumentationBreakpointParamsBuilder {
370            event_name: event_name.into(),
371        }
372    }
373    /// Instrumentation name to stop on.
374    pub fn event_name(&self) -> &str { self.event_name.as_ref() }
375}
376
377
378pub struct RemoveInstrumentationBreakpointParamsBuilder<'a> {
379    event_name: Cow<'a, str>,
380}
381
382impl<'a> RemoveInstrumentationBreakpointParamsBuilder<'a> {
383    pub fn build(self) -> RemoveInstrumentationBreakpointParams<'a> {
384        RemoveInstrumentationBreakpointParams {
385            event_name: self.event_name,
386        }
387    }
388}
389
390impl<'a> RemoveInstrumentationBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.removeInstrumentationBreakpoint"; }
391
392impl<'a> crate::CdpCommand<'a> for RemoveInstrumentationBreakpointParams<'a> {
393    const METHOD: &'static str = "DOMDebugger.removeInstrumentationBreakpoint";
394    type Response = crate::EmptyReturns;
395}
396
397/// Removes breakpoint from XMLHttpRequest.
398
399#[derive(Debug, Clone, Serialize, Deserialize, Default)]
400#[serde(rename_all = "camelCase")]
401pub struct RemoveXHRBreakpointParams<'a> {
402    /// Resource URL substring.
403    url: Cow<'a, str>,
404}
405
406impl<'a> RemoveXHRBreakpointParams<'a> {
407    /// Creates a builder for this type with the required parameters:
408    /// * `url`: Resource URL substring.
409    pub fn builder(url: impl Into<Cow<'a, str>>) -> RemoveXHRBreakpointParamsBuilder<'a> {
410        RemoveXHRBreakpointParamsBuilder {
411            url: url.into(),
412        }
413    }
414    /// Resource URL substring.
415    pub fn url(&self) -> &str { self.url.as_ref() }
416}
417
418
419pub struct RemoveXHRBreakpointParamsBuilder<'a> {
420    url: Cow<'a, str>,
421}
422
423impl<'a> RemoveXHRBreakpointParamsBuilder<'a> {
424    pub fn build(self) -> RemoveXHRBreakpointParams<'a> {
425        RemoveXHRBreakpointParams {
426            url: self.url,
427        }
428    }
429}
430
431impl<'a> RemoveXHRBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.removeXHRBreakpoint"; }
432
433impl<'a> crate::CdpCommand<'a> for RemoveXHRBreakpointParams<'a> {
434    const METHOD: &'static str = "DOMDebugger.removeXHRBreakpoint";
435    type Response = crate::EmptyReturns;
436}
437
438/// Sets breakpoint on particular CSP violations.
439
440#[derive(Debug, Clone, Serialize, Deserialize, Default)]
441#[serde(rename_all = "camelCase")]
442pub struct SetBreakOnCSPViolationParams {
443    /// CSP Violations to stop upon.
444    #[serde(rename = "violationTypes")]
445    violation_types: Vec<CSPViolationType>,
446}
447
448impl SetBreakOnCSPViolationParams {
449    /// Creates a builder for this type with the required parameters:
450    /// * `violation_types`: CSP Violations to stop upon.
451    pub fn builder(violation_types: Vec<CSPViolationType>) -> SetBreakOnCSPViolationParamsBuilder {
452        SetBreakOnCSPViolationParamsBuilder {
453            violation_types: violation_types,
454        }
455    }
456    /// CSP Violations to stop upon.
457    pub fn violation_types(&self) -> &[CSPViolationType] { &self.violation_types }
458}
459
460
461pub struct SetBreakOnCSPViolationParamsBuilder {
462    violation_types: Vec<CSPViolationType>,
463}
464
465impl SetBreakOnCSPViolationParamsBuilder {
466    pub fn build(self) -> SetBreakOnCSPViolationParams {
467        SetBreakOnCSPViolationParams {
468            violation_types: self.violation_types,
469        }
470    }
471}
472
473impl SetBreakOnCSPViolationParams { pub const METHOD: &'static str = "DOMDebugger.setBreakOnCSPViolation"; }
474
475impl<'a> crate::CdpCommand<'a> for SetBreakOnCSPViolationParams {
476    const METHOD: &'static str = "DOMDebugger.setBreakOnCSPViolation";
477    type Response = crate::EmptyReturns;
478}
479
480/// Sets breakpoint on particular operation with DOM.
481
482#[derive(Debug, Clone, Serialize, Deserialize, Default)]
483#[serde(rename_all = "camelCase")]
484pub struct SetDOMBreakpointParams {
485    /// Identifier of the node to set breakpoint on.
486    #[serde(rename = "nodeId")]
487    node_id: crate::dom::NodeId,
488    /// Type of the operation to stop upon.
489    #[serde(rename = "type")]
490    type_: DOMBreakpointType,
491}
492
493impl SetDOMBreakpointParams {
494    /// Creates a builder for this type with the required parameters:
495    /// * `node_id`: Identifier of the node to set breakpoint on.
496    /// * `type_`: Type of the operation to stop upon.
497    pub fn builder(node_id: crate::dom::NodeId, type_: impl Into<DOMBreakpointType>) -> SetDOMBreakpointParamsBuilder {
498        SetDOMBreakpointParamsBuilder {
499            node_id: node_id,
500            type_: type_.into(),
501        }
502    }
503    /// Identifier of the node to set breakpoint on.
504    pub fn node_id(&self) -> &crate::dom::NodeId { &self.node_id }
505    /// Type of the operation to stop upon.
506    pub fn type_(&self) -> &DOMBreakpointType { &self.type_ }
507}
508
509
510pub struct SetDOMBreakpointParamsBuilder {
511    node_id: crate::dom::NodeId,
512    type_: DOMBreakpointType,
513}
514
515impl SetDOMBreakpointParamsBuilder {
516    pub fn build(self) -> SetDOMBreakpointParams {
517        SetDOMBreakpointParams {
518            node_id: self.node_id,
519            type_: self.type_,
520        }
521    }
522}
523
524impl SetDOMBreakpointParams { pub const METHOD: &'static str = "DOMDebugger.setDOMBreakpoint"; }
525
526impl<'a> crate::CdpCommand<'a> for SetDOMBreakpointParams {
527    const METHOD: &'static str = "DOMDebugger.setDOMBreakpoint";
528    type Response = crate::EmptyReturns;
529}
530
531/// Sets breakpoint on particular DOM event.
532
533#[derive(Debug, Clone, Serialize, Deserialize, Default)]
534#[serde(rename_all = "camelCase")]
535pub struct SetEventListenerBreakpointParams<'a> {
536    /// DOM Event name to stop on (any DOM event will do).
537    #[serde(rename = "eventName")]
538    event_name: Cow<'a, str>,
539    /// EventTarget interface name to stop on. If equal to '"*"' or not provided, will stop on any
540    /// EventTarget.
541    #[serde(skip_serializing_if = "Option::is_none", rename = "targetName")]
542    target_name: Option<Cow<'a, str>>,
543}
544
545impl<'a> SetEventListenerBreakpointParams<'a> {
546    /// Creates a builder for this type with the required parameters:
547    /// * `event_name`: DOM Event name to stop on (any DOM event will do).
548    pub fn builder(event_name: impl Into<Cow<'a, str>>) -> SetEventListenerBreakpointParamsBuilder<'a> {
549        SetEventListenerBreakpointParamsBuilder {
550            event_name: event_name.into(),
551            target_name: None,
552        }
553    }
554    /// DOM Event name to stop on (any DOM event will do).
555    pub fn event_name(&self) -> &str { self.event_name.as_ref() }
556    /// EventTarget interface name to stop on. If equal to '"*"' or not provided, will stop on any
557    /// EventTarget.
558    pub fn target_name(&self) -> Option<&str> { self.target_name.as_deref() }
559}
560
561
562pub struct SetEventListenerBreakpointParamsBuilder<'a> {
563    event_name: Cow<'a, str>,
564    target_name: Option<Cow<'a, str>>,
565}
566
567impl<'a> SetEventListenerBreakpointParamsBuilder<'a> {
568    /// EventTarget interface name to stop on. If equal to '"*"' or not provided, will stop on any
569    /// EventTarget.
570    pub fn target_name(mut self, target_name: impl Into<Cow<'a, str>>) -> Self { self.target_name = Some(target_name.into()); self }
571    pub fn build(self) -> SetEventListenerBreakpointParams<'a> {
572        SetEventListenerBreakpointParams {
573            event_name: self.event_name,
574            target_name: self.target_name,
575        }
576    }
577}
578
579impl<'a> SetEventListenerBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.setEventListenerBreakpoint"; }
580
581impl<'a> crate::CdpCommand<'a> for SetEventListenerBreakpointParams<'a> {
582    const METHOD: &'static str = "DOMDebugger.setEventListenerBreakpoint";
583    type Response = crate::EmptyReturns;
584}
585
586/// Sets breakpoint on particular native event.
587
588#[derive(Debug, Clone, Serialize, Deserialize, Default)]
589#[serde(rename_all = "camelCase")]
590pub struct SetInstrumentationBreakpointParams<'a> {
591    /// Instrumentation name to stop on.
592    #[serde(rename = "eventName")]
593    event_name: Cow<'a, str>,
594}
595
596impl<'a> SetInstrumentationBreakpointParams<'a> {
597    /// Creates a builder for this type with the required parameters:
598    /// * `event_name`: Instrumentation name to stop on.
599    pub fn builder(event_name: impl Into<Cow<'a, str>>) -> SetInstrumentationBreakpointParamsBuilder<'a> {
600        SetInstrumentationBreakpointParamsBuilder {
601            event_name: event_name.into(),
602        }
603    }
604    /// Instrumentation name to stop on.
605    pub fn event_name(&self) -> &str { self.event_name.as_ref() }
606}
607
608
609pub struct SetInstrumentationBreakpointParamsBuilder<'a> {
610    event_name: Cow<'a, str>,
611}
612
613impl<'a> SetInstrumentationBreakpointParamsBuilder<'a> {
614    pub fn build(self) -> SetInstrumentationBreakpointParams<'a> {
615        SetInstrumentationBreakpointParams {
616            event_name: self.event_name,
617        }
618    }
619}
620
621impl<'a> SetInstrumentationBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.setInstrumentationBreakpoint"; }
622
623impl<'a> crate::CdpCommand<'a> for SetInstrumentationBreakpointParams<'a> {
624    const METHOD: &'static str = "DOMDebugger.setInstrumentationBreakpoint";
625    type Response = crate::EmptyReturns;
626}
627
628/// Sets breakpoint on XMLHttpRequest.
629
630#[derive(Debug, Clone, Serialize, Deserialize, Default)]
631#[serde(rename_all = "camelCase")]
632pub struct SetXHRBreakpointParams<'a> {
633    /// Resource URL substring. All XHRs having this substring in the URL will get stopped upon.
634    url: Cow<'a, str>,
635}
636
637impl<'a> SetXHRBreakpointParams<'a> {
638    /// Creates a builder for this type with the required parameters:
639    /// * `url`: Resource URL substring. All XHRs having this substring in the URL will get stopped upon.
640    pub fn builder(url: impl Into<Cow<'a, str>>) -> SetXHRBreakpointParamsBuilder<'a> {
641        SetXHRBreakpointParamsBuilder {
642            url: url.into(),
643        }
644    }
645    /// Resource URL substring. All XHRs having this substring in the URL will get stopped upon.
646    pub fn url(&self) -> &str { self.url.as_ref() }
647}
648
649
650pub struct SetXHRBreakpointParamsBuilder<'a> {
651    url: Cow<'a, str>,
652}
653
654impl<'a> SetXHRBreakpointParamsBuilder<'a> {
655    pub fn build(self) -> SetXHRBreakpointParams<'a> {
656        SetXHRBreakpointParams {
657            url: self.url,
658        }
659    }
660}
661
662impl<'a> SetXHRBreakpointParams<'a> { pub const METHOD: &'static str = "DOMDebugger.setXHRBreakpoint"; }
663
664impl<'a> crate::CdpCommand<'a> for SetXHRBreakpointParams<'a> {
665    const METHOD: &'static str = "DOMDebugger.setXHRBreakpoint";
666    type Response = crate::EmptyReturns;
667}
browser_protocol/domdebugger/mod.rs

browser_protocol/domdebugger/
mod.rs
