mirror of
https://github.com/servo/servo.git
synced 2025-06-06 16:45:39 +00:00
b6b80d4f6f
All logic is implemented in `report_csp_violations` to avoid pulling in various element-logic into SecurityManager. Update the `icon-blocked.sub.html` WPT test to ensure that the document is the correct target (verified in Firefox and Chrome). Fixes #36806 Signed-off-by: Tim van der Lippe <tvanderlippe@gmail.com>
1034 lines
40 KiB
Rust
1034 lines
40 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
||
|
||
use std::collections::HashSet;
|
||
use std::rc::Rc;
|
||
use std::sync::{Arc, Mutex};
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
|
||
use content_security_policy as csp;
|
||
use content_security_policy::Destination;
|
||
use dom_struct::dom_struct;
|
||
use embedder_traits::{
|
||
EmbedderMsg, Notification as EmbedderNotification,
|
||
NotificationAction as EmbedderNotificationAction,
|
||
};
|
||
use ipc_channel::ipc;
|
||
use ipc_channel::router::ROUTER;
|
||
use js::jsapi::Heap;
|
||
use js::jsval::JSVal;
|
||
use js::rust::{HandleObject, MutableHandleValue};
|
||
use net_traits::http_status::HttpStatus;
|
||
use net_traits::image_cache::{
|
||
ImageCache, ImageCacheResult, ImageOrMetadataAvailable, ImageResponder, ImageResponse,
|
||
PendingImageId, PendingImageResponse, UsePlaceholder,
|
||
};
|
||
use net_traits::request::{RequestBuilder, RequestId};
|
||
use net_traits::{
|
||
FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError, ResourceFetchTiming,
|
||
ResourceTimingType,
|
||
};
|
||
use pixels::Image;
|
||
use servo_url::{ImmutableOrigin, ServoUrl};
|
||
use uuid::Uuid;
|
||
|
||
use super::bindings::cell::DomRefCell;
|
||
use super::bindings::refcounted::{Trusted, TrustedPromise};
|
||
use super::bindings::reflector::DomGlobal;
|
||
use super::performanceresourcetiming::InitiatorType;
|
||
use super::permissionstatus::PermissionStatus;
|
||
use crate::dom::bindings::callback::ExceptionHandling;
|
||
use crate::dom::bindings::codegen::Bindings::NotificationBinding::{
|
||
NotificationAction, NotificationDirection, NotificationMethods, NotificationOptions,
|
||
NotificationPermission, NotificationPermissionCallback,
|
||
};
|
||
use crate::dom::bindings::codegen::Bindings::PermissionStatusBinding::PermissionStatus_Binding::PermissionStatusMethods;
|
||
use crate::dom::bindings::codegen::Bindings::PermissionStatusBinding::{
|
||
PermissionDescriptor, PermissionName, PermissionState,
|
||
};
|
||
use crate::dom::bindings::codegen::UnionTypes::UnsignedLongOrUnsignedLongSequence;
|
||
use crate::dom::bindings::error::{Error, Fallible};
|
||
use crate::dom::bindings::inheritance::Castable;
|
||
use crate::dom::bindings::reflector::reflect_dom_object_with_proto;
|
||
use crate::dom::bindings::root::{Dom, DomRoot};
|
||
use crate::dom::bindings::str::{DOMString, USVString};
|
||
use crate::dom::bindings::trace::RootedTraceableBox;
|
||
use crate::dom::bindings::utils::to_frozen_array;
|
||
use crate::dom::eventtarget::EventTarget;
|
||
use crate::dom::globalscope::GlobalScope;
|
||
use crate::dom::permissions::{PermissionAlgorithm, Permissions, descriptor_permission_state};
|
||
use crate::dom::promise::Promise;
|
||
use crate::dom::serviceworkerglobalscope::ServiceWorkerGlobalScope;
|
||
use crate::dom::serviceworkerregistration::ServiceWorkerRegistration;
|
||
use crate::fetch::create_a_potential_cors_request;
|
||
use crate::network_listener::{self, PreInvoke, ResourceTimingListener};
|
||
use crate::script_runtime::{CanGc, JSContext as SafeJSContext};
|
||
|
||
// TODO: Service Worker API (persistent notification)
|
||
// https://notifications.spec.whatwg.org/#service-worker-api
|
||
|
||
/// <https://notifications.spec.whatwg.org/#notifications>
|
||
#[dom_struct]
|
||
pub(crate) struct Notification {
|
||
eventtarget: EventTarget,
|
||
/// <https://notifications.spec.whatwg.org/#service-worker-registration>
|
||
serviceworker_registration: Option<Dom<ServiceWorkerRegistration>>,
|
||
/// <https://notifications.spec.whatwg.org/#concept-title>
|
||
title: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#body>
|
||
body: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#data>
|
||
#[ignore_malloc_size_of = "mozjs"]
|
||
data: Heap<JSVal>,
|
||
/// <https://notifications.spec.whatwg.org/#concept-direction>
|
||
dir: NotificationDirection,
|
||
/// <https://notifications.spec.whatwg.org/#image-url>
|
||
image: Option<USVString>,
|
||
/// <https://notifications.spec.whatwg.org/#icon-url>
|
||
icon: Option<USVString>,
|
||
/// <https://notifications.spec.whatwg.org/#badge-url>
|
||
badge: Option<USVString>,
|
||
/// <https://notifications.spec.whatwg.org/#concept-language>
|
||
lang: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#silent-preference-flag>
|
||
silent: Option<bool>,
|
||
/// <https://notifications.spec.whatwg.org/#tag>
|
||
tag: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#concept-origin>
|
||
#[no_trace] // ImmutableOrigin is not traceable
|
||
origin: ImmutableOrigin,
|
||
/// <https://notifications.spec.whatwg.org/#vibration-pattern>
|
||
vibration_pattern: Vec<u32>,
|
||
/// <https://notifications.spec.whatwg.org/#timestamp>
|
||
timestamp: u64,
|
||
/// <https://notifications.spec.whatwg.org/#renotify-preference-flag>
|
||
renotify: bool,
|
||
/// <https://notifications.spec.whatwg.org/#require-interaction-preference-flag>
|
||
require_interaction: bool,
|
||
/// <https://notifications.spec.whatwg.org/#actions>
|
||
actions: Vec<Action>,
|
||
/// Pending image, icon, badge, action icon resource request's id
|
||
#[no_trace] // RequestId is not traceable
|
||
pending_request_ids: DomRefCell<HashSet<RequestId>>,
|
||
/// <https://notifications.spec.whatwg.org/#image-resource>
|
||
#[ignore_malloc_size_of = "Arc"]
|
||
#[no_trace]
|
||
image_resource: DomRefCell<Option<Arc<Image>>>,
|
||
/// <https://notifications.spec.whatwg.org/#icon-resource>
|
||
#[ignore_malloc_size_of = "Arc"]
|
||
#[no_trace]
|
||
icon_resource: DomRefCell<Option<Arc<Image>>>,
|
||
/// <https://notifications.spec.whatwg.org/#badge-resource>
|
||
#[ignore_malloc_size_of = "Arc"]
|
||
#[no_trace]
|
||
badge_resource: DomRefCell<Option<Arc<Image>>>,
|
||
}
|
||
|
||
impl Notification {
|
||
#[allow(clippy::too_many_arguments)]
|
||
pub(crate) fn new(
|
||
global: &GlobalScope,
|
||
title: DOMString,
|
||
options: RootedTraceableBox<NotificationOptions>,
|
||
origin: ImmutableOrigin,
|
||
base_url: ServoUrl,
|
||
fallback_timestamp: u64,
|
||
proto: Option<HandleObject>,
|
||
can_gc: CanGc,
|
||
) -> DomRoot<Self> {
|
||
let notification = reflect_dom_object_with_proto(
|
||
Box::new(Notification::new_inherited(
|
||
global,
|
||
title,
|
||
&options,
|
||
origin,
|
||
base_url,
|
||
fallback_timestamp,
|
||
)),
|
||
global,
|
||
proto,
|
||
can_gc,
|
||
);
|
||
|
||
notification.data.set(options.data.get());
|
||
|
||
notification
|
||
}
|
||
|
||
/// partial implementation of <https://notifications.spec.whatwg.org/#create-a-notification>
|
||
fn new_inherited(
|
||
global: &GlobalScope,
|
||
title: DOMString,
|
||
options: &RootedTraceableBox<NotificationOptions>,
|
||
origin: ImmutableOrigin,
|
||
base_url: ServoUrl,
|
||
fallback_timestamp: u64,
|
||
) -> Self {
|
||
// TODO: missing call to https://html.spec.whatwg.org/multipage/#structuredserializeforstorage
|
||
// may be find in `dom/bindings/structuredclone.rs`
|
||
let data = Heap::default();
|
||
|
||
let title = title.clone();
|
||
let dir = options.dir;
|
||
let lang = options.lang.clone();
|
||
let body = options.body.clone();
|
||
let tag = options.tag.clone();
|
||
|
||
// If options["image"] exists, then parse it using baseURL, and if that does not return failure,
|
||
// set notification’s image URL to the return value. (Otherwise notification’s image URL is not set.)
|
||
let image = options.image.as_ref().and_then(|image_url| {
|
||
ServoUrl::parse_with_base(Some(&base_url), image_url.as_ref())
|
||
.map(|url| USVString::from(url.to_string()))
|
||
.ok()
|
||
});
|
||
// If options["icon"] exists, then parse it using baseURL, and if that does not return failure,
|
||
// set notification’s icon URL to the return value. (Otherwise notification’s icon URL is not set.)
|
||
let icon = options.icon.as_ref().and_then(|icon_url| {
|
||
ServoUrl::parse_with_base(Some(&base_url), icon_url.as_ref())
|
||
.map(|url| USVString::from(url.to_string()))
|
||
.ok()
|
||
});
|
||
// If options["badge"] exists, then parse it using baseURL, and if that does not return failure,
|
||
// set notification’s badge URL to the return value. (Otherwise notification’s badge URL is not set.)
|
||
let badge = options.badge.as_ref().and_then(|badge_url| {
|
||
ServoUrl::parse_with_base(Some(&base_url), badge_url.as_ref())
|
||
.map(|url| USVString::from(url.to_string()))
|
||
.ok()
|
||
});
|
||
// If options["vibrate"] exists, then validate and normalize it and
|
||
// set notification’s vibration pattern to the return value.
|
||
let vibration_pattern = match &options.vibrate {
|
||
Some(pattern) => validate_and_normalize_vibration_pattern(pattern),
|
||
None => Vec::new(),
|
||
};
|
||
// If options["timestamp"] exists, then set notification’s timestamp to the value.
|
||
// Otherwise, set notification’s timestamp to fallbackTimestamp.
|
||
let timestamp = options.timestamp.unwrap_or(fallback_timestamp);
|
||
let renotify = options.renotify;
|
||
let silent = options.silent;
|
||
let require_interaction = options.requireInteraction;
|
||
|
||
// For each entry in options["actions"]
|
||
// up to the maximum number of actions supported (skip any excess entries):
|
||
let mut actions: Vec<Action> = Vec::new();
|
||
let max_actions = Notification::MaxActions(global);
|
||
for action in options.actions.iter().take(max_actions as usize) {
|
||
actions.push(Action {
|
||
id: Uuid::new_v4().simple().to_string(),
|
||
name: action.action.clone(),
|
||
title: action.title.clone(),
|
||
// If entry["icon"] exists, then parse it using baseURL, and if that does not return failure
|
||
// set action’s icon URL to the return value. (Otherwise action’s icon URL remains null.)
|
||
icon_url: action.icon.as_ref().and_then(|icon_url| {
|
||
ServoUrl::parse_with_base(Some(&base_url), icon_url.as_ref())
|
||
.map(|url| USVString::from(url.to_string()))
|
||
.ok()
|
||
}),
|
||
icon_resource: DomRefCell::new(None),
|
||
});
|
||
}
|
||
|
||
Self {
|
||
eventtarget: EventTarget::new_inherited(),
|
||
// A non-persistent notification is a notification whose service worker registration is null.
|
||
serviceworker_registration: None,
|
||
title,
|
||
body,
|
||
data,
|
||
dir,
|
||
image,
|
||
icon,
|
||
badge,
|
||
lang,
|
||
silent,
|
||
origin,
|
||
vibration_pattern,
|
||
timestamp,
|
||
renotify,
|
||
tag,
|
||
require_interaction,
|
||
actions,
|
||
pending_request_ids: DomRefCell::new(HashSet::new()),
|
||
image_resource: DomRefCell::new(None),
|
||
icon_resource: DomRefCell::new(None),
|
||
badge_resource: DomRefCell::new(None),
|
||
}
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#notification-show-steps>
|
||
fn show(&self) {
|
||
// step 3: set shown to false
|
||
let shown = false;
|
||
|
||
// TODO: step 4: Let oldNotification be the notification in the list of notifications
|
||
// whose tag is not the empty string and is notification’s tag,
|
||
// and whose origin is same origin with notification’s origin,
|
||
// if any, and null otherwise.
|
||
|
||
// TODO: step 5: If oldNotification is non-null, then:
|
||
// TODO: step 5.1: Handle close events with oldNotification.
|
||
// TODO: step 5.2: If the notification platform supports replacement, then:
|
||
// TODO: step 5.2.1: Replace oldNotification with notification, in the list of notifications.
|
||
// TODO: step 5.2.2: Set shown to true.
|
||
// TODO: step 5.3: Otherwise, remove oldNotification from the list of notifications.
|
||
|
||
// step 6: If shown is false, then:
|
||
if !shown {
|
||
// TODO: step 6.1: Append notification to the list of notifications.
|
||
// step 6.2: Display notification on the device
|
||
self.global()
|
||
.send_to_embedder(EmbedderMsg::ShowNotification(
|
||
self.global().webview_id(),
|
||
self.to_embedder_notification(),
|
||
));
|
||
}
|
||
|
||
// TODO: step 7: If shown is false or oldNotification is non-null,
|
||
// and notification’s renotify preference is true,
|
||
// then run the alert steps for notification.
|
||
|
||
// step 8: If notification is a non-persistent notification,
|
||
// then queue a task to fire an event named show on
|
||
// the Notification object representing notification.
|
||
if self.serviceworker_registration.is_none() {
|
||
self.global()
|
||
.task_manager()
|
||
.dom_manipulation_task_source()
|
||
.queue_simple_event(self.upcast(), atom!("show"));
|
||
}
|
||
}
|
||
|
||
/// Create an [`embedder_traits::Notification`].
|
||
fn to_embedder_notification(&self) -> EmbedderNotification {
|
||
EmbedderNotification {
|
||
title: self.title.to_string(),
|
||
body: self.body.to_string(),
|
||
tag: self.tag.to_string(),
|
||
language: self.lang.to_string(),
|
||
require_interaction: self.require_interaction,
|
||
silent: self.silent,
|
||
icon_url: self
|
||
.icon
|
||
.as_ref()
|
||
.and_then(|icon| ServoUrl::parse(icon).ok()),
|
||
badge_url: self
|
||
.badge
|
||
.as_ref()
|
||
.and_then(|badge| ServoUrl::parse(badge).ok()),
|
||
image_url: self
|
||
.image
|
||
.as_ref()
|
||
.and_then(|image| ServoUrl::parse(image).ok()),
|
||
actions: self
|
||
.actions
|
||
.iter()
|
||
.map(|action| EmbedderNotificationAction {
|
||
name: action.name.to_string(),
|
||
title: action.title.to_string(),
|
||
icon_url: action
|
||
.icon_url
|
||
.as_ref()
|
||
.and_then(|icon| ServoUrl::parse(icon).ok()),
|
||
icon_resource: action.icon_resource.borrow().clone(),
|
||
})
|
||
.collect(),
|
||
icon_resource: self.icon_resource.borrow().clone(),
|
||
badge_resource: self.badge_resource.borrow().clone(),
|
||
image_resource: self.image_resource.borrow().clone(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl NotificationMethods<crate::DomTypeHolder> for Notification {
|
||
/// <https://notifications.spec.whatwg.org/#constructors>
|
||
fn Constructor(
|
||
global: &GlobalScope,
|
||
proto: Option<HandleObject>,
|
||
can_gc: CanGc,
|
||
title: DOMString,
|
||
options: RootedTraceableBox<NotificationOptions>,
|
||
) -> Fallible<DomRoot<Notification>> {
|
||
// step 1: Check global is a ServiceWorkerGlobalScope
|
||
if global.is::<ServiceWorkerGlobalScope>() {
|
||
return Err(Error::Type(
|
||
"Notification constructor cannot be used in service worker.".to_string(),
|
||
));
|
||
}
|
||
|
||
// step 2: Check options.actions must be empty
|
||
if !options.actions.is_empty() {
|
||
return Err(Error::Type(
|
||
"Actions are only supported for persistent notifications.".to_string(),
|
||
));
|
||
}
|
||
|
||
// step 3: Create a notification with a settings object
|
||
let notification =
|
||
create_notification_with_settings_object(global, title, options, proto, can_gc)?;
|
||
|
||
// TODO: Run step 5.1, 5.2 in parallel
|
||
// step 5.1: If the result of getting the notifications permission state is not "granted",
|
||
// then queue a task to fire an event named error on this, and abort these steps.
|
||
let permission_state = get_notifications_permission_state(global);
|
||
if permission_state != NotificationPermission::Granted {
|
||
global
|
||
.task_manager()
|
||
.dom_manipulation_task_source()
|
||
.queue_simple_event(notification.upcast(), atom!("error"));
|
||
// TODO: abort steps
|
||
} else {
|
||
// step 5.2: Run the notification show steps for notification
|
||
// <https://notifications.spec.whatwg.org/#notification-show-steps>
|
||
// step 1: Run the fetch steps for notification.
|
||
notification.fetch_resources_and_show_when_ready();
|
||
}
|
||
|
||
Ok(notification)
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-permission>
|
||
fn GetPermission(global: &GlobalScope) -> Fallible<NotificationPermission> {
|
||
Ok(get_notifications_permission_state(global))
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-requestpermission>
|
||
fn RequestPermission(
|
||
global: &GlobalScope,
|
||
permission_callback: Option<Rc<NotificationPermissionCallback>>,
|
||
can_gc: CanGc,
|
||
) -> Rc<Promise> {
|
||
// Step 2: Let promise be a new promise in this’s relevant Realm.
|
||
let promise = Promise::new(global, can_gc);
|
||
|
||
// TODO: Step 3: Run these steps in parallel:
|
||
// Step 3.1: Let permissionState be the result of requesting permission to use "notifications".
|
||
let notification_permission = request_notification_permission(global, can_gc);
|
||
|
||
// Step 3.2: Queue a global task on the DOM manipulation task source given global to run these steps:
|
||
let trusted_promise = TrustedPromise::new(promise.clone());
|
||
let uuid = Uuid::new_v4().simple().to_string();
|
||
let uuid_ = uuid.clone();
|
||
|
||
if let Some(callback) = permission_callback {
|
||
global.add_notification_permission_request_callback(uuid.clone(), callback.clone());
|
||
}
|
||
|
||
global.task_manager().dom_manipulation_task_source().queue(
|
||
task!(request_permission: move || {
|
||
let promise = trusted_promise.root();
|
||
let global = promise.global();
|
||
|
||
// Step 3.2.1: If deprecatedCallback is given,
|
||
// then invoke deprecatedCallback with « permissionState » and "report".
|
||
if let Some(callback) = global.remove_notification_permission_request_callback(uuid_) {
|
||
let _ = callback.Call__(notification_permission, ExceptionHandling::Report, CanGc::note());
|
||
}
|
||
|
||
// Step 3.2.2: Resolve promise with permissionState.
|
||
promise.resolve_native(¬ification_permission, CanGc::note());
|
||
}),
|
||
);
|
||
|
||
promise
|
||
}
|
||
|
||
// <https://notifications.spec.whatwg.org/#dom-notification-onclick>
|
||
event_handler!(click, GetOnclick, SetOnclick);
|
||
// <https://notifications.spec.whatwg.org/#dom-notification-onshow>
|
||
event_handler!(show, GetOnshow, SetOnshow);
|
||
// <https://notifications.spec.whatwg.org/#dom-notification-onerror>
|
||
event_handler!(error, GetOnerror, SetOnerror);
|
||
// <https://notifications.spec.whatwg.org/#dom-notification-onclose>
|
||
event_handler!(close, GetOnclose, SetOnclose);
|
||
|
||
/// <https://notifications.spec.whatwg.org/#maximum-number-of-actions>
|
||
fn MaxActions(_global: &GlobalScope) -> u32 {
|
||
// TODO: determine the maximum number of actions
|
||
2
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-title>
|
||
fn Title(&self) -> DOMString {
|
||
self.title.clone()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-dir>
|
||
fn Dir(&self) -> NotificationDirection {
|
||
self.dir
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-lang>
|
||
fn Lang(&self) -> DOMString {
|
||
self.lang.clone()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-body>
|
||
fn Body(&self) -> DOMString {
|
||
self.body.clone()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-tag>
|
||
fn Tag(&self) -> DOMString {
|
||
self.tag.clone()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-image>
|
||
fn Image(&self) -> USVString {
|
||
// step 1: If there is no this’s notification’s image URL, then return the empty string.
|
||
// step 2: Return this’s notification’s image URL, serialized.
|
||
self.image.clone().unwrap_or_default()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-icon>
|
||
fn Icon(&self) -> USVString {
|
||
// step 1: If there is no this’s notification’s icon URL, then return the empty string.
|
||
// step 2: Return this’s notification’s icon URL, serialized.
|
||
self.icon.clone().unwrap_or_default()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-badge>
|
||
fn Badge(&self) -> USVString {
|
||
// step 1: If there is no this’s notification’s badge URL, then return the empty string.
|
||
// step 2: Return this’s notification’s badge URL, serialized.
|
||
self.badge.clone().unwrap_or_default()
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-renotify>
|
||
fn Renotify(&self) -> bool {
|
||
self.renotify
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-silent>
|
||
fn GetSilent(&self) -> Option<bool> {
|
||
self.silent
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-requireinteraction>
|
||
fn RequireInteraction(&self) -> bool {
|
||
self.require_interaction
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-data>
|
||
fn Data(&self, _cx: SafeJSContext, mut retval: MutableHandleValue) {
|
||
retval.set(self.data.get());
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-actions>
|
||
fn Actions(&self, cx: SafeJSContext, can_gc: CanGc, retval: MutableHandleValue) {
|
||
// step 1: Let frozenActions be an empty list of type NotificationAction.
|
||
let mut frozen_actions: Vec<NotificationAction> = Vec::new();
|
||
|
||
// step 2: For each entry of this’s notification’s actions
|
||
for action in self.actions.iter() {
|
||
let action = NotificationAction {
|
||
action: action.name.clone(),
|
||
title: action.title.clone(),
|
||
// If entry’s icon URL is non-null,
|
||
// then set action["icon"] to entry’s icon URL, icon_url, serialized.
|
||
icon: action.icon_url.clone(),
|
||
};
|
||
|
||
// TODO: step 2.5: Call Object.freeze on action, to prevent accidental mutation by scripts.
|
||
// step 2.6: Append action to frozenActions.
|
||
frozen_actions.push(action);
|
||
}
|
||
|
||
// step 3: Return the result of create a frozen array from frozenActions.
|
||
to_frozen_array(frozen_actions.as_slice(), cx, retval, can_gc);
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-vibrate>
|
||
fn Vibrate(&self, cx: SafeJSContext, can_gc: CanGc, retval: MutableHandleValue) {
|
||
to_frozen_array(self.vibration_pattern.as_slice(), cx, retval, can_gc);
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-timestamp>
|
||
fn Timestamp(&self) -> u64 {
|
||
self.timestamp
|
||
}
|
||
/// <https://notifications.spec.whatwg.org/#dom-notification-close>
|
||
fn Close(&self) {
|
||
// TODO: If notification is a persistent notification and notification was closed by the end user
|
||
// then fire a service worker notification event named "notificationclose" given notification.
|
||
|
||
// If notification is a non-persistent notification
|
||
// then queue a task to fire an event named close on the Notification object representing notification.
|
||
if self.serviceworker_registration.is_none() {
|
||
self.global()
|
||
.task_manager()
|
||
.dom_manipulation_task_source()
|
||
.queue_simple_event(self.upcast(), atom!("close"));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#actions>
|
||
#[derive(JSTraceable, MallocSizeOf)]
|
||
struct Action {
|
||
id: String,
|
||
/// <https://notifications.spec.whatwg.org/#action-name>
|
||
name: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#action-title>
|
||
title: DOMString,
|
||
/// <https://notifications.spec.whatwg.org/#action-icon-url>
|
||
icon_url: Option<USVString>,
|
||
/// <https://notifications.spec.whatwg.org/#action-icon-resource>
|
||
#[ignore_malloc_size_of = "Arc"]
|
||
#[no_trace]
|
||
icon_resource: DomRefCell<Option<Arc<Image>>>,
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#create-a-notification-with-a-settings-object>
|
||
fn create_notification_with_settings_object(
|
||
global: &GlobalScope,
|
||
title: DOMString,
|
||
options: RootedTraceableBox<NotificationOptions>,
|
||
proto: Option<HandleObject>,
|
||
can_gc: CanGc,
|
||
) -> Fallible<DomRoot<Notification>> {
|
||
// step 1: Let origin be settings’s origin.
|
||
let origin = global.origin().immutable().clone();
|
||
// step 2: Let baseURL be settings’s API base URL.
|
||
let base_url = global.api_base_url();
|
||
// step 3: Let fallbackTimestamp be the number of milliseconds from
|
||
// the Unix epoch to settings’s current wall time, rounded to the nearest integer.
|
||
let fallback_timestamp = SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.unwrap_or_default()
|
||
.as_millis() as u64;
|
||
// step 4: Return the result of creating a notification given title, options, origin,
|
||
// baseURL, and fallbackTimestamp.
|
||
create_notification(
|
||
global,
|
||
title,
|
||
options,
|
||
origin,
|
||
base_url,
|
||
fallback_timestamp,
|
||
proto,
|
||
can_gc,
|
||
)
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#create-a-notification
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn create_notification(
|
||
global: &GlobalScope,
|
||
title: DOMString,
|
||
options: RootedTraceableBox<NotificationOptions>,
|
||
origin: ImmutableOrigin,
|
||
base_url: ServoUrl,
|
||
fallback_timestamp: u64,
|
||
proto: Option<HandleObject>,
|
||
can_gc: CanGc,
|
||
) -> Fallible<DomRoot<Notification>> {
|
||
// If options["silent"] is true and options["vibrate"] exists, then throw a TypeError.
|
||
if options.silent.is_some() && options.vibrate.is_some() {
|
||
return Err(Error::Type(
|
||
"Can't specify vibration patterns when setting notification to silent.".to_string(),
|
||
));
|
||
}
|
||
// If options["renotify"] is true and options["tag"] is the empty string, then throw a TypeError.
|
||
if options.renotify && options.tag.is_empty() {
|
||
return Err(Error::Type(
|
||
"tag must be set to renotify as an existing notification.".to_string(),
|
||
));
|
||
}
|
||
|
||
Ok(Notification::new(
|
||
global,
|
||
title,
|
||
options,
|
||
origin,
|
||
base_url,
|
||
fallback_timestamp,
|
||
proto,
|
||
can_gc,
|
||
))
|
||
}
|
||
|
||
/// <https://w3c.github.io/vibration/#dfn-validate-and-normalize>
|
||
fn validate_and_normalize_vibration_pattern(
|
||
pattern: &UnsignedLongOrUnsignedLongSequence,
|
||
) -> Vec<u32> {
|
||
// Step 1: If pattern is a list, proceed to the next step. Otherwise run the following substeps:
|
||
let mut pattern: Vec<u32> = match pattern {
|
||
UnsignedLongOrUnsignedLongSequence::UnsignedLong(value) => {
|
||
// Step 1.1: Let list be an initially empty list, and add pattern to list.
|
||
// Step 1.2: Set pattern to list.
|
||
vec![*value]
|
||
},
|
||
UnsignedLongOrUnsignedLongSequence::UnsignedLongSequence(values) => values.clone(),
|
||
};
|
||
|
||
// Step 2: Let max length have the value 10.
|
||
// Step 3: If the length of pattern is greater than max length, truncate pattern,
|
||
// leaving only the first max length entries.
|
||
pattern.truncate(10);
|
||
|
||
// If the length of the pattern is even and not zero then the last entry in the pattern will
|
||
// have no effect so an implementation can remove it from the pattern at this point.
|
||
if pattern.len() % 2 == 0 && !pattern.is_empty() {
|
||
pattern.pop();
|
||
}
|
||
|
||
// Step 4: Let max duration have the value 10000.
|
||
// Step 5: For each entry in pattern whose value is greater than max duration,
|
||
// set the entry's value to max duration.
|
||
pattern.iter_mut().for_each(|entry| {
|
||
*entry = 10000.min(*entry);
|
||
});
|
||
|
||
// Step 6: Return pattern.
|
||
pattern
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#get-the-notifications-permission-state>
|
||
fn get_notifications_permission_state(global: &GlobalScope) -> NotificationPermission {
|
||
let permission_state = descriptor_permission_state(PermissionName::Notifications, Some(global));
|
||
match permission_state {
|
||
PermissionState::Granted => NotificationPermission::Granted,
|
||
PermissionState::Denied => NotificationPermission::Denied,
|
||
PermissionState::Prompt => NotificationPermission::Default,
|
||
}
|
||
}
|
||
|
||
fn request_notification_permission(global: &GlobalScope, can_gc: CanGc) -> NotificationPermission {
|
||
let cx = GlobalScope::get_cx();
|
||
let promise = &Promise::new(global, can_gc);
|
||
let descriptor = PermissionDescriptor {
|
||
name: PermissionName::Notifications,
|
||
};
|
||
let status = PermissionStatus::new(global, &descriptor, can_gc);
|
||
|
||
// The implementation of `request_notification_permission` seemed to be synchronous
|
||
Permissions::permission_request(cx, promise, &descriptor, &status);
|
||
|
||
match status.State() {
|
||
PermissionState::Granted => NotificationPermission::Granted,
|
||
PermissionState::Denied => NotificationPermission::Denied,
|
||
// Should only receive "Granted" or "Denied" from the permission request
|
||
PermissionState::Prompt => NotificationPermission::Default,
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||
enum ResourceType {
|
||
Image,
|
||
Icon,
|
||
Badge,
|
||
ActionIcon(String), // action id
|
||
}
|
||
|
||
struct ResourceFetchListener {
|
||
/// The ID of the pending image cache for this request.
|
||
pending_image_id: PendingImageId,
|
||
/// A reference to the global image cache.
|
||
image_cache: Arc<dyn ImageCache>,
|
||
/// The notification instance which makes this request.
|
||
notification: Trusted<Notification>,
|
||
/// Request status that indicates whether this request failed, and the reason.
|
||
status: Result<(), NetworkError>,
|
||
/// Resource URL of this request.
|
||
url: ServoUrl,
|
||
/// Timing data for this resource.
|
||
resource_timing: ResourceFetchTiming,
|
||
}
|
||
|
||
impl FetchResponseListener for ResourceFetchListener {
|
||
fn process_request_body(&mut self, _: RequestId) {}
|
||
fn process_request_eof(&mut self, _: RequestId) {}
|
||
|
||
fn process_response(
|
||
&mut self,
|
||
request_id: RequestId,
|
||
metadata: Result<FetchMetadata, NetworkError>,
|
||
) {
|
||
self.image_cache.notify_pending_response(
|
||
self.pending_image_id,
|
||
FetchResponseMsg::ProcessResponse(request_id, metadata.clone()),
|
||
);
|
||
|
||
let metadata = metadata.ok().map(|meta| match meta {
|
||
FetchMetadata::Unfiltered(m) => m,
|
||
FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
|
||
});
|
||
|
||
let status = metadata
|
||
.as_ref()
|
||
.map(|m| m.status.clone())
|
||
.unwrap_or_else(HttpStatus::new_error);
|
||
|
||
self.status = {
|
||
if status.is_success() {
|
||
Ok(())
|
||
} else if status.is_error() {
|
||
Err(NetworkError::Internal(
|
||
"No http status code received".to_owned(),
|
||
))
|
||
} else {
|
||
Err(NetworkError::Internal(format!(
|
||
"HTTP error code {}",
|
||
status.code()
|
||
)))
|
||
}
|
||
};
|
||
}
|
||
|
||
fn process_response_chunk(&mut self, request_id: RequestId, payload: Vec<u8>) {
|
||
if self.status.is_ok() {
|
||
self.image_cache.notify_pending_response(
|
||
self.pending_image_id,
|
||
FetchResponseMsg::ProcessResponseChunk(request_id, payload),
|
||
);
|
||
}
|
||
}
|
||
|
||
fn process_response_eof(
|
||
&mut self,
|
||
request_id: RequestId,
|
||
response: Result<ResourceFetchTiming, NetworkError>,
|
||
) {
|
||
self.image_cache.notify_pending_response(
|
||
self.pending_image_id,
|
||
FetchResponseMsg::ProcessResponseEOF(request_id, response),
|
||
);
|
||
}
|
||
|
||
fn resource_timing_mut(&mut self) -> &mut ResourceFetchTiming {
|
||
&mut self.resource_timing
|
||
}
|
||
|
||
fn resource_timing(&self) -> &ResourceFetchTiming {
|
||
&self.resource_timing
|
||
}
|
||
|
||
fn submit_resource_timing(&mut self) {
|
||
network_listener::submit_timing(self, CanGc::note())
|
||
}
|
||
|
||
fn process_csp_violations(&mut self, _request_id: RequestId, violations: Vec<csp::Violation>) {
|
||
let global = &self.resource_timing_global();
|
||
global.report_csp_violations(violations, None);
|
||
}
|
||
}
|
||
|
||
impl ResourceTimingListener for ResourceFetchListener {
|
||
fn resource_timing_information(&self) -> (InitiatorType, ServoUrl) {
|
||
(InitiatorType::Other, self.url.clone())
|
||
}
|
||
|
||
fn resource_timing_global(&self) -> DomRoot<GlobalScope> {
|
||
self.notification.root().global()
|
||
}
|
||
}
|
||
|
||
impl PreInvoke for ResourceFetchListener {
|
||
fn should_invoke(&self) -> bool {
|
||
true
|
||
}
|
||
}
|
||
|
||
impl Notification {
|
||
fn build_resource_request(&self, url: &ServoUrl) -> RequestBuilder {
|
||
let global = &self.global();
|
||
create_a_potential_cors_request(
|
||
None,
|
||
url.clone(),
|
||
Destination::Image,
|
||
None, // TODO: check which CORS should be used
|
||
None,
|
||
global.get_referrer(),
|
||
global.insecure_requests_policy(),
|
||
global.has_trustworthy_ancestor_or_current_origin(),
|
||
global.policy_container(),
|
||
)
|
||
.origin(global.origin().immutable().clone())
|
||
.pipeline_id(Some(global.pipeline_id()))
|
||
}
|
||
|
||
/// <https://notifications.spec.whatwg.org/#fetch-steps>
|
||
fn fetch_resources_and_show_when_ready(&self) {
|
||
let mut pending_requests: Vec<(RequestBuilder, ResourceType)> = vec![];
|
||
if let Some(image_url) = &self.image {
|
||
if let Ok(url) = ServoUrl::parse(image_url) {
|
||
let request = self.build_resource_request(&url);
|
||
self.pending_request_ids.borrow_mut().insert(request.id);
|
||
pending_requests.push((request, ResourceType::Image));
|
||
}
|
||
}
|
||
if let Some(icon_url) = &self.icon {
|
||
if let Ok(url) = ServoUrl::parse(icon_url) {
|
||
let request = self.build_resource_request(&url);
|
||
self.pending_request_ids.borrow_mut().insert(request.id);
|
||
pending_requests.push((request, ResourceType::Icon));
|
||
}
|
||
}
|
||
if let Some(badge_url) = &self.badge {
|
||
if let Ok(url) = ServoUrl::parse(badge_url) {
|
||
let request = self.build_resource_request(&url);
|
||
self.pending_request_ids.borrow_mut().insert(request.id);
|
||
pending_requests.push((request, ResourceType::Badge));
|
||
}
|
||
}
|
||
for action in self.actions.iter() {
|
||
if let Some(icon_url) = &action.icon_url {
|
||
if let Ok(url) = ServoUrl::parse(icon_url) {
|
||
let request = self.build_resource_request(&url);
|
||
self.pending_request_ids.borrow_mut().insert(request.id);
|
||
pending_requests.push((request, ResourceType::ActionIcon(action.id.clone())));
|
||
}
|
||
}
|
||
}
|
||
|
||
for (request, resource_type) in pending_requests {
|
||
self.fetch_and_show_when_ready(request, resource_type);
|
||
}
|
||
}
|
||
|
||
fn fetch_and_show_when_ready(&self, request: RequestBuilder, resource_type: ResourceType) {
|
||
let global: &GlobalScope = &self.global();
|
||
let request_id = request.id;
|
||
|
||
let cache_result = global.image_cache().get_cached_image_status(
|
||
request.url.clone(),
|
||
global.origin().immutable().clone(),
|
||
None, // TODO: check which CORS should be used
|
||
UsePlaceholder::No,
|
||
);
|
||
match cache_result {
|
||
ImageCacheResult::Available(ImageOrMetadataAvailable::ImageAvailable {
|
||
image, ..
|
||
}) => {
|
||
self.set_resource_and_show_when_ready(request_id, &resource_type, Some(image));
|
||
},
|
||
ImageCacheResult::Available(ImageOrMetadataAvailable::MetadataAvailable(
|
||
_,
|
||
pending_image_id,
|
||
)) => {
|
||
self.register_image_cache_callback(
|
||
request_id,
|
||
pending_image_id,
|
||
resource_type.clone(),
|
||
);
|
||
},
|
||
ImageCacheResult::Pending(pending_image_id) => {
|
||
self.register_image_cache_callback(
|
||
request_id,
|
||
pending_image_id,
|
||
resource_type.clone(),
|
||
);
|
||
},
|
||
ImageCacheResult::ReadyForRequest(pending_image_id) => {
|
||
self.register_image_cache_callback(
|
||
request_id,
|
||
pending_image_id,
|
||
resource_type.clone(),
|
||
);
|
||
self.fetch(pending_image_id, request, global);
|
||
},
|
||
ImageCacheResult::LoadError => {
|
||
self.set_resource_and_show_when_ready(request_id, &resource_type, None);
|
||
},
|
||
};
|
||
}
|
||
|
||
fn register_image_cache_callback(
|
||
&self,
|
||
request_id: RequestId,
|
||
pending_image_id: PendingImageId,
|
||
resource_type: ResourceType,
|
||
) {
|
||
let (sender, receiver) =
|
||
ipc::channel::<PendingImageResponse>().expect("ipc channel failure");
|
||
|
||
let global: &GlobalScope = &self.global();
|
||
|
||
let trusted_this = Trusted::new(self);
|
||
let resource_type = resource_type.clone();
|
||
let task_source = global.task_manager().networking_task_source().to_sendable();
|
||
|
||
ROUTER.add_typed_route(
|
||
receiver,
|
||
Box::new(move |response| {
|
||
let trusted_this = trusted_this.clone();
|
||
let resource_type = resource_type.clone();
|
||
task_source.queue(task!(handle_response: move || {
|
||
let this = trusted_this.root();
|
||
if let Ok(response) = response {
|
||
this.handle_image_cache_response(request_id, response.response, resource_type);
|
||
} else {
|
||
this.handle_image_cache_response(request_id, ImageResponse::None, resource_type);
|
||
}
|
||
}));
|
||
}),
|
||
);
|
||
|
||
global.image_cache().add_listener(ImageResponder::new(
|
||
sender,
|
||
global.pipeline_id(),
|
||
pending_image_id,
|
||
));
|
||
}
|
||
|
||
fn handle_image_cache_response(
|
||
&self,
|
||
request_id: RequestId,
|
||
response: ImageResponse,
|
||
resource_type: ResourceType,
|
||
) {
|
||
match response {
|
||
ImageResponse::Loaded(image, _) => {
|
||
self.set_resource_and_show_when_ready(request_id, &resource_type, Some(image));
|
||
},
|
||
ImageResponse::PlaceholderLoaded(image, _) => {
|
||
self.set_resource_and_show_when_ready(request_id, &resource_type, Some(image));
|
||
},
|
||
ImageResponse::None => {
|
||
self.set_resource_and_show_when_ready(request_id, &resource_type, None);
|
||
},
|
||
_ => (),
|
||
};
|
||
}
|
||
|
||
fn set_resource_and_show_when_ready(
|
||
&self,
|
||
request_id: RequestId,
|
||
resource_type: &ResourceType,
|
||
image: Option<Arc<Image>>,
|
||
) {
|
||
match resource_type {
|
||
ResourceType::Image => {
|
||
*self.image_resource.borrow_mut() = image;
|
||
},
|
||
ResourceType::Icon => {
|
||
*self.icon_resource.borrow_mut() = image;
|
||
},
|
||
ResourceType::Badge => {
|
||
*self.badge_resource.borrow_mut() = image;
|
||
},
|
||
ResourceType::ActionIcon(id) => {
|
||
if let Some(action) = self.actions.iter().find(|&action| *action.id == *id) {
|
||
*action.icon_resource.borrow_mut() = image;
|
||
}
|
||
},
|
||
}
|
||
|
||
let mut pending_requests_id = self.pending_request_ids.borrow_mut();
|
||
pending_requests_id.remove(&request_id);
|
||
|
||
// <https://notifications.spec.whatwg.org/#notification-show-steps>
|
||
// step 2: Wait for any fetches to complete and notification’s resources to be set
|
||
if pending_requests_id.is_empty() {
|
||
self.show();
|
||
}
|
||
}
|
||
|
||
fn fetch(
|
||
&self,
|
||
pending_image_id: PendingImageId,
|
||
request: RequestBuilder,
|
||
global: &GlobalScope,
|
||
) {
|
||
let context = Arc::new(Mutex::new(ResourceFetchListener {
|
||
pending_image_id,
|
||
image_cache: global.image_cache(),
|
||
notification: Trusted::new(self),
|
||
url: request.url.clone(),
|
||
status: Ok(()),
|
||
resource_timing: ResourceFetchTiming::new(ResourceTimingType::Resource),
|
||
}));
|
||
|
||
global.fetch(
|
||
request,
|
||
context,
|
||
global.task_manager().networking_task_source().into(),
|
||
);
|
||
}
|
||
}
|