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),

ports/cef/types.rs

@@ -373,6 +373,7 @@ pub struct cef_point {
 //
 // Structure representing a rectangle.
 //
+#[derive(Default)]
 pub struct cef_rect {
   pub x: c_int,
   pub y: c_int,
@@ -1599,6 +1600,7 @@ pub enum cef_cursor_type_t {
 // passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled
 // in by the client.
 ///
+#[derive(Default)]
 pub struct _cef_screen_info {
   ///
   // Device scale factor. Specifies the ratio between physical and logical

ports/cef/window.rs

@@ -14,7 +14,7 @@ use eutil::Downcast;
 use interfaces::CefApp;
 use interfaces::CefBrowser;
 use render_handler::CefRenderHandlerExtensions;
-use types::{cef_cursor_handle_t, cef_cursor_type_t, cef_rect_t};
+use types::{cef_cursor_handle_t, cef_cursor_type_t, cef_rect_t, CefScreenInfo};
 use wrappers::CefWrap;
 
 use compositing::compositor_thread::EventLoopWaker;
@@ -169,6 +169,19 @@ impl Window {
     fn cursor_handle_for_cursor(&self, _: Cursor) -> cef_cursor_handle_t {
         0
     }
+
+    fn screen_info(&self) -> CefScreenInfo {
+        let mut screen_info = CefScreenInfo::default();
+        let browser = self.cef_browser.borrow();
+        if let Some(ref browser) = *browser {
+            browser.get_host()
+                   .get_client()
+                   .get_render_handler()
+                   .get_screen_info(browser.clone(), &mut screen_info);
+        }
+        screen_info
+    }
+
 }
 
 impl WindowMethods for Window {
@@ -501,6 +514,16 @@ impl WindowMethods for Window {
     fn supports_clipboard(&self) -> bool {
         false
     }
+
+    fn screen_size(&self, _: BrowserId) -> Size2D<u32> {
+        let screen_info = self.screen_info();
+        Size2D::new(screen_info.rect.width as u32, screen_info.rect.height as u32)
+    }
+
+    fn screen_avail_size(&self, _: BrowserId) -> Size2D<u32> {
+        let screen_info = self.screen_info();
+        Size2D::new(screen_info.available_rect.width as u32, screen_info.available_rect.height as u32)
+    }
 }
 
 #[cfg(target_os="macos")]

ports/glutin/window.rs

@@ -1033,6 +1033,31 @@ impl WindowMethods for Window {
 
     }
 
+    fn screen_size(&self, _: BrowserId) -> Size2D<u32> {
+        match self.kind {
+            WindowKind::Window(_) => {
+                let (width, height) = glutin::get_primary_monitor().get_dimensions();
+                Size2D::new(width, height)
+            }
+            WindowKind::Headless(ref context) => {
+                Size2D::new(context.width, context.height)
+            }
+        }
+    }
+
+    fn screen_avail_size(&self, _: BrowserId) -> Size2D<u32> {
+        // FIXME: Glutin doesn't have API for available size. Fallback to screen size
+        match self.kind {
+            WindowKind::Window(_) => {
+                let (width, height) = glutin::get_primary_monitor().get_dimensions();
+                Size2D::new(width, height)
+            }
+            WindowKind::Headless(ref context) => {
+                Size2D::new(context.width, context.height)
+            }
+        }
+    }
+
     fn set_animation_state(&self, state: AnimationState) {
         self.animation_state.set(state);
     }

tests/wpt/metadata/css/cssom-view/interfaces.html.ini

@@ -465,30 +465,6 @@
   [Range interface: new Range() must inherit property "getBoundingClientRect()" with the proper type]
     expected: FAIL
 
-  [Screen interface: attribute availWidth]
-    expected: FAIL
-
-  [Screen interface: attribute availHeight]
-    expected: FAIL
-
-  [Screen interface: attribute width]
-    expected: FAIL
-
-  [Screen interface: attribute height]
-    expected: FAIL
-
-  [Screen interface: screen must inherit property "availWidth" with the proper type]
-    expected: FAIL
-
-  [Screen interface: screen must inherit property "availHeight" with the proper type]
-    expected: FAIL
-
-  [Screen interface: screen must inherit property "width" with the proper type]
-    expected: FAIL
-
-  [Screen interface: screen must inherit property "height" with the proper type]
-    expected: FAIL
-
   [CaretPosition interface: existence and properties of interface object]
     expected: FAIL