Media Session API

components/compositing/windowing.rs

@@ -10,7 +10,7 @@ use euclid::Scale;
 use gleam::gl;
 use keyboard_types::KeyboardEvent;
 use msg::constellation_msg::{PipelineId, TopLevelBrowsingContextId, TraversalDirection};
-use script_traits::{MouseButton, TouchEventType, TouchId, WheelDelta};
+use script_traits::{MediaSessionActionType, MouseButton, TouchEventType, TouchId, WheelDelta};
 use servo_geometry::DeviceIndependentPixel;
 use servo_media::player::context::{GlApi, GlContext, NativeDisplay};
 use servo_url::ServoUrl;
@@ -102,6 +102,9 @@ pub enum WindowEvent {
     CaptureWebRender,
     /// Toggle sampling profiler with the given sampling rate and max duration.
     ToggleSamplingProfiler(Duration, Duration),
+    /// Sent when the user triggers a media action through the UA exposed media UI
+    /// (play, pause, seek, etc.).
+    MediaSessionAction(MediaSessionActionType),
 }
 
 impl Debug for WindowEvent {
@@ -132,6 +135,7 @@ impl Debug for WindowEvent {
             WindowEvent::CaptureWebRender => write!(f, "CaptureWebRender"),
             WindowEvent::ToggleSamplingProfiler(..) => write!(f, "ToggleSamplingProfiler"),
             WindowEvent::ExitFullScreen(..) => write!(f, "ExitFullScreen"),
+            WindowEvent::MediaSessionAction(..) => write!(f, "MediaSessionAction"),
         }
     }
 }

components/constellation/constellation.rs

@@ -112,6 +112,7 @@ use compositing::SendableFrameTree;
 use crossbeam_channel::{after, never, unbounded, Receiver, Sender};
 use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg};
 use embedder_traits::{Cursor, EmbedderMsg, EmbedderProxy, EventLoopWaker};
+use embedder_traits::{MediaSessionEvent, MediaSessionPlaybackState};
 use euclid::{default::Size2D as UntypedSize2D, Size2D};
 use gfx::font_cache_thread::FontCacheThread;
 use gfx_traits::Epoch;
@@ -139,7 +140,6 @@ use net_traits::{self, FetchResponseMsg, IpcSend, ResourceThreads};
 use profile_traits::mem;
 use profile_traits::time;
 use script_traits::CompositorEvent::{MouseButtonEvent, MouseMoveEvent};
-use script_traits::MouseEventType;
 use script_traits::{webdriver_msg, LogEntry, ScriptToConstellationChan, ServiceWorkerMsg};
 use script_traits::{
     AnimationState, AnimationTickType, AuxiliaryBrowsingContextLoadInfo, CompositorEvent,
@@ -153,6 +153,7 @@ use script_traits::{
     IFrameLoadInfo, IFrameLoadInfoWithData, IFrameSandboxState, TimerSchedulerMsg,
 };
 use script_traits::{LayoutMsg as FromLayoutMsg, ScriptMsg as FromScriptMsg, ScriptThreadFactory};
+use script_traits::{MediaSessionActionType, MouseEventType};
 use script_traits::{MessagePortMsg, PortMessageTask, StructuredSerializedData};
 use script_traits::{SWManagerMsg, ScopeThings, UpdatePipelineIdReason, WebDriverCommandMsg};
 use serde::{Deserialize, Serialize};
@@ -474,6 +475,9 @@ pub struct Constellation<Message, LTF, STF> {
 
     /// Mechanism to force the compositor to process events.
     event_loop_waker: Option<Box<dyn EventLoopWaker>>,
+
+    /// Pipeline ID of the active media session.
+    active_media_session: Option<PipelineId>,
 }
 
 /// State needed to construct a constellation.
@@ -843,6 +847,7 @@ where
                     glplayer_threads: state.glplayer_threads,
                     player_context: state.player_context,
                     event_loop_waker: state.event_loop_waker,
+                    active_media_session: None,
                 };
 
                 constellation.run();
@@ -1541,6 +1546,9 @@ where
             FromCompositorMsg::ExitFullScreen(top_level_browsing_context_id) => {
                 self.handle_exit_fullscreen_msg(top_level_browsing_context_id);
             },
+            FromCompositorMsg::MediaSessionAction(action) => {
+                self.handle_media_session_action_msg(action);
+            },
         }
     }
 
@@ -1771,6 +1779,31 @@ where
                     new_value,
                 );
             },
+            FromScriptMsg::MediaSessionEvent(pipeline_id, event) => {
+                // Unlikely at this point, but we may receive events coming from
+                // different media sessions, so we set the active media session based
+                // on Playing events.
+                // The last media session claiming to be in playing state is set to
+                // the active media session.
+                // Events coming from inactive media sessions are discarded.
+                if self.active_media_session.is_some() {
+                    match event {
+                        MediaSessionEvent::PlaybackStateChange(ref state) => {
+                            match state {
+                                MediaSessionPlaybackState::Playing |
+                                MediaSessionPlaybackState::Paused => (),
+                                _ => return,
+                            };
+                        },
+                        _ => (),
+                    };
+                }
+                self.active_media_session = Some(pipeline_id);
+                self.embedder_proxy.send((
+                    Some(source_top_ctx_id),
+                    EmbedderMsg::MediaSessionEvent(event),
+                ));
+            },
         }
     }
 
