Enable screen.availHeight/availWidth/Height/Width

components/compositing/compositor_thread.rs

@@ -124,6 +124,10 @@ pub enum EmbedderMsg {
     ResizeTo(TopLevelBrowsingContextId, Size2D<u32>),
     /// Get Window Informations size and position
     GetClientWindow(TopLevelBrowsingContextId, IpcSender<(Size2D<u32>, Point2D<i32>)>),
+    /// Get screen size (pixel)
+    GetScreenSize(TopLevelBrowsingContextId, IpcSender<(Size2D<u32>)>),
+    /// Get screen available size (pixel)
+    GetScreenAvailSize(TopLevelBrowsingContextId, IpcSender<(Size2D<u32>)>),
     /// Wether or not to follow a link
     AllowNavigation(TopLevelBrowsingContextId, ServoUrl, IpcSender<bool>),
     /// Sends an unconsumed key event back to the embedder.
@@ -222,6 +226,8 @@ impl Debug for EmbedderMsg {
             EmbedderMsg::MoveTo(..) => write!(f, "MoveTo"),
             EmbedderMsg::ResizeTo(..) => write!(f, "ResizeTo"),
             EmbedderMsg::GetClientWindow(..) => write!(f, "GetClientWindow"),
+            EmbedderMsg::GetScreenSize(..) => write!(f, "GetScreenSize"),
+            EmbedderMsg::GetScreenAvailSize(..) => write!(f, "GetScreenAvailSize"),
             EmbedderMsg::AllowNavigation(..) => write!(f, "AllowNavigation"),
             EmbedderMsg::KeyEvent(..) => write!(f, "KeyEvent"),
             EmbedderMsg::SetCursor(..) => write!(f, "SetCursor"),

components/compositing/windowing.rs

@@ -133,6 +133,10 @@ pub trait WindowMethods {
 
     /// Return the size of the window with head and borders and position of the window values
     fn client_window(&self, ctx: TopLevelBrowsingContextId) -> (Size2D<u32>, Point2D<i32>);
+    /// Return the size of the screen (pixel)
+    fn screen_size(&self, ctx: TopLevelBrowsingContextId) -> Size2D<u32>;
+    /// Return the available size of the screen (pixel)
+    fn screen_avail_size(&self, ctx: TopLevelBrowsingContextId) -> Size2D<u32>;
     /// Set the size inside of borders and head
     fn set_inner_size(&self, ctx: TopLevelBrowsingContextId, size: Size2D<u32>);
     /// Set the window position

components/constellation/constellation.rs

@@ -1261,6 +1261,14 @@ impl<Message, LTF, STF> Constellation<Message, LTF, STF>
                 self.embedder_proxy.send(EmbedderMsg::ResizeTo(source_top_ctx_id, size));
             }
 
+            FromScriptMsg::GetScreenSize(send) => {
+                self.embedder_proxy.send(EmbedderMsg::GetScreenSize(source_top_ctx_id, send));
+            }
+
+            FromScriptMsg::GetScreenAvailSize(send) => {
+                self.embedder_proxy.send(EmbedderMsg::GetScreenAvailSize(source_top_ctx_id, send));
+            }
+
             FromScriptMsg::Exit => {
                 self.compositor_proxy.send(ToCompositorMsg::Exit);
             }

components/script/dom/screen.rs

@@ -4,31 +4,73 @@
 
 use dom::bindings::codegen::Bindings::ScreenBinding;
 use dom::bindings::codegen::Bindings::ScreenBinding::ScreenMethods;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::num::Finite;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
-use dom::bindings::root::DomRoot;
+use dom::bindings::root::{Dom, DomRoot};
+use dom::globalscope::GlobalScope;
 use dom::window::Window;
 use dom_struct::dom_struct;
+use euclid::Size2D;
+use ipc_channel::ipc;
+use script_traits::ScriptMsg;
 
 #[dom_struct]
 pub struct Screen {
     reflector_: Reflector,
+    window: Dom<Window>,
 }
 
 impl Screen {
-    fn new_inherited() -> Screen {
+    fn new_inherited(window: &Window) -> Screen {
         Screen {
             reflector_: Reflector::new(),
+            window: Dom::from_ref(&window),
         }
     }
 
     pub fn new(window: &Window) -> DomRoot<Screen> {
-        reflect_dom_object(Box::new(Screen::new_inherited()),
+        reflect_dom_object(Box::new(Screen::new_inherited(window)),
                            window,
                            ScreenBinding::Wrap)
     }
+
+    fn screen_size(&self) -> Size2D<u32> {
+        let (send, recv) = ipc::channel::<(Size2D<u32>)>().unwrap();
+        self.window.upcast::<GlobalScope>()
+            .script_to_constellation_chan().send(ScriptMsg::GetScreenSize(send)).unwrap();
+        recv.recv().unwrap_or((Size2D::zero()))
+    }
+
+    fn screen_avail_size(&self) -> Size2D<u32> {
+        let (send, recv) = ipc::channel::<(Size2D<u32>)>().unwrap();
+        self.window.upcast::<GlobalScope>()
+            .script_to_constellation_chan().send(ScriptMsg::GetScreenAvailSize(send)).unwrap();
+        recv.recv().unwrap_or((Size2D::zero()))
+    }
 }
 
 impl ScreenMethods for Screen {
+    // https://drafts.csswg.org/cssom-view/#dom-screen-availwidth
+    fn AvailWidth(&self) -> Finite<f64> {
+        Finite::wrap(self.screen_avail_size().width as f64)
+    }
+
+    // https://drafts.csswg.org/cssom-view/#dom-screen-availheight
+    fn AvailHeight(&self) -> Finite<f64> {
+        Finite::wrap(self.screen_avail_size().height as f64)
+    }
+
+    // https://drafts.csswg.org/cssom-view/#dom-screen-width
+    fn Width(&self) -> Finite<f64> {
+        Finite::wrap(self.screen_size().width as f64)
+    }
+
+    // https://drafts.csswg.org/cssom-view/#dom-screen-height
+    fn Height(&self) -> Finite<f64> {
+        Finite::wrap(self.screen_size().height as f64)
+    }
+
     // https://drafts.csswg.org/cssom-view/#dom-screen-colordepth
     fn ColorDepth(&self) -> u32 {
         24

components/script/dom/webidls/Screen.webidl

@@ -5,10 +5,10 @@
 // http://dev.w3.org/csswg/cssom-view/#the-screen-interface
 [Exposed=Window]
 interface Screen {
-  //readonly attribute double availWidth;
-  //readonly attribute double availHeight;
-  //readonly attribute double width;
-  //readonly attribute double height;
+  readonly attribute double availWidth;
+  readonly attribute double availHeight;
+  readonly attribute double width;
+  readonly attribute double height;
   readonly attribute unsigned long colorDepth;
   readonly attribute unsigned long pixelDepth;
 };

components/script_traits/script_msg.rs

@@ -157,6 +157,10 @@ pub enum ScriptMsg {
     RegisterServiceWorker(ScopeThings, ServoUrl),
     /// Enter or exit fullscreen
     SetFullscreenState(bool),
+    /// Get the screen size (pixel)
+    GetScreenSize(IpcSender<(Size2D<u32>)>),
+    /// Get the available screen size (pixel)
+    GetScreenAvailSize(IpcSender<(Size2D<u32>)>),
     /// Requests that the compositor shut down.
     Exit,
 }

components/servo/lib.rs

@@ -395,6 +395,22 @@ impl<Window> Servo<Window> where Window: WindowMethods + 'static {
                     }
                 },
 
+                (EmbedderMsg::GetScreenSize(top_level_browsing_context, send),
+                 ShutdownState::NotShuttingDown) => {
+                    let rect = self.compositor.window.screen_size(top_level_browsing_context);
+                    if let Err(e) = send.send(rect) {
+                        warn!("Sending response to get screen size failed ({}).", e);
+                    }
+                },
+
+                (EmbedderMsg::GetScreenAvailSize(top_level_browsing_context, send),
+                 ShutdownState::NotShuttingDown) => {
+                    let rect = self.compositor.window.screen_avail_size(top_level_browsing_context);
+                    if let Err(e) = send.send(rect) {
+                        warn!("Sending response to get screen available size failed ({}).", e);
+                    }
+                },
+
                 (EmbedderMsg::AllowNavigation(top_level_browsing_context,
                                               url,
                                               response_chan),