Extract device_pixels_per_px from global opts

This is also an embedder specific option, so removing it from the
global options makes sense.

ports/glutin/app.rs

@@ -34,12 +34,18 @@ pub struct App {
 }
 
 impl App {
-    pub fn run(angle: bool, enable_vsync: bool, use_msaa: bool, no_native_titlebar: bool) {
+    pub fn run(
+        angle: bool,
+        enable_vsync: bool,
+        use_msaa: bool,
+        no_native_titlebar: bool,
+        device_pixels_per_px: Option<f32>,
+    ) {
         let events_loop = EventsLoop::new(opts::get().headless);
 
         // Implements window methods, used by compositor.
         let window = if opts::get().headless {
-            headless_window::Window::new(opts::get().initial_window_size)
+            headless_window::Window::new(opts::get().initial_window_size, device_pixels_per_px)
         } else {
             Rc::new(headed_window::Window::new(
                 opts::get().initial_window_size,
@@ -49,6 +55,7 @@ impl App {
                 enable_vsync,
                 use_msaa,
                 no_native_titlebar,
+                device_pixels_per_px,
             ))
         };
 
@@ -63,7 +70,7 @@ impl App {
         // Handle browser state.
         let browser = Browser::new(window.clone());
 
-        let mut servo = Servo::new(embedder, window.clone());
+        let mut servo = Servo::new(embedder, window.clone(), device_pixels_per_px);
         let browser_id = BrowserId::new();
         servo.handle_events(vec![WindowEvent::NewBrowser(get_default_url(), browser_id)]);
         servo.setup_logging();

ports/glutin/headed_window.rs

@@ -75,6 +75,7 @@ pub struct Window {
     enable_vsync: bool,
     use_msaa: bool,
     no_native_titlebar: bool,
+    device_pixels_per_px: Option<f32>,
 }
 
 #[cfg(not(target_os = "windows"))]
@@ -98,6 +99,7 @@ impl Window {
         enable_vsync: bool,
         use_msaa: bool,
         no_native_titlebar: bool,
+        device_pixels_per_px: Option<f32>,
     ) -> Window {
         let opts = opts::get();
 
@@ -210,6 +212,7 @@ impl Window {
             enable_vsync,
             use_msaa,
             no_native_titlebar,
+            device_pixels_per_px,
         };
 
         window.present();
@@ -329,7 +332,7 @@ impl Window {
     }
 
     fn servo_hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
-        match opts::get().device_pixels_per_px {
+        match self.device_pixels_per_px {
             Some(device_pixels_per_px) => Scale::new(device_pixels_per_px),
             _ => match opts::get().output_file {
                 Some(_) => Scale::new(1.0),
@@ -561,6 +564,7 @@ impl webxr::glwindow::GlWindow for Window {
             self.enable_vsync,
             self.use_msaa,
             self.no_native_titlebar,
+            self.device_pixels_per_px,
         ));
         app::register_window(window.clone());
         Ok(window)

ports/glutin/headless_window.rs

@@ -5,12 +5,11 @@
 //! A headless window implementation.
 
 use crate::window_trait::WindowPortsMethods;
-use glutin;
 use euclid::{default::Size2D as UntypedSize2D, Point2D, Rotation3D, Scale, Size2D, UnknownUnit};
 use gleam::gl;
+use glutin;
 use servo::compositing::windowing::{AnimationState, WindowEvent};
 use servo::compositing::windowing::{EmbedderCoordinates, WindowMethods};
-use servo::servo_config::opts;
 use servo::servo_geometry::DeviceIndependentPixel;
 use servo::style_traits::DevicePixel;
 use servo::webrender_api::units::{DeviceIntRect, DeviceIntSize};
@@ -92,10 +91,14 @@ pub struct Window {
     animation_state: Cell<AnimationState>,
     fullscreen: Cell<bool>,
     gl: Rc<dyn gl::Gl>,
+    device_pixels_per_px: Option<f32>,
 }
 
 impl Window {
-    pub fn new(size: Size2D<u32, DeviceIndependentPixel>) -> Rc<dyn WindowPortsMethods> {
+    pub fn new(
+        size: Size2D<u32, DeviceIndependentPixel>,
+        device_pixels_per_px: Option<f32>,
+    ) -> Rc<dyn WindowPortsMethods> {
         let context = HeadlessContext::new(size.width, size.height, None);
         let gl = unsafe { gl::GlFns::load_with(|s| HeadlessContext::get_proc_address(s)) };
 
@@ -110,13 +113,14 @@ impl Window {
             gl,
             animation_state: Cell::new(AnimationState::Idle),
             fullscreen: Cell::new(false),
+            device_pixels_per_px,
         };
 
         Rc::new(window)
     }
 
     fn servo_hidpi_factor(&self) -> Scale<f32, DeviceIndependentPixel, DevicePixel> {
-        match opts::get().device_pixels_per_px {
+        match self.device_pixels_per_px {
             Some(device_pixels_per_px) => Scale::new(device_pixels_per_px),
             _ => Scale::new(1.0),
         }
@@ -133,9 +137,7 @@ impl WindowPortsMethods for Window {
     }
 
     fn id(&self) -> glutin::WindowId {
-        unsafe {
-            glutin::WindowId::dummy()
-        }
+        unsafe { glutin::WindowId::dummy() }
     }
 
     fn page_height(&self) -> f32 {
@@ -167,8 +169,7 @@ impl WindowMethods for Window {
 
     fn get_coordinates(&self) -> EmbedderCoordinates {
         let dpr = self.servo_hidpi_factor();
-        let size =
-            (Size2D::new(self.context.width, self.context.height).to_f32() * dpr).to_i32();
+        let size = (Size2D::new(self.context.width, self.context.height).to_f32() * dpr).to_i32();
         let viewport = DeviceIntRect::new(Point2D::zero(), size);
         let framebuffer = DeviceIntSize::from_untyped(size.to_untyped());
         EmbedderCoordinates {
@@ -223,7 +224,10 @@ impl webxr::glwindow::GlWindow for Window {
     fn swap_buffers(&self) {}
     fn size(&self) -> UntypedSize2D<gl::GLsizei> {
         let dpr = self.servo_hidpi_factor().get();
-        Size2D::new((self.context.width as f32 * dpr) as gl::GLsizei, (self.context.height as f32 * dpr) as gl::GLsizei)
+        Size2D::new(
+            (self.context.width as f32 * dpr) as gl::GLsizei,
+            (self.context.height as f32 * dpr) as gl::GLsizei,
+        )
     }
     fn new_window(&self) -> Result<Rc<dyn webxr::glwindow::GlWindow>, ()> {
         let width = self.context.width;
@@ -236,6 +240,7 @@ impl webxr::glwindow::GlWindow for Window {
             gl,
             animation_state: Cell::new(AnimationState::Idle),
             fullscreen: Cell::new(false),
+            device_pixels_per_px: self.device_pixels_per_px,
         }))
     }
     fn get_rotation(&self) -> Rotation3D<f32, UnknownUnit, UnknownUnit> {

ports/glutin/main2.rs

@@ -96,6 +96,7 @@ pub fn main() {
     );
     opts.optflag("", "msaa", "Use multisample antialiasing in WebRender.");
     opts.optflag("b", "no-native-titlebar", "Do not use native titlebar");
+    opts.optopt("", "device-pixel-ratio", "Device pixels per px", "");
 
     let opts_matches;
     let content_process_token;
@@ -159,7 +160,14 @@ pub fn main() {
         opts_matches.opt_present("no-native-titlebar") || !(pref!(shell.native_titlebar.enabled));
     let enable_vsync = !opts_matches.opt_present("disable-vsync");
     let use_msaa = opts_matches.opt_present("msaa");
-    App::run(angle, enable_vsync, use_msaa, do_not_use_native_titlebar);
+    let device_pixels_per_px = opts_matches.opt_str("device-pixel-ratio").map(|dppx_str| {
+        dppx_str.parse().unwrap_or_else(|err| {
+            error!( "Error parsing option: --device-pixel-ratio ({})", err);
+            process::exit(1);
+        })
+    });
+
+    App::run(angle, enable_vsync, use_msaa, do_not_use_native_titlebar, device_pixels_per_px);
 
     platform::deinit(clean_shutdown)
 }

ports/libsimpleservo/api/src/lib.rs

@@ -205,7 +205,7 @@ pub fn init(
         gl: gl.clone(),
     });
 
-    let servo = Servo::new(embedder_callbacks, window_callbacks.clone());
+    let servo = Servo::new(embedder_callbacks, window_callbacks.clone(), None);
 
     SERVO.with(|s| {
         let mut servo_glue = ServoGlue {