Bug 1469244: Remove stale servo/components/{servo,nonzero} directories. r=jwatt
authorEmilio Cobos Álvarez <emilio@crisal.io>
Mon, 18 Jun 2018 10:54:35 +0200
changeset 479553 705644bd3788e039c147373182fa7fd19fec0e6d
parent 479552 4e6031a71ca31be8bd3a8e0241735233e297df58
child 479554 d7079fb3a17993021fd7908af2b22e363d3143e3
push id1757
push userffxbld-merge
push dateFri, 24 Aug 2018 17:02:43 +0000
treeherdermozilla-release@736023aebdb1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjwatt
bugs1469244, 1464834
milestone62.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1469244: Remove stale servo/components/{servo,nonzero} directories. r=jwatt Summary: Looks like I missed this in bug 1464834. Test Plan: Not part of the build, so no tests. Reviewers: jwatt Subscribers: heycam, xidorn Bug #: 1469244 Differential Revision: https://phabricator.services.mozilla.com/D1679 MozReview-Commit-ID: Bx14lTv6GDD
servo/components/nonzero/Cargo.toml
servo/components/nonzero/lib.rs
servo/components/servo/Cargo.toml
servo/components/servo/lib.rs
deleted file mode 100644
--- a/servo/components/nonzero/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "nonzero"
-version = "0.0.1"
-authors = ["The Servo Project Developers"]
-license = "MPL-2.0"
-publish = false
-
-[lib]
-path = "lib.rs"
-
-[features]
-unstable = ["serde/unstable"]
-
-[dependencies]
-serde = "1.0.14"
deleted file mode 100644
--- a/servo/components/nonzero/lib.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! `NonZero*` types that are either `core::nonzero::NonZero<_>`
-//! or some stable types with an equivalent API (but no memory layout optimization).
-
-#![cfg_attr(feature = "unstable", feature(nonzero))]
-#![cfg_attr(feature = "unstable", feature(const_fn))]
-
-extern crate serde;
-
-use std::fmt;
-
-macro_rules! impl_nonzero_fmt {
-    ( ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
-        $(
-            impl fmt::$Trait for $Ty {
-                #[inline]
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    self.get().fmt(f)
-                }
-            }
-        )+
-    }
-}
-
-macro_rules! nonzero_integers {
-    ( $( $Ty: ident($Int: ty); )+ ) => {
-        $(
-            #[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
-            pub struct $Ty(
-                #[cfg(feature = "unstable")] std::num::$Ty,
-                #[cfg(not(feature = "unstable"))] $Int,
-            );
-
-            impl $Ty {
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub const unsafe fn new_unchecked(n: $Int) -> Self {
-                    $Ty(std::num::$Ty::new_unchecked(n))
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub unsafe fn new_unchecked(n: $Int) -> Self {
-                    $Ty(n)
-                }
-
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub fn new(n: $Int) -> Option<Self> {
-                    std::num::$Ty::new(n).map($Ty)
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub fn new(n: $Int) -> Option<Self> {
-                    if n != 0 {
-                        Some($Ty(n))
-                    } else {
-                        None
-                    }
-                }
-
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub fn get(self) -> $Int {
-                    self.0.get()
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub fn get(self) -> $Int {
-                    self.0
-                }
-            }
-
-            impl_nonzero_fmt! {
-                (Debug, Display, Binary, Octal, LowerHex, UpperHex) for $Ty
-            }
-
-            impl serde::Serialize for $Ty {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                    where S: serde::Serializer
-                {
-                    self.get().serialize(serializer)
-                }
-            }
-
-            impl<'de> serde::Deserialize<'de> for $Ty {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                    where D: serde::Deserializer<'de>
-                {
-                    let value = <$Int>::deserialize(deserializer)?;
-                    match <$Ty>::new(value) {
-                        Some(nonzero) => Ok(nonzero),
-                        None => Err(serde::de::Error::custom("expected a non-zero value")),
-                    }
-                }
-            }
-        )+
-    }
-}
-
-nonzero_integers! {
-    NonZeroU8(u8);
-    NonZeroU16(u16);
-    NonZeroU32(u32);
-    NonZeroU64(u64);
-    NonZeroUsize(usize);
-}
deleted file mode 100644
--- a/servo/components/servo/Cargo.toml
+++ /dev/null
@@ -1,67 +0,0 @@
-[package]
-
-name = "libservo"
-version = "0.0.1"
-authors = ["The Servo Project Developers"]
-license = "MPL-2.0"
-publish = false
-
-[lib]
-name = "servo"
-path = "lib.rs"
-crate-type = ["rlib"]
-
-[features]
-max_log_level = ["log/release_max_level_info"]
-webdriver = ["webdriver_server"]
-energy-profiling = ["profile_traits/energy-profiling"]
-debugmozjs = ["script/debugmozjs"]
-googlevr = ["webvr/googlevr"]
-webrender_debugger = ["webrender/debugger"]
-oculusvr = ["webvr/oculusvr"]
-unstable = [
-    "euclid/unstable",
-    "gfx/unstable",
-    "msg/unstable",
-    "profile/unstable",
-    "script/unstable",
-]
-
-[dependencies]
-bluetooth_traits = {path = "../bluetooth_traits"}
-bluetooth = {path = "../bluetooth"}
-canvas = {path = "../canvas"}
-canvas_traits = {path = "../canvas_traits"}
-compositing = {path = "../compositing"}
-constellation = {path = "../constellation"}
-debugger = {path = "../debugger"}
-devtools = {path = "../devtools"}
-devtools_traits = {path = "../devtools_traits"}
-env_logger = "0.5"
-euclid = "0.17"
-gfx = {path = "../gfx"}
-gleam = "0.4.29"
-ipc-channel = "0.10"
-layout_thread = {path = "../layout_thread"}
-log = "0.4"
-msg = {path = "../msg"}
-net = {path = "../net"}
-net_traits = {path = "../net_traits"}
-profile = {path = "../profile"}
-profile_traits = {path = "../profile_traits"}
-script = {path = "../script"}
-script_layout_interface = {path = "../script_layout_interface"}
-script_traits = {path = "../script_traits"}
-servo_config = {path = "../config"}
-servo_geometry = {path = "../geometry"}
-servo_url = {path = "../url"}
-style = {path = "../style", features = ["servo"]}
-style_traits = {path = "../style_traits", features = ["servo"]}
-webrender = {git = "https://github.com/servo/webrender"}
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
-webdriver_server = {path = "../webdriver_server", optional = true}
-webvr = {path = "../webvr"}
-webvr_traits = {path = "../webvr_traits"}
-
-[target.'cfg(all(not(target_os = "windows"), not(target_os = "ios")))'.dependencies]
-gaol = {git = "https://github.com/servo/gaol"}
deleted file mode 100644
--- a/servo/components/servo/lib.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! Servo, the mighty web browser engine from the future.
-//!
-//! This is a very simple library that wires all of Servo's components
-//! together as type `Servo`, along with a generic client
-//! implementing the `WindowMethods` trait, to create a working web
-//! browser.
-//!
-//! The `Servo` type is responsible for configuring a
-//! `Constellation`, which does the heavy lifting of coordinating all
-//! of Servo's internal subsystems, including the `ScriptThread` and the
-//! `LayoutThread`, as well maintains the navigation context.
-//!
-//! `Servo` is fed events from a generic type that implements the
-//! `WindowMethods` trait.
-
-extern crate env_logger;
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-extern crate gaol;
-extern crate gleam;
-#[macro_use]
-extern crate log;
-
-pub extern crate bluetooth;
-pub extern crate bluetooth_traits;
-pub extern crate canvas;
-pub extern crate canvas_traits;
-pub extern crate compositing;
-pub extern crate constellation;
-pub extern crate debugger;
-pub extern crate devtools;
-pub extern crate devtools_traits;
-pub extern crate euclid;
-pub extern crate gfx;
-pub extern crate ipc_channel;
-pub extern crate layout_thread;
-pub extern crate msg;
-pub extern crate net;
-pub extern crate net_traits;
-pub extern crate profile;
-pub extern crate profile_traits;
-pub extern crate script;
-pub extern crate script_traits;
-pub extern crate script_layout_interface;
-pub extern crate servo_config;
-pub extern crate servo_geometry;
-pub extern crate servo_url;
-pub extern crate style;
-pub extern crate style_traits;
-pub extern crate webrender_api;
-pub extern crate webvr;
-pub extern crate webvr_traits;
-
-#[cfg(feature = "webdriver")]
-extern crate webdriver_server;
-
-extern crate webrender;
-
-#[cfg(feature = "webdriver")]
-fn webdriver(port: u16, constellation: Sender<ConstellationMsg>) {
-    webdriver_server::start_server(port, constellation);
-}
-
-#[cfg(not(feature = "webdriver"))]
-fn webdriver(_port: u16, _constellation: Sender<ConstellationMsg>) { }
-
-use bluetooth::BluetoothThreadFactory;
-use bluetooth_traits::BluetoothRequest;
-use canvas::gl_context::GLContextFactory;
-use canvas::webgl_thread::WebGLThreads;
-use compositing::{IOCompositor, ShutdownState, RenderNotifier};
-use compositing::compositor_thread::{self, CompositorProxy, CompositorReceiver, InitialCompositorState};
-use compositing::compositor_thread::{EmbedderMsg, EmbedderProxy, EmbedderReceiver};
-use compositing::windowing::{WindowEvent, WindowMethods};
-use constellation::{Constellation, InitialConstellationState, UnprivilegedPipelineContent};
-use constellation::{FromCompositorLogger, FromScriptLogger};
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-use constellation::content_process_sandbox_profile;
-use env_logger::Builder as EnvLoggerBuilder;
-use euclid::Length;
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-use gaol::sandbox::{ChildSandbox, ChildSandboxMethods};
-use gfx::font_cache_thread::FontCacheThread;
-use ipc_channel::ipc::{self, IpcSender};
-use log::{Log, Metadata, Record};
-use net::resource_thread::new_resource_threads;
-use net_traits::IpcSend;
-use profile::mem as profile_mem;
-use profile::time as profile_time;
-use profile_traits::mem;
-use profile_traits::time;
-use script_traits::{ConstellationMsg, SWManagerSenders, ScriptToConstellationChan};
-use servo_config::opts;
-use servo_config::prefs::PREFS;
-use servo_config::resource_files::resources_dir_path;
-use std::borrow::Cow;
-use std::cmp::max;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::mpsc::{Sender, channel};
-use webrender::RendererKind;
-use webvr::{WebVRThread, WebVRCompositorHandler};
-
-pub use gleam::gl;
-pub use servo_config as config;
-pub use servo_url as url;
-pub use msg::constellation_msg::{KeyState, TopLevelBrowsingContextId as BrowserId};
-
-/// The in-process interface to Servo.
-///
-/// It does everything necessary to render the web, primarily
-/// orchestrating the interaction between JavaScript, CSS layout,
-/// rendering, and the client window.
-///
-/// Clients create a `Servo` instance for a given reference-counted type
-/// implementing `WindowMethods`, which is the bridge to whatever
-/// application Servo is embedded in. Clients then create an event
-/// loop to pump messages between the embedding application and
-/// various browser components.
-pub struct Servo<Window: WindowMethods + 'static> {
-    compositor: IOCompositor<Window>,
-    constellation_chan: Sender<ConstellationMsg>,
-    embedder_receiver: EmbedderReceiver,
-    embedder_events: Vec<EmbedderMsg>,
-}
-
-impl<Window> Servo<Window> where Window: WindowMethods + 'static {
-    pub fn new(window: Rc<Window>) -> Servo<Window> {
-        // Global configuration options, parsed from the command line.
-        let opts = opts::get();
-
-        // Make sure the gl context is made current.
-        window.prepare_for_composite(Length::new(0), Length::new(0));
-
-        // Get both endpoints of a special channel for communication between
-        // the client window and the compositor. This channel is unique because
-        // messages to client may need to pump a platform-specific event loop
-        // to deliver the message.
-        let (compositor_proxy, compositor_receiver) =
-            create_compositor_channel(window.create_event_loop_waker());
-        let (embedder_proxy, embedder_receiver) =
-            create_embedder_channel(window.create_event_loop_waker());
-        let supports_clipboard = window.supports_clipboard();
-        let time_profiler_chan = profile_time::Profiler::create(&opts.time_profiling,
-                                                                opts.time_profiler_trace_path.clone());
-        let mem_profiler_chan = profile_mem::Profiler::create(opts.mem_profiler_period);
-        let debugger_chan = opts.debugger_port.map(|port| {
-            debugger::start_server(port)
-        });
-        let devtools_chan = opts.devtools_port.map(|port| {
-            devtools::start_server(port)
-        });
-
-        let mut resource_path = resources_dir_path().unwrap();
-        resource_path.push("shaders");
-
-        let coordinates = window.get_coordinates();
-
-        let (mut webrender, webrender_api_sender) = {
-            let renderer_kind = if opts::get().should_use_osmesa() {
-                RendererKind::OSMesa
-            } else {
-                RendererKind::Native
-            };
-
-            let recorder = if opts.webrender_record {
-                let record_path = PathBuf::from("wr-record.bin");
-                let recorder = Box::new(webrender::BinaryRecorder::new(&record_path));
-                Some(recorder as Box<webrender::ApiRecordingReceiver>)
-            } else {
-                None
-            };
-
-            let mut debug_flags = webrender::DebugFlags::empty();
-            debug_flags.set(webrender::DebugFlags::PROFILER_DBG, opts.webrender_stats);
-
-            let render_notifier = Box::new(RenderNotifier::new(compositor_proxy.clone()));
-
-            webrender::Renderer::new(window.gl(), render_notifier, webrender::RendererOptions {
-                device_pixel_ratio: coordinates.hidpi_factor.get(),
-                resource_override_path: Some(resource_path),
-                enable_aa: opts.enable_text_antialiasing,
-                debug_flags: debug_flags,
-                recorder: recorder,
-                precache_shaders: opts.precache_shaders,
-                enable_scrollbars: opts.output_file.is_none(),
-                renderer_kind: renderer_kind,
-                enable_subpixel_aa: opts.enable_subpixel_text_antialiasing,
-                ..Default::default()
-            }).expect("Unable to initialize webrender!")
-        };
-
-        let webrender_api = webrender_api_sender.create_api();
-        let wr_document_layer = 0; //TODO
-        let webrender_document = webrender_api.add_document(coordinates.framebuffer, wr_document_layer);
-
-        // Important that this call is done in a single-threaded fashion, we
-        // can't defer it after `create_constellation` has started.
-        script::init();
-
-        // Create the constellation, which maintains the engine
-        // pipelines, including the script and layout threads, as well
-        // as the navigation context.
-        let (constellation_chan, sw_senders) = create_constellation(opts.user_agent.clone(),
-                                                                    opts.config_dir.clone(),
-                                                                    embedder_proxy.clone(),
-                                                                    compositor_proxy.clone(),
-                                                                    time_profiler_chan.clone(),
-                                                                    mem_profiler_chan.clone(),
-                                                                    debugger_chan,
-                                                                    devtools_chan,
-                                                                    supports_clipboard,
-                                                                    &mut webrender,
-                                                                    webrender_document,
-                                                                    webrender_api_sender,
-                                                                    window.gl());
-
-        // Send the constellation's swmanager sender to service worker manager thread
-        script::init_service_workers(sw_senders);
-
-        if cfg!(feature = "webdriver") {
-            if let Some(port) = opts.webdriver_port {
-                webdriver(port, constellation_chan.clone());
-            }
-        }
-
-        // The compositor coordinates with the client window to create the final
-        // rendered page and display it somewhere.
-        let compositor = IOCompositor::create(window, InitialCompositorState {
-            sender: compositor_proxy,
-            receiver: compositor_receiver,
-            constellation_chan: constellation_chan.clone(),
-            time_profiler_chan: time_profiler_chan,
-            mem_profiler_chan: mem_profiler_chan,
-            webrender,
-            webrender_document,
-            webrender_api,
-        });
-
-        Servo {
-            compositor: compositor,
-            constellation_chan: constellation_chan,
-            embedder_receiver: embedder_receiver,
-            embedder_events: Vec::new(),
-        }
-    }
-
-    fn handle_window_event(&mut self, event: WindowEvent) {
-        match event {
-            WindowEvent::Idle => {
-            }
-
-            WindowEvent::Refresh => {
-                self.compositor.composite();
-            }
-
-            WindowEvent::Resize => {
-                self.compositor.on_resize_window_event();
-            }
-
-            WindowEvent::LoadUrl(top_level_browsing_context_id, url) => {
-                let msg = ConstellationMsg::LoadUrl(top_level_browsing_context_id, url);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending load url to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::MouseWindowEventClass(mouse_window_event) => {
-                self.compositor.on_mouse_window_event_class(mouse_window_event);
-            }
-
-            WindowEvent::MouseWindowMoveEventClass(cursor) => {
-                self.compositor.on_mouse_window_move_event_class(cursor);
-            }
-
-            WindowEvent::Touch(event_type, identifier, location) => {
-                self.compositor.on_touch_event(event_type, identifier, location);
-            }
-
-            WindowEvent::Scroll(delta, cursor, phase) => {
-                self.compositor.on_scroll_event(delta, cursor, phase);
-            }
-
-            WindowEvent::Zoom(magnification) => {
-                self.compositor.on_zoom_window_event(magnification);
-            }
-
-            WindowEvent::ResetZoom => {
-                self.compositor.on_zoom_reset_window_event();
-            }
-
-            WindowEvent::PinchZoom(magnification) => {
-                self.compositor.on_pinch_zoom_window_event(magnification);
-            }
-
-            WindowEvent::Navigation(top_level_browsing_context_id, direction) => {
-                let msg = ConstellationMsg::TraverseHistory(top_level_browsing_context_id, direction);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending navigation to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::KeyEvent(ch, key, state, modifiers) => {
-                let msg = ConstellationMsg::KeyEvent(ch, key, state, modifiers);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending key event to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::Quit => {
-                self.compositor.maybe_start_shutting_down();
-            }
-
-            WindowEvent::Reload(top_level_browsing_context_id) => {
-                let msg = ConstellationMsg::Reload(top_level_browsing_context_id);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending reload to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::ToggleWebRenderDebug(option) => {
-                self.compositor.toggle_webrender_debug(option);
-            }
-
-            WindowEvent::CaptureWebRender => {
-                self.compositor.capture_webrender();
-            }
-
-            WindowEvent::NewBrowser(url, response_chan) => {
-                let msg = ConstellationMsg::NewBrowser(url, response_chan);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending NewBrowser message to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::SelectBrowser(ctx) => {
-                let msg = ConstellationMsg::SelectBrowser(ctx);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending SelectBrowser message to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::CloseBrowser(ctx) => {
-                let msg = ConstellationMsg::CloseBrowser(ctx);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending CloseBrowser message to constellation failed ({}).", e);
-                }
-            }
-        }
-    }
-
-    fn receive_messages(&mut self) {
-        while let Some(msg) = self.embedder_receiver.try_recv_embedder_msg() {
-            match (msg, self.compositor.shutdown_state) {
-                (_, ShutdownState::FinishedShuttingDown) => {
-                    error!("embedder shouldn't be handling messages after compositor has shut down");
-                },
-
-                (_, ShutdownState::ShuttingDown) => {},
-
-                (EmbedderMsg::KeyEvent(top_level_browsing_context, ch, key, state, modified),
-                 ShutdownState::NotShuttingDown) => {
-                    if state == KeyState::Pressed {
-                        let msg = EmbedderMsg::KeyEvent(top_level_browsing_context, ch, key, state, modified);
-                        self.embedder_events.push(msg);
-                    }
-                },
-
-                (msg, ShutdownState::NotShuttingDown) => {
-                    self.embedder_events.push(msg);
-                },
-            }
-        }
-    }
-
-    pub fn get_events(&mut self) -> Vec<EmbedderMsg> {
-        ::std::mem::replace(&mut self.embedder_events, Vec::new())
-    }
-
-    pub fn handle_events(&mut self, events: Vec<WindowEvent>) {
-        if self.compositor.receive_messages() {
-            self.receive_messages();
-        }
-        for event in events {
-            self.handle_window_event(event);
-        }
-        if self.compositor.shutdown_state != ShutdownState::FinishedShuttingDown {
-            self.compositor.perform_updates();
-        } else {
-            self.embedder_events.push(EmbedderMsg::Shutdown);
-        }
-    }
-
-    pub fn repaint_synchronously(&mut self) {
-        self.compositor.repaint_synchronously()
-    }
-
-    pub fn pinch_zoom_level(&self) -> f32 {
-        self.compositor.pinch_zoom_level()
-    }
-
-    pub fn setup_logging(&self) {
-        let constellation_chan = self.constellation_chan.clone();
-        let env = env_logger::Env::default();
-        let env_logger = EnvLoggerBuilder::from_env(env).build();
-        let con_logger = FromCompositorLogger::new(constellation_chan);
-
-        let filter = max(env_logger.filter(), con_logger.filter());
-        let logger = BothLogger(env_logger, con_logger);
-
-        log::set_boxed_logger(Box::new(logger)).expect("Failed to set logger.");
-        log::set_max_level(filter);
-    }
-
-    pub fn deinit(self) {
-        self.compositor.deinit();
-    }
-}
-
-fn create_embedder_channel(event_loop_waker: Box<compositor_thread::EventLoopWaker>)
-    -> (EmbedderProxy, EmbedderReceiver) {
-    let (sender, receiver) = channel();
-    (EmbedderProxy {
-         sender: sender,
-         event_loop_waker: event_loop_waker,
-     },
-     EmbedderReceiver {
-         receiver: receiver
-     })
-}
-
-fn create_compositor_channel(event_loop_waker: Box<compositor_thread::EventLoopWaker>)
-    -> (CompositorProxy, CompositorReceiver) {
-    let (sender, receiver) = channel();
-    (CompositorProxy {
-         sender: sender,
-         event_loop_waker: event_loop_waker,
-     },
-     CompositorReceiver {
-         receiver: receiver
-     })
-}
-
-fn create_constellation(user_agent: Cow<'static, str>,
-                        config_dir: Option<PathBuf>,
-                        embedder_proxy: EmbedderProxy,
-                        compositor_proxy: CompositorProxy,
-                        time_profiler_chan: time::ProfilerChan,
-                        mem_profiler_chan: mem::ProfilerChan,
-                        debugger_chan: Option<debugger::Sender>,
-                        devtools_chan: Option<Sender<devtools_traits::DevtoolsControlMsg>>,
-                        supports_clipboard: bool,
-                        webrender: &mut webrender::Renderer,
-                        webrender_document: webrender_api::DocumentId,
-                        webrender_api_sender: webrender_api::RenderApiSender,
-                        window_gl: Rc<gl::Gl>)
-                        -> (Sender<ConstellationMsg>, SWManagerSenders) {
-    let bluetooth_thread: IpcSender<BluetoothRequest> = BluetoothThreadFactory::new();
-
-    let (public_resource_threads, private_resource_threads) =
-        new_resource_threads(user_agent,
-                             devtools_chan.clone(),
-                             time_profiler_chan.clone(),
-                             mem_profiler_chan.clone(),
-                             config_dir);
-    let font_cache_thread = FontCacheThread::new(public_resource_threads.sender(),
-                                                 webrender_api_sender.create_api());
-
-    let resource_sender = public_resource_threads.sender();
-
-    let (webvr_chan, webvr_constellation_sender, webvr_compositor) = if PREFS.is_webvr_enabled() {
-        // WebVR initialization
-        let (mut handler, sender) = WebVRCompositorHandler::new();
-        let (webvr_thread, constellation_sender) = WebVRThread::spawn(sender);
-        handler.set_webvr_thread_sender(webvr_thread.clone());
-        (Some(webvr_thread), Some(constellation_sender), Some(handler))
-    } else {
-        (None, None, None)
-    };
-
-    // GLContext factory used to create WebGL Contexts
-    let gl_factory = if opts::get().should_use_osmesa() {
-        GLContextFactory::current_osmesa_handle()
-    } else {
-        GLContextFactory::current_native_handle(&compositor_proxy)
-    };
-
-    // Initialize WebGL Thread entry point.
-    let webgl_threads = gl_factory.map(|factory| {
-        let (webgl_threads, image_handler, output_handler) =
-            WebGLThreads::new(
-                factory,
-                window_gl,
-                webrender_api_sender.clone(),
-                webvr_compositor.map(|c| c as Box<_>),
-            );
-
-        // Set webrender external image handler for WebGL textures
-        webrender.set_external_image_handler(image_handler);
-
-        // Set DOM to texture handler, if enabled.
-        if let Some(output_handler) = output_handler {
-            webrender.set_output_image_handler(output_handler);
-        }
-
-        webgl_threads
-    });
-
-    let initial_state = InitialConstellationState {
-        compositor_proxy,
-        embedder_proxy,
-        debugger_chan,
-        devtools_chan,
-        bluetooth_thread,
-        font_cache_thread,
-        public_resource_threads,
-        private_resource_threads,
-        time_profiler_chan,
-        mem_profiler_chan,
-        supports_clipboard,
-        webrender_document,
-        webrender_api_sender,
-        webgl_threads,
-        webvr_chan,
-    };
-    let (constellation_chan, from_swmanager_sender) =
-        Constellation::<script_layout_interface::message::Msg,
-                        layout_thread::LayoutThread,
-                        script::script_thread::ScriptThread>::start(initial_state);
-
-    if let Some(webvr_constellation_sender) = webvr_constellation_sender {
-        // Set constellation channel used by WebVR thread to broadcast events
-        webvr_constellation_sender.send(constellation_chan.clone()).unwrap();
-    }
-
-    // channels to communicate with Service Worker Manager
-    let sw_senders = SWManagerSenders {
-        swmanager_sender: from_swmanager_sender,
-        resource_sender: resource_sender
-    };
-
-    (constellation_chan, sw_senders)
-}
-
-// A logger that logs to two downstream loggers.
-// This should probably be in the log crate.
-struct BothLogger<Log1, Log2>(Log1, Log2);
-
-impl<Log1, Log2> Log for BothLogger<Log1, Log2> where Log1: Log, Log2: Log {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.0.enabled(metadata) || self.1.enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        self.0.log(record);
-        self.1.log(record);
-    }
-
-    fn flush(&self) {
-        self.0.flush();
-        self.1.flush();
-    }
-}
-
-pub fn set_logger(script_to_constellation_chan: ScriptToConstellationChan) {
-    let con_logger = FromScriptLogger::new(script_to_constellation_chan);
-    let env = env_logger::Env::default();
-    let env_logger = EnvLoggerBuilder::from_env(env).build();
-
-    let filter = max(env_logger.filter(), con_logger.filter());
-    let logger = BothLogger(env_logger, con_logger);
-
-    log::set_boxed_logger(Box::new(logger)).expect("Failed to set logger.");
-    log::set_max_level(filter);
-}
-
-/// Content process entry point.
-pub fn run_content_process(token: String) {
-    let (unprivileged_content_sender, unprivileged_content_receiver) =
-        ipc::channel::<UnprivilegedPipelineContent>().unwrap();
-    let connection_bootstrap: IpcSender<IpcSender<UnprivilegedPipelineContent>> =
-        IpcSender::connect(token).unwrap();
-    connection_bootstrap.send(unprivileged_content_sender).unwrap();
-
-    let unprivileged_content = unprivileged_content_receiver.recv().unwrap();
-    opts::set_defaults(unprivileged_content.opts());
-    PREFS.extend(unprivileged_content.prefs());
-    set_logger(unprivileged_content.script_to_constellation_chan().clone());
-
-    // Enter the sandbox if necessary.
-    if opts::get().sandbox {
-       create_sandbox();
-    }
-
-    // send the required channels to the service worker manager
-    let sw_senders = unprivileged_content.swmanager_senders();
-    script::init();
-    script::init_service_workers(sw_senders);
-
-    unprivileged_content.start_all::<script_layout_interface::message::Msg,
-                                     layout_thread::LayoutThread,
-                                     script::script_thread::ScriptThread>(true);
-}
-
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-fn create_sandbox() {
-    ChildSandbox::new(content_process_sandbox_profile()).activate()
-        .expect("Failed to activate sandbox!");
-}
-
-#[cfg(any(target_os = "windows", target_os = "ios"))]
-fn create_sandbox() {
-    panic!("Sandboxing is not supported on Windows or iOS.");
-}