Introduce WebrenderExternalImageRegistry

components/media/lib.rs

@@ -21,7 +21,8 @@ use crate::media_channel::{GLPlayerChan, GLPlayerPipeline, GLPlayerReceiver, GLP
 use crate::media_thread::GLPlayerThread;
 use euclid::Size2D;
 use servo_media::player::context::{GlApi, GlContext, NativeDisplay, PlayerGLContext};
-use webrender_traits::WebrenderExternalImageApi;
+use std::sync::{Arc, Mutex};
+use webrender_traits::{WebrenderExternalImageApi, WebrenderExternalImageRegistry};
 
 /// These are the messages that the GLPlayer thread will forward to
 /// the video player which lives in htmlmediaelement
@@ -99,8 +100,10 @@ impl PlayerGLContext for WindowGLContext {
 pub struct GLPlayerThreads(GLPlayerSender<GLPlayerMsg>);
 
 impl GLPlayerThreads {
-    pub fn new() -> (GLPlayerThreads, Box<dyn WebrenderExternalImageApi>) {
-        let channel = GLPlayerThread::start();
+    pub fn new(
+        external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
+    ) -> (GLPlayerThreads, Box<dyn WebrenderExternalImageApi>) {
+        let channel = GLPlayerThread::start(external_images);
         let external = GLPlayerExternalImages::new(channel.clone());
         (GLPlayerThreads(channel), Box::new(external))
     }

components/media/media_thread.rs

@@ -7,31 +7,36 @@ use crate::media_channel::{glplayer_channel, GLPlayerSender};
 /// constellation.
 use crate::{GLPlayerMsg, GLPlayerMsgForward};
 use fnv::FnvHashMap;
+use std::sync::{Arc, Mutex};
 use std::thread;
+use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
 
 /// A GLPlayerThrx1ead manages the life cycle and message multiplexign of
 /// a set of video players with GL render.
 pub struct GLPlayerThread {
     // Map of live players.
     players: FnvHashMap<u64, GLPlayerSender<GLPlayerMsgForward>>,
-    /// Id generator for new WebGLContexts.
-    next_player_id: u64,
+    /// List of registered webrender external images.
+    /// We use it to get an unique ID for new players.
+    external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
 }
 
 impl GLPlayerThread {
-    pub fn new() -> Self {
+    pub fn new(external_images: Arc<Mutex<WebrenderExternalImageRegistry>>) -> Self {
         GLPlayerThread {
             players: Default::default(),
-            next_player_id: 1,
+            external_images,
         }
     }
 
-    pub fn start() -> GLPlayerSender<GLPlayerMsg> {
+    pub fn start(
+        external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
+    ) -> GLPlayerSender<GLPlayerMsg> {
         let (sender, receiver) = glplayer_channel::<GLPlayerMsg>().unwrap();
         thread::Builder::new()
             .name("GLPlayerThread".to_owned())
             .spawn(move || {
-                let mut renderer = GLPlayerThread::new();
+                let mut renderer = GLPlayerThread::new(external_images);
                 loop {
                     let msg = receiver.recv().unwrap();
                     let exit = renderer.handle_msg(msg);
@@ -51,12 +56,20 @@ impl GLPlayerThread {
         trace!("processing {:?}", msg);
         match msg {
             GLPlayerMsg::RegisterPlayer(sender) => {
-                let id = self.next_player_id;
+                let id = self
+                    .external_images
+                    .lock()
+                    .unwrap()
+                    .next_id(WebrenderImageHandlerType::Media)
+                    .0;
                 self.players.insert(id, sender.clone());
                 sender.send(GLPlayerMsgForward::PlayerId(id)).unwrap();
-                self.next_player_id += 1;
             },
             GLPlayerMsg::UnregisterPlayer(id) => {
+                self.external_images
+                    .lock()
+                    .unwrap()
+                    .remove(&webrender_api::ExternalImageId(id));
                 if self.players.remove(&id).is_none() {
                     warn!("Tried to remove an unknown player");
                 }