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

browser_protocol/domdebugger/
mod.rs