@@ -5019,4 +5052,29 @@ where
                 .send(ToCompositorMsg::SetFrameTree(frame_tree));
         }
     }
+
+    fn handle_media_session_action_msg(&mut self, action: MediaSessionActionType) {
+        if let Some(media_session_pipeline_id) = self.active_media_session {
+            let result = match self.pipelines.get(&media_session_pipeline_id) {
+                None => {
+                    return warn!(
+                        "Pipeline {} got media session action request after closure.",
+                        media_session_pipeline_id,
+                    )
+                },
+                Some(pipeline) => {
+                    let msg = ConstellationControlMsg::MediaSessionAction(
+                        media_session_pipeline_id,
+                        action,
+                    );
+                    pipeline.event_loop.send(msg)
+                },
+            };
+            if let Err(e) = result {
+                self.handle_send_error(media_session_pipeline_id, e);
+            }
+        } else {
+            error!("Got a media session action but no active media session is registered");
+        }
+    }
 }

components/embedder_traits/lib.rs

@@ -162,6 +162,9 @@ pub enum EmbedderMsg {
     Shutdown,
     /// Report a complete sampled profile
     ReportProfile(Vec<u8>),
+    /// Notifies the embedder about media session events
+    /// (i.e. when there is metadata for the active media session, playback state changes...).
+    MediaSessionEvent(MediaSessionEvent),
 }
 
 impl Debug for EmbedderMsg {
@@ -194,6 +197,7 @@ impl Debug for EmbedderMsg {
             EmbedderMsg::AllowOpeningBrowser(..) => write!(f, "AllowOpeningBrowser"),
             EmbedderMsg::BrowserCreated(..) => write!(f, "BrowserCreated"),
             EmbedderMsg::ReportProfile(..) => write!(f, "ReportProfile"),
+            EmbedderMsg::MediaSessionEvent(..) => write!(f, "MediaSessionEvent"),
         }
     }
 }
@@ -202,3 +206,45 @@ impl Debug for EmbedderMsg {
 /// the `String` content is expected to be extension (e.g, "doc", without the prefixing ".")
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct FilterPattern(pub String);
+
+/// https://w3c.github.io/mediasession/#mediametadata
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct MediaMetadata {
+    /// Title
+    pub title: String,
+    /// Artist
+    pub artist: String,
+    /// Album
+    pub album: String,
+}
+
+impl MediaMetadata {
+    pub fn new(title: String) -> Self {
+        Self {
+            title,
+            artist: "".to_owned(),
+            album: "".to_owned(),
+        }
+    }
+}
+
+/// https://w3c.github.io/mediasession/#enumdef-mediasessionplaybackstate
+#[repr(i32)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum MediaSessionPlaybackState {
+    /// The browsing context does not specify whether it’s playing or paused.
+    None_ = 1,
+    /// The browsing context is currently playing media and it can be paused.
+    Playing,
+    /// The browsing context has paused media and it can be resumed.
+    Paused,
+}
+
+/// Type of events sent from script to the embedder about the media session.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum MediaSessionEvent {
+    /// Indicates that the media metadata is available.
+    SetMetadata(MediaMetadata),
+    /// Indicates that the playback state has changed.
+    PlaybackStateChange(MediaSessionPlaybackState),
+}

components/script/dom/bindings/trace.rs

@@ -57,7 +57,7 @@ use content_security_policy::CspList;
 use crossbeam_channel::{Receiver, Sender};
 use cssparser::RGBA;
 use devtools_traits::{CSSError, TimelineMarkerType, WorkerId};
-use embedder_traits::EventLoopWaker;
+use embedder_traits::{EventLoopWaker, MediaMetadata};
 use encoding_rs::{Decoder, Encoding};
 use euclid::default::{Point2D, Rect, Rotation3D, Transform2D, Transform3D};
 use euclid::Length as EuclidLength;
@@ -94,8 +94,8 @@ use profile_traits::time::ProfilerChan as TimeProfilerChan;
 use script_layout_interface::rpc::LayoutRPC;
 use script_layout_interface::OpaqueStyleAndLayoutData;
 use script_traits::transferable::MessagePortImpl;
-use script_traits::DrawAPaintImageResult;
-use script_traits::{DocumentActivity, ScriptToConstellationChan, TimerEventId, TimerSource};
+use script_traits::{DocumentActivity, DrawAPaintImageResult};
+use script_traits::{MediaSessionActionType, ScriptToConstellationChan, TimerEventId, TimerSource};
 use script_traits::{UntrustedNodeAddress, WindowSizeData, WindowSizeType};
 use selectors::matching::ElementSelectorFlags;
 use serde::{Deserialize, Serialize};
