chromiumoxide/handler/
target.rs

1use std::collections::VecDeque;
2use std::pin::Pin;
3use std::sync::Arc;
4use std::time::Instant;
5
6use futures::channel::oneshot::Sender;
7use futures::stream::Stream;
8use futures::task::{Context, Poll};
9
10use crate::auth::Credentials;
11use crate::cdp::browser_protocol::target::CloseTargetParams;
12use crate::cmd::CommandChain;
13use crate::cmd::CommandMessage;
14use crate::error::{CdpError, Result};
15use crate::handler::browser::BrowserContext;
16use crate::handler::domworld::DOMWorldKind;
17use crate::handler::emulation::EmulationManager;
18use crate::handler::frame::FrameRequestedNavigation;
19use crate::handler::frame::{
20    FrameEvent, FrameManager, NavigationError, NavigationId, NavigationOk,
21};
22use crate::handler::network::{NetworkEvent, NetworkManager};
23use crate::handler::page::PageHandle;
24use crate::handler::viewport::Viewport;
25use crate::handler::{PageInner, REQUEST_TIMEOUT};
26use crate::listeners::{EventListenerRequest, EventListeners};
27use crate::{page::Page, ArcHttpRequest};
28use chromiumoxide_cdp::cdp::browser_protocol::{
29    browser::BrowserContextId,
30    log as cdplog,
31    page::{FrameId, GetFrameTreeParams},
32    target::{AttachToTargetParams, SessionId, SetAutoAttachParams, TargetId, TargetInfo},
33};
34use chromiumoxide_cdp::cdp::events::CdpEvent;
35use chromiumoxide_cdp::cdp::js_protocol::runtime::{
36    ExecutionContextId, RunIfWaitingForDebuggerParams,
37};
38use chromiumoxide_cdp::cdp::CdpEventMessage;
39use chromiumoxide_types::{Command, Method, MethodId, Request, Response};
40use spider_network_blocker::intercept_manager::NetworkInterceptManager;
41use std::time::Duration;
42
43macro_rules! advance_state {
44    ($s:ident, $cx:ident, $now:ident, $cmds: ident, $next_state:expr ) => {{
45        if let Poll::Ready(poll) = $cmds.poll($now) {
46            return match poll {
47                None => {
48                    $s.init_state = $next_state;
49                    $s.poll($cx, $now)
50                }
51                Some(Ok((method, params))) => Some(TargetEvent::Request(Request {
52                    method,
53                    session_id: $s.session_id.clone().map(Into::into),
54                    params,
55                })),
56                Some(Err(_)) => Some($s.on_initialization_failed()),
57            };
58        } else {
59            return None;
60        }
61    }};
62}
63
64lazy_static::lazy_static! {
65    /// Initial start command params (global SetAutoAttach + disable logging + optional performance).
66    static ref INIT_COMMANDS_PARAMS: Vec<(MethodId, serde_json::Value)> = {
67        if let Ok(attach) = SetAutoAttachParams::builder()
68            .flatten(true)
69            .auto_attach(true)
70            .wait_for_debugger_on_start(true)
71            .build() {
72                let disable_log = cdplog::DisableParams::default();
73
74                let mut cmds =  vec![
75                    (
76                        attach.identifier(),
77                        serde_json::to_value(attach).unwrap_or_default(),
78                    ),
79                    (
80                        disable_log.identifier(),
81                        serde_json::to_value(disable_log).unwrap_or_default(),
82                    )
83                ];
84
85                // enable performance on pages.
86                if cfg!(feature = "collect_metrics") {
87                    let enable_performance = chromiumoxide_cdp::cdp::browser_protocol::performance::EnableParams::default();
88                    cmds.push((
89                        enable_performance.identifier(),
90                        serde_json::to_value(enable_performance).unwrap_or_default(),
91                    ));
92                }
93
94                cmds
95            } else {
96                vec![]
97            }
98    };
99
100    /// Attach to target commands (RunIfWaitingForDebugger).
101    static ref ATTACH_TARGET: (MethodId, serde_json::Value) = {
102        let runtime_cmd = RunIfWaitingForDebuggerParams::default();
103        (
104            runtime_cmd.identifier(),
105            serde_json::to_value(runtime_cmd).unwrap_or_default()
106        )
107    };
108}
109
110#[derive(Debug)]
111pub struct Target {
112    /// Info about this target as returned from the chromium instance
113    info: TargetInfo,
114    /// The type of this target
115    r#type: TargetType,
116    /// Configs for this target
117    config: TargetConfig,
118    /// The context this target is running in
119    browser_context: BrowserContext,
120    /// The frame manager that maintains the state of all frames and handles
121    /// navigations of frames
122    frame_manager: FrameManager,
123    /// Handles all the https
124    pub(crate) network_manager: NetworkManager,
125    emulation_manager: EmulationManager,
126    /// The identifier of the session this target is attached to
127    session_id: Option<SessionId>,
128    /// The handle of the browser page of this target
129    page: Option<PageHandle>,
130    /// Drives this target towards initialization
131    pub(crate) init_state: TargetInit,
132    /// Currently queued events to report to the `Handler`
133    queued_events: VecDeque<TargetEvent>,
134    /// All registered event subscriptions
135    event_listeners: EventListeners,
136    /// Senders that need to be notified once the main frame has loaded
137    wait_for_frame_navigation: Vec<Sender<ArcHttpRequest>>,
138    /// Senders that need to be notified once the main frame reaches `networkIdle`.
139    wait_for_network_idle: Vec<Sender<ArcHttpRequest>>,
140    /// (Optional) for `networkAlmostIdle` if you want it as well.
141    wait_for_network_almost_idle: Vec<Sender<ArcHttpRequest>>,
142    /// The sender who requested the page.
143    initiator: Option<Sender<Result<Page>>>,
144    /// Emulation init commands we want to forward to worker / service_worker / shared_worker targets.
145    attached_emulation_init_cmds: Vec<(MethodId, serde_json::Value)>,
146    /// Set attached agents.
147    attached_user_agent_override: Option<(MethodId, serde_json::Value)>,
148}
149
150impl Target {
151    /// Create a new target instance with `TargetInfo` after a
152    /// `CreateTargetParams` request.
153    pub fn new(info: TargetInfo, config: TargetConfig, browser_context: BrowserContext) -> Self {
154        let ty = TargetType::new(&info.r#type);
155        let request_timeout: Duration = config.request_timeout;
156        let mut network_manager = NetworkManager::new(config.ignore_https_errors, request_timeout);
157
158        if !config.cache_enabled {
159            network_manager.set_cache_enabled(false);
160        }
161
162        if !config.service_worker_enabled {
163            network_manager.set_service_worker_enabled(true);
164        }
165
166        network_manager.set_request_interception(config.request_intercept);
167        network_manager.max_bytes_allowed = config.max_bytes_allowed;
168
169        if let Some(headers) = &config.extra_headers {
170            network_manager.set_extra_headers(headers.clone());
171        }
172
173        if let Some(white_list) = &config.whitelist_patterns {
174            network_manager.set_whitelist_patterns(white_list.clone());
175        }
176
177        network_manager.ignore_visuals = config.ignore_visuals;
178        network_manager.block_javascript = config.ignore_javascript;
179        network_manager.block_analytics = config.ignore_analytics;
180        network_manager.block_stylesheets = config.ignore_stylesheets;
181        network_manager.only_html = config.only_html;
182        network_manager.intercept_manager = config.intercept_manager;
183
184        Self {
185            info,
186            r#type: ty,
187            config,
188            frame_manager: FrameManager::new(request_timeout),
189            network_manager,
190            emulation_manager: EmulationManager::new(request_timeout),
191            session_id: None,
192            page: None,
193            init_state: TargetInit::AttachToTarget,
194            wait_for_frame_navigation: Default::default(),
195            wait_for_network_idle: Default::default(),
196            wait_for_network_almost_idle: Default::default(),
197            queued_events: Default::default(),
198            event_listeners: Default::default(),
199            initiator: None,
200            browser_context,
201            attached_emulation_init_cmds: Vec::new(),
202            attached_user_agent_override: None,
203        }
204    }
205
206    /// Set the session id.
207    pub fn set_session_id(&mut self, id: SessionId) {
208        self.session_id = Some(id)
209    }
210
211    /// Get the session id.
212    pub fn session_id(&self) -> Option<&SessionId> {
213        self.session_id.as_ref()
214    }
215
216    /// Get the session id mut.
217    pub fn session_id_mut(&mut self) -> &mut Option<SessionId> {
218        &mut self.session_id
219    }
220
221    /// Get the browser context.
222    pub fn browser_context(&self) -> &BrowserContext {
223        &self.browser_context
224    }
225
226    /// The identifier for this target
227    pub fn target_id(&self) -> &TargetId {
228        &self.info.target_id
229    }
230
231    /// The type of this target
232    pub fn r#type(&self) -> &TargetType {
233        &self.r#type
234    }
235
236    /// Whether this target is already initialized
237    pub fn is_initialized(&self) -> bool {
238        matches!(self.init_state, TargetInit::Initialized)
239    }
240
241    /// Navigate a frame
242    pub fn goto(&mut self, req: FrameRequestedNavigation) {
243        if self.network_manager.has_target_domain() {
244            self.network_manager.clear_target_domain();
245            let goto_url = req
246                .req
247                .params
248                .as_object()
249                .and_then(|o| o.get("url"))
250                .and_then(|v| v.as_str());
251
252            if let Some(url) = goto_url {
253                self.network_manager.set_page_url(url.into());
254            }
255        }
256        self.frame_manager.goto(req);
257    }
258
259    /// Create a new page from the session.
260    fn create_page(&mut self) {
261        if self.page.is_none() {
262            if let Some(session) = self.session_id.clone() {
263                let handle =
264                    PageHandle::new(self.target_id().clone(), session, self.opener_id().cloned());
265                self.page = Some(handle);
266            }
267        }
268    }
269
270    /// Tries to create the `PageInner` if this target is already initialized
271    pub(crate) fn get_or_create_page(&mut self) -> Option<&Arc<PageInner>> {
272        self.create_page();
273        self.page.as_ref().map(|p| p.inner())
274    }
275
276    /// Is the target a page?
277    pub fn is_page(&self) -> bool {
278        self.r#type().is_page()
279    }
280
281    /// The browser context ID.
282    pub fn browser_context_id(&self) -> Option<&BrowserContextId> {
283        self.info.browser_context_id.as_ref()
284    }
285
286    /// The target connection info.
287    pub fn info(&self) -> &TargetInfo {
288        &self.info
289    }
290
291    /// Get the target that opened this target. Top-level targets return `None`.
292    pub fn opener_id(&self) -> Option<&TargetId> {
293        self.info.opener_id.as_ref()
294    }
295
296    pub fn frame_manager(&self) -> &FrameManager {
297        &self.frame_manager
298    }
299
300    /// The frame manager.
301    pub fn frame_manager_mut(&mut self) -> &mut FrameManager {
302        &mut self.frame_manager
303    }
304
305    /// Get event listeners mutably.
306    pub fn event_listeners_mut(&mut self) -> &mut EventListeners {
307        &mut self.event_listeners
308    }
309
310    /// Received a response to a command issued by this target
311    pub fn on_response(&mut self, resp: Response, method: &str) {
312        if let Some(cmds) = self.init_state.commands_mut() {
313            cmds.received_response(method);
314        }
315
316        if let GetFrameTreeParams::IDENTIFIER = method {
317            if let Some(resp) = resp
318                .result
319                .and_then(|val| GetFrameTreeParams::response_from_value(val).ok())
320            {
321                self.frame_manager.on_frame_tree(resp.frame_tree);
322            }
323        }
324        // requests originated from the network manager all return an empty response, hence they
325        // can be ignored here
326    }
327
328    /// On CDP Event message.
329    pub fn on_event(&mut self, event: CdpEventMessage) {
330        let CdpEventMessage {
331            params,
332            method,
333            session_id,
334            ..
335        } = event;
336
337        let is_session_scoped = matches!(
338            params,
339            CdpEvent::FetchRequestPaused(_)
340                | CdpEvent::FetchAuthRequired(_)
341                | CdpEvent::NetworkRequestWillBeSent(_)
342                | CdpEvent::NetworkResponseReceived(_)
343                | CdpEvent::NetworkLoadingFinished(_)
344                | CdpEvent::NetworkLoadingFailed(_)
345                | CdpEvent::PageFrameAttached(_)
346                | CdpEvent::PageFrameDetached(_)
347                | CdpEvent::PageFrameNavigated(_)
348                | CdpEvent::PageNavigatedWithinDocument(_)
349                | CdpEvent::PageLifecycleEvent(_)
350                | CdpEvent::PageFrameStartedLoading(_)
351                | CdpEvent::PageFrameStoppedLoading(_)
352                | CdpEvent::RuntimeExecutionContextCreated(_)
353                | CdpEvent::RuntimeExecutionContextDestroyed(_)
354                | CdpEvent::RuntimeExecutionContextsCleared(_)
355                | CdpEvent::RuntimeBindingCalled(_)
356        );
357
358        if is_session_scoped {
359            let ev_sid: &str = match session_id.as_deref() {
360                Some(s) => s,
361                None => return,
362            };
363
364            let self_sid: &str = match self.session_id.as_ref() {
365                Some(sid) => sid.as_ref(),
366                None => return,
367            };
368
369            if self_sid != ev_sid {
370                return;
371            }
372        }
373
374        match &params {
375            // `FrameManager` events
376            CdpEvent::PageFrameAttached(ev) => self
377                .frame_manager
378                .on_frame_attached(ev.frame_id.clone(), Some(ev.parent_frame_id.clone())),
379            CdpEvent::PageFrameDetached(ev) => self.frame_manager.on_frame_detached(ev),
380            CdpEvent::PageFrameNavigated(ev) => {
381                self.frame_manager.on_frame_navigated(&ev.frame);
382            }
383            CdpEvent::PageNavigatedWithinDocument(ev) => {
384                self.frame_manager.on_frame_navigated_within_document(ev)
385            }
386            CdpEvent::RuntimeExecutionContextCreated(ev) => {
387                self.frame_manager.on_frame_execution_context_created(ev)
388            }
389            CdpEvent::RuntimeExecutionContextDestroyed(ev) => {
390                self.frame_manager.on_frame_execution_context_destroyed(ev)
391            }
392            CdpEvent::RuntimeExecutionContextsCleared(_) => {
393                self.frame_manager.on_execution_contexts_cleared()
394            }
395            CdpEvent::RuntimeBindingCalled(ev) => {
396                // TODO check if binding registered and payload is json
397                self.frame_manager.on_runtime_binding_called(ev)
398            }
399            CdpEvent::PageLifecycleEvent(ev) => self.frame_manager.on_page_lifecycle_event(ev),
400            CdpEvent::PageFrameStartedLoading(ev) => {
401                self.frame_manager.on_frame_started_loading(ev);
402            }
403            CdpEvent::PageFrameStoppedLoading(ev) => {
404                self.frame_manager.on_frame_stopped_loading(ev);
405            }
406            // `Target` events
407            CdpEvent::TargetAttachedToTarget(ev) => {
408                if ev.waiting_for_debugger {
409                    let runtime_cmd = ATTACH_TARGET.clone();
410
411                    self.queued_events.push_back(TargetEvent::Request(Request {
412                        method: runtime_cmd.0,
413                        session_id: Some(ev.session_id.clone().into()),
414                        params: runtime_cmd.1,
415                    }));
416                }
417
418                let target_type = ev.target_info.r#type.as_str();
419                let is_worker_like =
420                    matches!(target_type, "worker" | "shared_worker" | "service_worker");
421
422                if is_worker_like {
423                    for (method, params) in &self.attached_emulation_init_cmds {
424                        self.queued_events.push_back(TargetEvent::Request(Request {
425                            method: method.clone(),
426                            session_id: Some(ev.session_id.clone().into()),
427                            params: params.clone(),
428                        }));
429                    }
430
431                    if let Some((method, params)) = &self.attached_user_agent_override {
432                        self.queued_events.push_back(TargetEvent::Request(Request {
433                            method: method.clone(),
434                            session_id: Some(ev.session_id.clone().into()),
435                            params: params.clone(),
436                        }));
437                    }
438                }
439            }
440            // `NetworkManager` events
441            CdpEvent::FetchRequestPaused(ev) => self.network_manager.on_fetch_request_paused(ev),
442            CdpEvent::FetchAuthRequired(ev) => self.network_manager.on_fetch_auth_required(ev),
443            CdpEvent::NetworkRequestWillBeSent(ev) => {
444                self.network_manager.on_request_will_be_sent(ev)
445            }
446            CdpEvent::NetworkRequestServedFromCache(ev) => {
447                self.network_manager.on_request_served_from_cache(ev)
448            }
449            CdpEvent::NetworkResponseReceived(ev) => self.network_manager.on_response_received(ev),
450            CdpEvent::NetworkLoadingFinished(ev) => {
451                self.network_manager.on_network_loading_finished(ev)
452            }
453            CdpEvent::NetworkLoadingFailed(ev) => {
454                self.network_manager.on_network_loading_failed(ev)
455            }
456            _ => (),
457        }
458        chromiumoxide_cdp::consume_event!(match params {
459           |ev| self.event_listeners.start_send(ev),
460           |json| { let _ = self.event_listeners.try_send_custom(&method, json);}
461        });
462    }
463
464    /// Called when a init command timed out
465    fn on_initialization_failed(&mut self) -> TargetEvent {
466        if let Some(initiator) = self.initiator.take() {
467            let _ = initiator.send(Err(CdpError::Timeout));
468        }
469        self.init_state = TargetInit::Closing;
470        let close_target = CloseTargetParams::new(self.info.target_id.clone());
471
472        TargetEvent::Request(Request {
473            method: close_target.identifier(),
474            session_id: self.session_id.clone().map(Into::into),
475            params: serde_json::to_value(close_target).unwrap_or_default(),
476        })
477    }
478
479    /// Advance that target's state
480    pub(crate) fn poll(&mut self, cx: &mut Context<'_>, now: Instant) -> Option<TargetEvent> {
481        if !self.is_page() {
482            // can only poll pages
483            return None;
484        }
485
486        match &mut self.init_state {
487            TargetInit::AttachToTarget => {
488                self.init_state = TargetInit::InitializingFrame(FrameManager::init_commands(
489                    self.config.request_timeout,
490                ));
491
492                if let Ok(params) = AttachToTargetParams::builder()
493                    .target_id(self.target_id().clone())
494                    .flatten(true)
495                    .build()
496                {
497                    return Some(TargetEvent::Request(Request::new(
498                        params.identifier(),
499                        serde_json::to_value(params).unwrap_or_default(),
500                    )));
501                } else {
502                    return None;
503                }
504            }
505            TargetInit::InitializingFrame(cmds) => {
506                self.session_id.as_ref()?;
507                if let Poll::Ready(poll) = cmds.poll(now) {
508                    return match poll {
509                        None => {
510                            if let Some(world_name) = self.frame_manager.get_isolated_world_name() {
511                                let world_name = world_name.clone();
512
513                                if let Some(isolated_world_cmds) =
514                                    self.frame_manager.ensure_isolated_world(&world_name)
515                                {
516                                    *cmds = isolated_world_cmds;
517                                } else {
518                                    self.init_state = TargetInit::InitializingNetwork(
519                                        self.network_manager.init_commands(),
520                                    );
521                                }
522                            } else {
523                                self.init_state = TargetInit::InitializingNetwork(
524                                    self.network_manager.init_commands(),
525                                );
526                            }
527                            self.poll(cx, now)
528                        }
529                        Some(Ok((method, params))) => Some(TargetEvent::Request(Request {
530                            method,
531                            session_id: self.session_id.clone().map(Into::into),
532                            params,
533                        })),
534                        Some(Err(_)) => Some(self.on_initialization_failed()),
535                    };
536                } else {
537                    return None;
538                }
539            }
540            TargetInit::InitializingNetwork(cmds) => {
541                advance_state!(
542                    self,
543                    cx,
544                    now,
545                    cmds,
546                    TargetInit::InitializingPage(Self::page_init_commands(
547                        self.config.request_timeout
548                    ))
549                );
550            }
551            TargetInit::InitializingPage(cmds) => {
552                advance_state!(
553                    self,
554                    cx,
555                    now,
556                    cmds,
557                    match self.config.viewport.as_ref() {
558                        Some(viewport) => TargetInit::InitializingEmulation(
559                            self.emulation_manager.init_commands(viewport)
560                        ),
561                        None => TargetInit::Initialized,
562                    }
563                );
564            }
565            TargetInit::InitializingEmulation(cmds) => {
566                if let Poll::Ready(poll) = cmds.poll(now) {
567                    return match poll {
568                        None => {
569                            self.init_state = TargetInit::Initialized;
570                            self.poll(cx, now)
571                        }
572                        Some(Ok((method, params))) => {
573                            if method.as_ref().starts_with("Emulation.") {
574                                self.attached_emulation_init_cmds
575                                    .push((method.clone(), params.clone()));
576                            }
577
578                            Some(TargetEvent::Request(Request {
579                                method,
580                                session_id: self.session_id.clone().map(Into::into),
581                                params,
582                            }))
583                        }
584                        Some(Err(_)) => Some(self.on_initialization_failed()),
585                    };
586                } else {
587                    return None;
588                }
589            }
590            TargetInit::Initialized => {
591                if let Some(initiator) = self.initiator.take() {
592                    // make sure that the main frame of the page has finished loading
593                    if self
594                        .frame_manager
595                        .main_frame()
596                        .map(|frame| frame.is_loaded())
597                        .unwrap_or_default()
598                    {
599                        if let Some(page) = self.get_or_create_page() {
600                            let _ = initiator.send(Ok(page.clone().into()));
601                        } else {
602                            self.initiator = Some(initiator);
603                        }
604                    } else {
605                        self.initiator = Some(initiator);
606                    }
607                }
608            }
609            TargetInit::Closing => return None,
610        };
611
612        loop {
613            if self.init_state == TargetInit::Closing {
614                break None;
615            }
616
617            if let Some(frame) = self.frame_manager.main_frame() {
618                if frame.is_loaded() {
619                    while let Some(tx) = self.wait_for_frame_navigation.pop() {
620                        let _ = tx.send(frame.http_request().cloned());
621                    }
622                }
623
624                if frame.is_network_idle() {
625                    while let Some(tx) = self.wait_for_network_idle.pop() {
626                        let _ = tx.send(frame.http_request().cloned());
627                    }
628                }
629
630                if frame.is_network_almost_idle() {
631                    while let Some(tx) = self.wait_for_network_almost_idle.pop() {
632                        let _ = tx.send(frame.http_request().cloned());
633                    }
634                }
635            }
636
637            // Drain queued messages first.
638            if let Some(ev) = self.queued_events.pop_front() {
639                return Some(ev);
640            }
641
642            if let Some(handle) = self.page.as_mut() {
643                while let Poll::Ready(Some(msg)) = Pin::new(&mut handle.rx).poll_next(cx) {
644                    if self.init_state == TargetInit::Closing {
645                        break;
646                    }
647
648                    match msg {
649                        TargetMessage::Command(cmd) => {
650                            if cmd.method == "Network.setBlockedURLs" {
651                                if let Some(arr) = cmd.params.get("urls").and_then(|v| v.as_array())
652                                {
653                                    let mut unblock_all = false;
654                                    let mut block_all = false;
655
656                                    for s in arr.iter().filter_map(|v| v.as_str()) {
657                                        if s == "!*" {
658                                            unblock_all = true;
659                                            break; // "!*" overrides any block rules
660                                        }
661                                        if s.contains('*') {
662                                            block_all = true;
663                                        }
664                                    }
665
666                                    if unblock_all {
667                                        self.network_manager.set_block_all(false);
668                                    } else if block_all {
669                                        self.network_manager.set_block_all(true);
670                                    }
671                                }
672                            }
673
674                            let method_str = cmd.method.as_ref();
675                            if method_str == "Network.setUserAgentOverride"
676                                || method_str == "Emulation.setUserAgentOverride"
677                            {
678                                self.attached_user_agent_override =
679                                    Some((cmd.method.clone(), cmd.params.clone()));
680                            }
681
682                            self.queued_events.push_back(TargetEvent::Command(cmd));
683                        }
684                        TargetMessage::MainFrame(tx) => {
685                            let _ =
686                                tx.send(self.frame_manager.main_frame().map(|f| f.id().clone()));
687                        }
688                        TargetMessage::AllFrames(tx) => {
689                            let _ = tx.send(
690                                self.frame_manager
691                                    .frames()
692                                    .map(|f| f.id().clone())
693                                    .collect(),
694                            );
695                        }
696                        #[cfg(feature = "_cache")]
697                        TargetMessage::CacheKey((cache_key, cache_policy)) => {
698                            self.network_manager.set_cache_site_key(cache_key);
699                            self.network_manager.set_cache_policy(cache_policy);
700                        }
701                        TargetMessage::Url(req) => {
702                            let GetUrl { frame_id, tx } = req;
703                            let frame = if let Some(frame_id) = frame_id {
704                                self.frame_manager.frame(&frame_id)
705                            } else {
706                                self.frame_manager.main_frame()
707                            };
708                            let _ = tx.send(frame.and_then(|f| f.url().map(str::to_string)));
709                        }
710                        TargetMessage::Name(req) => {
711                            let GetName { frame_id, tx } = req;
712                            let frame = if let Some(frame_id) = frame_id {
713                                self.frame_manager.frame(&frame_id)
714                            } else {
715                                self.frame_manager.main_frame()
716                            };
717                            let _ = tx.send(frame.and_then(|f| f.name().map(str::to_string)));
718                        }
719                        TargetMessage::Parent(req) => {
720                            let GetParent { frame_id, tx } = req;
721                            let frame = self.frame_manager.frame(&frame_id);
722                            let _ = tx.send(frame.and_then(|f| f.parent_id().cloned()));
723                        }
724                        TargetMessage::WaitForNavigation(tx) => {
725                            if let Some(frame) = self.frame_manager.main_frame() {
726                                // TODO submit a navigation watcher: waitForFrameNavigation
727
728                                // TODO return the watchers navigationResponse
729                                if frame.is_loaded() {
730                                    let _ = tx.send(frame.http_request().cloned());
731                                } else {
732                                    self.wait_for_frame_navigation.push(tx);
733                                }
734                            } else {
735                                self.wait_for_frame_navigation.push(tx);
736                            }
737                        }
738                        TargetMessage::WaitForNetworkIdle(tx) => {
739                            if let Some(frame) = self.frame_manager.main_frame() {
740                                if frame.is_network_idle() {
741                                    let _ = tx.send(frame.http_request().cloned());
742                                } else {
743                                    self.wait_for_network_idle.push(tx);
744                                }
745                            } else {
746                                self.wait_for_network_idle.push(tx);
747                            }
748                        }
749                        TargetMessage::WaitForNetworkAlmostIdle(tx) => {
750                            if let Some(frame) = self.frame_manager.main_frame() {
751                                if frame.is_network_almost_idle() {
752                                    let _ = tx.send(frame.http_request().cloned());
753                                } else {
754                                    self.wait_for_network_almost_idle.push(tx);
755                                }
756                            } else {
757                                self.wait_for_network_almost_idle.push(tx);
758                            }
759                        }
760                        TargetMessage::AddEventListener(req) => {
761                            if req.method == "Fetch.requestPaused" {
762                                self.network_manager.enable_request_intercept();
763                            }
764                            // register a new listener
765                            self.event_listeners.add_listener(req);
766                        }
767                        TargetMessage::GetExecutionContext(ctx) => {
768                            let GetExecutionContext {
769                                dom_world,
770                                frame_id,
771                                tx,
772                            } = ctx;
773                            let frame = if let Some(frame_id) = frame_id {
774                                self.frame_manager.frame(&frame_id)
775                            } else {
776                                self.frame_manager.main_frame()
777                            };
778
779                            if let Some(frame) = frame {
780                                match dom_world {
781                                    DOMWorldKind::Main => {
782                                        let _ = tx.send(frame.main_world().execution_context());
783                                    }
784                                    DOMWorldKind::Secondary => {
785                                        let _ =
786                                            tx.send(frame.secondary_world().execution_context());
787                                    }
788                                }
789                            } else {
790                                let _ = tx.send(None);
791                            }
792                        }
793                        TargetMessage::Authenticate(credentials) => {
794                            self.network_manager.authenticate(credentials);
795                        }
796                    }
797                }
798            }
799
800            while let Some(event) = self.network_manager.poll() {
801                if self.init_state == TargetInit::Closing {
802                    break;
803                }
804                match event {
805                    NetworkEvent::SendCdpRequest((method, params)) => {
806                        // send a message to the browser
807                        self.queued_events.push_back(TargetEvent::Request(Request {
808                            method,
809                            session_id: self.session_id.clone().map(Into::into),
810                            params,
811                        }))
812                    }
813                    NetworkEvent::Request(_) => {}
814                    NetworkEvent::Response(_) => {}
815                    NetworkEvent::RequestFailed(request) => {
816                        self.frame_manager.on_http_request_finished(request);
817                    }
818                    NetworkEvent::RequestFinished(request) => {
819                        self.frame_manager.on_http_request_finished(request);
820                    }
821                    NetworkEvent::BytesConsumed(n) => {
822                        self.queued_events.push_back(TargetEvent::BytesConsumed(n));
823                    }
824                }
825            }
826
827            while let Some(event) = self.frame_manager.poll(now) {
828                if self.init_state == TargetInit::Closing {
829                    break;
830                }
831                match event {
832                    FrameEvent::NavigationResult(res) => {
833                        self.queued_events
834                            .push_back(TargetEvent::NavigationResult(res));
835                    }
836                    FrameEvent::NavigationRequest(id, req) => {
837                        self.queued_events
838                            .push_back(TargetEvent::NavigationRequest(id, req));
839                    }
840                }
841            }
842
843            if self.queued_events.is_empty() {
844                return None;
845            }
846        }
847    }
848
849    /// Set the sender half of the channel who requested the creation of this
850    /// target
851    pub fn set_initiator(&mut self, tx: Sender<Result<Page>>) {
852        self.initiator = Some(tx);
853    }
854
855    pub(crate) fn page_init_commands(timeout: Duration) -> CommandChain {
856        CommandChain::new(INIT_COMMANDS_PARAMS.clone(), timeout)
857    }
858}
859
860/// Configuration for how a single target/page should be fetched and processed.
861#[derive(Debug, Clone)]
862pub struct TargetConfig {
863    pub ignore_https_errors: bool,
864    pub request_timeout: Duration,
865    pub viewport: Option<Viewport>,
866    pub request_intercept: bool,
867    pub cache_enabled: bool,
868    pub ignore_visuals: bool,
869    pub ignore_javascript: bool,
870    pub ignore_analytics: bool,
871    pub ignore_stylesheets: bool,
872    pub only_html: bool,
873    pub service_worker_enabled: bool,
874    pub extra_headers: Option<std::collections::HashMap<String, String>>,
875    pub intercept_manager: NetworkInterceptManager,
876    pub max_bytes_allowed: Option<u64>,
877    pub whitelist_patterns: Option<Vec<String>>,
878}
879
880impl Default for TargetConfig {
881    fn default() -> Self {
882        Self {
883            ignore_https_errors: true,
884            request_timeout: Duration::from_secs(REQUEST_TIMEOUT),
885            viewport: Default::default(),
886            request_intercept: false,
887            cache_enabled: true,
888            service_worker_enabled: true,
889            ignore_javascript: false,
890            ignore_visuals: false,
891            ignore_stylesheets: false,
892            ignore_analytics: true,
893            only_html: false,
894            extra_headers: Default::default(),
895            intercept_manager: NetworkInterceptManager::Unknown,
896            max_bytes_allowed: None,
897            whitelist_patterns: None,
898        }
899    }
900}
901
902#[derive(Debug, Clone, Eq, PartialEq)]
903pub enum TargetType {
904    Page,
905    BackgroundPage,
906    ServiceWorker,
907    SharedWorker,
908    Other,
909    Browser,
910    Webview,
911    Unknown(String),
912}
913
914impl TargetType {
915    pub fn new(ty: &str) -> Self {
916        match ty {
917            "page" => TargetType::Page,
918            "background_page" => TargetType::BackgroundPage,
919            "service_worker" => TargetType::ServiceWorker,
920            "shared_worker" => TargetType::SharedWorker,
921            "other" => TargetType::Other,
922            "browser" => TargetType::Browser,
923            "webview" => TargetType::Webview,
924            s => TargetType::Unknown(s.to_string()),
925        }
926    }
927
928    pub fn is_page(&self) -> bool {
929        matches!(self, TargetType::Page)
930    }
931
932    pub fn is_background_page(&self) -> bool {
933        matches!(self, TargetType::BackgroundPage)
934    }
935
936    pub fn is_service_worker(&self) -> bool {
937        matches!(self, TargetType::ServiceWorker)
938    }
939
940    pub fn is_shared_worker(&self) -> bool {
941        matches!(self, TargetType::SharedWorker)
942    }
943
944    pub fn is_other(&self) -> bool {
945        matches!(self, TargetType::Other)
946    }
947
948    pub fn is_browser(&self) -> bool {
949        matches!(self, TargetType::Browser)
950    }
951
952    pub fn is_webview(&self) -> bool {
953        matches!(self, TargetType::Webview)
954    }
955}
956
957#[derive(Debug)]
958pub(crate) enum TargetEvent {
959    /// An internal request
960    Request(Request),
961    /// An internal navigation request
962    NavigationRequest(NavigationId, Request),
963    /// Indicates that a previous requested navigation has finished
964    NavigationResult(Result<NavigationOk, NavigationError>),
965    /// A new command arrived via a channel
966    Command(CommandMessage),
967    /// The bytes consumed by the network.
968    BytesConsumed(u64),
969}
970
971// TODO this can be moved into the classes?
972#[derive(Debug, PartialEq)]
973pub enum TargetInit {
974    InitializingFrame(CommandChain),
975    InitializingNetwork(CommandChain),
976    InitializingPage(CommandChain),
977    InitializingEmulation(CommandChain),
978    AttachToTarget,
979    Initialized,
980    Closing,
981}
982
983impl TargetInit {
984    fn commands_mut(&mut self) -> Option<&mut CommandChain> {
985        match self {
986            TargetInit::InitializingFrame(cmd) => Some(cmd),
987            TargetInit::InitializingNetwork(cmd) => Some(cmd),
988            TargetInit::InitializingPage(cmd) => Some(cmd),
989            TargetInit::InitializingEmulation(cmd) => Some(cmd),
990            TargetInit::AttachToTarget => None,
991            TargetInit::Initialized => None,
992            TargetInit::Closing => None,
993        }
994    }
995}
996
997#[derive(Debug)]
998pub struct GetExecutionContext {
999    /// For which world the execution context was requested
1000    pub dom_world: DOMWorldKind,
1001    /// The id of the frame to get the `ExecutionContext` for
1002    pub frame_id: Option<FrameId>,
1003    /// Sender half of the channel to send the response back
1004    pub tx: Sender<Option<ExecutionContextId>>,
1005}
1006
1007impl GetExecutionContext {
1008    pub fn new(tx: Sender<Option<ExecutionContextId>>) -> Self {
1009        Self {
1010            dom_world: DOMWorldKind::Main,
1011            frame_id: None,
1012            tx,
1013        }
1014    }
1015}
1016
1017#[derive(Debug)]
1018pub struct GetUrl {
1019    /// The id of the frame to get the url for (None = main frame)
1020    pub frame_id: Option<FrameId>,
1021    /// Sender half of the channel to send the response back
1022    pub tx: Sender<Option<String>>,
1023}
1024
1025impl GetUrl {
1026    pub fn new(tx: Sender<Option<String>>) -> Self {
1027        Self { frame_id: None, tx }
1028    }
1029}
1030
1031#[derive(Debug)]
1032pub struct GetName {
1033    /// The id of the frame to get the name for (None = main frame)
1034    pub frame_id: Option<FrameId>,
1035    /// Sender half of the channel to send the response back
1036    pub tx: Sender<Option<String>>,
1037}
1038
1039#[derive(Debug)]
1040pub struct GetParent {
1041    /// The id of the frame to get the parent for (None = main frame)
1042    pub frame_id: FrameId,
1043    /// Sender half of the channel to send the response back
1044    pub tx: Sender<Option<FrameId>>,
1045}
1046
1047#[derive(Debug)]
1048pub enum TargetMessage {
1049    /// Execute a command within the session of this target
1050    Command(CommandMessage),
1051    /// Return the main frame of this target's page
1052    MainFrame(Sender<Option<FrameId>>),
1053    /// Return all the frames of this target's page
1054    AllFrames(Sender<Vec<FrameId>>),
1055    #[cfg(feature = "_cache")]
1056    /// Set the cache key and policy for the target page.
1057    CacheKey((Option<String>, Option<crate::cache::BasicCachePolicy>)),
1058    /// Return the url if available
1059    Url(GetUrl),
1060    /// Return the name if available
1061    Name(GetName),
1062    /// Return the parent id of a frame
1063    Parent(GetParent),
1064    /// A Message that resolves when the frame finished loading a new url
1065    WaitForNavigation(Sender<ArcHttpRequest>),
1066    /// A Message that resolves when the frame network is idle
1067    WaitForNetworkIdle(Sender<ArcHttpRequest>),
1068    /// A Message that resolves when the frame network is almost idle
1069    WaitForNetworkAlmostIdle(Sender<ArcHttpRequest>),
1070    /// A request to submit a new listener that gets notified with every
1071    /// received event
1072    AddEventListener(EventListenerRequest),
1073    /// Get the `ExecutionContext` if available
1074    GetExecutionContext(GetExecutionContext),
1075    Authenticate(Credentials),
1076}
chromiumoxide/handler/target.rs

chromiumoxide/handler/
target.rs
