No more headless compositor. Just the normal one.

notriddle · notriddle · commit e4857ef519c1 · 2015-11-21T14:24:54.000-07:00
Fixes #8573
diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs
@@ -280,7 +280,10 @@ enum CompositeTarget {
     WindowAndPng,
 
     /// Compose to a PNG, write it to disk, and then exit the browser (used for reftests)
-    PngFile
+    PngFile,
+
+    /// Nothing (used for script tests)
+    None,
 }
 
 fn initialize_png(width: usize, height: usize) -> (Vec<gl::GLuint>, Vec<gl::GLuint>) {
@@ -326,7 +329,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         let hidpi_factor = window.hidpi_factor();
         let composite_target = match opts::get().output_file {
             Some(_) => CompositeTarget::PngFile,
-            None => CompositeTarget::Window
+            None if opts::get().headless => CompositeTarget::None,
+            None => CompositeTarget::Window,
         };
         let native_display = window.native_display();
         IOCompositor {
@@ -1464,10 +1468,10 @@ impl<Window: WindowMethods> IOCompositor<Window> {
     fn device_pixels_per_screen_px(&self) -> ScaleFactor<ScreenPx, DevicePixel, f32> {
         match opts::get().device_pixels_per_px {
             Some(device_pixels_per_px) => ScaleFactor::new(device_pixels_per_px),
-            None => match opts::get().output_file {
-                Some(_) => ScaleFactor::new(1.0),
-                None => self.hidpi_factor
-            }
+            None if opts::get().output_file.is_some() || opts::get().headless => {
+                ScaleFactor::new(1.0)
+            },
+            None => self.hidpi_factor,
         }
     }
 
@@ -1802,11 +1806,14 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                     }
                 }
             }