@@ -536,6 +536,8 @@ unsafe_no_jsmanaged_fields!(WindowGLContext);
 unsafe_no_jsmanaged_fields!(VideoFrame);
 unsafe_no_jsmanaged_fields!(WebGLContextId);
 unsafe_no_jsmanaged_fields!(Arc<Mutex<dyn AudioRenderer>>);
+unsafe_no_jsmanaged_fields!(MediaSessionActionType);
+unsafe_no_jsmanaged_fields!(MediaMetadata);
 
 unsafe impl<'a> JSTraceable for &'a str {
     #[inline]

components/script/dom/htmlmediaelement.rs

@@ -15,8 +15,10 @@ use crate::dom::bindings::codegen::Bindings::HTMLMediaElementBinding::HTMLMediaE
 use crate::dom::bindings::codegen::Bindings::HTMLSourceElementBinding::HTMLSourceElementMethods;
 use crate::dom::bindings::codegen::Bindings::MediaErrorBinding::MediaErrorConstants::*;
 use crate::dom::bindings::codegen::Bindings::MediaErrorBinding::MediaErrorMethods;
+use crate::dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorBinding::NavigatorMethods;
 use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeBinding::NodeMethods;
 use crate::dom::bindings::codegen::Bindings::TextTrackBinding::{TextTrackKind, TextTrackMode};
+use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowBinding::WindowMethods;
 use crate::dom::bindings::codegen::InheritTypes::{ElementTypeId, HTMLElementTypeId};
 use crate::dom::bindings::codegen::InheritTypes::{HTMLMediaElementTypeId, NodeTypeId};
 use crate::dom::bindings::codegen::UnionTypes::{
@@ -65,6 +67,7 @@ use crate::script_thread::ScriptThread;
 use crate::task_source::TaskSource;
 use dom_struct::dom_struct;
 use embedder_traits::resources::{self, Resource as EmbedderResource};
+use embedder_traits::{MediaSessionEvent, MediaSessionPlaybackState};
 use euclid::default::Size2D;
 use headers::{ContentLength, ContentRange, HeaderMapExt};
 use html5ever::{LocalName, Prefix};
@@ -592,7 +595,6 @@ impl HTMLMediaElement {
         match (old_ready_state, ready_state) {
             (ReadyState::HaveNothing, ReadyState::HaveMetadata) => {
                 task_source.queue_simple_event(self.upcast(), atom!("loadedmetadata"), &window);
-
                 // No other steps are applicable in this case.
                 return;
             },
@@ -1725,6 +1727,17 @@ impl HTMLMediaElement {
                 if self.Controls() {
                     self.render_controls();
                 }
+
+                let global = self.global();
+                let window = global.as_window();
+
+                // Update the media session metadata title with the obtained metadata.
+                window.Navigator().MediaSession().update_title(
+                    metadata
+                        .title
+                        .clone()
+                        .unwrap_or(window.get_url().into_string()),
+                );
             },
             PlayerEvent::NeedData => {
                 // The player needs more data.
@@ -1782,13 +1795,33 @@ impl HTMLMediaElement {
                 };
                 ScriptThread::await_stable_state(Microtask::MediaElement(task));
             },
-            PlayerEvent::StateChanged(ref state) => match *state {
-                PlaybackState::Paused => {
-                    if self.ready_state.get() == ReadyState::HaveMetadata {
-                        self.change_ready_state(ReadyState::HaveEnoughData);
-                    }
-                },
-                _ => {},
+            PlayerEvent::StateChanged(ref state) => {
+                let mut media_session_playback_state = MediaSessionPlaybackState::None_;
+                match *state {
+                    PlaybackState::Paused => {
+                        media_session_playback_state = MediaSessionPlaybackState::Paused;
+                        if self.ready_state.get() == ReadyState::HaveMetadata {
+                            self.change_ready_state(ReadyState::HaveEnoughData);
+                        }
+                    },
+                    PlaybackState::Playing => {
+                        media_session_playback_state = MediaSessionPlaybackState::Playing;
+                    },
+                    PlaybackState::Buffering => {
+                        // Do not send the media session playback state change event
+                        // in this case as a None_ state is expected to clean up the
+                        // session.
+                        return;
+                    },
+                    _ => {},
+                };
+                debug!(
+                    "Sending media session event playback state changed to {:?}",
+                    media_session_playback_state
+                );
+                self.send_media_session_event(MediaSessionEvent::PlaybackStateChange(
+                    media_session_playback_state,
+                ));
             },
         }
     }
@@ -1883,6 +1916,15 @@ impl HTMLMediaElement {
             self.media_element_load_algorithm();
         }
     }
+
+    fn send_media_session_event(&self, event: MediaSessionEvent) {
+        let global = self.global();
+        let media_session = global.as_window().Navigator().MediaSession();
+
+        media_session.register_media_instance(&self);
+
+        media_session.send_event(event);
+    }
 }
 
 // XXX Placeholder for [https://github.com/servo/servo/issues/22293]