use super::InterceptGuard;
use crate::engines::engine_client::{EngineError, InternalScrapeRequest};
use crate::engines::intercept::{InterceptController, ResourceKind, BLOCK_REASON};
use chromiumoxide::cdp::browser_protocol::fetch::{
ContinueRequestParams, EnableParams, EventRequestPaused, FailRequestParams,
};
use futures::StreamExt;
use std::sync::Arc;
pub(super) async fn setup_request_interception(
page: &chromiumoxide::page::Page,
request: &InternalScrapeRequest,
intercept_guard: &mut InterceptGuard,
) -> Result<(), EngineError> {
if request.block_ads || request.block_media {
let controller = Arc::new(InterceptController::new(
request.block_ads,
request.block_media,
));
page.execute(EnableParams::default()).await.map_err(|e| {
EngineError::BrowserError(format!("Failed to enable Fetch interception: {}", e))
})?;
let mut events = page
.event_listener::<EventRequestPaused>()
.await
.map_err(|e| {
EngineError::BrowserError(format!("Failed to subscribe EventRequestPaused: {}", e))
})?;
let page_clone = page.clone();
let controller_clone = Arc::clone(&controller);
let intercept_handle = tokio::spawn(async move {
while let Some(event) = events.next().await {
dispatch_paused_request(&page_clone, &controller_clone, event).await;
}
});
intercept_guard.set(intercept_handle);
}
Ok(())
}
async fn dispatch_paused_request(
page: &chromiumoxide::page::Page,
controller: &InterceptController,
event: Arc<EventRequestPaused>,
) {
let url = event.request.url.clone();
let kind = ResourceKind::from(event.resource_type.clone());
let request_id = event.request_id.clone();
if controller.should_block(&url, Some(kind)) {
controller.record_block();
if let Err(e) = page
.execute(FailRequestParams::new(request_id, BLOCK_REASON))
.await
{
log::debug!("FailRequest failed for {}: {}", url, e);
}
} else if let Err(e) = page.execute(ContinueRequestParams::new(request_id)).await {
log::debug!("ContinueRequest failed for {}: {}", url, e);
}
}