+            CompositeTarget::None => (),
         }
 
         let (framebuffer_ids, texture_ids) = match target {
-            CompositeTarget::Window => (vec!(), vec!()),
-            _ => initialize_png(width, height)
+            CompositeTarget::Window | CompositeTarget::None => (vec!(), vec!()),
+            CompositeTarget::WindowAndPng | CompositeTarget::PngFile => {
+                initialize_png(width, height)
+            }
         };
 
         profile(ProfilerCategory::Compositing, None, self.time_profiler_chan.clone(), || {
@@ -1854,7 +1861,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
         });
 
         let rv = match target {
-            CompositeTarget::Window => None,
+            CompositeTarget::Window | CompositeTarget::None => None,
             CompositeTarget::WindowAndPng => {
                 let img = self.draw_img(framebuffer_ids, texture_ids, width, height);
                 Some(Image {
diff --git a/components/compositing/compositor_task.rs b/components/compositing/compositor_task.rs
@@ -7,7 +7,6 @@
 use compositor;
 use euclid::point::Point2D;
 use euclid::size::Size2D;
-use headless;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use layers::layers::{BufferRequest, LayerBufferSet};
 use layers::platform::surface::{NativeDisplay, NativeSurface};
@@ -265,20 +264,12 @@ impl Debug for Msg {
 pub struct CompositorTask;
 
 impl CompositorTask {
-    pub fn create<Window>(window: Option<Rc<Window>>,
+    pub fn create<Window>(window: Rc<Window>,
                           state: InitialCompositorState)
                           -> Box<CompositorEventListener + 'static>
                           where Window: WindowMethods + 'static {
-        match window {
-            Some(window) => {
-                box compositor::IOCompositor::create(window, state)
-                    as Box<CompositorEventListener>
-            }
-            None => {
-                box headless::NullCompositor::create(state)
-                    as Box<CompositorEventListener>
-            }
-        }
+        box compositor::IOCompositor::create(window, state)
+            as Box<CompositorEventListener>
     }
 }
 
diff --git a/components/compositing/headless.rs b/components/compositing/headless.rs
diff --git a/components/compositing/lib.rs b/components/compositing/lib.rs
@@ -59,7 +59,6 @@ pub use constellation::Constellation;
 
 mod compositor;
 mod compositor_layer;
-mod headless;
 mod scrolling;
 mod surface_map;
 mod timer_scheduler;
diff --git a/components/compositing/windowing.rs b/components/compositing/windowing.rs
@@ -15,7 +15,6 @@ use msg::constellation_msg::{Key, KeyModifiers, KeyState};
 use net_traits::net_error_list::NetError;
 use script_traits::{MouseButton, TouchEventType, TouchId};
 use std::fmt::{Debug, Error, Formatter};
-use std::rc::Rc;
 use url::Url;
 use util::cursor::Cursor;
 use util::geometry::ScreenPx;
@@ -143,8 +142,7 @@ pub trait WindowMethods {
     ///
     /// This is part of the windowing system because its implementation often involves OS-specific
     /// magic to wake the up window's event loop.
-    fn create_compositor_channel(_: &Option<Rc<Self>>)
-                                 -> (Box<CompositorProxy + Send>, Box<CompositorReceiver>);
+    fn create_compositor_channel(&self) -> (Box<CompositorProxy + Send>, Box<CompositorReceiver>);
 
     /// Requests that the window system prepare a composite. Typically this will involve making
     /// some type of platform-specific graphics context current. Returns true if the composite may
diff --git a/components/servo/lib.rs b/components/servo/lib.rs
@@ -78,7 +78,6 @@ use profile::mem as profile_mem;
 use profile::time as profile_time;
 use profile_traits::mem;
 use profile_traits::time;
-use std::borrow::Borrow;
 use std::rc::Rc;
 use std::sync::mpsc::Sender;
 use util::opts;
@@ -121,7 +120,7 @@ pub struct Browser {
 /// loop to pump messages between the embedding application and
 /// various browser components.
 impl Browser {
-    pub fn new<Window>(window: Option<Rc<Window>>) -> Browser
+    pub fn new<Window>(window: Rc<Window>) -> Browser
                        where Window: WindowMethods + 'static {
         // Global configuration options, parsed from the command line.
         let opts = opts::get();
@@ -133,14 +132,8 @@ impl Browser {
         // messages to client may need to pump a platform-specific event loop
         // to deliver the message.
         let (compositor_proxy, compositor_receiver) =
-            WindowMethods::create_compositor_channel(&window);
-        let supports_clipboard = match window {
-            Some(ref win_rc) => {
-                let win: &Window = win_rc.borrow();
-                win.supports_clipboard()
-            }
-            None => false
-        };
+            window.create_compositor_channel();
+        let supports_clipboard = window.supports_clipboard();
         let time_profiler_chan = profile_time::Profiler::create(opts.time_profiler_period);
         let mem_profiler_chan = profile_mem::Profiler::create(opts.mem_profiler_period);
         let devtools_chan = opts.devtools_port.map(|port| {
diff --git a/components/servo/main.rs b/components/servo/main.rs
@@ -34,22 +34,12 @@ extern crate time;
 extern crate gleam;
 extern crate offscreen_gl_context;
 
-use gleam::gl;
-use offscreen_gl_context::GLContext;
 use servo::Browser;
 use servo::compositing::windowing::WindowEvent;
 use servo::net_traits::hosts;
 use servo::util::opts::{self, ArgumentParsingResult};
 use std::rc::Rc;
 
-#[cfg(not(target_os = "android"))]
-fn load_gl_when_headless() {
-    gl::load_with(|addr| GLContext::get_proc_address(addr) as *const _);
-}
-
-#[cfg(target_os = "android")]
-fn load_gl_when_headless() {}
-
 fn main() {
     // Parse the command line options and store them globally
     let opts_result = opts::from_cmdline_args(&*args());
@@ -75,60 +65,40 @@ fn main() {
         return servo::run_content_process(token)
     }
 
-    let window = if opts::get().headless {
-        // Load gl functions even when in headless mode,
-        // to avoid crashing with webgl
-        load_gl_when_headless();
-        None
-    } else {
-        Some(app::create_window(None))
-    };
+    let window = app::create_window(None);
 
     // Our wrapper around `Browser` that also implements some
     // callbacks required by the glutin window implementation.
     let mut browser = BrowserWrapper {
         browser: Browser::new(window.clone()),
     };
 
-    maybe_register_glutin_resize_handler(&window, &mut browser);
+    register_glutin_resize_handler(&window, &mut browser);
 
     browser.browser.handle_events(vec![WindowEvent::InitializeCompositing]);
 
     // Feed events from the window to the browser until the browser
     // says to stop.
     loop {
-        let should_continue = match window {
-            None => browser.browser.handle_events(Vec::new()),
-            Some(ref window) => browser.browser.handle_events(window.wait_events()),
-        };
+        let should_continue =  browser.browser.handle_events(window.wait_events());
         if !should_continue {
             break
         }
     };
 
-    maybe_unregister_glutin_resize_handler(&window);
+    unregister_glutin_resize_handler(&window);
 }
 
-fn maybe_register_glutin_resize_handler(window: &Option<Rc<app::window::Window>>,
+fn register_glutin_resize_handler(window: &Rc<app::window::Window>,
                                         browser: &mut BrowserWrapper) {
-    match *window {
-        None => {}
-        Some(ref window) => {
-            unsafe {
-                window.set_nested_event_loop_listener(browser);
-            }
-        }
+    unsafe {
+        window.set_nested_event_loop_listener(browser);
     }
 }
 
-fn maybe_unregister_glutin_resize_handler(window: &Option<Rc<app::window::Window>>) {
-    match *window {
-        None => {}
-        Some(ref window) => {
-            unsafe {
-                window.remove_nested_event_loop_listener();
-            }
-        }
+fn unregister_glutin_resize_handler(window: &Rc<app::window::Window>) {
+    unsafe {
+        window.remove_nested_event_loop_listener();
     }
 }
 
diff --git a/ports/glutin/lib.rs b/ports/glutin/lib.rs
diff --git a/ports/glutin/window.rs b/ports/glutin/window.rs
