servo: Merge #9201 - task -> thread (from ajnirp:8512-task-thread); r=jdm
authorrohan.prinja <rohan.prinja@samsung.com>
Sun, 10 Jan 2016 15:19:34 +0500
changeset 337903 9bf75b2f9f04bab3909c05daa8a00b035f1474ec
parent 337902 d43685e7d171c2a8d21b2359db86847484ec7e3c
child 337904 8069d19fd8cbd40d2fe6e432f68ef96a7f7ac2b5
push id31307
push usergszorc@mozilla.com
push dateSat, 04 Feb 2017 00:59:06 +0000
treeherdermozilla-central@94079d43835f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjdm
servo: Merge #9201 - task -> thread (from ajnirp:8512-task-thread); r=jdm for #8512 Source-Repo: https://github.com/servo/servo Source-Revision: d3e2f94f2024f4735f836588ed11303a0abafdf8
servo/components/canvas/canvas_paint_task.rs
servo/components/canvas/canvas_paint_thread.rs
servo/components/canvas/lib.rs
servo/components/canvas/webgl_paint_task.rs
servo/components/canvas/webgl_paint_thread.rs
servo/components/compositing/compositor.rs
servo/components/compositing/compositor_layer.rs
servo/components/compositing/compositor_task.rs
servo/components/compositing/compositor_thread.rs
servo/components/compositing/constellation.rs
servo/components/compositing/headless.rs
servo/components/compositing/lib.rs
servo/components/compositing/pipeline.rs
servo/components/compositing/scrolling.rs
servo/components/compositing/surface_map.rs
servo/components/compositing/timer_scheduler.rs
servo/components/compositing/windowing.rs
servo/components/devtools/actors/timeline.rs
servo/components/devtools/lib.rs
servo/components/devtools_traits/lib.rs
servo/components/gfx/display_list/mod.rs
servo/components/gfx/font_cache_task.rs
servo/components/gfx/font_cache_thread.rs
servo/components/gfx/font_context.rs
servo/components/gfx/lib.rs
servo/components/gfx/paint_task.rs
servo/components/gfx/paint_thread.rs
servo/components/gfx_traits/paint_listener.rs
servo/components/layout/block.rs
servo/components/layout/context.rs
servo/components/layout/display_list_builder.rs
servo/components/layout/fragment.rs
servo/components/layout/layout_debug.rs
servo/components/layout/layout_task.rs
servo/components/layout/layout_thread.rs
servo/components/layout/lib.rs
servo/components/layout/query.rs
servo/components/layout/traversal.rs
servo/components/layout/wrapper.rs
servo/components/layout_traits/lib.rs
servo/components/msg/constellation_msg.rs
servo/components/net/about_loader.rs
servo/components/net/data_loader.rs
servo/components/net/fetch/cors_cache.rs
servo/components/net/fetch/request.rs
servo/components/net/file_loader.rs
servo/components/net/http_loader.rs
servo/components/net/image_cache_task.rs
servo/components/net/image_cache_thread.rs
servo/components/net/lib.rs
servo/components/net/resource_task.rs
servo/components/net/resource_thread.rs
servo/components/net/storage_task.rs
servo/components/net/storage_thread.rs
servo/components/net/websocket_loader.rs
servo/components/net_traits/image_cache_task.rs
servo/components/net_traits/image_cache_thread.rs
servo/components/net_traits/lib.rs
servo/components/net_traits/storage_task.rs
servo/components/net_traits/storage_thread.rs
servo/components/plugins/lints/unrooted_must_root.rs
servo/components/profile/mem.rs
servo/components/profile/time.rs
servo/components/profile_traits/mem.rs
servo/components/script/cors.rs
servo/components/script/devtools.rs
servo/components/script/document_loader.rs
servo/components/script/dom/bindings/cell.rs
servo/components/script/dom/bindings/global.rs
servo/components/script/dom/bindings/js.rs
servo/components/script/dom/bindings/refcounted.rs
servo/components/script/dom/bindings/trace.rs
servo/components/script/dom/canvasrenderingcontext2d.rs
servo/components/script/dom/closeevent.rs
servo/components/script/dom/dedicatedworkerglobalscope.rs
servo/components/script/dom/document.rs
servo/components/script/dom/filereader.rs
servo/components/script/dom/htmlcanvaselement.rs
servo/components/script/dom/htmlformelement.rs
servo/components/script/dom/htmlimageelement.rs
servo/components/script/dom/htmlinputelement.rs
servo/components/script/dom/htmllinkelement.rs
servo/components/script/dom/htmlscriptelement.rs
servo/components/script/dom/mod.rs
servo/components/script/dom/node.rs
servo/components/script/dom/servohtmlparser.rs
servo/components/script/dom/servoxmlparser.rs
servo/components/script/dom/storage.rs
servo/components/script/dom/webglrenderingcontext.rs
servo/components/script/dom/webglshader.rs
servo/components/script/dom/websocket.rs
servo/components/script/dom/window.rs
servo/components/script/dom/worker.rs
servo/components/script/dom/workerglobalscope.rs
servo/components/script/dom/xmlhttprequest.rs
servo/components/script/layout_interface.rs
servo/components/script/lib.rs
servo/components/script/network_listener.rs
servo/components/script/script_task.rs
servo/components/script/script_thread.rs
servo/components/script/timers.rs
servo/components/script/webdriver_handlers.rs
servo/components/script_traits/lib.rs
servo/components/script_traits/script_msg.rs
servo/components/servo/lib.rs
servo/components/servo/main.rs
servo/components/style/traversal.rs
servo/components/util/lib.rs
servo/components/util/opts.rs
servo/components/util/task.rs
servo/components/util/task_state.rs
servo/components/util/taskpool.rs
servo/components/util/thread.rs
servo/components/util/thread_state.rs
servo/components/util/threadpool.rs
servo/components/util/tid.rs
servo/components/util/workqueue.rs
servo/components/webdriver_server/lib.rs
servo/ports/cef/browser.rs
servo/ports/cef/interfaces/cef_browser.rs
servo/ports/cef/interfaces/cef_task.rs
servo/ports/cef/task.rs
servo/ports/cef/window.rs
servo/ports/glutin/window.rs
servo/ports/gonk/src/window.rs
servo/support/rust-task_info/src/task_basic_info.rs
servo/tests/unit/gfx/font_cache_task.rs
servo/tests/unit/gfx/font_cache_thread.rs
servo/tests/unit/gfx/lib.rs
servo/tests/unit/net/data_loader.rs
servo/tests/unit/net/http_loader.rs
servo/tests/unit/net/lib.rs
servo/tests/unit/net/resource_task.rs
servo/tests/unit/net/resource_thread.rs
servo/tests/unit/util/lib.rs
servo/tests/unit/util/task.rs
servo/tests/unit/util/thread.rs
rename from servo/components/canvas/canvas_paint_task.rs
rename to servo/components/canvas/canvas_paint_thread.rs
--- a/servo/components/canvas/canvas_paint_task.rs
+++ b/servo/components/canvas/canvas_paint_thread.rs
@@ -17,20 +17,20 @@ use ipc_channel::ipc::{self, IpcSender};
 use ipc_channel::router::ROUTER;
 use layers::platform::surface::NativeSurface;
 use num::ToPrimitive;
 use premultiplytable::PREMULTIPLY_TABLE;
 use std::borrow::ToOwned;
 use std::mem;
 use std::sync::mpsc::{Sender, channel};
 use util::opts;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use util::vec::byte_swap;
 
-impl<'a> CanvasPaintTask<'a> {
+impl<'a> CanvasPaintThread<'a> {
     /// It reads image data from the canvas
     /// canvas_size: The size of the canvas we're reading from
     /// read_rect: The area of the canvas we want to read from
     fn read_pixels(&self, read_rect: Rect<i32>, canvas_size: Size2D<f64>) -> Vec<u8>{
         let canvas_size = canvas_size.to_i32();
         let canvas_rect = Rect::new(Point2D::new(0i32, 0i32), canvas_size);
         let src_read_rect = canvas_rect.intersection(&read_rect).unwrap_or(Rect::zero());
 
@@ -52,17 +52,17 @@ impl<'a> CanvasPaintTask<'a> {
             image_data.extend_from_slice(row);
             src += stride as usize;
         }
 
         image_data
     }
 }
 
-pub struct CanvasPaintTask<'a> {
+pub struct CanvasPaintThread<'a> {
     drawtarget: DrawTarget,
     /// TODO(pcwalton): Support multiple paths.
     path_builder: PathBuilder,
     state: CanvasPaintState<'a>,
     saved_states: Vec<CanvasPaintState<'a>>,
 }
 
 #[derive(Clone)]
@@ -96,38 +96,38 @@ impl<'a> CanvasPaintState<'a> {
             shadow_offset_x: 0.0,
             shadow_offset_y: 0.0,
             shadow_blur: 0.0,
             shadow_color: color::transparent(),
         }
     }
 }
 
-impl<'a> CanvasPaintTask<'a> {
-    fn new(size: Size2D<i32>) -> CanvasPaintTask<'a> {
-        let draw_target = CanvasPaintTask::create(size);
+impl<'a> CanvasPaintThread<'a> {
+    fn new(size: Size2D<i32>) -> CanvasPaintThread<'a> {
+        let draw_target = CanvasPaintThread::create(size);
         let path_builder = draw_target.create_path_builder();
-        CanvasPaintTask {
+        CanvasPaintThread {
             drawtarget: draw_target,
             path_builder: path_builder,
             state: CanvasPaintState::new(),
             saved_states: Vec::new(),
         }
     }
 
-    /// Creates a new `CanvasPaintTask` and returns the out-of-process sender and the in-process
+    /// Creates a new `CanvasPaintThread` and returns the out-of-process sender and the in-process
     /// sender for it.
     pub fn start(size: Size2D<i32>) -> (IpcSender<CanvasMsg>, Sender<CanvasMsg>) {
         // TODO(pcwalton): Ask the pipeline to create this for us instead of spawning it directly.
         // This will be needed for multiprocess Servo.
         let (out_of_process_chan, out_of_process_port) = ipc::channel::<CanvasMsg>().unwrap();
         let (in_process_chan, in_process_port) = channel();
         ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan.clone());
-        spawn_named("CanvasTask".to_owned(), move || {
-            let mut painter = CanvasPaintTask::new(size);
+        spawn_named("CanvasThread".to_owned(), move || {
+            let mut painter = CanvasPaintThread::new(size);
             loop {
                 let msg = in_process_port.recv();
                 match msg.unwrap() {
                     CanvasMsg::Canvas2d(message) => {
                         match message {
                             Canvas2dMsg::FillRect(ref rect) => painter.fill_rect(rect),
                             Canvas2dMsg::StrokeRect(ref rect) => painter.stroke_rect(rect),
                             Canvas2dMsg::ClearRect(ref rect) => painter.clear_rect(rect),
@@ -197,17 +197,17 @@ impl<'a> CanvasPaintTask<'a> {
                     }
                     CanvasMsg::FromPaint(message) => {
                         match message {
                             FromPaintMsg::SendNativeSurface(chan) => {
                                 painter.send_native_surface(chan)
                             }
                         }
                     }
-                    CanvasMsg::WebGL(_) => panic!("Wrong message sent to Canvas2D task"),
+                    CanvasMsg::WebGL(_) => panic!("Wrong message sent to Canvas2D thread"),
                 }
             }
         });
 
         (out_of_process_chan, in_process_chan)
     }
 
     fn save_context_state(&mut self) {
@@ -511,17 +511,17 @@ impl<'a> CanvasPaintTask<'a> {
         self.state.draw_options.set_composition_op(op.to_azure_style());
     }
 
     fn create(size: Size2D<i32>) -> DrawTarget {
         DrawTarget::new(BackendType::Skia, size, SurfaceFormat::B8G8R8A8)
     }
 
     fn recreate(&mut self, size: Size2D<i32>) {
-        self.drawtarget = CanvasPaintTask::create(size);
+        self.drawtarget = CanvasPaintThread::create(size);
     }
 
     fn send_pixel_contents(&mut self, chan: IpcSender<IpcSharedMemory>) {
         self.drawtarget.snapshot().get_data_surface().with_data(|element| {
             chan.send(IpcSharedMemory::from_bytes(element)).unwrap();
         })
     }
 
--- a/servo/components/canvas/lib.rs
+++ b/servo/components/canvas/lib.rs
@@ -17,11 +17,11 @@ extern crate gleam;
 extern crate ipc_channel;
 extern crate layers;
 #[macro_use]
 extern crate log;
 extern crate num;
 extern crate offscreen_gl_context;
 extern crate util;
 
-pub mod canvas_paint_task;
+pub mod canvas_paint_thread;
 mod premultiplytable;
-pub mod webgl_paint_task;
+pub mod webgl_paint_thread;
rename from servo/components/canvas/webgl_paint_task.rs
rename to servo/components/canvas/webgl_paint_thread.rs
--- a/servo/components/canvas/webgl_paint_task.rs
+++ b/servo/components/canvas/webgl_paint_thread.rs
@@ -9,35 +9,35 @@ use euclid::size::Size2D;
 use gleam::gl;
 use gleam::gl::types::{GLsizei};
 use ipc_channel::ipc::{self, IpcSender, IpcSharedMemory};
 use ipc_channel::router::ROUTER;
 use layers::platform::surface::NativeSurface;
 use offscreen_gl_context::{ColorAttachmentType, GLContext, GLContextAttributes, NativeGLContext};
 use std::borrow::ToOwned;
 use std::sync::mpsc::{Sender, channel};
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use util::vec::byte_swap;
 
-pub struct WebGLPaintTask {
+pub struct WebGLPaintThread {
     size: Size2D<i32>,
     original_context_size: Size2D<i32>,
     gl_context: GLContext<NativeGLContext>,
 }
 
-impl WebGLPaintTask {
-    fn new(size: Size2D<i32>, attrs: GLContextAttributes) -> Result<WebGLPaintTask, &'static str> {
+impl WebGLPaintThread {
+    fn new(size: Size2D<i32>, attrs: GLContextAttributes) -> Result<WebGLPaintThread, &'static str> {
         let context = try!(GLContext::new(size, attrs, ColorAttachmentType::Texture, None));
 
         // NOTE: As of right now this is always equal to the size parameter,
         // but this doesn't have to be true. Firefox after failing with
         // the requested size, tries with the nearest powers of two, for example.
         let real_size = context.borrow_draw_buffer().unwrap().size();
 
-        Ok(WebGLPaintTask {
+        Ok(WebGLPaintThread {
             size: real_size,
             original_context_size: real_size,
             gl_context: context
         })
     }
 
     /// In this function the gl commands are called.
     /// Those messages that just involve a gl call have the call inlined,
@@ -178,29 +178,29 @@ impl WebGLPaintTask {
             CanvasWebGLMsg::DrawingBufferHeight(sender) =>
                 self.send_drawing_buffer_height(sender),
         }
 
         // FIXME: Convert to `debug_assert!` once tests are run with debug assertions
         assert!(gl::get_error() == gl::NO_ERROR);
     }
 
-    /// Creates a new `WebGLPaintTask` and returns the out-of-process sender and the in-process
+    /// Creates a new `WebGLPaintThread` and returns the out-of-process sender and the in-process
     /// sender for it.
     pub fn start(size: Size2D<i32>, attrs: GLContextAttributes)
                  -> Result<(IpcSender<CanvasMsg>, Sender<CanvasMsg>), &'static str> {
         let (out_of_process_chan, out_of_process_port) = ipc::channel::<CanvasMsg>().unwrap();
         let (in_process_chan, in_process_port) = channel();
         let (result_chan, result_port) = channel();
         ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan.clone());
-        spawn_named("WebGLTask".to_owned(), move || {
-            let mut painter = match WebGLPaintTask::new(size, attrs) {
-                Ok(task) => {
+        spawn_named("WebGLThread".to_owned(), move || {
+            let mut painter = match WebGLPaintThread::new(size, attrs) {
+                Ok(thread) => {
                     result_chan.send(Ok(())).unwrap();
-                    task
+                    thread
                 },
                 Err(e) => {
                     result_chan.send(Err(e)).unwrap();
                     return
                 }
             };
             painter.init();
             loop {
@@ -220,17 +220,17 @@ impl WebGLPaintTask {
                         }
                     }
                     CanvasMsg::FromPaint(message) => {
                         match message {
                             FromPaintMsg::SendNativeSurface(chan) =>
                                 painter.send_native_surface(chan),
                         }
                     }
-                    CanvasMsg::Canvas2d(_) => panic!("Wrong message sent to WebGLTask"),
+                    CanvasMsg::Canvas2d(_) => panic!("Wrong message sent to WebGLThread"),
                 }
             }
         });
 
         result_port.recv().unwrap().map(|_| (out_of_process_chan, in_process_chan))
     }
 
     #[inline]
@@ -274,17 +274,17 @@ impl WebGLPaintTask {
             None
         } else {
             Some(unsafe { NonZero::new(renderbuffer) })
         };
         chan.send(renderbuffer).unwrap();
     }
 
     fn create_texture(&self, chan: IpcSender<Option<NonZero<u32>>>) {
-        let texture = gl::gen_textures(1)[0];
+        let texture = gl::gen_framebuffers(1)[0];
         let texture = if texture == 0 {
             None
         } else {
             Some(unsafe { NonZero::new(texture) })
         };
         chan.send(texture).unwrap();
     }
 
--- a/servo/components/compositing/compositor.rs
+++ b/servo/components/compositing/compositor.rs
@@ -1,24 +1,24 @@
 /* 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/. */
 
 use CompositorMsg as ConstellationMsg;
 use app_units::Au;
 use compositor_layer::{CompositorData, CompositorLayer, RcCompositorLayer, WantsScrollEventsFlag};
-use compositor_task::{CompositorEventListener, CompositorProxy};
-use compositor_task::{CompositorReceiver, InitialCompositorState, Msg};
+use compositor_thread::{CompositorEventListener, CompositorProxy};
+use compositor_thread::{CompositorReceiver, InitialCompositorState, Msg};
 use constellation::SendableFrameTree;
 use euclid::point::TypedPoint2D;
 use euclid::rect::TypedRect;
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::TypedSize2D;
 use euclid::{Matrix4, Point2D, Rect, Size2D};
-use gfx::paint_task::{ChromeToPaintMsg, PaintRequest};
+use gfx::paint_thread::{ChromeToPaintMsg, PaintRequest};
 use gfx_traits::{color, LayerId, LayerKind, LayerProperties, ScrollPolicy};
 use gleam::gl;
 use gleam::gl::types::{GLint, GLsizei};
 use image::{DynamicImage, ImageFormat, RgbImage};
 use ipc_channel::ipc::{self, IpcSender, IpcSharedMemory};
 use ipc_channel::router::ROUTER;
 use layers::geometry::{DevicePixel, LayerPixel};
 use layers::layers::{BufferRequest, Layer, LayerBuffer, LayerBufferSet};
@@ -370,23 +370,23 @@ impl<Window: WindowMethods> IOCompositor
         self.mem_profiler_chan.send(mem::ProfilerMsg::UnregisterReporter(reporter_name()));
 
         self.shutdown_state = ShutdownState::ShuttingDown;
     }
 
     pub fn finish_shutting_down(&mut self) {
         debug!("Compositor received message that constellation shutdown is complete");
 
-        // Clear out the compositor layers so that painting tasks can destroy the buffers.
+        // Clear out the compositor layers so that painting threads can destroy the buffers.
         if let Some(ref root_layer) = self.scene.root {
             root_layer.forget_all_tiles();
         }
 
         // Drain compositor port, sometimes messages contain channels that are blocking
-        // another task from finishing (i.e. SetFrameTree).
+        // another thread from finishing (i.e. SetFrameTree).
         while self.port.try_recv_compositor_msg().is_some() {}
 
         // Tell the profiler, memory profiler, and scrolling timer to shut down.
         self.time_profiler_chan.send(time::ProfilerMsg::Exit);
         self.mem_profiler_chan.send(mem::ProfilerMsg::Exit);
         self.scrolling_timer.shutdown();
 
         self.shutdown_state = ShutdownState::FinishedShuttingDown;
@@ -541,17 +541,17 @@ impl<Window: WindowMethods> IOCompositor
             }
 
             (Msg::CreatePng(reply), ShutdownState::NotShuttingDown) => {
                 let res = self.composite_specific_target(CompositeTarget::WindowAndPng);
                 let img = res.unwrap_or(None);
                 reply.send(img).unwrap();
             }
 
-            (Msg::PaintTaskExited(pipeline_id), ShutdownState::NotShuttingDown) => {
+            (Msg::PaintThreadExited(pipeline_id), ShutdownState::NotShuttingDown) => {
                 self.remove_pipeline_root_layer(pipeline_id);
             }
 
             (Msg::ViewportConstrained(pipeline_id, constraints),
              ShutdownState::NotShuttingDown) => {
                 self.constrain_viewport(pipeline_id, constraints);
             }
 
@@ -575,17 +575,17 @@ impl<Window: WindowMethods> IOCompositor
                 self.window.set_favicon(url);
             }
 
             (Msg::HeadParsed, ShutdownState::NotShuttingDown) => {
                 self.window.head_parsed();
             }
 
             (Msg::CollectMemoryReports(reports_chan), ShutdownState::NotShuttingDown) => {
-                let name = "compositor-task";
+                let name = "compositor-thread";
                 // These are both `ExplicitUnknownLocationSize` because the memory might be in the
                 // GPU or on the heap.
                 let reports = vec![mem::Report {
                     path: path![name, "surface-map"],
                     kind: ReportKind::ExplicitUnknownLocationSize,
                     size: self.surface_map.mem(),
                 }, mem::Report {
                     path: path![name, "layer-tree"],
@@ -970,17 +970,17 @@ impl<Window: WindowMethods> IOCompositor
 
     fn assign_painted_buffers(&mut self,
                               pipeline_id: PipelineId,
                               layer_id: LayerId,
                               new_layer_buffer_set: Box<LayerBufferSet>,
                               epoch: Epoch,
                               frame_tree_id: FrameTreeId) {
         // If the frame tree id has changed since this paint request was sent,
-        // reject the buffers and send them back to the paint task. If this isn't handled
+        // reject the buffers and send them back to the paint thread. If this isn't handled
         // correctly, the content_age in the tile grid can get out of sync when iframes are
         // loaded and the frame tree changes. This can result in the compositor thinking it
         // has already drawn the most recently painted buffer, and missing a frame.
         if frame_tree_id == self.frame_tree_id {
             if let Some(layer) = self.find_layer_with_pipeline_and_layer_id(pipeline_id,
                                                                             layer_id) {
                 let requested_epoch = layer.extra_data.borrow().requested_epoch;
                 if requested_epoch == epoch {
@@ -1465,17 +1465,17 @@ impl<Window: WindowMethods> IOCompositor
                 Occupied(entry) => {
                     entry.into_mut()
                 }
                 Vacant(entry) => {
                     entry.insert(Vec::new())
                 }
             };
 
-            // All the BufferRequests are in layer/device coordinates, but the paint task
+            // All the BufferRequests are in layer/device coordinates, but the paint thread
             // wants to know the page coordinates. We scale them before sending them.
             for request in &mut layer_requests {
                 request.page_rect = request.page_rect / scale.get();
             }
 
             let layer_kind = if layer.transform_state.borrow().has_transform {
                 LayerKind::HasTransform
             } else {
@@ -1563,17 +1563,17 @@ impl<Window: WindowMethods> IOCompositor
         };
 
         // Only check layers that have requested the current epoch, as there may be
         // layers that are not visible in the current viewport, and therefore
         // have not requested a paint of the current epoch.
         // If a layer has sent a request for the current epoch, but it hasn't
         // arrived yet then this layer is waiting for a paint message.
         //
-        // Also don't check the root layer, because the paint task won't paint
+        // Also don't check the root layer, because the paint thread won't paint
         // anything for it after first layout.
         if layer_data.id != LayerId::null() &&
                 layer_data.requested_epoch == current_epoch &&
                 layer_data.painted_epoch != current_epoch {
             return true;
         }
 
         for child in &*layer.children() {
@@ -1582,17 +1582,17 @@ impl<Window: WindowMethods> IOCompositor
             }
         }
 
         false
     }
 
     /// Query the constellation to see if the current compositor
     /// output matches the current frame tree output, and if the
-    /// associated script tasks are idle.
+    /// associated script threads are idle.
     fn is_ready_to_paint_image_output(&mut self) -> Result<(), NotReadyToPaint> {
         match self.ready_to_save_state {
             ReadyState::Unknown => {
                 // Unsure if the output image is stable.
 
                 // Check if any layers are waiting for paints to complete
                 // of their current epoch request. If so, early exit
                 // from this check.
@@ -1996,17 +1996,17 @@ fn find_layer_with_pipeline_and_layer_id
         }
     }
 
     None
 }
 
 impl<Window> CompositorEventListener for IOCompositor<Window> where Window: WindowMethods {
     fn handle_events(&mut self, messages: Vec<WindowEvent>) -> bool {
-        // Check for new messages coming from the other tasks in the system.
+        // Check for new messages coming from the other threads in the system.
         while let Some(msg) = self.port.try_recv_compositor_msg() {
             if !self.handle_browser_message(msg) {
                 break
             }
         }
 
         if self.shutdown_state == ShutdownState::FinishedShuttingDown {
             return false;
--- a/servo/components/compositing/compositor_layer.rs
+++ b/servo/components/compositing/compositor_layer.rs
@@ -92,27 +92,27 @@ pub trait CompositorLayer {
 
     /// Destroys tiles for this layer and all descendent layers, sending the buffers back to the
     /// painter to be destroyed or reused.
     fn clear_all_tiles<Window>(&self, compositor: &mut IOCompositor<Window>)
                                where Window: WindowMethods;
 
     /// Removes the root layer (and any children) for a given pipeline from the
     /// compositor. Buffers that the compositor is holding are returned to the
-    /// owning paint task.
+    /// owning paint thread.
     fn remove_root_layer_with_pipeline_id<Window>(&self,
                                                   compositor: &mut IOCompositor<Window>,
                                                   pipeline_id: PipelineId)
                                                   where Window: WindowMethods;
 
     /// Destroys all tiles of all layers, including children, *without* sending them back to the
-    /// painter. You must call this only when the paint task is destined to be going down;
+    /// painter. You must call this only when the paint thread is destined to be going down;
     /// otherwise, you will leak tiles.
     ///
-    /// This is used during shutdown, when we know the paint task is going away.
+    /// This is used during shutdown, when we know the paint thread is going away.
     fn forget_all_tiles(&self);
 
     /// Move the layer's descendants that don't want scroll events and scroll by a relative
     /// specified amount in page coordinates. This also takes in a cursor position to see if the
     /// mouse is over child layers first. If a layer successfully scrolled returns either
     /// ScrollPositionUnchanged or ScrollPositionChanged. If no layer was targeted by the event
     /// returns ScrollEventUnhandled.
     fn handle_scroll_event(&self,
@@ -275,34 +275,34 @@ impl CompositorLayer for Layer<Composito
         // Find the child that is the root layer for this pipeline.
         let index = self.children().iter().position(|kid| {
             let extra_data = kid.extra_data.borrow();
             extra_data.pipeline_id == pipeline_id && extra_data.id == LayerId::null()
         });
 
         match index {
             Some(index) => {
-                // Remove the root layer, and return buffers to the paint task
+                // Remove the root layer, and return buffers to the paint thread
                 let child = self.children().remove(index);
                 child.clear_all_tiles(compositor);
             }
             None => {
                 // Wasn't found, recurse into child layers
                 for kid in &*self.children() {
                     kid.remove_root_layer_with_pipeline_id(compositor, pipeline_id);
                 }
             }
         }
     }
 
     /// Destroys all tiles of all layers, including children, *without* sending them back to the
-    /// painter. You must call this only when the paint task is destined to be going down;
+    /// painter. You must call this only when the paint thread is destined to be going down;
     /// otherwise, you will leak tiles.
     ///
-    /// This is used during shutdown, when we know the paint task is going away.
+    /// This is used during shutdown, when we know the paint thread is going away.
     fn forget_all_tiles(&self) {
         let tiles = self.collect_buffers();
         for tile in tiles {
             let mut tile = tile;
             tile.mark_wont_leak()
         }
 
         for kid in &*self.children() {
rename from servo/components/compositing/compositor_task.rs
rename to servo/components/compositing/compositor_thread.rs
--- a/servo/components/compositing/compositor_task.rs
+++ b/servo/components/compositing/compositor_thread.rs
@@ -1,13 +1,13 @@
 /* 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/. */
 
-//! Communication with the compositor task.
+//! Communication with the compositor thread.
 
 use CompositorMsg as ConstellationMsg;
 use compositor;
 use euclid::point::Point2D;
 use euclid::size::Size2D;
 use gfx_traits::{LayerId, LayerProperties, PaintListener};
 use headless;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
@@ -102,20 +102,20 @@ pub fn run_script_listener_thread(compos
     }
 }
 
 /// Implementation of the abstract `PaintListener` interface.
 impl PaintListener for Box<CompositorProxy + 'static + Send> {
     fn native_display(&mut self) -> Option<NativeDisplay> {
         let (chan, port) = channel();
         self.send(Msg::GetNativeDisplay(chan));
-        // If the compositor is shutting down when a paint task
+        // If the compositor is shutting down when a paint thread
         // is being created, the compositor won't respond to
         // this message, resulting in an eventual panic. Instead,
-        // just return None in this case, since the paint task
+        // just return None in this case, since the paint thread
         // will exit shortly and never actually be requested
         // to paint buffers by the compositor.
         port.recv().unwrap_or(None)
     }
 
     fn assign_painted_buffers(&mut self,
                               pipeline_id: PipelineId,
                               epoch: Epoch,
@@ -141,22 +141,22 @@ impl PaintListener for Box<CompositorPro
                                       properties: Vec<LayerProperties>,
                                       epoch: Epoch) {
         // FIXME(#2004, pcwalton): This assumes that the first layer determines the page size, and
         // that all other layers are immediate children of it. This is sufficient to handle
         // `position: fixed` but will not be sufficient to handle `overflow: scroll` or transforms.
         self.send(Msg::InitializeLayersForPipeline(pipeline_id, epoch, properties));
     }
 
-    fn notify_paint_task_exiting(&mut self, pipeline_id: PipelineId) {
-        self.send(Msg::PaintTaskExited(pipeline_id))
+    fn notify_paint_thread_exiting(&mut self, pipeline_id: PipelineId) {
+        self.send(Msg::PaintThreadExited(pipeline_id))
     }
 }
 
-/// Messages from the painting task and the constellation task to the compositor task.
+/// Messages from the painting thread and the constellation thread to the compositor thread.
 pub enum Msg {
     /// Requests that the compositor shut down.
     Exit(IpcSender<()>),
 
     /// Informs the compositor that the constellation has completed shutdown.
     /// Required because the constellation can have pending calls to make
     /// (e.g. SetFrameTree) at the time that we send it an ExitMsg.
     ShutdownComplete,
@@ -194,27 +194,27 @@ pub enum Msg {
     /// Sends an unconsumed key event back to the compositor.
     KeyEvent(Key, KeyState, KeyModifiers),
     /// Script has handled a touch event, and either prevented or allowed default actions.
     TouchEventProcessed(EventResult),
     /// Changes the cursor.
     SetCursor(Cursor),
     /// Composite to a PNG file and return the Image over a passed channel.
     CreatePng(IpcSender<Option<Image>>),
-    /// Informs the compositor that the paint task for the given pipeline has exited.
-    PaintTaskExited(PipelineId),
+    /// Informs the compositor that the paint thread for the given pipeline has exited.
+    PaintThreadExited(PipelineId),
     /// Alerts the compositor that the viewport has been constrained in some manner
     ViewportConstrained(PipelineId, ViewportConstraints),
     /// A reply to the compositor asking if the output image is stable.
     IsReadyToSaveImageReply(bool),
     /// A favicon was detected
     NewFavicon(Url),
     /// <head> tag finished parsing
     HeadParsed,
-    /// Signal that the paint task ignored the paint requests that carried
+    /// Signal that the paint thread ignored the paint requests that carried
     /// these native surfaces, so that they can be re-added to the surface cache.
     ReturnUnusedNativeSurfaces(Vec<NativeSurface>),
     /// Collect memory reports and send them back to the given mem::ReportsChan.
     CollectMemoryReports(mem::ReportsChan),
     /// A status message to be displayed by the browser chrome.
     Status(Option<String>),
     /// Get Window Informations size and position
     GetClientWindow(IpcSender<(Size2D<u32>, Point2D<i32>)>),
@@ -242,35 +242,35 @@ impl Debug for Msg {
             Msg::LoadComplete(..) => write!(f, "LoadComplete"),
             Msg::LoadStart(..) => write!(f, "LoadStart"),
             Msg::ScrollTimeout(..) => write!(f, "ScrollTimeout"),
             Msg::RecompositeAfterScroll => write!(f, "RecompositeAfterScroll"),
             Msg::KeyEvent(..) => write!(f, "KeyEvent"),
             Msg::TouchEventProcessed(..) => write!(f, "TouchEventProcessed"),
             Msg::SetCursor(..) => write!(f, "SetCursor"),
             Msg::CreatePng(..) => write!(f, "CreatePng"),
-            Msg::PaintTaskExited(..) => write!(f, "PaintTaskExited"),
+            Msg::PaintThreadExited(..) => write!(f, "PaintThreadExited"),
             Msg::ViewportConstrained(..) => write!(f, "ViewportConstrained"),
             Msg::IsReadyToSaveImageReply(..) => write!(f, "IsReadyToSaveImageReply"),
             Msg::NewFavicon(..) => write!(f, "NewFavicon"),
             Msg::HeadParsed => write!(f, "HeadParsed"),
             Msg::ReturnUnusedNativeSurfaces(..) => write!(f, "ReturnUnusedNativeSurfaces"),
             Msg::CollectMemoryReports(..) => write!(f, "CollectMemoryReports"),
             Msg::Status(..) => write!(f, "Status"),
             Msg::GetClientWindow(..) => write!(f, "GetClientWindow"),
             Msg::MoveTo(..) => write!(f, "MoveTo"),
             Msg::ResizeTo(..) => write!(f, "ResizeTo"),
             Msg::PipelineExited(..) => write!(f, "PipelineExited"),
         }
     }
 }
 
-pub struct CompositorTask;
+pub struct CompositorThread;
 
-impl CompositorTask {
+impl CompositorThread {
     pub fn create<Window>(window: Option<Rc<Window>>,
                           state: InitialCompositorState)
                           -> Box<CompositorEventListener + 'static>
                           where Window: WindowMethods + 'static {
         match window {
             Some(window) => {
                 box compositor::IOCompositor::create(window, state)
                     as Box<CompositorEventListener>
--- a/servo/components/compositing/constellation.rs
+++ b/servo/components/compositing/constellation.rs
@@ -1,145 +1,145 @@
 /* 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/. */
 
 //! The `Constellation`, Servo's Grand Central Station
 //!
 //! The primary duty of a `Constellation` is to mediate between the
 //! graphics compositor and the many `Pipeline`s in the browser's
-//! navigation context, each `Pipeline` encompassing a `ScriptTask`,
-//! `LayoutTask`, and `PaintTask`.
+//! navigation context, each `Pipeline` encompassing a `ScriptThread`,
+//! `LayoutThread`, and `PaintThread`.
 
 use CompositorMsg as FromCompositorMsg;
-use canvas::canvas_paint_task::CanvasPaintTask;
-use canvas::webgl_paint_task::WebGLPaintTask;
+use canvas::canvas_paint_thread::CanvasPaintThread;
+use canvas::webgl_paint_thread::WebGLPaintThread;
 use canvas_traits::CanvasMsg;
 use clipboard::ClipboardContext;
-use compositor_task::CompositorProxy;
-use compositor_task::Msg as ToCompositorMsg;
+use compositor_thread::CompositorProxy;
+use compositor_thread::Msg as ToCompositorMsg;
 use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg};
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::{Size2D, TypedSize2D};
 use gaol;
 use gaol::sandbox::{self, Sandbox, SandboxMethods};
-use gfx::font_cache_task::FontCacheTask;
+use gfx::font_cache_thread::FontCacheThread;
 use gfx_traits::PaintMsg as FromPaintMsg;
 use ipc_channel::ipc::{self, IpcOneShotServer, IpcSender};
 use ipc_channel::router::ROUTER;
-use layout_traits::{LayoutControlChan, LayoutTaskFactory};
+use layout_traits::{LayoutControlChan, LayoutThreadFactory};
 use msg::compositor_msg::Epoch;
 use msg::constellation_msg::AnimationState;
 use msg::constellation_msg::WebDriverCommandMsg;
 use msg::constellation_msg::{DocumentState, FrameId, PipelineId};
 use msg::constellation_msg::{IframeLoadInfo, IFrameSandboxState, MozBrowserEvent, NavigationDirection};
 use msg::constellation_msg::{Key, KeyModifiers, KeyState, LoadData};
 use msg::constellation_msg::{PipelineNamespace, PipelineNamespaceId};
 use msg::constellation_msg::{SubpageId, WindowSizeData};
 use msg::constellation_msg::{self, ConstellationChan, Failure};
 use msg::webdriver_msg;
-use net_traits::image_cache_task::ImageCacheTask;
-use net_traits::storage_task::{StorageTask, StorageTaskMsg};
-use net_traits::{self, ResourceTask};
+use net_traits::image_cache_thread::ImageCacheThread;
+use net_traits::storage_thread::{StorageThread, StorageThreadMsg};
+use net_traits::{self, ResourceThread};
 use offscreen_gl_context::GLContextAttributes;
 use pipeline::{CompositionPipeline, InitialPipelineState, Pipeline, UnprivilegedPipelineContent};
 use profile_traits::mem;
 use profile_traits::time;
 use sandboxing;
 use script_traits::{CompositorEvent, ConstellationControlMsg, LayoutControlMsg};
-use script_traits::{LayoutMsg as FromLayoutMsg, ScriptMsg as FromScriptMsg, ScriptTaskFactory};
+use script_traits::{LayoutMsg as FromLayoutMsg, ScriptMsg as FromScriptMsg, ScriptThreadFactory};
 use script_traits::{TimerEventRequest};
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::env;
 use std::io::{self, Write};
 use std::marker::PhantomData;
 use std::mem::replace;
 use std::process;
 use std::sync::mpsc::{Sender, channel, Receiver};
 use style_traits::viewport::ViewportConstraints;
 use timer_scheduler::TimerScheduler;
 use url::Url;
 use util::cursor::Cursor;
 use util::geometry::PagePx;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use util::{opts, prefs};
 
 #[derive(Debug, PartialEq)]
 enum ReadyToSave {
     NoRootFrame,
     PendingFrames,
     WebFontNotLoaded,
     DocumentLoading,
     EpochMismatch,
     PipelineUnknown,
     Ready,
 }
 
 /// Maintains the pipelines and navigation context and grants permission to composite.
 ///
-/// It is parameterized over a `LayoutTaskFactory` and a
-/// `ScriptTaskFactory` (which in practice are implemented by
-/// `LayoutTask` in the `layout` crate, and `ScriptTask` in
+/// It is parameterized over a `LayoutThreadFactory` and a
+/// `ScriptThreadFactory` (which in practice are implemented by
+/// `LayoutThread` in the `layout` crate, and `ScriptThread` in
 /// the `script` crate).
 pub struct Constellation<LTF, STF> {
     /// A channel through which script messages can be sent to this object.
     pub script_sender: ConstellationChan<FromScriptMsg>,
 
     /// A channel through which compositor messages can be sent to this object.
     pub compositor_sender: Sender<FromCompositorMsg>,
 
-    /// A channel through which layout task messages can be sent to this object.
+    /// A channel through which layout thread messages can be sent to this object.
     pub layout_sender: ConstellationChan<FromLayoutMsg>,
 
-    /// A channel through which paint task messages can be sent to this object.
+    /// A channel through which paint thread messages can be sent to this object.
     pub painter_sender: ConstellationChan<FromPaintMsg>,
 
     /// Receives messages from scripts.
     pub script_receiver: Receiver<FromScriptMsg>,
 
     /// Receives messages from the compositor
     pub compositor_receiver: Receiver<FromCompositorMsg>,
 
-    /// Receives messages from the layout task
+    /// Receives messages from the layout thread
     pub layout_receiver: Receiver<FromLayoutMsg>,
 
-    /// Receives messages from paint task.
+    /// Receives messages from paint thread.
     pub painter_receiver: Receiver<FromPaintMsg>,
 
     /// A channel (the implementation of which is port-specific) through which messages can be sent
     /// to the compositor.
     pub compositor_proxy: Box<CompositorProxy>,
 
-    /// A channel through which messages can be sent to the resource task.
-    pub resource_task: ResourceTask,
+    /// A channel through which messages can be sent to the resource thread.
+    pub resource_thread: ResourceThread,
 
-    /// A channel through which messages can be sent to the image cache task.
-    pub image_cache_task: ImageCacheTask,
+    /// A channel through which messages can be sent to the image cache thread.
+    pub image_cache_thread: ImageCacheThread,
 
     /// A channel through which messages can be sent to the developer tools.
     devtools_chan: Option<Sender<DevtoolsControlMsg>>,
 
-    /// A channel through which messages can be sent to the storage task.
-    storage_task: StorageTask,
+    /// A channel through which messages can be sent to the storage thread.
+    storage_thread: StorageThread,
 
     /// A list of all the pipelines. (See the `pipeline` module for more details.)
     pipelines: HashMap<PipelineId, Pipeline>,
 
     /// A list of all the frames
     frames: HashMap<FrameId, Frame>,
 
     /// Maps from pipeline ID to the frame that contains it.
     pipeline_to_frame_map: HashMap<PipelineId, FrameId>,
 
     /// Maps from a (parent pipeline, subpage) to the actual child pipeline ID.
     subpage_map: HashMap<(PipelineId, SubpageId), PipelineId>,
 
     /// A channel through which messages can be sent to the font cache.
-    font_cache_task: FontCacheTask,
+    font_cache_thread: FontCacheThread,
 
     /// ID of the root frame.
     root_frame_id: Option<FrameId>,
 
     /// The next free ID to assign to a pipeline ID namespace.
     next_pipeline_namespace_id: PipelineNamespaceId,
 
     /// The next free ID to assign to a frame.
@@ -162,45 +162,45 @@ pub struct Constellation<LTF, STF> {
     pub window_size: WindowSizeData,
 
     /// Means of accessing the clipboard
     clipboard_ctx: Option<ClipboardContext>,
 
     /// Bits of state used to interact with the webdriver implementation
     webdriver: WebDriverData,
 
-    /// A list of in-process senders to `CanvasPaintTask`s.
-    canvas_paint_tasks: Vec<Sender<CanvasMsg>>,
+    /// A list of in-process senders to `CanvasPaintThread`s.
+    canvas_paint_threads: Vec<Sender<CanvasMsg>>,
 
-    /// A list of in-process senders to `WebGLPaintTask`s.
-    webgl_paint_tasks: Vec<Sender<CanvasMsg>>,
+    /// A list of in-process senders to `WebGLPaintThread`s.
+    webgl_paint_threads: Vec<Sender<CanvasMsg>>,
 
     scheduler_chan: IpcSender<TimerEventRequest>,
 
     /// A list of child content processes.
     child_processes: Vec<ChildProcess>,
 
     /// Document states for loaded pipelines (used only when writing screenshots).
     document_states: HashMap<PipelineId, DocumentState>,
 }
 
 /// State needed to construct a constellation.
 pub struct InitialConstellationState {
     /// A channel through which messages can be sent to the compositor.
     pub compositor_proxy: Box<CompositorProxy + Send>,
     /// A channel to the developer tools, if applicable.
     pub devtools_chan: Option<Sender<DevtoolsControlMsg>>,
-    /// A channel to the image cache task.
-    pub image_cache_task: ImageCacheTask,
-    /// A channel to the font cache task.
-    pub font_cache_task: FontCacheTask,
-    /// A channel to the resource task.
-    pub resource_task: ResourceTask,
-    /// A channel to the storage task.
-    pub storage_task: StorageTask,
+    /// A channel to the image cache thread.
+    pub image_cache_thread: ImageCacheThread,
+    /// A channel to the font cache thread.
+    pub font_cache_thread: FontCacheThread,
+    /// A channel to the resource thread.
+    pub resource_thread: ResourceThread,
+    /// A channel to the storage thread.
+    pub storage_thread: StorageThread,
     /// A channel to the time profiler thread.
     pub time_profiler_chan: time::ProfilerChan,
     /// A channel to the memory profiler thread.
     pub mem_profiler_chan: mem::ProfilerChan,
     /// Whether the constellation supports the clipboard.
     pub supports_clipboard: bool,
 }
 
@@ -283,17 +283,17 @@ enum ExitPipelineMode {
     Force,
 }
 
 enum ChildProcess {
     Sandboxed(gaol::platform::process::Process),
     Unsandboxed(process::Child),
 }
 
-impl<LTF: LayoutTaskFactory, STF: ScriptTaskFactory> Constellation<LTF, STF> {
+impl<LTF: LayoutThreadFactory, STF: ScriptThreadFactory> Constellation<LTF, STF> {
     pub fn start(state: InitialConstellationState) -> Sender<FromCompositorMsg> {
         let (ipc_script_receiver, ipc_script_sender) = ConstellationChan::<FromScriptMsg>::new();
         let script_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_script_receiver);
         let (compositor_sender, compositor_receiver) = channel();
         let (ipc_layout_receiver, ipc_layout_sender) = ConstellationChan::<FromLayoutMsg>::new();
         let layout_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_layout_receiver);
         let (ipc_painter_receiver, ipc_painter_sender) = ConstellationChan::<FromPaintMsg>::new();
         let painter_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_painter_receiver);
@@ -305,20 +305,20 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 layout_sender: ipc_layout_sender,
                 painter_sender: ipc_painter_sender,
                 script_receiver: script_receiver,
                 compositor_receiver: compositor_receiver,
                 layout_receiver: layout_receiver,
                 painter_receiver: painter_receiver,
                 compositor_proxy: state.compositor_proxy,
                 devtools_chan: state.devtools_chan,
-                resource_task: state.resource_task,
-                image_cache_task: state.image_cache_task,
-                font_cache_task: state.font_cache_task,
-                storage_task: state.storage_task,
+                resource_thread: state.resource_thread,
+                image_cache_thread: state.image_cache_thread,
+                font_cache_thread: state.font_cache_thread,
+                storage_thread: state.storage_thread,
                 pipelines: HashMap::new(),
                 frames: HashMap::new(),
                 pipeline_to_frame_map: HashMap::new(),
                 subpage_map: HashMap::new(),
                 pending_frames: vec!(),
                 next_pipeline_namespace_id: PipelineNamespaceId(0),
                 root_frame_id: None,
                 next_frame_id: FrameId(0),
@@ -335,18 +335,18 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 },
                 phantom: PhantomData,
                 clipboard_ctx: if state.supports_clipboard {
                     ClipboardContext::new().ok()
                 } else {
                     None
                 },
                 webdriver: WebDriverData::new(),
-                canvas_paint_tasks: Vec::new(),
-                webgl_paint_tasks: Vec::new(),
+                canvas_paint_threads: Vec::new(),
+                webgl_paint_threads: Vec::new(),
                 scheduler_chan: TimerScheduler::start(),
                 child_processes: Vec::new(),
                 document_states: HashMap::new(),
             };
             let namespace_id = constellation.next_pipeline_namespace_id();
             PipelineNamespace::install(namespace_id);
             constellation.run();
         });
@@ -381,31 +381,31 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 id: pipeline_id,
                 parent_info: parent_info,
                 constellation_chan: self.script_sender.clone(),
                 layout_to_constellation_chan: self.layout_sender.clone(),
                 painter_chan: self.painter_sender.clone(),
                 scheduler_chan: self.scheduler_chan.clone(),
                 compositor_proxy: self.compositor_proxy.clone_compositor_proxy(),
                 devtools_chan: self.devtools_chan.clone(),
-                image_cache_task: self.image_cache_task.clone(),
-                font_cache_task: self.font_cache_task.clone(),
-                resource_task: self.resource_task.clone(),
-                storage_task: self.storage_task.clone(),
+                image_cache_thread: self.image_cache_thread.clone(),
+                font_cache_thread: self.font_cache_thread.clone(),
+                resource_thread: self.resource_thread.clone(),
+                storage_thread: self.storage_thread.clone(),
                 time_profiler_chan: self.time_profiler_chan.clone(),
                 mem_profiler_chan: self.mem_profiler_chan.clone(),
                 window_size: initial_window_size,
                 script_chan: script_channel,
                 load_data: load_data,
                 device_pixel_ratio: self.window_size.device_pixel_ratio,
                 pipeline_namespace_id: self.next_pipeline_namespace_id(),
             });
 
         if spawning_paint_only {
-            privileged_pipeline_content.start_paint_task();
+            privileged_pipeline_content.start_paint_thread();
         } else {
             privileged_pipeline_content.start_all();
 
             // Spawn the child process.
             //
             // Yes, that's all there is to it!
             if opts::multiprocess() {
                 let (server, token) =
@@ -676,35 +676,35 @@ impl<LTF: LayoutTaskFactory, STF: Script
             Request::Script(FromScriptMsg::NewFavicon(url)) => {
                 debug!("constellation got new favicon message");
                 self.compositor_proxy.send(ToCompositorMsg::NewFavicon(url));
             }
             Request::Script(FromScriptMsg::HeadParsed) => {
                 debug!("constellation got head parsed message");
                 self.compositor_proxy.send(ToCompositorMsg::HeadParsed);
             }
-            Request::Script(FromScriptMsg::CreateCanvasPaintTask(size, sender)) => {
-                debug!("constellation got create-canvas-paint-task message");
-                self.handle_create_canvas_paint_task_msg(&size, sender)
+            Request::Script(FromScriptMsg::CreateCanvasPaintThread(size, sender)) => {
+                debug!("constellation got create-canvas-paint-thread message");
+                self.handle_create_canvas_paint_thread_msg(&size, sender)
             }
-            Request::Script(FromScriptMsg::CreateWebGLPaintTask(size, attributes, sender)) => {
-                debug!("constellation got create-WebGL-paint-task message");
-                self.handle_create_webgl_paint_task_msg(&size, attributes, sender)
+            Request::Script(FromScriptMsg::CreateWebGLPaintThread(size, attributes, sender)) => {
+                debug!("constellation got create-WebGL-paint-thread message");
+                self.handle_create_webgl_paint_thread_msg(&size, attributes, sender)
             }
             Request::Script(FromScriptMsg::NodeStatus(message)) => {
                 debug!("constellation got NodeStatus message");
                 self.compositor_proxy.send(ToCompositorMsg::Status(message));
             }
             Request::Script(FromScriptMsg::SetDocumentState(pipeline_id, state)) => {
                 debug!("constellation got SetDocumentState message");
                 self.document_states.insert(pipeline_id, state);
             }
 
 
-            // Messages from layout task
+            // Messages from layout thread
 
             Request::Layout(FromLayoutMsg::ChangeRunningAnimationsState(pipeline_id, animation_state)) => {
                 self.handle_change_running_animations_state(pipeline_id, animation_state)
             }
             Request::Layout(FromLayoutMsg::Failure(Failure { pipeline_id, parent_info })) => {
                 debug!("handling paint failure message from pipeline {:?}, {:?}", pipeline_id, parent_info);
                 self.handle_failure_msg(pipeline_id, parent_info);
             }
@@ -712,49 +712,49 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 self.handle_set_cursor_msg(cursor)
             }
             Request::Layout(FromLayoutMsg::ViewportConstrained(pipeline_id, constraints)) => {
                 debug!("constellation got viewport-constrained event message");
                 self.handle_viewport_constrained_msg(pipeline_id, constraints);
             }
 
 
-            // Messages from paint task
+            // Messages from paint thread
 
 
             // Notification that painting has finished and is requesting permission to paint.
             Request::Paint(FromPaintMsg::Failure(Failure { pipeline_id, parent_info })) => {
                 debug!("handling paint failure message from pipeline {:?}, {:?}", pipeline_id, parent_info);
                 self.handle_failure_msg(pipeline_id, parent_info);
             }
 
         }
         true
     }
 
     fn handle_exit(&mut self) {
         for (_id, ref pipeline) in &self.pipelines {
             pipeline.exit();
         }
-        self.image_cache_task.exit();
-        self.resource_task.send(net_traits::ControlMsg::Exit).unwrap();
+        self.image_cache_thread.exit();
+        self.resource_thread.send(net_traits::ControlMsg::Exit).unwrap();
         self.devtools_chan.as_ref().map(|chan| {
             chan.send(DevtoolsControlMsg::FromChrome(
                     ChromeToDevtoolsControlMsg::ServerExitMsg)).unwrap();
         });
-        self.storage_task.send(StorageTaskMsg::Exit).unwrap();
-        self.font_cache_task.exit();
+        self.storage_thread.send(StorageThreadMsg::Exit).unwrap();
+        self.font_cache_thread.exit();
         self.compositor_proxy.send(ToCompositorMsg::ShutdownComplete);
     }
 
     fn handle_failure_msg(&mut self,
                           pipeline_id: PipelineId,
                           parent_info: Option<(PipelineId, SubpageId)>) {
         if opts::get().hard_fail {
-            // It's quite difficult to make Servo exit cleanly if some tasks have failed.
+            // It's quite difficult to make Servo exit cleanly if some threads have failed.
             // Hard fail exists for test runners so we crash and that's good enough.
             let mut stderr = io::stderr();
             stderr.write_all("Pipeline failed in hard-fail mode.  Crashing!\n".as_bytes()).unwrap();
             process::exit(1);
         }
 
         self.close_pipeline(pipeline_id, ExitPipelineMode::Force);
 
@@ -820,45 +820,45 @@ impl<LTF: LayoutTaskFactory, STF: Script
         let parent_pipeline = self.pipeline(subframe_parent.0);
         let msg = ConstellationControlMsg::DispatchFrameLoadEvent {
             target: pipeline_id,
             parent: subframe_parent.0
         };
         parent_pipeline.script_chan.send(msg).unwrap();
     }
 
-    // The script task associated with pipeline_id has loaded a URL in an iframe via script. This
+    // The script thread associated with pipeline_id has loaded a URL in an iframe via script. This
     // will result in a new pipeline being spawned and a frame tree being added to
     // containing_page_pipeline_id's frame tree's children. This message is never the result of a
     // page navigation.
     fn handle_script_loaded_url_in_iframe_msg(&mut self, load_info: IframeLoadInfo) {
         let old_pipeline_id = load_info.old_subpage_id.map(|old_subpage_id| {
             self.find_subpage(load_info.containing_pipeline_id, old_subpage_id).id
         });
 
         // If no url is specified, reload.
         let new_url = match (old_pipeline_id, load_info.url) {
             (_, Some(ref url)) => url.clone(),
             (Some(old_pipeline_id), None) => self.pipeline(old_pipeline_id).url.clone(),
             (None, None) => url!("about:blank"),
         };
 
         // Compare the pipeline's url to the new url. If the origin is the same,
-        // then reuse the script task in creating the new pipeline
+        // then reuse the script thread in creating the new pipeline
         let script_chan = {
             let source_pipeline = self.pipeline(load_info.containing_pipeline_id);
 
             let source_url = source_pipeline.url.clone();
 
             let same_script = (source_url.host() == new_url.host() &&
                                source_url.port() == new_url.port()) &&
                                load_info.sandbox == IFrameSandboxState::IFrameUnsandboxed;
 
             // FIXME(tkuehn): Need to follow the standardized spec for checking same-origin
-            // Reuse the script task if the URL is same-origin
+            // Reuse the script thread if the URL is same-origin
             if same_script {
                 debug!("Constellation: loading same-origin iframe, \
                         parent url {:?}, iframe url {:?}", source_url, new_url);
                 Some(source_pipeline.script_chan.clone())
             } else {
                 debug!("Constellation: loading cross-origin iframe, \
                         parent url {:?}, iframe url {:?}", source_url, new_url);
                 None
@@ -905,23 +905,23 @@ impl<LTF: LayoutTaskFactory, STF: Script
     }
 
     fn handle_load_url_msg(&mut self, source_id: PipelineId, load_data: LoadData) {
         self.load_url(source_id, load_data);
     }
 
     fn load_url(&mut self, source_id: PipelineId, load_data: LoadData) -> Option<PipelineId> {
         // If this load targets an iframe, its framing element may exist
-        // in a separate script task than the framed document that initiated
+        // in a separate script thread than the framed document that initiated
         // the new load. The framing element must be notified about the
         // requested change so it can update its internal state.
         match self.pipeline(source_id).parent_info {
             Some((parent_pipeline_id, subpage_id)) => {
                 self.handle_load_start_msg(&source_id);
-                // Message the constellation to find the script task for this iframe
+                // Message the constellation to find the script thread for this iframe
                 // and issue an iframe load through there.
                 let parent_pipeline = self.pipeline(parent_pipeline_id);
                 let script_channel = &parent_pipeline.script_chan;
                 script_channel.send(ConstellationControlMsg::Navigate(parent_pipeline_id,
                                                                       subpage_id,
                                                                       load_data)).unwrap();
                 Some(source_id)
             }
@@ -939,17 +939,17 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 // changes would be overridden by changing the subframe associated with source_id.
 
                 // Create the new pipeline
                 let window_size = self.pipeline(source_id).size;
                 let new_pipeline_id = PipelineId::new();
                 self.new_pipeline(new_pipeline_id, None, window_size, None, load_data);
                 self.push_pending_frame(new_pipeline_id, Some(source_id));
 
-                // Send message to ScriptTask that will suspend all timers
+                // Send message to ScriptThread that will suspend all timers
                 let old_pipeline = self.pipelines.get(&source_id).unwrap();
                 old_pipeline.freeze();
                 Some(new_pipeline_id)
             }
         }
     }
 
     fn handle_load_start_msg(&mut self, pipeline_id: &PipelineId) {
@@ -1106,17 +1106,17 @@ impl<LTF: LayoutTaskFactory, STF: Script
 
     fn handle_mozbrowser_event_msg(&mut self,
                                    containing_pipeline_id: PipelineId,
                                    subpage_id: SubpageId,
                                    event: MozBrowserEvent) {
         assert!(prefs::get_pref("dom.mozbrowser.enabled").as_boolean().unwrap_or(false));
 
         // Find the script channel for the given parent pipeline,
-        // and pass the event to that script task.
+        // and pass the event to that script thread.
         let pipeline = self.pipeline(containing_pipeline_id);
         pipeline.trigger_mozbrowser_event(subpage_id, event);
     }
 
     fn handle_get_pipeline(&mut self, frame_id: Option<FrameId>,
                            resp_chan: IpcSender<Option<PipelineId>>) {
         let current_pipeline_id = frame_id.or(self.root_frame_id).map(|frame_id| {
             let frame = self.frames.get(&frame_id).unwrap();
@@ -1166,46 +1166,46 @@ impl<LTF: LayoutTaskFactory, STF: Script
                 // This iframe is currently loading / painting for the first time.
                 // In this case, it doesn't exist in the frame tree, but the pipeline
                 // still needs to be shut down.
                 self.close_pipeline(pipeline_id, ExitPipelineMode::Normal);
             }
         }
     }
 
-    fn handle_create_canvas_paint_task_msg(
+    fn handle_create_canvas_paint_thread_msg(
             &mut self,
             size: &Size2D<i32>,
             response_sender: IpcSender<(IpcSender<CanvasMsg>, usize)>) {
-        let id = self.canvas_paint_tasks.len();
-        let (out_of_process_sender, in_process_sender) = CanvasPaintTask::start(*size);
-        self.canvas_paint_tasks.push(in_process_sender);
+        let id = self.canvas_paint_threads.len();
+        let (out_of_process_sender, in_process_sender) = CanvasPaintThread::start(*size);
+        self.canvas_paint_threads.push(in_process_sender);
         response_sender.send((out_of_process_sender, id)).unwrap()
     }
 
-    fn handle_create_webgl_paint_task_msg(
+    fn handle_create_webgl_paint_thread_msg(
             &mut self,
             size: &Size2D<i32>,
             attributes: GLContextAttributes,
             response_sender: IpcSender<Result<(IpcSender<CanvasMsg>, usize), String>>) {
-        let response = match WebGLPaintTask::start(*size, attributes) {
+        let response = match WebGLPaintThread::start(*size, attributes) {
             Ok((out_of_process_sender, in_process_sender)) => {
-                let id = self.webgl_paint_tasks.len();
-                self.webgl_paint_tasks.push(in_process_sender);
+                let id = self.webgl_paint_threads.len();
+                self.webgl_paint_threads.push(in_process_sender);
                 Ok((out_of_process_sender, id))
             },
             Err(msg) => Err(msg.to_owned()),
         };
 
         response_sender.send(response).unwrap()
     }
 
     fn handle_webdriver_msg(&mut self, msg: WebDriverCommandMsg) {
         // Find the script channel for the given parent pipeline,
-        // and pass the event to that script task.
+        // and pass the event to that script thread.
         match msg {
             WebDriverCommandMsg::LoadUrl(pipeline_id, load_data, reply) => {
                 self.load_url_for_webdriver(pipeline_id, load_data, reply);
             },
             WebDriverCommandMsg::Refresh(pipeline_id, reply) => {
                 let load_data = {
                     let pipeline = self.pipeline(pipeline_id);
                     LoadData::new(pipeline.url.clone())
@@ -1399,17 +1399,17 @@ impl<LTF: LayoutTaskFactory, STF: Script
         }
 
         // If there are pending loads, wait for those to complete.
         if self.pending_frames.len() > 0 {
             return ReadyToSave::PendingFrames;
         }
 
         // Step through the current frame tree, checking that the script
-        // task is idle, and that the current epoch of the layout task
+        // thread is idle, and that the current epoch of the layout thread
         // matches what the compositor has painted. If all these conditions
         // are met, then the output image should not change and a reftest
         // screenshot can safely be written.
         for frame in self.current_frame_tree_iter(self.root_frame_id) {
             let pipeline = self.pipeline(frame.current);
 
             // Check to see if there are any webfonts still loading.
             //
@@ -1436,47 +1436,47 @@ impl<LTF: LayoutTaskFactory, STF: Script
 
             // Check the visible rectangle for this pipeline. If the constellation has received a
             // size for the pipeline, then its painting should be up to date. If the constellation
             // *hasn't* received a size, it could be that the layer was hidden by script before the
             // compositor discovered it, so we just don't check the layer.
             if let Some(size) = pipeline.size {
                 // If the rectangle for this pipeline is zero sized, it will
                 // never be painted. In this case, don't query the layout
-                // task as it won't contribute to the final output image.
+                // thread as it won't contribute to the final output image.
                 if size == Size2D::zero() {
                     continue;
                 }
 
                 // Get the epoch that the compositor has drawn for this pipeline.
                 let compositor_epoch = pipeline_states.get(&frame.current);
                 match compositor_epoch {
                     Some(compositor_epoch) => {
-                        // Synchronously query the layout task to see if the current
+                        // Synchronously query the layout thread to see if the current
                         // epoch matches what the compositor has drawn. If they match
                         // (and script is idle) then this pipeline won't change again
                         // and can be considered stable.
                         let (sender, receiver) = ipc::channel().unwrap();
                         let LayoutControlChan(ref layout_chan) = pipeline.layout_chan;
                         layout_chan.send(LayoutControlMsg::GetCurrentEpoch(sender)).unwrap();
-                        let layout_task_epoch = receiver.recv().unwrap();
-                        if layout_task_epoch != *compositor_epoch {
+                        let layout_thread_epoch = receiver.recv().unwrap();
+                        if layout_thread_epoch != *compositor_epoch {
                             return ReadyToSave::EpochMismatch;
                         }
                     }
                     None => {
                         // The compositor doesn't know about this pipeline yet.
                         // Assume it hasn't rendered yet.
                         return ReadyToSave::PipelineUnknown;
                     }
                 }
             }
         }
 
-        // All script tasks are idle and layout epochs match compositor, so output image!
+        // All script threads are idle and layout epochs match compositor, so output image!
         ReadyToSave::Ready
     }
 
     // Close a frame (and all children)
     fn close_frame(&mut self, frame_id: FrameId, exit_mode: ExitPipelineMode) {
         // Store information about the pipelines to be closed. Then close the
         // pipelines, before removing ourself from the frames hash map. This
         // ordering is vital - so that if close_pipeline() ends up closing
--- a/servo/components/compositing/headless.rs
+++ b/servo/components/compositing/headless.rs
@@ -1,15 +1,15 @@
 /* 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/. */
 
 use CompositorMsg as ConstellationMsg;
-use compositor_task::{CompositorEventListener, CompositorReceiver};
-use compositor_task::{InitialCompositorState, Msg};
+use compositor_thread::{CompositorEventListener, CompositorReceiver};
+use compositor_thread::{InitialCompositorState, Msg};
 use euclid::scale_factor::ScaleFactor;
 use euclid::{Point2D, Size2D};
 use msg::constellation_msg::AnimationState;
 use msg::constellation_msg::WindowSizeData;
 use profile_traits::mem;
 use profile_traits::time;
 use std::sync::mpsc::Sender;
 use util::opts;
@@ -65,17 +65,17 @@ impl CompositorEventListener for NullCom
                 self.constellation_chan.send(ConstellationMsg::Exit).unwrap();
                 chan.send(()).unwrap();
             }
 
             Msg::ShutdownComplete => {
                 debug!("constellation completed shutdown");
 
                 // Drain compositor port, sometimes messages contain channels that are blocking
-                // another task from finishing (i.e. SetIds)
+                // another thread from finishing (i.e. SetIds)
                 while self.port.try_recv_compositor_msg().is_some() {}
 
                 self.time_profiler_chan.send(time::ProfilerMsg::Exit);
                 self.mem_profiler_chan.send(mem::ProfilerMsg::Exit);
 
                 return false
             }
 
@@ -118,17 +118,17 @@ impl CompositorEventListener for NullCom
             Msg::RecompositeAfterScroll |
             Msg::ChangePageTitle(..) |
             Msg::ChangePageUrl(..) |
             Msg::KeyEvent(..) |
             Msg::TouchEventProcessed(..) |
             Msg::SetCursor(..) |
             Msg::ViewportConstrained(..) => {}
             Msg::CreatePng(..) |
-            Msg::PaintTaskExited(..) |
+            Msg::PaintThreadExited(..) |
             Msg::MoveTo(..) |
             Msg::ResizeTo(..) |
             Msg::IsReadyToSaveImageReply(..) => {}
             Msg::NewFavicon(..) => {}
             Msg::HeadParsed => {}
             Msg::ReturnUnusedNativeSurfaces(..) => {}
             Msg::CollectMemoryReports(..) => {}
             Msg::PipelineExited(..) => {}
--- a/servo/components/compositing/lib.rs
+++ b/servo/components/compositing/lib.rs
@@ -45,30 +45,30 @@ extern crate profile_traits;
 extern crate script_traits;
 extern crate serde;
 extern crate style_traits;
 extern crate time;
 extern crate url;
 #[macro_use]
 extern crate util;
 
-pub use compositor_task::{CompositorEventListener, CompositorProxy, CompositorTask};
+pub use compositor_thread::{CompositorEventListener, CompositorProxy, CompositorThread};
 pub use constellation::Constellation;
 use euclid::size::{Size2D};
 use ipc_channel::ipc::{IpcSender};
 use msg::compositor_msg::Epoch;
 use msg::constellation_msg::{FrameId, Key, KeyState, KeyModifiers, LoadData};
 use msg::constellation_msg::{NavigationDirection, PipelineId, SubpageId};
 use msg::constellation_msg::{WebDriverCommandMsg, WindowSizeData};
 use std::collections::HashMap;
 use url::Url;
 
 mod compositor;
 mod compositor_layer;
-pub mod compositor_task;
+pub mod compositor_thread;
 pub mod constellation;
 mod headless;
 pub mod pipeline;
 pub mod sandboxing;
 mod scrolling;
 mod surface_map;
 mod timer_scheduler;
 mod touch;
--- a/servo/components/compositing/pipeline.rs
+++ b/servo/components/compositing/pipeline.rs
@@ -1,47 +1,47 @@
 /* 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/. */
 
 use CompositorProxy;
-use compositor_task;
-use compositor_task::Msg as CompositorMsg;
+use compositor_thread;
+use compositor_thread::Msg as CompositorMsg;
 use devtools_traits::{DevtoolsControlMsg, ScriptToDevtoolsControlMsg};
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::TypedSize2D;
-use gfx::font_cache_task::FontCacheTask;
-use gfx::paint_task::{ChromeToPaintMsg, LayoutToPaintMsg, PaintTask};
+use gfx::font_cache_thread::FontCacheThread;
+use gfx::paint_thread::{ChromeToPaintMsg, LayoutToPaintMsg, PaintThread};
 use gfx_traits::PaintMsg;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use layers::geometry::DevicePixel;
-use layout_traits::{LayoutControlChan, LayoutTaskFactory};
+use layout_traits::{LayoutControlChan, LayoutThreadFactory};
 use msg::constellation_msg::{ConstellationChan, Failure, FrameId, PipelineId, SubpageId};
 use msg::constellation_msg::{LoadData, MozBrowserEvent, WindowSizeData};
 use msg::constellation_msg::{PipelineNamespaceId};
-use net_traits::ResourceTask;
-use net_traits::image_cache_task::ImageCacheTask;
-use net_traits::storage_task::StorageTask;
+use net_traits::ResourceThread;
+use net_traits::image_cache_thread::ImageCacheThread;
+use net_traits::storage_thread::StorageThread;
 use profile_traits::mem as profile_mem;
 use profile_traits::time;
 use script_traits::{ConstellationControlMsg, InitialScriptState};
 use script_traits::{LayoutControlMsg, LayoutMsg, NewLayoutInfo, ScriptMsg};
-use script_traits::{ScriptToCompositorMsg, ScriptTaskFactory, TimerEventRequest};
+use script_traits::{ScriptToCompositorMsg, ScriptThreadFactory, TimerEventRequest};
 use std::mem;
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 use url::Url;
 use util;
 use util::geometry::{PagePx, ViewportPx};
 use util::ipc::OptionalIpcSender;
 use util::opts::{self, Opts};
 use util::prefs;
 
-/// A uniquely-identifiable pipeline of script task, layout task, and paint task.
+/// A uniquely-identifiable pipeline of script thread, layout thread, and paint thread.
 pub struct Pipeline {
     pub id: PipelineId,
     pub parent_info: Option<(PipelineId, SubpageId)>,
     pub script_chan: IpcSender<ConstellationControlMsg>,
     /// A channel to layout, for performing reflows and shutdown.
     pub layout_chan: LayoutControlChan,
     /// A channel to the compositor.
     pub compositor_proxy: Box<CompositorProxy + 'static + Send>,
@@ -75,34 +75,34 @@ pub struct CompositionPipeline {
 pub struct InitialPipelineState {
     /// The ID of the pipeline to create.
     pub id: PipelineId,
     /// The subpage ID of this pipeline to create in its pipeline parent.
     /// If `None`, this is the root.
     pub parent_info: Option<(PipelineId, SubpageId)>,
     /// A channel to the associated constellation.
     pub constellation_chan: ConstellationChan<ScriptMsg>,
-    /// A channel for the layout task to send messages to the constellation.
+    /// A channel for the layout thread to send messages to the constellation.
     pub layout_to_constellation_chan: ConstellationChan<LayoutMsg>,
-    /// A channel to the associated paint task.
+    /// A channel to the associated paint thread.
     pub painter_chan: ConstellationChan<PaintMsg>,
     /// A channel to schedule timer events.
     pub scheduler_chan: IpcSender<TimerEventRequest>,
     /// A channel to the compositor.
     pub compositor_proxy: Box<CompositorProxy + 'static + Send>,
     /// A channel to the developer tools, if applicable.
     pub devtools_chan: Option<Sender<DevtoolsControlMsg>>,
-    /// A channel to the image cache task.
-    pub image_cache_task: ImageCacheTask,
-    /// A channel to the font cache task.
-    pub font_cache_task: FontCacheTask,
-    /// A channel to the resource task.
-    pub resource_task: ResourceTask,
-    /// A channel to the storage task.
-    pub storage_task: StorageTask,
+    /// A channel to the image cache thread.
+    pub image_cache_thread: ImageCacheThread,
+    /// A channel to the font cache thread.
+    pub font_cache_thread: FontCacheThread,
+    /// A channel to the resource thread.
+    pub resource_thread: ResourceThread,
+    /// A channel to the storage thread.
+    pub storage_thread: StorageThread,
     /// A channel to the time profiler thread.
     pub time_profiler_chan: time::ProfilerChan,
     /// A channel to the memory profiler thread.
     pub mem_profiler_chan: profile_mem::ProfilerChan,
     /// Information about the initial window size.
     pub window_size: Option<TypedSize2D<PagePx, f32>>,
     /// Information about the device pixel ratio.
     pub device_pixel_ratio: ScaleFactor<ViewportPx, DevicePixel, f32>,
@@ -111,21 +111,21 @@ pub struct InitialPipelineState {
     pub script_chan: Option<IpcSender<ConstellationControlMsg>>,
     /// Information about the page to load.
     pub load_data: LoadData,
     /// The ID of the pipeline namespace for this script thread.
     pub pipeline_namespace_id: PipelineNamespaceId,
 }
 
 impl Pipeline {
-    /// Starts a paint task, layout task, and possibly a script task.
+    /// Starts a paint thread, layout thread, and possibly a script thread.
     /// Returns the channels wrapped in a struct.
     pub fn create<LTF, STF>(state: InitialPipelineState)
                             -> (Pipeline, UnprivilegedPipelineContent, PrivilegedPipelineContent)
-                            where LTF: LayoutTaskFactory, STF: ScriptTaskFactory {
+                            where LTF: LayoutThreadFactory, STF: ScriptThreadFactory {
         let (layout_to_paint_chan, layout_to_paint_port) = util::ipc::optional_ipc_channel();
         let (chrome_to_paint_chan, chrome_to_paint_port) = channel();
         let (paint_shutdown_chan, paint_shutdown_port) = ipc::channel().unwrap();
         let (layout_shutdown_chan, layout_shutdown_port) = ipc::channel().unwrap();
         let (pipeline_chan, pipeline_port) = ipc::channel().unwrap();
         let (script_to_compositor_chan, script_to_compositor_port) = ipc::channel().unwrap();
         let mut pipeline_port = Some(pipeline_port);
 
@@ -197,20 +197,20 @@ impl Pipeline {
                                      state.window_size);
 
         let unprivileged_pipeline_content = UnprivilegedPipelineContent {
             id: state.id,
             parent_info: state.parent_info,
             constellation_chan: state.constellation_chan,
             scheduler_chan: state.scheduler_chan,
             devtools_chan: script_to_devtools_chan,
-            image_cache_task: state.image_cache_task,
-            font_cache_task: state.font_cache_task.clone(),
-            resource_task: state.resource_task,
-            storage_task: state.storage_task,
+            image_cache_thread: state.image_cache_thread,
+            font_cache_thread: state.font_cache_thread.clone(),
+            resource_thread: state.resource_thread,
+            storage_thread: state.storage_thread,
             time_profiler_chan: state.time_profiler_chan.clone(),
             mem_profiler_chan: state.mem_profiler_chan.clone(),
             window_size: window_size,
             layout_to_constellation_chan: state.layout_to_constellation_chan,
             script_chan: script_chan,
             load_data: state.load_data.clone(),
             failure: failure,
             script_port: script_port,
@@ -226,17 +226,17 @@ impl Pipeline {
             script_content_process_shutdown_chan: script_content_process_shutdown_chan,
             script_content_process_shutdown_port: script_content_process_shutdown_port,
         };
 
         let privileged_pipeline_content = PrivilegedPipelineContent {
             id: state.id,
             painter_chan: state.painter_chan,
             compositor_proxy: state.compositor_proxy,
-            font_cache_task: state.font_cache_task,
+            font_cache_thread: state.font_cache_thread,
             time_profiler_chan: state.time_profiler_chan,
             mem_profiler_chan: state.mem_profiler_chan,
             load_data: state.load_data,
             failure: failure,
             layout_to_paint_port: layout_to_paint_port,
             chrome_to_paint_chan: chrome_to_paint_chan,
             chrome_to_paint_port: chrome_to_paint_port,
             paint_shutdown_chan: paint_shutdown_chan,
@@ -281,23 +281,23 @@ impl Pipeline {
     pub fn revoke_paint_permission(&self) {
         debug!("pipeline revoking paint channel paint permission");
         let _ = self.chrome_to_paint_chan.send(ChromeToPaintMsg::PaintPermissionRevoked);
     }
 
     pub fn exit(&self) {
         debug!("pipeline {:?} exiting", self.id);
 
-        // Script task handles shutting down layout, and layout handles shutting down the painter.
-        // For now, if the script task has failed, we give up on clean shutdown.
+        // Script thread handles shutting down layout, and layout handles shutting down the painter.
+        // For now, if the script thread has failed, we give up on clean shutdown.
         if self.script_chan
                .send(ConstellationControlMsg::ExitPipeline(self.id))
                .is_ok() {
-            // Wait until all slave tasks have terminated and run destructors
-            // NOTE: We don't wait for script task as we don't always own it
+            // Wait until all slave threads have terminated and run destructors
+            // NOTE: We don't wait for script thread as we don't always own it
             let _ = self.paint_shutdown_port.recv();
             let _ = self.layout_shutdown_port.recv();
         }
 
         // The compositor wants to know when pipelines shut down too.
         self.compositor_proxy.send(CompositorMsg::PipelineExited(self.id))
     }
 
@@ -350,20 +350,20 @@ impl Pipeline {
 pub struct UnprivilegedPipelineContent {
     id: PipelineId,
     parent_info: Option<(PipelineId, SubpageId)>,
     constellation_chan: ConstellationChan<ScriptMsg>,
     layout_to_constellation_chan: ConstellationChan<LayoutMsg>,
     scheduler_chan: IpcSender<TimerEventRequest>,
     devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
     script_to_compositor_chan: IpcSender<ScriptToCompositorMsg>,
-    image_cache_task: ImageCacheTask,
-    font_cache_task: FontCacheTask,
-    resource_task: ResourceTask,
-    storage_task: StorageTask,
+    image_cache_thread: ImageCacheThread,
+    font_cache_thread: FontCacheThread,
+    resource_thread: ResourceThread,
+    storage_thread: StorageThread,
     time_profiler_chan: time::ProfilerChan,
     mem_profiler_chan: profile_mem::ProfilerChan,
     window_size: Option<WindowSizeData>,
     script_chan: IpcSender<ConstellationControlMsg>,
     load_data: LoadData,
     failure: Failure,
     script_port: Option<IpcReceiver<ConstellationControlMsg>>,
     layout_to_paint_chan: OptionalIpcSender<LayoutToPaintMsg>,
@@ -375,52 +375,52 @@ pub struct UnprivilegedPipelineContent {
     layout_content_process_shutdown_chan: IpcSender<()>,
     layout_content_process_shutdown_port: IpcReceiver<()>,
     script_content_process_shutdown_chan: IpcSender<()>,
     script_content_process_shutdown_port: IpcReceiver<()>,
 }
 
 impl UnprivilegedPipelineContent {
     pub fn start_all<LTF, STF>(mut self, wait_for_completion: bool)
-                               where LTF: LayoutTaskFactory, STF: ScriptTaskFactory {
-        let layout_pair = ScriptTaskFactory::create_layout_channel(None::<&mut STF>);
+                               where LTF: LayoutThreadFactory, STF: ScriptThreadFactory {
+        let layout_pair = ScriptThreadFactory::create_layout_channel(None::<&mut STF>);
 
-        ScriptTaskFactory::create(None::<&mut STF>, InitialScriptState {
+        ScriptThreadFactory::create(None::<&mut STF>, InitialScriptState {
             id: self.id,
             parent_info: self.parent_info,
             compositor: self.script_to_compositor_chan,
             control_chan: self.script_chan.clone(),
             control_port: mem::replace(&mut self.script_port, None).unwrap(),
             constellation_chan: self.constellation_chan.clone(),
             layout_to_constellation_chan: self.layout_to_constellation_chan.clone(),
             scheduler_chan: self.scheduler_chan.clone(),
             failure_info: self.failure.clone(),
-            resource_task: self.resource_task,
-            storage_task: self.storage_task.clone(),
-            image_cache_task: self.image_cache_task.clone(),
+            resource_thread: self.resource_thread,
+            storage_thread: self.storage_thread.clone(),
+            image_cache_thread: self.image_cache_thread.clone(),
             time_profiler_chan: self.time_profiler_chan.clone(),
             mem_profiler_chan: self.mem_profiler_chan.clone(),
             devtools_chan: self.devtools_chan,
             window_size: self.window_size,
             pipeline_namespace_id: self.pipeline_namespace_id,
             content_process_shutdown_chan: self.script_content_process_shutdown_chan.clone(),
         }, &layout_pair, self.load_data.clone());
 
-        LayoutTaskFactory::create(None::<&mut LTF>,
+        LayoutThreadFactory::create(None::<&mut LTF>,
                                   self.id,
                                   self.load_data.url.clone(),
                                   self.parent_info.is_some(),
                                   layout_pair,
                                   self.pipeline_port.unwrap(),
                                   self.layout_to_constellation_chan,
                                   self.failure,
                                   self.script_chan.clone(),
                                   self.layout_to_paint_chan.clone(),
-                                  self.image_cache_task,
-                                  self.font_cache_task,
+                                  self.image_cache_thread,
+                                  self.font_cache_thread,
                                   self.time_profiler_chan,
                                   self.mem_profiler_chan,
                                   self.layout_shutdown_chan,
                                   self.layout_content_process_shutdown_chan.clone());
 
         if wait_for_completion {
             self.script_content_process_shutdown_port.recv().unwrap();
             self.layout_content_process_shutdown_port.recv().unwrap();
@@ -432,60 +432,60 @@ impl UnprivilegedPipelineContent {
     }
 }
 
 pub struct PrivilegedPipelineContent {
     id: PipelineId,
     painter_chan: ConstellationChan<PaintMsg>,
     compositor_proxy: Box<CompositorProxy + Send + 'static>,
     script_to_compositor_port: IpcReceiver<ScriptToCompositorMsg>,
-    font_cache_task: FontCacheTask,
+    font_cache_thread: FontCacheThread,
     time_profiler_chan: time::ProfilerChan,
     mem_profiler_chan: profile_mem::ProfilerChan,
     load_data: LoadData,
     failure: Failure,
     layout_to_paint_port: Receiver<LayoutToPaintMsg>,
     chrome_to_paint_chan: Sender<ChromeToPaintMsg>,
     chrome_to_paint_port: Receiver<ChromeToPaintMsg>,
     paint_shutdown_chan: IpcSender<()>,
 }
 
 impl PrivilegedPipelineContent {
     pub fn start_all(self) {
-        PaintTask::create(self.id,
+        PaintThread::create(self.id,
                           self.load_data.url,
                           self.chrome_to_paint_chan,
                           self.layout_to_paint_port,
                           self.chrome_to_paint_port,
                           self.compositor_proxy.clone_compositor_proxy(),
                           self.painter_chan,
-                          self.font_cache_task,
+                          self.font_cache_thread,
                           self.failure,
                           self.time_profiler_chan,
                           self.mem_profiler_chan,
                           self.paint_shutdown_chan);
 
         let compositor_proxy_for_script_listener_thread =
             self.compositor_proxy.clone_compositor_proxy();
         let script_to_compositor_port = self.script_to_compositor_port;
         thread::spawn(move || {
-            compositor_task::run_script_listener_thread(
+            compositor_thread::run_script_listener_thread(
                 compositor_proxy_for_script_listener_thread,
                 script_to_compositor_port)
         });
     }
 
-    pub fn start_paint_task(self) {
-        PaintTask::create(self.id,
+    pub fn start_paint_thread(self) {
+        PaintThread::create(self.id,
                           self.load_data.url,
                           self.chrome_to_paint_chan,
                           self.layout_to_paint_port,
                           self.chrome_to_paint_port,
                           self.compositor_proxy,
                           self.painter_chan,
-                          self.font_cache_task,
+                          self.font_cache_thread,
                           self.failure,
                           self.time_profiler_chan,
                           self.mem_profiler_chan,
                           self.paint_shutdown_chan);
 
     }
 }
--- a/servo/components/compositing/scrolling.rs
+++ b/servo/components/compositing/scrolling.rs
@@ -1,15 +1,15 @@
 /* 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/. */
 
-//! A timer thread that gives the painting task a little time to catch up when the user scrolls.
+//! A timer thread that gives the painting thread a little time to catch up when the user scrolls.
 
-use compositor_task::{CompositorProxy, Msg};
+use compositor_thread::{CompositorProxy, Msg};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread::{self, Builder};
 use time;
 use util::time::duration_from_nanoseconds;
 
 /// The amount of time in nanoseconds that we give to the painting thread to paint new tiles upon
 /// processing a scroll event that caused new tiles to be revealed. When this expires, we give up
 /// and composite anyway (showing a "checkerboard") to avoid dropping the frame.
--- a/servo/components/compositing/surface_map.rs
+++ b/servo/components/compositing/surface_map.rs
@@ -4,17 +4,17 @@
 
 use euclid::size::Size2D;
 use layers::platform::surface::{NativeDisplay, NativeSurface};
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::hash::{Hash, Hasher};
 
 /// This is a struct used to store surfaces when they are not in use.
-/// The paint task can quickly query for a particular size of surface when it
+/// The paint thread can quickly query for a particular size of surface when it
 /// needs it.
 pub struct SurfaceMap {
     /// A HashMap that stores the Buffers.
     map: HashMap<SurfaceKey, SurfaceValue>,
     /// The current amount of memory stored by the SurfaceMap's surfaces.
     mem: usize,
     /// The maximum allowed memory. Unused surfaces will be deleted
     /// when this threshold is exceeded.
--- a/servo/components/compositing/timer_scheduler.rs
+++ b/servo/components/compositing/timer_scheduler.rs
@@ -11,17 +11,17 @@ use script_traits::{TimerEvent, TimerEve
 use std::cell::RefCell;
 use std::cmp::{self, Ord};
 use std::collections::BinaryHeap;
 use std::sync::Arc;
 use std::sync::atomic::{self, AtomicBool};
 use std::sync::mpsc::{channel, Receiver, Select};
 use std::thread::{self, spawn, Thread};
 use std::time::Duration;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 /// A quick hack to work around the removal of [`std::old_io::timer::Timer`](
 /// http://doc.rust-lang.org/1.0.0-beta/std/old_io/timer/struct.Timer.html )
 struct CancelableOneshotTimer {
     thread: Thread,
     canceled: Arc<AtomicBool>,
     port: Receiver<()>,
 }
@@ -124,18 +124,18 @@ impl TimerScheduler {
         spawn_named("TimerScheduler".to_owned(), move || {
             timer_scheduler.run_event_loop();
         });
 
         chan
     }
 
     fn run_event_loop(&self) {
-        while let Some(task) = self.receive_next_task() {
-            match task {
+        while let Some(thread) = self.receive_next_task() {
+            match thread {
                 Task::HandleRequest(request) => self.handle_request(request),
                 Task::DispatchDueEvents => self.dispatch_due_events(),
             }
         }
     }
 
     #[allow(unsafe_code)]
     fn receive_next_task(&self) -> Option<Task> {
--- a/servo/components/compositing/windowing.rs
+++ b/servo/components/compositing/windowing.rs
@@ -1,15 +1,15 @@
 /* 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/. */
 
 //! Abstract windowing methods. The concrete implementations of these can be found in `platform/`.
 
-use compositor_task::{CompositorProxy, CompositorReceiver};
+use compositor_thread::{CompositorProxy, CompositorReceiver};
 use euclid::point::TypedPoint2D;
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::TypedSize2D;
 use euclid::{Point2D, Size2D};
 use layers::geometry::DevicePixel;
 use layers::platform::surface::NativeDisplay;
 use msg::constellation_msg::{Key, KeyModifiers, KeyState, MouseButton};
 use net_traits::net_error_list::NetError;
@@ -36,17 +36,17 @@ pub enum WindowNavigateMsg {
 /// Events that the windowing system sends to Servo.
 #[derive(Clone)]
 pub enum WindowEvent {
     /// Sent when no message has arrived, but the event loop was kicked for some reason (perhaps
     /// by another Servo subsystem).
     ///
     /// FIXME(pcwalton): This is kind of ugly and may not work well with multiprocess Servo.
     /// It's possible that this should be something like
-    /// `CompositorMessageWindowEvent(compositor_task::Msg)` instead.
+    /// `CompositorMessageWindowEvent(compositor_thread::Msg)` instead.
     Idle,
     /// Sent when part of the window is marked dirty and needs to be redrawn. Before sending this
     /// message, the window must make the same GL context as in `PrepareRenderingEvent` current.
     Refresh,
     /// Sent to initialize the GL context. The windowing system must have a valid, current GL
     /// context when this message is sent.
     InitializeCompositing,
     /// Sent when the window is resized.
--- a/servo/components/devtools/actors/timeline.rs
+++ b/servo/components/devtools/actors/timeline.rs
@@ -13,17 +13,17 @@ use msg::constellation_msg::PipelineId;
 use protocol::JsonPacketStream;
 use rustc_serialize::{Encodable, Encoder, json};
 use std::cell::RefCell;
 use std::net::TcpStream;
 use std::sync::mpsc::channel;
 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
-use util::task;
+use util::thread::spawn_named;
 
 pub struct TimelineActor {
     name: String,
     script_sender: IpcSender<DevtoolScriptControlMsg>,
     marker_types: Vec<TimelineMarkerType>,
     pipeline: PipelineId,
     is_recording: Arc<Mutex<bool>>,
     stream: RefCell<Option<TcpStream>>,
@@ -142,17 +142,17 @@ impl TimelineActor {
 
     fn pull_timeline_data(&self, receiver: IpcReceiver<TimelineMarker>, mut emitter: Emitter) {
         let is_recording = self.is_recording.clone();
 
         if !*is_recording.lock().unwrap() {
             return;
         }
 
-        task::spawn_named("PullTimelineMarkers".to_owned(), move || {
+        spawn_named("PullTimelineMarkers".to_owned(), move || {
             loop {
                 if !*is_recording.lock().unwrap() {
                     break;
                 }
 
                 let mut markers = vec![];
                 while let Ok(marker) = receiver.try_recv() {
                     markers.push(emitter.marker(marker));
--- a/servo/components/devtools/lib.rs
+++ b/servo/components/devtools/lib.rs
@@ -53,17 +53,17 @@ use std::borrow::ToOwned;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::error::Error;
 use std::net::{Shutdown, TcpListener, TcpStream};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::sync::{Arc, Mutex};
 use time::precise_time_ns;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 mod actor;
 /// Corresponds to http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/
 mod actors {
     pub mod console;
     pub mod framerate;
     pub mod inspector;
     pub mod memory;
@@ -501,17 +501,17 @@ fn run_server(sender: Sender<DevtoolsCon
                 actors.register(box actor);
                 actor_name
             }
         }
     }
 
     let sender_clone = sender.clone();
     spawn_named("DevtoolsClientAcceptor".to_owned(), move || {
-        // accept connections and process them, spawning a new task for each one
+        // accept connections and process them, spawning a new thread for each one
         for stream in listener.incoming() {
             // connection succeeded
             sender_clone.send(DevtoolsControlMsg::FromChrome(
                     ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()))).unwrap();
         }
     });
 
     while let Ok(msg) = receiver.recv() {
--- a/servo/components/devtools_traits/lib.rs
+++ b/servo/components/devtools_traits/lib.rs
@@ -43,19 +43,19 @@ use url::Url;
 pub struct DevtoolsPageInfo {
     pub title: String,
     pub url: Url
 }
 
 /// Messages to instruct the devtools server to update its known actors/state
 /// according to changes in the browser.
 pub enum DevtoolsControlMsg {
-    /// Messages from tasks in the chrome process (resource/constellation/devtools)
+    /// Messages from threads in the chrome process (resource/constellation/devtools)
     FromChrome(ChromeToDevtoolsControlMsg),
-    /// Messages from script tasks
+    /// Messages from script threads
     FromScript(ScriptToDevtoolsControlMsg),
 }
 
 /// Events that the devtools server must act upon.
 pub enum ChromeToDevtoolsControlMsg {
     /// A new client has connected to the server.
     AddClient(TcpStream),
     /// The browser is shutting down.
@@ -70,17 +70,17 @@ pub enum ChromeToDevtoolsControlMsg {
 pub enum ScriptToDevtoolsControlMsg {
     /// A new global object was created, associated with a particular pipeline.
     /// The means of communicating directly with it are provided.
     NewGlobal((PipelineId, Option<WorkerId>),
               IpcSender<DevtoolScriptControlMsg>,
               DevtoolsPageInfo),
     /// A particular page has invoked the console API.
     ConsoleAPI(PipelineId, ConsoleMessage, Option<WorkerId>),
-    /// An animation frame with the given timestamp was processed in a script task.
+    /// An animation frame with the given timestamp was processed in a script thread.
     /// The actor with the provided name should be notified.
     FramerateTick(String, f64),
 }
 
 /// Serialized JS return values
 /// TODO: generalize this beyond the EvaluateJS message?
 #[derive(Deserialize, Serialize)]
 pub enum EvaluateJSReply {
@@ -144,17 +144,17 @@ pub enum TimelineMarkerType {
 
 /// The properties of a DOM node as computed by layout.
 #[derive(Deserialize, Serialize)]
 pub struct ComputedNodeLayout {
     pub width: f32,
     pub height: f32,
 }
 
-/// Messages to process in a particular script task, as instructed by a devtools client.
+/// Messages to process in a particular script thread, as instructed by a devtools client.
 #[derive(Deserialize, Serialize)]
 pub enum DevtoolScriptControlMsg {
     /// Evaluate a JS snippet in the context of the global for the given pipeline.
     EvaluateJS(PipelineId, String, IpcSender<EvaluateJSReply>),
     /// Retrieve the details of the root node (ie. the document) for the given pipeline.
     GetRootNode(PipelineId, IpcSender<NodeInfo>),
     /// Retrieve the details of the document element for the given pipeline.
     GetDocumentElement(PipelineId, IpcSender<NodeInfo>),
--- a/servo/components/gfx/display_list/mod.rs
+++ b/servo/components/gfx/display_list/mod.rs
@@ -20,17 +20,17 @@ use azure::azure_hl::{Color, DrawTarget}
 use display_list::optimizer::DisplayListOptimizer;
 use euclid::approxeq::ApproxEq;
 use euclid::num::Zero;
 use euclid::{Matrix2D, Matrix4, Point2D, Rect, SideOffsets2D, Size2D};
 use gfx_traits::{color, LayerId, LayerKind, ScrollPolicy};
 use msg::constellation_msg::PipelineId;
 use net_traits::image::base::Image;
 use paint_context::PaintContext;
-use paint_task::{PaintLayerContents, PaintLayer};
+use paint_thread::{PaintLayerContents, PaintLayer};
 use self::DisplayItem::*;
 use self::DisplayItemIterator::*;
 use smallvec::SmallVec;
 use std::cmp::Ordering;
 use std::collections::linked_list::{self, LinkedList};
 use std::fmt;
 use std::mem;
 use std::slice::Iter;
@@ -1135,17 +1135,17 @@ impl ClippingRegion {
                     radii: complex.radii,
                 }
             }).collect(),
         }
     }
 }
 
 
-/// Metadata attached to each display item. This is useful for performing auxiliary tasks with
+/// Metadata attached to each display item. This is useful for performing auxiliary threads with
 /// the display list involving hit testing: finding the originating DOM node and determining the
 /// cursor to use when the element is hovered over.
 #[derive(Clone, Copy, HeapSizeOf, Deserialize, Serialize)]
 pub struct DisplayItemMetadata {
     /// The DOM node from which this display item originated.
     pub node: OpaqueNode,
     /// The value of the `cursor` property when the mouse hovers over this display item. If `None`,
     /// this display item is ineligible for pointer events (`pointer-events: none`).
rename from servo/components/gfx/font_cache_task.rs
rename to servo/components/gfx/font_cache_thread.rs
--- a/servo/components/gfx/font_cache_task.rs
+++ b/servo/components/gfx/font_cache_thread.rs
@@ -1,17 +1,17 @@
 /* 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/. */
 
 use font_template::{FontTemplate, FontTemplateDescriptor};
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use mime::{TopLevel, SubLevel};
-use net_traits::{AsyncResponseTarget, LoadContext, PendingAsyncLoad, ResourceTask, ResponseAction};
+use net_traits::{AsyncResponseTarget, LoadContext, PendingAsyncLoad, ResourceThread, ResponseAction};
 use platform::font_context::FontContextHandle;
 use platform::font_list::for_each_available_family;
 use platform::font_list::for_each_variation;
 use platform::font_list::last_resort_font_families;
 use platform::font_list::system_default_family;
 use platform::font_template::FontTemplateData;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
@@ -19,17 +19,17 @@ use std::mem;
 use std::sync::mpsc::channel;
 use std::sync::{Arc, Mutex};
 use string_cache::Atom;
 use style::font_face::Source;
 use style::properties::longhands::font_family::computed_value::FontFamily;
 use url::Url;
 use util::prefs;
 use util::str::LowercaseString;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 /// A list of font templates that make up a given font family.
 struct FontTemplates {
     templates: Vec<FontTemplate>,
 }
 
 impl FontTemplates {
     fn new() -> FontTemplates {
@@ -74,42 +74,42 @@ impl FontTemplates {
             }
         }
 
         let template = FontTemplate::new(identifier, maybe_data);
         self.templates.push(template);
     }
 }
 
-/// Commands that the FontContext sends to the font cache task.
+/// Commands that the FontContext sends to the font cache thread.
 #[derive(Deserialize, Serialize, Debug)]
 pub enum Command {
     GetFontTemplate(FontFamily, FontTemplateDescriptor, IpcSender<Reply>),
     GetLastResortFontTemplate(FontTemplateDescriptor, IpcSender<Reply>),
     AddWebFont(FontFamily, Source, IpcSender<()>),
     AddDownloadedWebFont(FontFamily, Url, Vec<u8>, IpcSender<()>),
     Exit(IpcSender<()>),
 }
 
-/// Reply messages sent from the font cache task to the FontContext caller.
+/// Reply messages sent from the font cache thread to the FontContext caller.
 #[derive(Deserialize, Serialize, Debug)]
 pub enum Reply {
     GetFontTemplateReply(Option<Arc<FontTemplateData>>),
 }
 
-/// The font cache task itself. It maintains a list of reference counted
+/// The font cache thread itself. It maintains a list of reference counted
 /// font templates that are currently in use.
 struct FontCache {
     port: IpcReceiver<Command>,
     channel_to_self: IpcSender<Command>,
     generic_fonts: HashMap<FontFamily, LowercaseString>,
     local_families: HashMap<LowercaseString, FontTemplates>,
     web_families: HashMap<LowercaseString, FontTemplates>,
     font_context: FontContextHandle,
-    resource_task: ResourceTask,
+    resource_thread: ResourceThread,
 }
 
 fn populate_generic_fonts() -> HashMap<FontFamily, LowercaseString> {
     let mut generic_fonts = HashMap::with_capacity(5);
 
     append_map(&mut generic_fonts, FontFamily::Serif, "Times New Roman");
     append_map(&mut generic_fonts, FontFamily::SansSerif, "Arial");
     append_map(&mut generic_fonts, FontFamily::Cursive, "Apple Chancery");
@@ -154,17 +154,17 @@ impl FontCache {
                         let templates = FontTemplates::new();
                         self.web_families.insert(family_name.clone(), templates);
                     }
 
                     match src {
                         Source::Url(ref url_source) => {
                             let url = &url_source.url;
                             let load = PendingAsyncLoad::new(LoadContext::Font,
-                                                             self.resource_task.clone(),
+                                                             self.resource_thread.clone(),
                                                              url.clone(),
                                                              None);
                             let (data_sender, data_receiver) = ipc::channel().unwrap();
                             let data_target = AsyncResponseTarget {
                                 sender: data_sender,
                             };
                             load.load_async(data_target);
                             let channel_to_self = self.channel_to_self.clone();
@@ -306,47 +306,47 @@ impl FontCache {
                 return family;
             }
         }
 
         panic!("Unable to find any fonts that match (do you have fallback fonts installed?)");
     }
 }
 
-/// The public interface to the font cache task, used exclusively by
-/// the per-thread/task FontContext structures.
+/// The public interface to the font cache thread, used exclusively by
+/// the per-thread/thread FontContext structures.
 #[derive(Clone, Deserialize, Serialize, Debug)]
-pub struct FontCacheTask {
+pub struct FontCacheThread {
     chan: IpcSender<Command>,
 }
 
-impl FontCacheTask {
-    pub fn new(resource_task: ResourceTask) -> FontCacheTask {
+impl FontCacheThread {
+    pub fn new(resource_thread: ResourceThread) -> FontCacheThread {
         let (chan, port) = ipc::channel().unwrap();
 
         let channel_to_self = chan.clone();
-        spawn_named("FontCacheTask".to_owned(), move || {
+        spawn_named("FontCacheThread".to_owned(), move || {
             // TODO: Allow users to specify these.
             let generic_fonts = populate_generic_fonts();
 
             let mut cache = FontCache {
                 port: port,
                 channel_to_self: channel_to_self,
                 generic_fonts: generic_fonts,
                 local_families: HashMap::new(),
                 web_families: HashMap::new(),
                 font_context: FontContextHandle::new(),
-                resource_task: resource_task,
+                resource_thread: resource_thread,
             };
 
             cache.refresh_local_families();
             cache.run();
         });
 
-        FontCacheTask {
+        FontCacheThread {
             chan: chan,
         }
     }
 
     pub fn find_font_template(&self, family: FontFamily, desc: FontTemplateDescriptor)
                                                 -> Option<Arc<FontTemplateData>> {
 
         let (response_chan, response_port) = ipc::channel().unwrap();
--- a/servo/components/gfx/font_context.rs
+++ b/servo/components/gfx/font_context.rs
@@ -6,17 +6,17 @@ use app_units::Au;
 use azure::azure_hl::BackendType;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use azure::scaled_font::FontInfo;
 use azure::scaled_font::ScaledFont;
 use fnv::FnvHasher;
 use font::FontHandleMethods;
 use font::SpecifiedFontStyle;
 use font::{Font, FontGroup};
-use font_cache_task::FontCacheTask;
+use font_cache_thread::FontCacheThread;
 use font_template::FontTemplateDescriptor;
 use platform::font::FontHandle;
 use platform::font_context::FontContextHandle;
 use platform::font_template::FontTemplateData;
 use smallvec::SmallVec;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::collections::hash_state::DefaultState;
@@ -50,58 +50,58 @@ struct LayoutFontCacheEntry {
     font: Option<Rc<RefCell<Font>>>,
 }
 
 #[derive(Debug)]
 struct FallbackFontCacheEntry {
     font: Rc<RefCell<Font>>,
 }
 
-/// A cached azure font (per paint task) that
+/// A cached azure font (per paint thread) that
 /// can be shared by multiple text runs.
 #[derive(Debug)]
 struct PaintFontCacheEntry {
     pt_size: Au,
     identifier: Atom,
     font: Rc<RefCell<ScaledFont>>,
 }
 
 /// An epoch for the font context cache. The cache is flushed if the current epoch does not match
 /// this one.
 static FONT_CACHE_EPOCH: AtomicUsize = ATOMIC_USIZE_INIT;
 
-/// The FontContext represents the per-thread/task state necessary for
+/// The FontContext represents the per-thread/thread state necessary for
 /// working with fonts. It is the public API used by the layout and
-/// paint code. It talks directly to the font cache task where
+/// paint code. It talks directly to the font cache thread where
 /// required.
 #[derive(Debug)]
 pub struct FontContext {
     platform_handle: FontContextHandle,
-    font_cache_task: FontCacheTask,
+    font_cache_thread: FontCacheThread,
 
     /// TODO: See bug https://github.com/servo/servo/issues/3300.
     layout_font_cache: Vec<LayoutFontCacheEntry>,
     fallback_font_cache: Vec<FallbackFontCacheEntry>,
 
     /// Strong reference as the paint FontContext is (for now) recycled
     /// per frame. TODO: Make this weak when incremental redraw is done.
     paint_font_cache: Vec<PaintFontCacheEntry>,
 
     layout_font_group_cache:
         HashMap<LayoutFontGroupCacheKey, Rc<FontGroup>, DefaultState<FnvHasher>>,
 
     epoch: usize,
 }
 
 impl FontContext {
-    pub fn new(font_cache_task: FontCacheTask) -> FontContext {
+    pub fn new(font_cache_thread: FontCacheThread) -> FontContext {
         let handle = FontContextHandle::new();
         FontContext {
             platform_handle: handle,
-            font_cache_task: font_cache_task,
+            font_cache_thread: font_cache_thread,
             layout_font_cache: vec!(),
             fallback_font_cache: vec!(),
             paint_font_cache: vec!(),
             layout_font_group_cache: HashMap::with_hash_state(Default::default()),
             epoch: 0,
         }
     }
 
@@ -197,17 +197,17 @@ impl FontContext {
                                 break;
                             }
                         }
                     }
                 }
             }
 
             if !cache_hit {
-                let font_template = self.font_cache_task.find_font_template(family.clone(),
+                let font_template = self.font_cache_thread.find_font_template(family.clone(),
                                                                             desc.clone());
                 match font_template {
                     Some(font_template) => {
                         let layout_font = self.create_layout_font(font_template,
                                                                   desc.clone(),
                                                                   style.font_size,
                                                                   style.font_variant);
                         let font = match layout_font {
@@ -246,17 +246,17 @@ impl FontContext {
                             cached_font.variant == style.font_variant {
                     fonts.push(cached_font_entry.font.clone());
                     cache_hit = true;
                     break;
                 }
             }
 
             if !cache_hit {
-                let font_template = self.font_cache_task.last_resort_font_template(desc.clone());
+                let font_template = self.font_cache_thread.last_resort_font_template(desc.clone());
                 let layout_font = self.create_layout_font(font_template,
                                                           desc.clone(),
                                                           style.font_size,
                                                           style.font_variant);
                 match layout_font {
                     Ok(layout_font) => {
                         let layout_font = Rc::new(RefCell::new(layout_font));
                         self.fallback_font_cache.push(FallbackFontCacheEntry {
@@ -291,19 +291,19 @@ impl FontContext {
         self.paint_font_cache.push(PaintFontCacheEntry {
             font: paint_font.clone(),
             pt_size: pt_size,
             identifier: template.identifier.clone(),
         });
         paint_font
     }
 
-    /// Returns a reference to the font cache task.
-    pub fn font_cache_task(&self) -> FontCacheTask {
-        self.font_cache_task.clone()
+    /// Returns a reference to the font cache thread.
+    pub fn font_cache_thread(&self) -> FontCacheThread {
+        self.font_cache_thread.clone()
     }
 }
 
 impl HeapSizeOf for FontContext {
     fn heap_size_of_children(&self) -> usize {
         // FIXME(njn): Measure other fields eventually.
         self.platform_handle.heap_size_of_children()
     }
--- a/servo/components/gfx/lib.rs
+++ b/servo/components/gfx/lib.rs
@@ -86,21 +86,21 @@ mod filters;
 mod paint_context;
 
 #[deny(unsafe_code)]
 #[path = "display_list/mod.rs"]
 pub mod display_list;
 
 // Fonts
 pub mod font;
-pub mod font_cache_task;
+pub mod font_cache_thread;
 pub mod font_context;
 pub mod font_template;
 
-pub mod paint_task;
+pub mod paint_thread;
 
 // Platform-specific implementations.
 #[path = "platform/mod.rs"]
 pub mod platform;
 
 // Text
 #[path = "text/mod.rs"]
 pub mod text;
rename from servo/components/gfx/paint_task.rs
rename to servo/components/gfx/paint_thread.rs
--- a/servo/components/gfx/paint_task.rs
+++ b/servo/components/gfx/paint_thread.rs
@@ -1,24 +1,24 @@
 /* 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/. */
 
-//! The task that handles all painting.
+//! The thread that handles all painting.
 
 use app_units::Au;
 use azure::AzFloat;
 use azure::azure_hl::{BackendType, Color, DrawTarget, SurfaceFormat};
 use canvas_traits::CanvasMsg;
 use display_list::{DisplayItem, DisplayList, LayerInfo, StackingContext};
 use euclid::Matrix4;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::size::Size2D;
-use font_cache_task::FontCacheTask;
+use font_cache_thread::FontCacheThread;
 use font_context::FontContext;
 use gfx_traits::{color, LayerId, LayerKind, LayerProperties, PaintListener, PaintMsg as ConstellationMsg, ScrollPolicy};
 use ipc_channel::ipc::IpcSender;
 use layers::layers::{BufferRequest, LayerBuffer, LayerBufferSet};
 use layers::platform::surface::{NativeDisplay, NativeSurface};
 use msg::compositor_msg::{Epoch, FrameTreeId};
 use msg::constellation_msg::{ConstellationChan, Failure, PipelineId};
 use paint_context::PaintContext;
@@ -29,26 +29,26 @@ use skia::gl_context::GLContext;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::mem as std_mem;
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Select, Sender, channel};
 use url::Url;
 use util::geometry::{ExpandToPixelBoundaries};
 use util::opts;
-use util::task;
-use util::task_state;
+use util::thread;
+use util::thread_state;
 
 #[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
 pub enum PaintLayerContents {
     StackingContext(Arc<StackingContext>),
     DisplayList(Arc<DisplayList>),
 }
 
-/// Information about a hardware graphics layer that layout sends to the painting task.
+/// Information about a hardware graphics layer that layout sends to the painting thread.
 #[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
 pub struct PaintLayer {
     /// A per-pipeline ID describing this layer that should be stable across reflows.
     pub id: LayerId,
     /// The color of the background in this layer. Used for unpainted content.
     pub background_color: Color,
     /// The content of this layer, which is either a stacking context or a display list.
     pub contents: PaintLayerContents,
@@ -200,109 +200,109 @@ pub enum LayoutToPaintMsg {
 pub enum ChromeToPaintMsg {
     Paint(Vec<PaintRequest>, FrameTreeId),
     PaintPermissionGranted,
     PaintPermissionRevoked,
     CollectReports(ReportsChan),
     Exit,
 }
 
-pub struct PaintTask<C> {
+pub struct PaintThread<C> {
     id: PipelineId,
     _url: Url,
     layout_to_paint_port: Receiver<LayoutToPaintMsg>,
     chrome_to_paint_port: Receiver<ChromeToPaintMsg>,
     compositor: C,
 
     /// A channel to the time profiler.
     time_profiler_chan: time::ProfilerChan,
 
     /// The root paint layer sent to us by the layout thread.
     root_paint_layer: Option<Arc<PaintLayer>>,
 
     /// Permission to send paint messages to the compositor
     paint_permission: bool,
 
-    /// The current epoch counter is passed by the layout task
+    /// The current epoch counter is passed by the layout thread
     current_epoch: Option<Epoch>,
 
     /// Communication handles to each of the worker threads.
     worker_threads: Vec<WorkerThreadProxy>,
 
     /// A map to track the canvas specific layers
     canvas_map: HashMap<LayerId, IpcSender<CanvasMsg>>,
 }
 
 // If we implement this as a function, we get borrowck errors from borrowing
-// the whole PaintTask struct.
+// the whole PaintThread struct.
 macro_rules! native_display(
-    ($task:expr) => (
-        $task.native_display.as_ref().expect("Need a graphics context to do painting")
+    ($thread:expr) => (
+        $thread.native_display.as_ref().expect("Need a graphics context to do painting")
     )
 );
 
-impl<C> PaintTask<C> where C: PaintListener + Send + 'static {
+impl<C> PaintThread<C> where C: PaintListener + Send + 'static {
     pub fn create(id: PipelineId,
                   url: Url,
                   chrome_to_paint_chan: Sender<ChromeToPaintMsg>,
                   layout_to_paint_port: Receiver<LayoutToPaintMsg>,
                   chrome_to_paint_port: Receiver<ChromeToPaintMsg>,
                   compositor: C,
                   constellation_chan: ConstellationChan<ConstellationMsg>,
-                  font_cache_task: FontCacheTask,
+                  font_cache_thread: FontCacheThread,
                   failure_msg: Failure,
                   time_profiler_chan: time::ProfilerChan,
                   mem_profiler_chan: mem::ProfilerChan,
                   shutdown_chan: IpcSender<()>) {
         let ConstellationChan(c) = constellation_chan.clone();
-        task::spawn_named_with_send_on_failure(format!("PaintTask {:?}", id),
-                                               task_state::PAINT,
+        thread::spawn_named_with_send_on_failure(format!("PaintThread {:?}", id),
+                                               thread_state::PAINT,
                                                move || {
             {
-                // Ensures that the paint task and graphics context are destroyed before the
+                // Ensures that the paint thread and graphics context are destroyed before the
                 // shutdown message.
                 let mut compositor = compositor;
                 let native_display = compositor.native_display().map(
                     |display| display);
                 let worker_threads = WorkerThreadProxy::spawn(native_display.clone(),
-                                                              font_cache_task,
+                                                              font_cache_thread,
                                                               time_profiler_chan.clone());
 
-                let mut paint_task = PaintTask {
+                let mut paint_thread = PaintThread {
                     id: id,
                     _url: url,
                     layout_to_paint_port: layout_to_paint_port,
                     chrome_to_paint_port: chrome_to_paint_port,
                     compositor: compositor,
                     time_profiler_chan: time_profiler_chan,
                     root_paint_layer: None,
                     paint_permission: false,
                     current_epoch: None,
                     worker_threads: worker_threads,
                     canvas_map: HashMap::new()
                 };
 
                 let reporter_name = format!("paint-reporter-{}", id);
                 mem_profiler_chan.run_with_memory_reporting(|| {
-                    paint_task.start();
+                    paint_thread.start();
                 }, reporter_name, chrome_to_paint_chan, ChromeToPaintMsg::CollectReports);
 
                 // Tell all the worker threads to shut down.
-                for worker_thread in &mut paint_task.worker_threads {
+                for worker_thread in &mut paint_thread.worker_threads {
                     worker_thread.exit()
                 }
             }
 
-            debug!("paint_task: shutdown_chan send");
+            debug!("paint_thread: shutdown_chan send");
             shutdown_chan.send(()).unwrap();
         }, ConstellationMsg::Failure(failure_msg), c);
     }
 
     fn start(&mut self) {
-        debug!("PaintTask: beginning painting loop");
+        debug!("PaintThread: beginning painting loop");
 
         loop {
             let message = {
                 let select = Select::new();
                 let mut layout_to_paint_handle = select.handle(&self.layout_to_paint_port);
                 let mut chrome_to_paint_handle = select.handle(&self.chrome_to_paint_port);
                 unsafe {
                     layout_to_paint_handle.add();
@@ -335,24 +335,24 @@ impl<C> PaintTask<C> where C: PaintListe
                 Msg::FromChrome(ChromeToPaintMsg::Paint(requests, frame_tree_id)) => {
                     if self.paint_permission && self.root_paint_layer.is_some() {
                         let mut replies = Vec::new();
                         for PaintRequest { buffer_requests, scale, layer_id, epoch, layer_kind }
                               in requests {
                             if self.current_epoch == Some(epoch) {
                                 self.paint(&mut replies, buffer_requests, scale, layer_id, layer_kind);
                             } else {
-                                debug!("PaintTask: Ignoring requests with epoch mismatch: {:?} != {:?}",
+                                debug!("PaintThread: Ignoring requests with epoch mismatch: {:?} != {:?}",
                                        self.current_epoch,
                                        epoch);
                                 self.compositor.ignore_buffer_requests(buffer_requests);
                             }
                         }
 
-                        debug!("PaintTask: returning surfaces");
+                        debug!("PaintThread: returning surfaces");
                         self.compositor.assign_painted_buffers(self.id,
                                                                self.current_epoch.unwrap(),
                                                                replies,
                                                                frame_tree_id);
                     }
                 }
                 Msg::FromChrome(ChromeToPaintMsg::PaintPermissionGranted) => {
                     self.paint_permission = true;
@@ -360,34 +360,34 @@ impl<C> PaintTask<C> where C: PaintListe
                     if self.root_paint_layer.is_some() {
                         self.initialize_layers();
                     }
                 }
                 Msg::FromChrome(ChromeToPaintMsg::PaintPermissionRevoked) => {
                     self.paint_permission = false;
                 }
                 Msg::FromChrome(ChromeToPaintMsg::CollectReports(ref channel)) => {
-                    // FIXME(njn): should eventually measure the paint task.
+                    // FIXME(njn): should eventually measure the paint thread.
                     channel.send(Vec::new())
                 }
                 Msg::FromLayout(LayoutToPaintMsg::Exit(ref response_channel)) => {
-                    // Ask the compositor to remove any layers it is holding for this paint task.
+                    // Ask the compositor to remove any layers it is holding for this paint thread.
                     // FIXME(mrobinson): This can probably move back to the constellation now.
-                    self.compositor.notify_paint_task_exiting(self.id);
+                    self.compositor.notify_paint_thread_exiting(self.id);
 
-                    debug!("PaintTask: Exiting.");
+                    debug!("PaintThread: Exiting.");
                     let _ = response_channel.send(());
                     break;
                 }
                 Msg::FromChrome(ChromeToPaintMsg::Exit) => {
-                    // Ask the compositor to remove any layers it is holding for this paint task.
+                    // Ask the compositor to remove any layers it is holding for this paint thread.
                     // FIXME(mrobinson): This can probably move back to the constellation now.
-                    self.compositor.notify_paint_task_exiting(self.id);
+                    self.compositor.notify_paint_thread_exiting(self.id);
 
-                    debug!("PaintTask: Exiting.");
+                    debug!("PaintThread: Exiting.");
                     break;
                 }
             }
         }
     }
 
     /// Paints one layer and places the painted tiles in `replies`.
     fn paint(&mut self,
@@ -541,34 +541,34 @@ impl<C> PaintTask<C> where C: PaintListe
 
 struct WorkerThreadProxy {
     sender: Sender<MsgToWorkerThread>,
     receiver: Receiver<MsgFromWorkerThread>,
 }
 
 impl WorkerThreadProxy {
     fn spawn(native_display: Option<NativeDisplay>,
-             font_cache_task: FontCacheTask,
+             font_cache_thread: FontCacheThread,
              time_profiler_chan: time::ProfilerChan)
              -> Vec<WorkerThreadProxy> {
         let thread_count = if opts::get().gpu_painting {
             1
         } else {
             opts::get().paint_threads
         };
         (0..thread_count).map(|_| {
             let (from_worker_sender, from_worker_receiver) = channel();
             let (to_worker_sender, to_worker_receiver) = channel();
-            let font_cache_task = font_cache_task.clone();
+            let font_cache_thread = font_cache_thread.clone();
             let time_profiler_chan = time_profiler_chan.clone();
-            task::spawn_named("PaintWorker".to_owned(), move || {
+            thread::spawn_named("PaintWorker".to_owned(), move || {
                 let mut worker_thread = WorkerThread::new(from_worker_sender,
                                                           to_worker_receiver,
                                                           native_display,
-                                                          font_cache_task,
+                                                          font_cache_thread,
                                                           time_profiler_chan);
                 worker_thread.main();
             });
             WorkerThreadProxy {
                 receiver: from_worker_receiver,
                 sender: to_worker_sender,
             }
         }).collect()
@@ -624,25 +624,25 @@ fn create_gl_context(native_display: Opt
         }
     }
 }
 
 impl WorkerThread {
     fn new(sender: Sender<MsgFromWorkerThread>,
            receiver: Receiver<MsgToWorkerThread>,
            native_display: Option<NativeDisplay>,
-           font_cache_task: FontCacheTask,
+           font_cache_thread: FontCacheThread,
            time_profiler_sender: time::ProfilerChan)
            -> WorkerThread {
         let gl_context = create_gl_context(native_display);
         WorkerThread {
             sender: sender,
             receiver: receiver,
             native_display: native_display,
-            font_context: box FontContext::new(font_cache_task.clone()),
+            font_context: box FontContext::new(font_cache_thread.clone()),
             time_profiler_sender: time_profiler_sender,
             gl_context: gl_context,
         }
     }
 
     fn main(&mut self) {
         loop {
             match self.receiver.recv().unwrap() {
@@ -772,17 +772,17 @@ impl WorkerThread {
         buffer
     }
 
     fn create_layer_buffer(&mut self,
                            tile: &mut BufferRequest,
                            scale: f32)
                            -> Box<LayerBuffer> {
         // Create an empty native surface. We mark it as not leaking
-        // in case it dies in transit to the compositor task.
+        // in case it dies in transit to the compositor thread.
         let width = tile.screen_rect.size.width;
         let height = tile.screen_rect.size.height;
         let mut native_surface = tile.native_surface.take().unwrap_or_else(|| {
             NativeSurface::new(native_display!(self), Size2D::new(width as i32, height as i32))
         });
         native_surface.mark_wont_leak();
 
         box LayerBuffer {
--- a/servo/components/gfx_traits/paint_listener.rs
+++ b/servo/components/gfx_traits/paint_listener.rs
@@ -27,10 +27,10 @@ pub trait PaintListener {
                               epoch: Epoch,
                               replies: Vec<(LayerId, Box<LayerBufferSet>)>,
                               frame_tree_id: FrameTreeId);
 
     /// Inform the compositor that these buffer requests will be ignored.
     fn ignore_buffer_requests(&mut self, buffer_requests: Vec<BufferRequest>);
 
     // Notification that the paint task wants to exit.
-    fn notify_paint_task_exiting(&mut self, pipeline_id: PipelineId);
+    fn notify_paint_thread_exiting(&mut self, pipeline_id: PipelineId);
 }
--- a/servo/components/layout/block.rs
+++ b/servo/components/layout/block.rs
@@ -42,17 +42,17 @@ use flow::{ImmutableFlowUtils, LateAbsol
 use flow::{NEEDS_LAYER, PostorderFlowTraversal, PreorderFlowTraversal, mut_base};
 use flow::{self, BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ForceNonfloatedFlag};
 use fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, HAS_LAYER};
 use fragment::{SpecificFragmentInfo};
 use gfx::display_list::{ClippingRegion, DisplayList};
 use gfx_traits::LayerId;
 use incremental::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPAINT};
 use layout_debug;
-use layout_task::DISPLAY_PORT_SIZE_FACTOR;
+use layout_thread::DISPLAY_PORT_SIZE_FACTOR;
 use model::{CollapsibleMargins, MaybeAuto, specified, specified_or_none};
 use model::{IntrinsicISizes, MarginCollapseInfo};
 use rustc_serialize::{Encodable, Encoder};
 use std::cmp::{max, min};
 use std::fmt;
 use std::sync::Arc;
 use style::computed_values::{border_collapse, box_sizing, display, float, overflow_x, overflow_y};
 use style::computed_values::{position, text_align, transform_style};
--- a/servo/components/layout/context.rs
+++ b/servo/components/layout/context.rs
@@ -1,27 +1,27 @@
 /* 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/. */
 
-//! Data needed by the layout task.
+//! Data needed by the layout thread.
 
 #![deny(unsafe_code)]
 
 use app_units::Au;
 use canvas_traits::CanvasMsg;
 use euclid::Rect;
 use fnv::FnvHasher;
-use gfx::font_cache_task::FontCacheTask;
+use gfx::font_cache_thread::FontCacheThread;
 use gfx::font_context::FontContext;
 use gfx_traits::LayerId;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::image::base::Image;
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheTask, ImageResponse, ImageState};
-use net_traits::image_cache_task::{UsePlaceholder};
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread, ImageResponse, ImageState};
+use net_traits::image_cache_thread::{UsePlaceholder};
 use std::cell::{RefCell, RefMut};
 use std::collections::HashMap;
 use std::collections::hash_state::DefaultState;
 use std::rc::Rc;
 use std::sync::mpsc::{Sender, channel};
 use std::sync::{Arc, Mutex};
 use style::context::{LocalStyleContext, SharedStyleContext, StyleContext};
 use style::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache};
@@ -54,48 +54,48 @@ fn create_or_get_local_context(shared_la
     LOCAL_CONTEXT_KEY.with(|r| {
         let mut r = r.borrow_mut();
         if let Some(context) = r.clone() {
             if shared_layout_context.style_context.screen_size_changed {
                 context.style_context.applicable_declarations_cache.borrow_mut().evict_all();
             }
             context
         } else {
-            let font_cache_task = shared_layout_context.font_cache_task.lock().unwrap().clone();
+            let font_cache_thread = shared_layout_context.font_cache_thread.lock().unwrap().clone();
             let context = Rc::new(LocalLayoutContext {
                 style_context: LocalStyleContext {
                     applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()),
                     style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()),
                 },
-                font_context: RefCell::new(FontContext::new(font_cache_task)),
+                font_context: RefCell::new(FontContext::new(font_cache_thread)),
             });
             *r = Some(context.clone());
             context
         }
     })
 }
 
 /// Layout information shared among all workers. This must be thread-safe.
 pub struct SharedLayoutContext {
     /// Bits shared by the layout and style system.
     pub style_context: SharedStyleContext,
 
-    /// The shared image cache task.
-    pub image_cache_task: ImageCacheTask,
+    /// The shared image cache thread.
+    pub image_cache_thread: ImageCacheThread,
 
     /// A channel for the image cache to send responses to.
     pub image_cache_sender: Mutex<ImageCacheChan>,
 
-    /// Interface to the font cache task.
-    pub font_cache_task: Mutex<FontCacheTask>,
+    /// Interface to the font cache thread.
+    pub font_cache_thread: Mutex<FontCacheThread>,
 
     /// The URL.
     pub url: Url,
 
-    /// A channel to send canvas renderers to paint task, in order to correctly paint the layers
+    /// A channel to send canvas renderers to paint thread, in order to correctly paint the layers
     pub canvas_layers_sender: Mutex<Sender<(LayerId, IpcSender<CanvasMsg>)>>,
 
     /// The visible rects for each layer, as reported to us by the compositor.
     pub visible_rects: Arc<HashMap<LayerId, Rect<Au>, DefaultState<FnvHasher>>>,
 }
 
 pub struct LayoutContext<'a> {
     pub shared: &'a SharedLayoutContext,
@@ -126,46 +126,46 @@ impl<'a> LayoutContext<'a> {
     #[inline(always)]
     pub fn font_context(&self) -> RefMut<FontContext> {
         self.cached_local_layout_context.font_context.borrow_mut()
     }
 
     pub fn get_or_request_image(&self, url: Url, use_placeholder: UsePlaceholder)
                                 -> Option<Arc<Image>> {
         // See if the image is already available
-        let result = self.shared.image_cache_task.find_image(url.clone(),
+        let result = self.shared.image_cache_thread.find_image(url.clone(),
                                                              use_placeholder);
 
         match result {
             Ok(image) => Some(image),
             Err(state) => {
                 // If we are emitting an output file, then we need to block on
                 // image load or we risk emitting an output file missing the image.
                 let is_sync = opts::get().output_file.is_some() ||
                               opts::get().exit_after_load;
 
                 match (state, is_sync) {
                     // Image failed to load, so just return nothing
                     (ImageState::LoadError, _) => None,
                     // Not loaded, test mode - load the image synchronously
                     (_, true) => {
                         let (sync_tx, sync_rx) = ipc::channel().unwrap();
-                        self.shared.image_cache_task.request_image(url,
+                        self.shared.image_cache_thread.request_image(url,
                                                                    ImageCacheChan(sync_tx),
                                                                    None);
                         match sync_rx.recv().unwrap().image_response {
                             ImageResponse::Loaded(image) |
                             ImageResponse::PlaceholderLoaded(image) => Some(image),
                             ImageResponse::None => None,
                         }
                     }
                     // Not yet requested, async mode - request image from the cache
                     (ImageState::NotRequested, false) => {
                         let sender = self.shared.image_cache_sender.lock().unwrap().clone();
-                        self.shared.image_cache_task.request_image(url, sender, None);
+                        self.shared.image_cache_thread.request_image(url, sender, None);
                         None
                     }
                     // Image has been requested, is still pending. Return no image
                     // for this paint loop. When the image loads it will trigger
                     // a reflow and/or repaint.
                     (ImageState::Pending, false) => None,
                 }
             }
--- a/servo/components/layout/display_list_builder.rs
+++ b/servo/components/layout/display_list_builder.rs
@@ -24,25 +24,25 @@ use fragment::{CoordinateSystem, Fragmen
 use fragment::{SpecificFragmentInfo};
 use gfx::display_list::{BLUR_INFLATION_FACTOR, BaseDisplayItem, BorderDisplayItem};
 use gfx::display_list::{BorderRadii, BoxShadowClipMode, BoxShadowDisplayItem, ClippingRegion};
 use gfx::display_list::{DisplayItem, DisplayItemMetadata, DisplayList, DisplayListSection};
 use gfx::display_list::{GradientDisplayItem};
 use gfx::display_list::{GradientStop, ImageDisplayItem, LayeredItem, LayerInfo};
 use gfx::display_list::{LineDisplayItem, OpaqueNode, SolidColorDisplayItem};
 use gfx::display_list::{StackingContext, TextDisplayItem, TextOrientation};
-use gfx::paint_task::THREAD_TINT_COLORS;
+use gfx::paint_thread::THREAD_TINT_COLORS;
 use gfx::text::glyph::CharIndex;
 use gfx_traits::{color, ScrollPolicy};
 use inline::{FIRST_FRAGMENT_OF_ELEMENT, InlineFlow, LAST_FRAGMENT_OF_ELEMENT};
 use ipc_channel::ipc::{self, IpcSharedMemory};
 use list_item::ListItemFlow;
 use model::{self, MaybeAuto, ToGfxMatrix};
 use net_traits::image::base::{Image, PixelFormat};
-use net_traits::image_cache_task::UsePlaceholder;
+use net_traits::image_cache_thread::UsePlaceholder;
 use std::default::Default;
 use std::sync::Arc;
 use std::sync::mpsc::channel;
 use std::{cmp, f32};
 use style::computed_values::filter::Filter;
 use style::computed_values::{background_attachment, background_clip, background_origin};
 use style::computed_values::{background_repeat, background_size};
 use style::computed_values::{border_style, image_rendering, overflow_x, position};
@@ -1136,17 +1136,17 @@ impl FragmentDisplayListBuilding for Fra
                     let canvas_data = match canvas_fragment_info.ipc_renderer {
                         Some(ref ipc_renderer) => {
                             let ipc_renderer = ipc_renderer.lock().unwrap();
                             let (sender, receiver) = ipc::channel().unwrap();
                             ipc_renderer.send(CanvasMsg::FromLayout(
                                 FromLayoutMsg::SendPixelContents(sender))).unwrap();
                             let data = receiver.recv().unwrap();
 
-                            // Propagate the layer and the renderer to the paint task.
+                            // Propagate the layer and the renderer to the paint thread.
                             layout_context.shared.canvas_layers_sender.lock().unwrap().send(
                                 (layer_id, (*ipc_renderer).clone())).unwrap();
 
                             data
                         },
                         None => IpcSharedMemory::from_byte(0xFFu8, width * height * 4),
                     };
                     let display_item = DisplayItem::ImageClass(box ImageDisplayItem {
--- a/servo/components/layout/fragment.rs
+++ b/servo/components/layout/fragment.rs
@@ -22,17 +22,17 @@ use incremental::{RECONSTRUCT_FLOW, Rest
 use inline::{FIRST_FRAGMENT_OF_ELEMENT, InlineFragmentContext, InlineFragmentNodeInfo};
 use inline::{InlineMetrics, LAST_FRAGMENT_OF_ELEMENT};
 use ipc_channel::ipc::IpcSender;
 use layout_debug;
 use model::{self, IntrinsicISizes, IntrinsicISizesContribution, MaybeAuto, specified};
 use msg::compositor_msg::LayerType;
 use msg::constellation_msg::PipelineId;
 use net_traits::image::base::Image;
-use net_traits::image_cache_task::UsePlaceholder;
+use net_traits::image_cache_thread::UsePlaceholder;
 use rustc_serialize::{Encodable, Encoder};
 use script::dom::htmlcanvaselement::HTMLCanvasData;
 use std::borrow::ToOwned;
 use std::cmp::{max, min};
 use std::collections::LinkedList;
 use std::fmt;
 use std::sync::{Arc, Mutex};
 use string_cache::Atom;
@@ -570,17 +570,17 @@ impl ReplacedImageFragmentInfo {
                                     Au(0));
 
         self.computed_block_size = Some(block_size);
         block_size + noncontent_block_size
     }
 }
 
 /// A fragment that represents an inline frame (iframe). This stores the pipeline ID so that the
-/// size of this iframe can be communicated via the constellation to the iframe's own layout task.
+/// size of this iframe can be communicated via the constellation to the iframe's own layout thread.
 #[derive(Clone)]
 pub struct IframeFragmentInfo {
     /// The pipeline ID of this iframe.
     pub pipeline_id: PipelineId,
 }
 
 impl IframeFragmentInfo {
     /// Creates the information specific to an iframe fragment.
--- a/servo/components/layout/layout_debug.rs
+++ b/servo/components/layout/layout_debug.rs
@@ -111,17 +111,17 @@ pub fn begin_trace(flow_root: FlowRef) {
         *r.borrow_mut() = Some(state);
     });
 }
 
 /// End the debug layout trace. This will write the layout
 /// trace to disk in the current directory. The output
 /// file can then be viewed with an external tool.
 pub fn end_trace() {
-    let mut task_state = STATE_KEY.with(|ref r| r.borrow_mut().take().unwrap());
-    assert!(task_state.scope_stack.len() == 1);
-    let mut root_scope = task_state.scope_stack.pop().unwrap();
-    root_scope.post = json::encode(&flow::base(&*task_state.flow_root)).unwrap();
+    let mut thread_state = STATE_KEY.with(|ref r| r.borrow_mut().take().unwrap());
+    assert!(thread_state.scope_stack.len() == 1);
+    let mut root_scope = thread_state.scope_stack.pop().unwrap();
+    root_scope.post = json::encode(&flow::base(&*thread_state.flow_root)).unwrap();
 
     let result = json::encode(&root_scope).unwrap();
     let mut file = File::create("layout_trace.json").unwrap();
     file.write_all(result.as_bytes()).unwrap();
 }
rename from servo/components/layout/layout_task.rs
rename to servo/components/layout/layout_thread.rs
--- a/servo/components/layout/layout_task.rs
+++ b/servo/components/layout/layout_thread.rs
@@ -1,13 +1,13 @@
 /* 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/. */
 
-//! The layout task. Performs layout on the DOM, builds display lists and sends them to be
+//! The layout thread. Performs layout on the DOM, builds display lists and sends them to be
 //! painted.
 
 #![allow(unsafe_code)]
 
 use animation;
 use app_units::Au;
 use azure::azure::AzColor;
 use canvas_traits::CanvasMsg;
@@ -19,40 +19,40 @@ use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::scale_factor::ScaleFactor;
 use euclid::size::Size2D;
 use flow::{self, Flow, ImmutableFlowUtils, MutableFlowUtils, MutableOwnedFlowUtils};
 use flow_ref::{self, FlowRef};
 use fnv::FnvHasher;
 use gfx::display_list::{ClippingRegion, DisplayList, LayerInfo, OpaqueNode, StackingContext};
 use gfx::font;
-use gfx::font_cache_task::FontCacheTask;
+use gfx::font_cache_thread::FontCacheThread;
 use gfx::font_context;
-use gfx::paint_task::{LayoutToPaintMsg, PaintLayer};
+use gfx::paint_thread::{LayoutToPaintMsg, PaintLayer};
 use gfx_traits::{color, LayerId, ScrollPolicy};
 use incremental::{LayoutDamageComputation, REFLOW, REFLOW_ENTIRE_DOCUMENT, REPAINT};
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use ipc_channel::router::ROUTER;
 use layout_debug;
-use layout_traits::LayoutTaskFactory;
+use layout_traits::LayoutThreadFactory;
 use log;
 use msg::ParseErrorReporter;
 use msg::compositor_msg::Epoch;
 use msg::constellation_msg::{ConstellationChan, Failure, PipelineId};
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheResult, ImageCacheTask};
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheResult, ImageCacheThread};
 use parallel;
 use profile_traits::mem::{self, Report, ReportKind, ReportsChan};
 use profile_traits::time::{TimerMetadataFrameType, TimerMetadataReflowType};
 use profile_traits::time::{self, TimerMetadata, profile};
 use query::{LayoutRPCImpl, process_content_box_request, process_content_boxes_request};
 use query::{process_node_geometry_request, process_offset_parent_query, process_resolved_style_request};
 use script::dom::node::OpaqueStyleAndLayoutData;
 use script::layout_interface::Animation;
 use script::layout_interface::{LayoutRPC, OffsetParentResponse};
-use script::layout_interface::{Msg, NewLayoutTaskInfo, Reflow, ReflowGoal, ReflowQueryType};
+use script::layout_interface::{Msg, NewLayoutThreadInfo, Reflow, ReflowGoal, ReflowQueryType};
 use script::layout_interface::{ScriptLayoutChan, ScriptReflow};
 use script::reporter::CSSErrorReporter;
 use script_traits::ConstellationControlMsg;
 use script_traits::{LayoutControlMsg, LayoutMsg as ConstellationMsg, OpaqueScriptLayoutChannel};
 use sequential;
 use serde_json;
 use std::borrow::ToOwned;
 use std::cell::RefCell;
@@ -72,31 +72,31 @@ use style::selector_matching::{Stylist, 
 use style::stylesheets::{CSSRuleIteratorExt, Stylesheet};
 use traversal::RecalcStyleAndConstructFlows;
 use url::Url;
 use util::geometry::MAX_RECT;
 use util::ipc::OptionalIpcSender;
 use util::logical_geometry::LogicalPoint;
 use util::mem::HeapSizeOf;
 use util::opts;
-use util::task;
-use util::task_state;
+use util::thread;
+use util::thread_state;
 use util::workqueue::WorkQueue;
 use wrapper::{LayoutNode, NonOpaqueStyleAndLayoutData, ServoLayoutNode, ThreadSafeLayoutNode};
 
 /// The number of screens of data we're allowed to generate display lists for in each direction.
 pub const DISPLAY_PORT_SIZE_FACTOR: i32 = 8;
 
 /// The number of screens we have to traverse before we decide to generate new display lists.
 const DISPLAY_PORT_THRESHOLD_SIZE_FACTOR: i32 = 4;
 
-/// Mutable data belonging to the LayoutTask.
+/// Mutable data belonging to the LayoutThread.
 ///
 /// This needs to be protected by a mutex so we can do fast RPCs.
-pub struct LayoutTaskData {
+pub struct LayoutThreadData {
     /// The channel on which messages can be sent to the constellation.
     pub constellation_chan: ConstellationChan<ConstellationMsg>,
 
     /// The root stacking context.
     pub stacking_context: Option<Arc<StackingContext>>,
 
     /// Performs CSS selector matching and style resolution.
     pub stylist: Box<Stylist>,
@@ -112,67 +112,67 @@ pub struct LayoutTaskData {
 
     /// A queued response for the resolved style property of an element.
     pub resolved_style_response: Option<String>,
 
     /// A queued response for the offset parent/rect of a node.
     pub offset_parent_response: OffsetParentResponse,
 }
 
-/// Information needed by the layout task.
-pub struct LayoutTask {
+/// Information needed by the layout thread.
+pub struct LayoutThread {
     /// The ID of the pipeline that we belong to.
     id: PipelineId,
 
     /// The URL of the pipeline that we belong to.
     url: RefCell<Url>,
 
     /// Is the current reflow of an iframe, as opposed to a root window?
     is_iframe: bool,
 
-    /// The port on which we receive messages from the script task.
+    /// The port on which we receive messages from the script thread.
     port: Receiver<Msg>,
 
     /// The port on which we receive messages from the constellation.
     pipeline_port: Receiver<LayoutControlMsg>,
 
     /// The port on which we receive messages from the image cache
     image_cache_receiver: Receiver<ImageCacheResult>,
 
     /// The channel on which the image cache can send messages to ourself.
     image_cache_sender: ImageCacheChan,
 
-    /// The port on which we receive messages from the font cache task.
+    /// The port on which we receive messages from the font cache thread.
     font_cache_receiver: Receiver<()>,
 
     /// The channel on which the font cache can send messages to us.
     font_cache_sender: IpcSender<()>,
 
     /// The channel on which messages can be sent to the constellation.
     constellation_chan: ConstellationChan<ConstellationMsg>,
 
-    /// The channel on which messages can be sent to the script task.
+    /// The channel on which messages can be sent to the script thread.
     script_chan: IpcSender<ConstellationControlMsg>,
 
-    /// The channel on which messages can be sent to the painting task.
+    /// The channel on which messages can be sent to the painting thread.
     paint_chan: OptionalIpcSender<LayoutToPaintMsg>,
 
     /// The channel on which messages can be sent to the time profiler.
     time_profiler_chan: time::ProfilerChan,
 
     /// The channel on which messages can be sent to the memory profiler.
     mem_profiler_chan: mem::ProfilerChan,
 
     /// The channel on which messages can be sent to the image cache.
-    image_cache_task: ImageCacheTask,
+    image_cache_thread: ImageCacheThread,
 
-    /// Public interface to the font cache task.
-    font_cache_task: FontCacheTask,
+    /// Public interface to the font cache thread.
+    font_cache_thread: FontCacheThread,
 
-    /// Is this the first reflow in this LayoutTask?
+    /// Is this the first reflow in this LayoutThread?
     first_reflow: bool,
 
     /// To receive a canvas renderer associated to a layer, this message is propagated
     /// to the paint chan
     canvas_layers_receiver: Receiver<(LayerId, IpcSender<CanvasMsg>)>,
     canvas_layers_sender: Sender<(LayerId, IpcSender<CanvasMsg>)>,
 
     /// The workers that we use for parallel operation.
@@ -208,107 +208,107 @@ pub struct LayoutTask {
     /// A counter for epoch messages
     epoch: Epoch,
 
     /// The size of the viewport. This may be different from the size of the screen due to viewport
     /// constraints.
     viewport_size: Size2D<Au>,
 
     /// A mutex to allow for fast, read-only RPC of layout's internal data
-    /// structures, while still letting the LayoutTask modify them.
+    /// structures, while still letting the LayoutThread modify them.
     ///
     /// All the other elements of this struct are read-only.
-    rw_data: Arc<Mutex<LayoutTaskData>>,
+    rw_data: Arc<Mutex<LayoutThreadData>>,
 
     /// The CSS error reporter for all CSS loaded in this layout thread
     error_reporter: CSSErrorReporter,
 
 }
 
-impl LayoutTaskFactory for LayoutTask {
-    /// Spawns a new layout task.
-    fn create(_phantom: Option<&mut LayoutTask>,
+impl LayoutThreadFactory for LayoutThread {
+    /// Spawns a new layout thread.
+    fn create(_phantom: Option<&mut LayoutThread>,
               id: PipelineId,
               url: Url,
               is_iframe: bool,
               chan: OpaqueScriptLayoutChannel,
               pipeline_port: IpcReceiver<LayoutControlMsg>,
               constellation_chan: ConstellationChan<ConstellationMsg>,
               failure_msg: Failure,
               script_chan: IpcSender<ConstellationControlMsg>,
               paint_chan: OptionalIpcSender<LayoutToPaintMsg>,
-              image_cache_task: ImageCacheTask,
-              font_cache_task: FontCacheTask,
+              image_cache_thread: ImageCacheThread,
+              font_cache_thread: FontCacheThread,
               time_profiler_chan: time::ProfilerChan,
               mem_profiler_chan: mem::ProfilerChan,
               shutdown_chan: IpcSender<()>,
               content_process_shutdown_chan: IpcSender<()>) {
         let ConstellationChan(con_chan) = constellation_chan.clone();
-        task::spawn_named_with_send_on_failure(format!("LayoutTask {:?}", id),
-                                               task_state::LAYOUT,
+        thread::spawn_named_with_send_on_failure(format!("LayoutThread {:?}", id),
+                                               thread_state::LAYOUT,
                                                move || {
-            { // Ensures layout task is destroyed before we send shutdown message
+            { // Ensures layout thread is destroyed before we send shutdown message
                 let sender = chan.sender();
-                let layout = LayoutTask::new(id,
+                let layout = LayoutThread::new(id,
                                              url,
                                              is_iframe,
                                              chan.receiver(),
                                              pipeline_port,
                                              constellation_chan,
                                              script_chan,
                                              paint_chan,
-                                             image_cache_task,
-                                             font_cache_task,
+                                             image_cache_thread,
+                                             font_cache_thread,
                                              time_profiler_chan,
                                              mem_profiler_chan.clone());
 
                 let reporter_name = format!("layout-reporter-{}", id);
                 mem_profiler_chan.run_with_memory_reporting(|| {
                     layout.start();
                 }, reporter_name, sender, Msg::CollectReports);
             }
             let _ = shutdown_chan.send(());
             let _ = content_process_shutdown_chan.send(());
         }, ConstellationMsg::Failure(failure_msg), con_chan);
     }
 }
 
-/// The `LayoutTask` `rw_data` lock must remain locked until the first reflow,
+/// The `LayoutThread` `rw_data` lock must remain locked until the first reflow,
 /// as RPC calls don't make sense until then. Use this in combination with
-/// `LayoutTask::lock_rw_data` and `LayoutTask::return_rw_data`.
+/// `LayoutThread::lock_rw_data` and `LayoutThread::return_rw_data`.
 pub enum RWGuard<'a> {
-    /// If the lock was previously held, from when the task started.
-    Held(MutexGuard<'a, LayoutTaskData>),
+    /// If the lock was previously held, from when the thread started.
+    Held(MutexGuard<'a, LayoutThreadData>),
     /// If the lock was just used, and has been returned since there has been
     /// a reflow already.
-    Used(MutexGuard<'a, LayoutTaskData>),
+    Used(MutexGuard<'a, LayoutThreadData>),
 }
 
 impl<'a> Deref for RWGuard<'a> {
-    type Target = LayoutTaskData;
-    fn deref(&self) -> &LayoutTaskData {
+    type Target = LayoutThreadData;
+    fn deref(&self) -> &LayoutThreadData {
         match *self {
             RWGuard::Held(ref x) => &**x,
             RWGuard::Used(ref x) => &**x,
         }
     }
 }
 
 impl<'a> DerefMut for RWGuard<'a> {
-    fn deref_mut(&mut self) -> &mut LayoutTaskData {
+    fn deref_mut(&mut self) -> &mut LayoutThreadData {
         match *self {
             RWGuard::Held(ref mut x) => &mut **x,
             RWGuard::Used(ref mut x) => &mut **x,
         }
     }
 }
 
 struct RwData<'a, 'b: 'a> {
-    rw_data: &'b Arc<Mutex<LayoutTaskData>>,
-    possibly_locked_rw_data: &'a mut Option<MutexGuard<'b, LayoutTaskData>>,
+    rw_data: &'b Arc<Mutex<LayoutThreadData>>,
+    possibly_locked_rw_data: &'a mut Option<MutexGuard<'b, LayoutThreadData>>,
 }
 
 impl<'a, 'b: 'a> RwData<'a, 'b> {
     /// If no reflow has happened yet, this will just return the lock in
     /// `possibly_locked_rw_data`. Otherwise, it will acquire the `rw_data` lock.
     ///
     /// If you do not wish RPCs to remain blocked, just drop the `RWGuard`
     /// returned from this function. If you _do_ wish for them to remain blocked,
@@ -328,102 +328,102 @@ impl<'a, 'b: 'a> RwData<'a, 'b> {
             RWGuard::Used(x) => drop(x),
             RWGuard::Held(x) => *self.possibly_locked_rw_data = Some(x),
         }
     }
 }
 
 fn add_font_face_rules(stylesheet: &Stylesheet,
                        device: &Device,
-                       font_cache_task: &FontCacheTask,
+                       font_cache_thread: &FontCacheThread,
                        font_cache_sender: &IpcSender<()>,
                        outstanding_web_fonts_counter: &Arc<AtomicUsize>) {
     for font_face in stylesheet.effective_rules(&device).font_face() {
         for source in &font_face.sources {
             if opts::get().load_webfonts_synchronously {
                 let (sender, receiver) = ipc::channel().unwrap();
-                font_cache_task.add_web_font(font_face.family.clone(),
+                font_cache_thread.add_web_font(font_face.family.clone(),
                                              (*source).clone(),
                                              sender);
                 receiver.recv().unwrap();
             } else {
                 outstanding_web_fonts_counter.fetch_add(1, Ordering::SeqCst);
-                font_cache_task.add_web_font(font_face.family.clone(),
+                font_cache_thread.add_web_font(font_face.family.clone(),
                                              (*source).clone(),
                                              (*font_cache_sender).clone());
             }
         }
     }
 }
 
-impl LayoutTask {
-    /// Creates a new `LayoutTask` structure.
+impl LayoutThread {
+    /// Creates a new `LayoutThread` structure.
     fn new(id: PipelineId,
            url: Url,
            is_iframe: bool,
            port: Receiver<Msg>,
            pipeline_port: IpcReceiver<LayoutControlMsg>,
            constellation_chan: ConstellationChan<ConstellationMsg>,
            script_chan: IpcSender<ConstellationControlMsg>,
            paint_chan: OptionalIpcSender<LayoutToPaintMsg>,
-           image_cache_task: ImageCacheTask,
-           font_cache_task: FontCacheTask,
+           image_cache_thread: ImageCacheThread,
+           font_cache_thread: FontCacheThread,
            time_profiler_chan: time::ProfilerChan,
            mem_profiler_chan: mem::ProfilerChan)
-           -> LayoutTask {
+           -> LayoutThread {
         let device = Device::new(
             MediaType::Screen,
             opts::get().initial_window_size.as_f32() * ScaleFactor::new(1.0));
         let parallel_traversal = if opts::get().layout_threads != 1 {
-            Some(WorkQueue::new("LayoutWorker", task_state::LAYOUT,
+            Some(WorkQueue::new("LayoutWorker", thread_state::LAYOUT,
                                 opts::get().layout_threads))
         } else {
             None
         };
 
         // Create the channel on which new animations can be sent.
         let (new_animations_sender, new_animations_receiver) = channel();
         let (canvas_layers_sender, canvas_layers_receiver) = channel();
 
         // Proxy IPC messages from the pipeline to the layout thread.
         let pipeline_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(pipeline_port);
 
-        // Ask the router to proxy IPC messages from the image cache task to the layout thread.
+        // Ask the router to proxy IPC messages from the image cache thread to the layout thread.
         let (ipc_image_cache_sender, ipc_image_cache_receiver) = ipc::channel().unwrap();
         let image_cache_receiver =
             ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_image_cache_receiver);
 
-        // Ask the router to proxy IPC messages from the font cache task to the layout thread.
+        // Ask the router to proxy IPC messages from the font cache thread to the layout thread.
         let (ipc_font_cache_sender, ipc_font_cache_receiver) = ipc::channel().unwrap();
         let font_cache_receiver =
             ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_font_cache_receiver);
 
         let stylist = box Stylist::new(device);
         let outstanding_web_fonts_counter = Arc::new(AtomicUsize::new(0));
         for stylesheet in &*USER_OR_USER_AGENT_STYLESHEETS {
             add_font_face_rules(stylesheet,
                                 &stylist.device,
-                                &font_cache_task,
+                                &font_cache_thread,
                                 &ipc_font_cache_sender,
                                 &outstanding_web_fonts_counter);
         }
 
-        LayoutTask {
+        LayoutThread {
             id: id,
             url: RefCell::new(url),
             is_iframe: is_iframe,
             port: port,
             pipeline_port: pipeline_receiver,
             script_chan: script_chan,
             constellation_chan: constellation_chan.clone(),
             paint_chan: paint_chan,
             time_profiler_chan: time_profiler_chan,
             mem_profiler_chan: mem_profiler_chan,
-            image_cache_task: image_cache_task,
-            font_cache_task: font_cache_task,
+            image_cache_thread: image_cache_thread,
+            font_cache_thread: font_cache_thread,
             first_reflow: true,
             image_cache_receiver: image_cache_receiver,
             image_cache_sender: ImageCacheChan(ipc_image_cache_sender),
             font_cache_receiver: font_cache_receiver,
             font_cache_sender: ipc_font_cache_sender,
             canvas_layers_receiver: canvas_layers_receiver,
             canvas_layers_sender: canvas_layers_sender,
             parallel_traversal: parallel_traversal,
@@ -433,17 +433,17 @@ impl LayoutTask {
             outstanding_web_fonts: outstanding_web_fonts_counter,
             root_flow: None,
             visible_rects: Arc::new(HashMap::with_hash_state(Default::default())),
             running_animations: Arc::new(RwLock::new(HashMap::new())),
             expired_animations: Arc::new(RwLock::new(HashMap::new())),
             epoch: Epoch(0),
             viewport_size: Size2D::new(Au(0), Au(0)),
             rw_data: Arc::new(Mutex::new(
-                LayoutTaskData {
+                LayoutThreadData {
                     constellation_chan: constellation_chan,
                     stacking_context: None,
                     stylist: stylist,
                     content_box_response: Rect::zero(),
                     content_boxes_response: Vec::new(),
                     client_rect_response: Rect::zero(),
                     resolved_style_response: None,
                     offset_parent_response: OffsetParentResponse::empty(),
@@ -462,43 +462,43 @@ impl LayoutTask {
         };
         while self.handle_request(&mut rw_data) {
             // Loop indefinitely.
         }
     }
 
     // Create a layout context for use in building display lists, hit testing, &c.
     fn build_shared_layout_context(&self,
-                                   rw_data: &LayoutTaskData,
+                                   rw_data: &LayoutThreadData,
                                    screen_size_changed: bool,
                                    url: &Url,
                                    goal: ReflowGoal)
                                    -> SharedLayoutContext {
         SharedLayoutContext {
             style_context: SharedStyleContext {
                 viewport_size: self.viewport_size.clone(),
                 screen_size_changed: screen_size_changed,
                 stylist: StylistWrapper(&*rw_data.stylist),
                 generation: self.generation,
                 goal: goal,
                 new_animations_sender: Mutex::new(self.new_animations_sender.clone()),
                 running_animations: self.running_animations.clone(),
                 expired_animations: self.expired_animations.clone(),
                 error_reporter: self.error_reporter.clone(),
             },
-            image_cache_task: self.image_cache_task.clone(),
+            image_cache_thread: self.image_cache_thread.clone(),
             image_cache_sender: Mutex::new(self.image_cache_sender.clone()),
-            font_cache_task: Mutex::new(self.font_cache_task.clone()),
+            font_cache_thread: Mutex::new(self.font_cache_thread.clone()),
             canvas_layers_sender: Mutex::new(self.canvas_layers_sender.clone()),
             url: (*url).clone(),
             visible_rects: self.visible_rects.clone(),
         }
     }
 
-    /// Receives and dispatches messages from the script and constellation tasks
+    /// Receives and dispatches messages from the script and constellation threads
     fn handle_request<'a, 'b>(&mut self, possibly_locked_rw_data: &mut RwData<'a, 'b>) -> bool {
         enum Request {
             FromPipeline(LayoutControlMsg),
             FromScript(Msg),
             FromImageCache,
             FromFontCache,
         }
 
@@ -579,17 +579,17 @@ impl LayoutTask {
         self.perform_post_style_recalc_layout_passes(&reflow_info,
                                                      &mut *rw_data,
                                                      &mut layout_context);
 
 
         true
     }
 
-    /// Receives and dispatches messages from other tasks.
+    /// Receives and dispatches messages from other threads.
     fn handle_request_helper<'a, 'b>(&mut self,
                                      request: Msg,
                                      possibly_locked_rw_data: &mut RwData<'a, 'b>)
                                      -> bool {
         match request {
             Msg::AddStylesheet(style_info) => {
                 self.handle_add_stylesheet(style_info, possibly_locked_rw_data)
             }
@@ -623,18 +623,18 @@ impl LayoutTask {
                 let _rw_data = possibly_locked_rw_data.lock();
                 sender.send(self.epoch).unwrap();
             },
             Msg::GetWebFontLoadState(sender) => {
                 let _rw_data = possibly_locked_rw_data.lock();
                 let outstanding_web_fonts = self.outstanding_web_fonts.load(Ordering::SeqCst);
                 sender.send(outstanding_web_fonts != 0).unwrap();
             },
-            Msg::CreateLayoutTask(info) => {
-                self.create_layout_task(info)
+            Msg::CreateLayoutThread(info) => {
+                self.create_layout_thread(info)
             }
             Msg::SetFinalUrl(final_url) => {
                 *self.url.borrow_mut() = final_url;
             },
             Msg::PrepareToExit(response_chan) => {
                 self.prepare_to_exit(response_chan);
                 return false
             },
@@ -653,24 +653,24 @@ impl LayoutTask {
                                possibly_locked_rw_data: &mut RwData<'a, 'b>) {
         let mut reports = vec![];
 
         // FIXME(njn): Just measuring the display tree for now.
         let rw_data = possibly_locked_rw_data.lock();
         let stacking_context = rw_data.stacking_context.as_ref();
         let formatted_url = &format!("url({})", *self.url.borrow());
         reports.push(Report {
-            path: path![formatted_url, "layout-task", "display-list"],
+            path: path![formatted_url, "layout-thread", "display-list"],
             kind: ReportKind::ExplicitJemallocHeapSize,
             size: stacking_context.map_or(0, |sc| sc.heap_size_of_children()),
         });
 
-        // The LayoutTask has a context in TLS...
+        // The LayoutThread has a context in TLS...
         reports.push(Report {
-            path: path![formatted_url, "layout-task", "local-context"],
+            path: path![formatted_url, "layout-thread", "local-context"],
             kind: ReportKind::ExplicitJemallocHeapSize,
             size: heap_size_of_local_context(),
         });
 
         // ... as do each of the LayoutWorkers, if present.
         if let Some(ref traversal) = self.parallel_traversal {
             let sizes = traversal.heap_size_of_tls(heap_size_of_local_context);
             for (i, size) in sizes.iter().enumerate() {
@@ -681,29 +681,29 @@ impl LayoutTask {
                     size: *size,
                 });
             }
         }
 
         reports_chan.send(reports);
     }
 
-    fn create_layout_task(&self, info: NewLayoutTaskInfo) {
-        LayoutTaskFactory::create(None::<&mut LayoutTask>,
+    fn create_layout_thread(&self, info: NewLayoutThreadInfo) {
+        LayoutThreadFactory::create(None::<&mut LayoutThread>,
                                   info.id,
                                   info.url.clone(),
                                   info.is_parent,
                                   info.layout_pair,
                                   info.pipeline_port,
                                   info.constellation_chan,
                                   info.failure,
                                   info.script_chan.clone(),
                                   info.paint_chan.to::<LayoutToPaintMsg>(),
-                                  self.image_cache_task.clone(),
-                                  self.font_cache_task.clone(),
+                                  self.image_cache_thread.clone(),
+                                  self.font_cache_thread.clone(),
                                   self.time_profiler_chan.clone(),
                                   self.mem_profiler_chan.clone(),
                                   info.layout_shutdown_chan,
                                   info.content_process_shutdown_chan);
     }
 
     /// Enters a quiescent state in which no new messages will be processed until an `ExitNow` is
     /// received. A pong is immediately sent on the given response channel.
@@ -712,31 +712,31 @@ impl LayoutTask {
         loop {
             match self.port.recv().unwrap() {
                 Msg::ReapStyleAndLayoutData(dead_data) => {
                     unsafe {
                         self.handle_reap_style_and_layout_data(dead_data)
                     }
                 }
                 Msg::ExitNow => {
-                    debug!("layout task is exiting...");
+                    debug!("layout thread is exiting...");
                     self.exit_now();
                     break
                 }
                 Msg::CollectReports(_) => {
                     // Just ignore these messages at this point.
                 }
                 _ => {
                     panic!("layout: unexpected message received after `PrepareToExitMsg`")
                 }
             }
         }
     }
 
-    /// Shuts down the layout task now. If there are any DOM nodes left, layout will now (safely)
+    /// Shuts down the layout thread now. If there are any DOM nodes left, layout will now (safely)
     /// crash.
     fn exit_now(&mut self) {
         if let Some(ref mut traversal) = self.parallel_traversal {
             traversal.shutdown()
         }
 
         let (response_chan, response_port) = ipc::channel().unwrap();
         self.paint_chan.send(LayoutToPaintMsg::Exit(response_chan)).unwrap();
@@ -748,17 +748,17 @@ impl LayoutTask {
                                      possibly_locked_rw_data: &mut RwData<'a, 'b>) {
         // Find all font-face rules and notify the font cache of them.
         // GWTODO: Need to handle unloading web fonts.
 
         let rw_data = possibly_locked_rw_data.lock();
         if stylesheet.is_effective_for_device(&rw_data.stylist.device) {
             add_font_face_rules(&*stylesheet,
                                 &rw_data.stylist.device,
-                                &self.font_cache_task,
+                                &self.font_cache_thread,
                                 &self.font_cache_sender,
                                 &self.outstanding_web_fonts);
         }
 
         possibly_locked_rw_data.block(rw_data);
     }
 
     /// Sets quirks mode for the document, causing the quirks mode stylesheet to be used.
@@ -824,17 +824,17 @@ impl LayoutTask {
                                               shared_layout_context,
                                               traversal);
     }
 
     fn compute_abs_pos_and_build_display_list(&mut self,
                                               data: &Reflow,
                                               layout_root: &mut FlowRef,
                                               shared_layout_context: &mut SharedLayoutContext,
-                                              rw_data: &mut LayoutTaskData) {
+                                              rw_data: &mut LayoutThreadData) {
         let writing_mode = flow::base(&**layout_root).writing_mode;
         let (metadata, sender) = (self.profiler_metadata(), self.time_profiler_chan.clone());
         profile(time::ProfilerCategory::LayoutDispListBuild,
                 metadata.clone(),
                 sender.clone(),
                 || {
             flow::mut_base(flow_ref::deref_mut(layout_root)).stacking_relative_position =
                 LogicalPoint::zero(writing_mode).to_physical(writing_mode,
@@ -907,17 +907,17 @@ impl LayoutTask {
                 self.epoch.next();
                 self.paint_chan
                     .send(LayoutToPaintMsg::PaintInit(self.epoch, paint_layer))
                     .unwrap();
             }
         });
     }
 
-    /// The high-level routine that performs layout tasks.
+    /// The high-level routine that performs layout threads.
     fn handle_reflow<'a, 'b>(&mut self,
                              data: &ScriptReflow,
                              possibly_locked_rw_data: &mut RwData<'a, 'b>) {
         let document = unsafe { ServoLayoutNode::new(&data.document) };
         let document = document.as_document().unwrap();
 
         debug!("layout: received layout request for: {}", self.url.borrow().serialize());
 
@@ -989,22 +989,22 @@ impl LayoutTask {
         }
 
         // If the entire flow tree is invalid, then it will be reflowed anyhow.
         let needs_dirtying = rw_data.stylist.update(&data.document_stylesheets,
                                                     data.stylesheets_changed);
         let needs_reflow = viewport_size_changed && !needs_dirtying;
         unsafe {
             if needs_dirtying {
-                LayoutTask::dirty_all_nodes(node);
+                LayoutThread::dirty_all_nodes(node);
             }
         }
         if needs_reflow {
             if let Some(mut flow) = self.try_get_layout_root(node) {
-                LayoutTask::reflow_all_nodes(flow_ref::deref_mut(&mut flow));
+                LayoutThread::reflow_all_nodes(flow_ref::deref_mut(&mut flow));
             }
         }
 
         let modified_elements = document.drain_modified_elements();
         if !needs_dirtying {
             for (el, snapshot) in modified_elements {
                 let hint = rw_data.stylist.compute_restyle_hint(&el, &snapshot, el.get_state());
                 el.note_restyle_hint(hint);
@@ -1047,17 +1047,17 @@ impl LayoutTask {
                                     text_shaping_time,
                                     0,
                                     0);
 
             // Retrieve the (possibly rebuilt) root flow.
             self.root_flow = self.try_get_layout_root(node);
         }
 
-        // Send new canvas renderers to the paint task
+        // Send new canvas renderers to the paint thread
         while let Ok((layer_id, renderer)) = self.canvas_layers_receiver.try_recv() {
             // Just send if there's an actual renderer
             self.paint_chan.send(LayoutToPaintMsg::CanvasLayer(layer_id, renderer)).unwrap();
         }
 
         // Perform post-style recalculation layout passes.
         self.perform_post_style_recalc_layout_passes(&data.reflow_info,
                                                      &mut rw_data,
@@ -1152,17 +1152,17 @@ impl LayoutTask {
         let mut rw_data = possibly_locked_rw_data.lock();
         self.tick_animations(&mut rw_data);
 
         self.script_chan
           .send(ConstellationControlMsg::TickAllAnimations(self.id))
           .unwrap();
     }
 
-    pub fn tick_animations(&mut self, rw_data: &mut LayoutTaskData) {
+    pub fn tick_animations(&mut self, rw_data: &mut LayoutThreadData) {
         let reflow_info = Reflow {
             goal: ReflowGoal::ForDisplay,
             page_clip_rect: MAX_RECT,
         };
 
         let mut layout_context = self.build_shared_layout_context(&*rw_data,
                                                                   false,
                                                                   &self.url.borrow(),
@@ -1205,17 +1205,17 @@ impl LayoutTask {
         }
         self.perform_post_style_recalc_layout_passes(&reflow_info,
                                                      &mut *rw_data,
                                                      &mut layout_context);
     }
 
     fn perform_post_style_recalc_layout_passes(&mut self,
                                                data: &Reflow,
-                                               rw_data: &mut LayoutTaskData,
+                                               rw_data: &mut LayoutThreadData,
                                                layout_context: &mut SharedLayoutContext) {
         if let Some(mut root_flow) = self.root_flow.clone() {
             // Kick off animations if any were triggered, expire completed ones.
             animation::update_animation_state(&self.constellation_chan,
                                               &mut *self.running_animations.write().unwrap(),
                                               &mut *self.expired_animations.write().unwrap(),
                                               &self.new_animations_receiver,
                                               self.id);
@@ -1246,36 +1246,36 @@ impl LayoutTask {
             profile(time::ProfilerCategory::LayoutMain,
                     self.profiler_metadata(),
                     self.time_profiler_chan.clone(),
                     || {
                 let profiler_metadata = self.profiler_metadata();
                 match self.parallel_traversal {
                     None => {
                         // Sequential mode.
-                        LayoutTask::solve_constraints(&mut root_flow, &layout_context)
+                        LayoutThread::solve_constraints(&mut root_flow, &layout_context)
                     }
                     Some(ref mut parallel) => {
                         // Parallel mode.
-                        LayoutTask::solve_constraints_parallel(parallel,
+                        LayoutThread::solve_constraints_parallel(parallel,
                                                                &mut root_flow,
                                                                profiler_metadata,
                                                                self.time_profiler_chan.clone(),
                                                                &*layout_context);
                     }
                 }
             });
 
             self.perform_post_main_layout_passes(data, rw_data, layout_context);
         }
     }
 
     fn perform_post_main_layout_passes(&mut self,
                                        data: &Reflow,
-                                       rw_data: &mut LayoutTaskData,
+                                       rw_data: &mut LayoutThreadData,
                                        layout_context: &mut SharedLayoutContext) {
         // Build the display list if necessary, and send it to the painter.
         if let Some(mut root_flow) = self.root_flow.clone() {
             self.compute_abs_pos_and_build_display_list(data,
                                                         &mut root_flow,
                                                         &mut *layout_context,
                                                         rw_data);
             self.first_reflow = false;
@@ -1302,21 +1302,21 @@ impl LayoutTask {
         }
     }
 
     fn reflow_all_nodes(flow: &mut Flow) {
         debug!("reflowing all nodes!");
         flow::mut_base(flow).restyle_damage.insert(REFLOW | REPAINT);
 
         for child in flow::child_iter(flow) {
-            LayoutTask::reflow_all_nodes(child);
+            LayoutThread::reflow_all_nodes(child);
         }
     }
 
-    /// Handles a message to destroy layout data. Layout data must be destroyed on *this* task
+    /// Handles a message to destroy layout data. Layout data must be destroyed on *this* thread
     /// because the struct type is transmuted to a different type on the script side.
     unsafe fn handle_reap_style_and_layout_data(&self, data: OpaqueStyleAndLayoutData) {
         let non_opaque: NonOpaqueStyleAndLayoutData = transmute(data.ptr);
         let _ = Box::from_raw(non_opaque);
     }
 
     /// Returns profiling information which is passed to the time profiler.
     fn profiler_metadata(&self) -> Option<TimerMetadata> {
--- a/servo/components/layout/lib.rs
+++ b/servo/components/layout/lib.rs
@@ -73,17 +73,17 @@ mod flex;
 mod floats;
 mod flow;
 mod flow_list;
 mod flow_ref;
 mod fragment;
 mod generated_content;
 mod incremental;
 mod inline;
-pub mod layout_task;
+pub mod layout_thread;
 mod list_item;
 mod model;
 mod multicol;
 mod opaque_node;
 mod parallel;
 mod query;
 mod sequential;
 mod table;
--- a/servo/components/layout/query.rs
+++ b/servo/components/layout/query.rs
@@ -1,23 +1,23 @@
 /* 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/. */
 
-//! Utilities for querying the layout, as needed by the layout task.
+//! Utilities for querying the layout, as needed by the layout thread.
 
 use app_units::Au;
 use construct::ConstructionResult;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use flow;
 use flow_ref::FlowRef;
 use fragment::{Fragment, FragmentBorderBoxIterator, SpecificFragmentInfo};
 use gfx::display_list::{DisplayItemMetadata, OpaqueNode};
-use layout_task::LayoutTaskData;
+use layout_thread::LayoutThreadData;
 use msg::constellation_msg::ConstellationChan;
 use opaque_node::OpaqueNodeMethods;
 use script::layout_interface::{ContentBoxResponse, ContentBoxesResponse, NodeGeometryResponse};
 use script::layout_interface::{HitTestResponse, LayoutRPC, MouseOverResponse, OffsetParentResponse};
 use script::layout_interface::{ResolvedStyleResponse, ScriptLayoutChan};
 use script_traits::LayoutMsg as ConstellationMsg;
 use selectors::parser::PseudoElement;
 use sequential;
@@ -27,17 +27,17 @@ use string_cache::Atom;
 use style::computed_values;
 use style::properties::longhands::{display, position};
 use style::properties::style_structs;
 use style::values::AuExtensionMethods;
 use util::cursor::Cursor;
 use util::logical_geometry::WritingMode;
 use wrapper::{LayoutNode, ThreadSafeLayoutNode};
 
-pub struct LayoutRPCImpl(pub Arc<Mutex<LayoutTaskData>>);
+pub struct LayoutRPCImpl(pub Arc<Mutex<LayoutThreadData>>);
 
 impl LayoutRPC for LayoutRPCImpl {
 
     // The neat thing here is that in order to answer the following two queries we only
     // need to compare nodes for equality. Thus we can safely work only with `OpaqueNode`.
     fn content_box(&self) -> ContentBoxResponse {
         let &LayoutRPCImpl(ref rw_data) = self;
         let rw_data = rw_data.lock().unwrap();
--- a/servo/components/layout/traversal.rs
+++ b/servo/components/layout/traversal.rs
@@ -10,17 +10,17 @@ use flow::{PostorderFlowTraversal, Preor
 use flow::{self, Flow};
 use gfx::display_list::OpaqueNode;
 use incremental::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPAINT, RestyleDamage};
 use script::layout_interface::ReflowGoal;
 use std::mem;
 use style::context::StyleContext;
 use style::matching::MatchMethods;
 use style::traversal::{DomTraversalContext, STYLE_BLOOM};
-use style::traversal::{put_task_local_bloom_filter, recalc_style_at};
+use style::traversal::{put_thread_local_bloom_filter, recalc_style_at};
 use util::opts;
 use util::tid::tid;
 use wrapper::{LayoutNode, ThreadSafeLayoutNode};
 
 pub struct RecalcStyleAndConstructFlows<'lc> {
     context: LayoutContext<'lc>,
     root: OpaqueNode,
 }
@@ -52,17 +52,17 @@ impl<'lc, 'ln, N: LayoutNode<'ln>> DomTr
         // live for the entire duration of the restyle. This really could _almost_ compile: all
         // we'd need to do is change the signature to to |new<'a: 'lc>|, and everything would
         // work great. But we can't do that, because that would cause a mismatch with the signature
         // in the trait we're implementing, and we can't mention 'lc in that trait at all for the
         // reasons described above.
         //
         // [1] For example, the WorkQueue type needs to be parameterized on the concrete type of
         // DomTraversalContext::SharedContext, and the WorkQueue lifetime is similar to that of the
-        // LayoutTask, generally much longer than that of a given SharedLayoutContext borrow.
+        // LayoutThread, generally much longer than that of a given SharedLayoutContext borrow.
         let shared_lc: &'lc SharedLayoutContext = unsafe { mem::transmute(shared) };
         RecalcStyleAndConstructFlows {
             context: LayoutContext::new(shared_lc),
             root: root,
         }
     }
 
     fn process_preorder(&self, node: N) { recalc_style_at(&self.context, self.root, node); }
@@ -115,23 +115,23 @@ fn construct_flows_at<'a, 'ln, N: Layout
         });
 
     assert_eq!(old_node, unsafe_layout_node);
     assert_eq!(old_generation, context.shared_context().generation);
 
     match node.layout_parent_node(root) {
         None => {
             debug!("[{}] - {:X}, and deleting BF.", tid(), unsafe_layout_node.0);
-            // If this is the reflow root, eat the task-local bloom filter.
+            // If this is the reflow root, eat the thread-local bloom filter.
         }
         Some(parent) => {
             // Otherwise, put it back, but remove this node.
             node.remove_from_bloom_filter(&mut *bf);
             let unsafe_parent = parent.to_unsafe();
-            put_task_local_bloom_filter(bf, &unsafe_parent, &context.shared_context());
+            put_thread_local_bloom_filter(bf, &unsafe_parent, &context.shared_context());
         },
     };
 }
 
 /// The bubble-inline-sizes traversal, the first part of layout computation. This computes
 /// preferred and intrinsic inline-sizes and bubbles them up the tree.
 pub struct BubbleISizes<'a> {
     pub layout_context: &'a LayoutContext<'a>,
--- a/servo/components/layout/wrapper.rs
+++ b/servo/components/layout/wrapper.rs
@@ -11,17 +11,17 @@
 //! this list. The cardinal rules are:
 //!
 //! 1. Layout is not allowed to mutate the DOM.
 //!
 //! 2. Layout is not allowed to see anything with `LayoutJS` in the name, because it could hang
 //!    onto these objects and cause use-after-free.
 //!
 //! When implementing wrapper functions, be careful that you do not touch the borrow flags, or you
-//! will race and cause spurious task failure. (Note that I do not believe these races are
+//! will race and cause spurious thread failure. (Note that I do not believe these races are
 //! exploitable, but they'll result in brokenness nonetheless.)
 //!
 //! Rules of the road for this file:
 //!
 //! * Do not call any methods on DOM nodes without checking to see whether they use borrow flags.
 //!
 //!   o Instead of `get_attr()`, use `.get_attr_val_for_layout()`.
 //!
--- a/servo/components/layout_traits/lib.rs
+++ b/servo/components/layout_traits/lib.rs
@@ -16,44 +16,44 @@ extern crate serde;
 extern crate url;
 extern crate util;
 
 // This module contains traits in layout used generically
 //   in the rest of Servo.
 // The traits are here instead of in layout so
 //   that these modules won't have to depend on layout.
 
-use gfx::font_cache_task::FontCacheTask;
-use gfx::paint_task::LayoutToPaintMsg;
+use gfx::font_cache_thread::FontCacheThread;
+use gfx::paint_thread::LayoutToPaintMsg;
 use ipc_channel::ipc::{IpcReceiver, IpcSender};
 use msg::constellation_msg::{ConstellationChan, Failure, PipelineId};
-use net_traits::image_cache_task::ImageCacheTask;
+use net_traits::image_cache_thread::ImageCacheThread;
 use profile_traits::{mem, time};
 use script_traits::LayoutMsg as ConstellationMsg;
 use script_traits::{LayoutControlMsg, ConstellationControlMsg, OpaqueScriptLayoutChannel};
 use url::Url;
 use util::ipc::OptionalIpcSender;
 
 /// A channel wrapper for constellation messages
 #[derive(Clone, Deserialize, Serialize)]
 pub struct LayoutControlChan(pub IpcSender<LayoutControlMsg>);
 
-// A static method creating a layout task
+// A static method creating a layout thread
 // Here to remove the compositor -> layout dependency
-pub trait LayoutTaskFactory {
+pub trait LayoutThreadFactory {
     // FIXME: use a proper static method
     fn create(_phantom: Option<&mut Self>,
               id: PipelineId,
               url: Url,
               is_iframe: bool,
               chan: OpaqueScriptLayoutChannel,
               pipeline_port: IpcReceiver<LayoutControlMsg>,
               constellation_chan: ConstellationChan<ConstellationMsg>,
               failure_msg: Failure,
               script_chan: IpcSender<ConstellationControlMsg>,
               layout_to_paint_chan: OptionalIpcSender<LayoutToPaintMsg>,
-              image_cache_task: ImageCacheTask,
-              font_cache_task: FontCacheTask,
+              image_cache_thread: ImageCacheThread,
+              font_cache_thread: FontCacheThread,
               time_profiler_chan: time::ProfilerChan,
               mem_profiler_chan: mem::ProfilerChan,
               shutdown_chan: IpcSender<()>,
               content_process_shutdown_chan: IpcSender<()>);
 }
--- a/servo/components/msg/constellation_msg.rs
+++ b/servo/components/msg/constellation_msg.rs
@@ -37,17 +37,17 @@ impl<T: Serialize + Deserialize> Clone f
 }
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug, Deserialize, Serialize)]
 pub enum IFrameSandboxState {
     IFrameSandboxed,
     IFrameUnsandboxed
 }
 
-// We pass this info to various tasks, so it lives in a separate, cloneable struct.
+// We pass this info to various threads, so it lives in a separate, cloneable struct.
 #[derive(Clone, Copy, Deserialize, Serialize)]
 pub struct Failure {
     pub pipeline_id: PipelineId,
     pub parent_info: Option<(PipelineId, SubpageId)>,
 }
 
 #[derive(Copy, Clone, Deserialize, Serialize, HeapSizeOf)]
 pub struct WindowSizeData {
@@ -334,17 +334,17 @@ pub enum PixelFormat {
 pub struct Image {
     pub width: u32,
     pub height: u32,
     pub format: PixelFormat,
     #[ignore_heap_size_of = "Defined in ipc-channel"]
     pub bytes: IpcSharedMemory,
 }
 
-/// Similar to net::resource_task::LoadData
+/// Similar to net::resource_thread::LoadData
 /// can be passed to LoadUrl to load a page with GET/POST
 /// parameters or headers
 #[derive(Clone, Deserialize, Serialize)]
 pub struct LoadData {
     pub url: Url,
     pub method: Method,
     pub headers: Headers,
     pub data: Option<Vec<u8>>,
--- a/servo/components/net/about_loader.rs
+++ b/servo/components/net/about_loader.rs
@@ -4,17 +4,17 @@
 
 use file_loader;
 use hyper::header::ContentType;
 use hyper::http::RawStatus;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::Done;
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::{CancellationListener, send_error, start_sending_sniffed_opt};
+use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
 use std::sync::Arc;
 use url::Url;
 use util::resource_files::resources_dir_path;
 
 pub fn factory(mut load_data: LoadData,
                start_chan: LoadConsumer,
                classifier: Arc<MIMEClassifier>,
                cancel_listener: CancellationListener) {
--- a/servo/components/net/data_loader.rs
+++ b/servo/components/net/data_loader.rs
@@ -1,30 +1,30 @@
 /* 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/. */
 
 use hyper::mime::{Mime, TopLevel, SubLevel, Attr, Value};
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::{CancellationListener, send_error, start_sending_sniffed_opt};
+use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
 use rustc_serialize::base64::FromBase64;
 use std::sync::Arc;
 use url::SchemeData;
 use url::percent_encoding::percent_decode;
 
 pub fn factory(load_data: LoadData,
                senders: LoadConsumer,
                classifier: Arc<MIMEClassifier>,
                cancel_listener: CancellationListener) {
-    // NB: we don't spawn a new task.
+    // NB: we don't spawn a new thread.
     // Hypothesis: data URLs are too small for parallel base64 etc. to be worth it.
     // Should be tested at some point.
-    // Left in separate function to allow easy moving to a task, if desired.
+    // Left in separate function to allow easy moving to a thread, if desired.
     load(load_data, senders, classifier, cancel_listener)
 }
 
 pub fn load(load_data: LoadData,
             start_chan: LoadConsumer,
             classifier: Arc<MIMEClassifier>,
             cancel_listener: CancellationListener) {
     let url = load_data.url;
--- a/servo/components/net/fetch/cors_cache.rs
+++ b/servo/components/net/fetch/cors_cache.rs
@@ -191,137 +191,137 @@ impl CORSCache for BasicCORSCache {
 
     fn insert(&mut self, entry: CORSCacheEntry) {
         self.cleanup();
         let BasicCORSCache(ref mut buf) = *self;
         buf.push(entry);
     }
 }
 
-/// Various messages that can be sent to a CORSCacheTask
-pub enum CORSCacheTaskMsg {
+/// Various messages that can be sent to a CORSCacheThread
+pub enum CORSCacheThreadMsg {
     Clear(CacheRequestDetails, Sender<()>),
     Cleanup(Sender<()>),
     MatchHeader(CacheRequestDetails, String, Sender<bool>),
     MatchHeaderUpdate(CacheRequestDetails, String, u32, Sender<bool>),
     MatchMethod(CacheRequestDetails, Method, Sender<bool>),
     MatchMethodUpdate(CacheRequestDetails, Method, u32, Sender<bool>),
     Insert(CORSCacheEntry, Sender<()>),
     ExitMsg
 }
 
-/// A Sender to a CORSCacheTask
+/// A Sender to a CORSCacheThread
 ///
 /// This can be used as a CORS Cache.
 /// The methods on this type block until they can run, and it behaves similar to a mutex
-pub type CORSCacheSender = Sender<CORSCacheTaskMsg>;
+pub type CORSCacheSender = Sender<CORSCacheThreadMsg>;
 
 impl CORSCache for CORSCacheSender {
     fn clear (&mut self, request: CacheRequestDetails) {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::Clear(request, tx));
+        let _ = self.send(CORSCacheThreadMsg::Clear(request, tx));
         let _ = rx.recv();
     }
 
     fn cleanup(&mut self) {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::Cleanup(tx));
+        let _ = self.send(CORSCacheThreadMsg::Cleanup(tx));
         let _ = rx.recv();
     }
 
     fn match_header(&mut self, request: CacheRequestDetails, header_name: &str) -> bool {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::MatchHeader(request, header_name.to_owned(), tx));
+        let _ = self.send(CORSCacheThreadMsg::MatchHeader(request, header_name.to_owned(), tx));
         rx.recv().unwrap_or(false)
     }
 
     fn match_header_and_update(&mut self, request: CacheRequestDetails, header_name: &str, new_max_age: u32) -> bool {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::MatchHeaderUpdate(request, header_name.to_owned(), new_max_age, tx));
+        let _ = self.send(CORSCacheThreadMsg::MatchHeaderUpdate(request, header_name.to_owned(), new_max_age, tx));
         rx.recv().unwrap_or(false)
     }
 
     fn match_method(&mut self, request: CacheRequestDetails, method: Method) -> bool {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::MatchMethod(request, method, tx));
+        let _ = self.send(CORSCacheThreadMsg::MatchMethod(request, method, tx));
         rx.recv().unwrap_or(false)
     }
 
     fn match_method_and_update(&mut self, request: CacheRequestDetails, method: Method, new_max_age: u32) -> bool {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::MatchMethodUpdate(request, method, new_max_age, tx));
+        let _ = self.send(CORSCacheThreadMsg::MatchMethodUpdate(request, method, new_max_age, tx));
         rx.recv().unwrap_or(false)
     }
 
     fn insert(&mut self, entry: CORSCacheEntry) {
         let (tx, rx) = channel();
-        let _ = self.send(CORSCacheTaskMsg::Insert(entry, tx));
+        let _ = self.send(CORSCacheThreadMsg::Insert(entry, tx));
         let _ = rx.recv();
     }
 }
 
-/// A simple task-based CORS Cache that can be sent messages
+/// A simple thread-based CORS Cache that can be sent messages
 ///
 /// #Example
 /// ```ignore
-/// let task = CORSCacheTask::new();
-/// let builder = TaskBuilder::new().named("XHRTask");
-/// let mut sender = task.sender();
-/// builder.spawn(move || { task.run() });
+/// let thread = CORSCacheThread::new();
+/// let builder = ThreadBuilder::new().named("XHRThread");
+/// let mut sender = thread.sender();
+/// builder.spawn(move || { thread.run() });
 /// sender.insert(CORSCacheEntry::new(/* parameters here */));
 /// ```
-pub struct CORSCacheTask {
-    receiver: Receiver<CORSCacheTaskMsg>,
+pub struct CORSCacheThread {
+    receiver: Receiver<CORSCacheThreadMsg>,
     cache: BasicCORSCache,
     sender: CORSCacheSender
 }
 
-impl CORSCacheTask {
-    pub fn new() -> CORSCacheTask {
+impl CORSCacheThread {
+    pub fn new() -> CORSCacheThread {
         let (tx, rx) = channel();
-        CORSCacheTask {
+        CORSCacheThread {
             receiver: rx,
             cache: BasicCORSCache(vec![]),
             sender: tx
         }
     }
 
-    /// Provides a sender to the cache task
+    /// Provides a sender to the cache thread
     pub fn sender(&self) -> CORSCacheSender {
         self.sender.clone()
     }
 
-    /// Runs the cache task
-    /// This blocks the current task, so it is advised
-    /// to spawn a new task for this
+    /// Runs the cache thread
+    /// This blocks the current thread, so it is advised
+    /// to spawn a new thread for this
     /// Send ExitMsg to the associated Sender to exit
     pub fn run(&mut self) {
         loop {
             match self.receiver.recv().unwrap() {
-                CORSCacheTaskMsg::Clear(request, tx) => {
+                CORSCacheThreadMsg::Clear(request, tx) => {
                     self.cache.clear(request);
                     let _ = tx.send(());
                 },
-                CORSCacheTaskMsg::Cleanup(tx) => {
+                CORSCacheThreadMsg::Cleanup(tx) => {
                     self.cache.cleanup();
                     let _ = tx.send(());
                 },
-                CORSCacheTaskMsg::MatchHeader(request, header, tx) => {
+                CORSCacheThreadMsg::MatchHeader(request, header, tx) => {
                     let _ = tx.send(self.cache.match_header(request, &header));
                 },
-                CORSCacheTaskMsg::MatchHeaderUpdate(request, header, new_max_age, tx) => {
+                CORSCacheThreadMsg::MatchHeaderUpdate(request, header, new_max_age, tx) => {
                     let _ = tx.send(self.cache.match_header_and_update(request, &header, new_max_age));
                 },
-                CORSCacheTaskMsg::MatchMethod(request, method, tx) => {
+                CORSCacheThreadMsg::MatchMethod(request, method, tx) => {
                     let _ = tx.send(self.cache.match_method(request, method));
                 },
-                CORSCacheTaskMsg::MatchMethodUpdate(request, method, new_max_age, tx) => {
+                CORSCacheThreadMsg::MatchMethodUpdate(request, method, new_max_age, tx) => {
                     let _ = tx.send(self.cache.match_method_and_update(request, method, new_max_age));
                 },
-                CORSCacheTaskMsg::Insert(entry, tx) => {
+                CORSCacheThreadMsg::Insert(entry, tx) => {
                     self.cache.insert(entry);
                     let _ = tx.send(());
                 },
-                CORSCacheTaskMsg::ExitMsg => break
+                CORSCacheThreadMsg::ExitMsg => break
             }
         }
     }
 }
--- a/servo/components/net/fetch/request.rs
+++ b/servo/components/net/fetch/request.rs
@@ -12,24 +12,24 @@ use hyper::header::{AcceptLanguage, Cont
 use hyper::header::{Authorization, Basic, ContentEncoding, Encoding};
 use hyper::header::{ContentType, Header, Headers, IfModifiedSince, IfNoneMatch};
 use hyper::header::{QualityItem, q, qitem, Referer as RefererHeader, UserAgent};
 use hyper::method::Method;
 use hyper::mime::{Attr, Mime, SubLevel, TopLevel, Value};
 use hyper::status::StatusCode;
 use net_traits::response::{CacheState, HttpsState, Response, ResponseType, TerminationReason};
 use net_traits::{AsyncFetchListener, Metadata};
-use resource_task::CancellationListener;
+use resource_thread::CancellationListener;
 use std::ascii::AsciiExt;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::str::FromStr;
 use std::thread;
 use url::{Origin, Url, UrlParser};
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 /// A [request context](https://fetch.spec.whatwg.org/#concept-request-context)
 #[derive(Copy, Clone, PartialEq)]
 pub enum Context {
     Audio, Beacon, CSPreport, Download, Embed, Eventsource,
     Favicon, Fetch, Font, Form, Frame, Hyperlink, IFrame, Image,
     ImageSet, Import, Internal, Location, Manifest, MetaRefresh, Object,
     Ping, Plugin, Prefetch, PreRender, Script, ServiceWorker, SharedWorker,
--- a/servo/components/net/file_loader.rs
+++ b/servo/components/net/file_loader.rs
@@ -2,26 +2,26 @@
  * 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/. */
 
 use about_loader;
 use mime_classifier::MIMEClassifier;
 use mime_guess::guess_mime_type;
 use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::{CancellationListener, ProgressSender};
-use resource_task::{send_error, start_sending_sniffed, start_sending_sniffed_opt};
+use resource_thread::{CancellationListener, ProgressSender};
+use resource_thread::{send_error, start_sending_sniffed, start_sending_sniffed_opt};
 use std::borrow::ToOwned;
 use std::error::Error;
 use std::fs::File;
 use std::io::Read;
 use std::path::PathBuf;
 use std::sync::Arc;
 use url::Url;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 static READ_SIZE: usize = 8192;
 
 enum ReadStatus {
     Partial(Vec<u8>),
     EOF,
 }
 
--- a/servo/components/net/http_loader.rs
+++ b/servo/components/net/http_loader.rs
@@ -24,29 +24,29 @@ use hyper::status::{StatusClass, StatusC
 use log;
 use mime_classifier::MIMEClassifier;
 use msg::constellation_msg::{PipelineId};
 use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::hosts::replace_hosts;
 use net_traits::{CookieSource, IncludeSubdomains, LoadConsumer, LoadContext, LoadData, Metadata};
 use openssl::ssl::error::{SslError, OpensslError};
 use openssl::ssl::{SSL_OP_NO_SSLV2, SSL_OP_NO_SSLV3, SSL_VERIFY_PEER, SslContext, SslMethod};
-use resource_task::{CancellationListener, send_error, start_sending_sniffed_opt};
+use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
 use std::collections::HashSet;
 use std::error::Error;
 use std::io::{self, Read, Write};
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, RwLock};
 use time;
 use time::Tm;
 use url::Url;
 use util::resource_files::resources_dir_path;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use uuid;
 
 pub type Connector = HttpsConnector<Openssl>;
 
 // The basic logic here is to prefer ciphers with ECDSA certificates, Forward
 // Secrecy, AES GCM ciphers, AES ciphers, and finally 3DES ciphers.
 // A complete discussion of the issues involved in TLS configuration can be found here:
 // https://wiki.mozilla.org/Security/Server_Side_TLS
rename from servo/components/net/image_cache_task.rs
rename to servo/components/net/image_cache_thread.rs
--- a/servo/components/net/image_cache_task.rs
+++ b/servo/components/net/image_cache_thread.rs
@@ -1,43 +1,43 @@
 /* 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/. */
 
 use ipc_channel::ipc::{self, IpcSender};
 use ipc_channel::router::ROUTER;
 use net_traits::image::base::{Image, load_from_memory};
-use net_traits::image_cache_task::ImageResponder;
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheCommand, ImageCacheTask, ImageState};
-use net_traits::image_cache_task::{ImageCacheResult, ImageResponse, UsePlaceholder};
-use net_traits::{AsyncResponseTarget, ControlMsg, LoadConsumer, LoadData, ResourceTask};
+use net_traits::image_cache_thread::ImageResponder;
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheCommand, ImageCacheThread, ImageState};
+use net_traits::image_cache_thread::{ImageCacheResult, ImageResponse, UsePlaceholder};
+use net_traits::{AsyncResponseTarget, ControlMsg, LoadConsumer, LoadData, ResourceThread};
 use net_traits::{ResponseAction, LoadContext};
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::fs::File;
 use std::io::Read;
 use std::mem;
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Select, Sender, channel};
 use url::Url;
 use util::resource_files::resources_dir_path;
-use util::task::spawn_named;
-use util::taskpool::TaskPool;
+use util::thread::spawn_named;
+use util::threadpool::ThreadPool;
 
 ///
 /// TODO(gw): Remaining work on image cache:
 ///     * Make use of the prefetch support in various parts of the code.
-///     * Profile time in GetImageIfAvailable - might be worth caching these results per paint / layout task.
+///     * Profile time in GetImageIfAvailable - might be worth caching these results per paint / layout thread.
 ///
 /// MAYBE(Yoric):
 ///     * For faster lookups, it might be useful to store the LoadKey in the DOM once we have performed a first load.
 
 /// Represents an image that is either being loaded
-/// by the resource task, or decoded by a worker thread.
+/// by the resource thread, or decoded by a worker thread.
 struct PendingLoad {
     // The bytes loaded so far. Reset to an empty vector once loading
     // is complete and the buffer has been transmitted to the decoder.
     bytes: Vec<u8>,
 
     // Once loading is complete, the result of the operation.
     result: Option<Result<(), String>>,
     listeners: Vec<ImageListener>,
@@ -210,47 +210,47 @@ struct ResourceLoadInfo {
     key: LoadKey,
 }
 
 /// Implementation of the image cache
 struct ImageCache {
     // Receive commands from clients
     cmd_receiver: Receiver<ImageCacheCommand>,
 
-    // Receive notifications from the resource task
+    // Receive notifications from the resource thread
     progress_receiver: Receiver<ResourceLoadInfo>,
     progress_sender: Sender<ResourceLoadInfo>,
 
     // Receive notifications from the decoder thread pool
     decoder_receiver: Receiver<DecoderMsg>,
     decoder_sender: Sender<DecoderMsg>,
 
     // Worker threads for decoding images.
-    task_pool: TaskPool,
+    thread_pool: ThreadPool,
 
-    // Resource task handle
-    resource_task: ResourceTask,
+    // Resource thread handle
+    resource_thread: ResourceThread,
 
     // Images that are loading over network, or decoding.
     pending_loads: AllPendingLoads,
 
     // Images that have finished loading (successful or not)
     completed_loads: HashMap<Arc<Url>, CompletedLoad>,
 
     // The placeholder image used when an image fails to load
     placeholder_image: Option<Arc<Image>>,
 }
 
-/// Message that the decoder worker threads send to main image cache task.
+/// Message that the decoder worker threads send to main image cache thread.
 struct DecoderMsg {
     key: LoadKey,
     image: Option<Image>,
 }
 
-/// The types of messages that the main image cache task receives.
+/// The types of messages that the main image cache thread receives.
 enum SelectResult {
     Command(ImageCacheCommand),
     Progress(ResourceLoadInfo),
     Decoder(DecoderMsg),
 }
 
 impl ImageCache {
     fn run(&mut self) {
@@ -333,34 +333,34 @@ impl ImageCache {
                 };
                 consumer.send(result).unwrap();
             }
         };
 
         None
     }
 
-    // Handle progress messages from the resource task
+    // Handle progress messages from the resource thread
     fn handle_progress(&mut self, msg: ResourceLoadInfo) {
         match (msg.action, msg.key) {
             (ResponseAction::HeadersAvailable(_), _) => {}
             (ResponseAction::DataAvailable(data), _) => {
                 let pending_load = self.pending_loads.get_by_key_mut(&msg.key).unwrap();
                 pending_load.bytes.extend_from_slice(&data);
             }
             (ResponseAction::ResponseComplete(result), key) => {
                 match result {
                     Ok(()) => {
                         let pending_load = self.pending_loads.get_by_key_mut(&msg.key).unwrap();
                         pending_load.result = Some(result);
 
                         let bytes = mem::replace(&mut pending_load.bytes, vec!());
                         let sender = self.decoder_sender.clone();
 
-                        self.task_pool.execute(move || {
+                        self.thread_pool.execute(move || {
                             let image = load_from_memory(&bytes);
                             let msg = DecoderMsg {
                                 key: key,
                                 image: image
                             };
                             sender.send(msg).unwrap();
                         });
                     }
@@ -418,46 +418,46 @@ impl ImageCache {
             }
             None => {
                 // Check if the load is already pending
                 let (cache_result, load_key, mut pending_load) = self.pending_loads.get_cached(ref_url.clone());
                 pending_load.add_listener(image_listener);
                 match cache_result {
                     CacheResult::Miss => {
                         // A new load request! Request the load from
-                        // the resource task.
+                        // the resource thread.
                         let load_data = LoadData::new(LoadContext::Image, (*ref_url).clone(), None);
                         let (action_sender, action_receiver) = ipc::channel().unwrap();
                         let response_target = AsyncResponseTarget {
                             sender: action_sender,
                         };
                         let msg = ControlMsg::Load(load_data,
                                                    LoadConsumer::Listener(response_target),
                                                    None);
                         let progress_sender = self.progress_sender.clone();
                         ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
                             let action: ResponseAction = message.to().unwrap();
                             progress_sender.send(ResourceLoadInfo {
                                 action: action,
                                 key: load_key,
                             }).unwrap();
                         });
-                        self.resource_task.send(msg).unwrap();
+                        self.resource_thread.send(msg).unwrap();
                     }
                     CacheResult::Hit => {
                         // Request is already on its way.
                     }
                 }
             }
         }
     }
 }
 
 /// Create a new image cache.
-pub fn new_image_cache_task(resource_task: ResourceTask) -> ImageCacheTask {
+pub fn new_image_cache_thread(resource_thread: ResourceThread) -> ImageCacheThread {
     let (ipc_command_sender, ipc_command_receiver) = ipc::channel().unwrap();
     let (progress_sender, progress_receiver) = channel();
     let (decoder_sender, decoder_receiver) = channel();
 
     spawn_named("ImageCacheThread".to_owned(), move || {
 
         // Preload the placeholder image, used when images fail to load.
         let mut placeholder_path = resources_dir_path();
@@ -475,20 +475,20 @@ pub fn new_image_cache_task(resource_tas
         let cmd_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_command_receiver);
 
         let mut cache = ImageCache {
             cmd_receiver: cmd_receiver,
             progress_sender: progress_sender,
             progress_receiver: progress_receiver,
             decoder_sender: decoder_sender,
             decoder_receiver: decoder_receiver,
-            task_pool: TaskPool::new(4),
+            thread_pool: ThreadPool::new(4),
             pending_loads: AllPendingLoads::new(),
             completed_loads: HashMap::new(),
-            resource_task: resource_task,
+            resource_thread: resource_thread,
             placeholder_image: placeholder_image,
         };
 
         cache.run();
     });
 
-    ImageCacheTask::new(ipc_command_sender)
+    ImageCacheThread::new(ipc_command_sender)
 }
--- a/servo/components/net/lib.rs
+++ b/servo/components/net/lib.rs
@@ -31,21 +31,21 @@ extern crate websocket;
 
 pub mod about_loader;
 pub mod cookie;
 pub mod cookie_storage;
 pub mod data_loader;
 pub mod file_loader;
 pub mod hsts;
 pub mod http_loader;
-pub mod image_cache_task;
+pub mod image_cache_thread;
 pub mod mime_classifier;
 pub mod pub_domains;
-pub mod resource_task;
-pub mod storage_task;
+pub mod resource_thread;
+pub mod storage_thread;
 pub mod websocket_loader;
 
 /// An implementation of the [Fetch spec](https://fetch.spec.whatwg.org/)
 pub mod fetch {
     #![allow(dead_code, unused)] // XXXManishearth this is only temporary until the Fetch mod starts being used
     pub mod cors_cache;
     pub mod request;
     pub mod response;
rename from servo/components/net/resource_task.rs
rename to servo/components/net/resource_thread.rs
--- a/servo/components/net/resource_task.rs
+++ b/servo/components/net/resource_thread.rs
@@ -1,41 +1,41 @@
 /* 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/. */
 
-//! A task that takes a URL and streams back the binary data.
+//! A thread that takes a URL and streams back the binary data.
 
 use about_loader;
 use cookie;
 use cookie_storage::CookieStorage;
 use data_loader;
 use devtools_traits::{DevtoolsControlMsg};
 use file_loader;
 use hsts::{HSTSList, preload_hsts_domains};
 use http_loader::{self, Connector, create_http_connector};
 use hyper::client::pool::Pool;
 use hyper::header::{ContentType, Header, SetCookie};
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use mime_classifier::{ApacheBugFlag, MIMEClassifier, NoSniffFlag};
 use net_traits::LoadContext;
 use net_traits::ProgressMsg::Done;
-use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResourceTask, ResponseAction};
+use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResourceThread, ResponseAction};
 use net_traits::{ControlMsg, CookieSource, LoadConsumer, LoadData, LoadResponse, ResourceId};
 use net_traits::{WebSocketCommunicate, WebSocketConnectData};
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
 use std::cell::Cell;
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::sync::{Arc, RwLock};
 use url::Url;
 use util::prefs;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use websocket_loader;
 
 pub enum ProgressSender {
     Channel(IpcSender<ProgressMsg>),
     Listener(AsyncResponseTarget),
 }
 
 impl ProgressSender {
@@ -140,19 +140,19 @@ fn start_sending_opt(start_chan: LoadCon
         }
         LoadConsumer::Listener(target) => {
             target.invoke_with_listener(ResponseAction::HeadersAvailable(metadata));
             Ok(ProgressSender::Listener(target))
         }
     }
 }
 
-/// Create a ResourceTask
-pub fn new_resource_task(user_agent: String,
-                         devtools_chan: Option<Sender<DevtoolsControlMsg>>) -> ResourceTask {
+/// Create a ResourceThread
+pub fn new_resource_thread(user_agent: String,
+                         devtools_chan: Option<Sender<DevtoolsControlMsg>>) -> ResourceThread {
     let hsts_preload = match preload_hsts_domains() {
         Some(list) => list,
         None => HSTSList::new()
     };
 
     let (setup_chan, setup_port) = ipc::channel().unwrap();
     let setup_chan_clone = setup_chan.clone();
     spawn_named("ResourceManager".to_owned(), move || {
@@ -170,17 +170,17 @@ pub fn new_resource_task(user_agent: Str
 }
 
 struct ResourceChannelManager {
     from_client: IpcReceiver<ControlMsg>,
     resource_manager: ResourceManager
 }
 
 impl ResourceChannelManager {
-    fn start(&mut self, control_sender: ResourceTask) {
+    fn start(&mut self, control_sender: ResourceThread) {
         loop {
             match self.from_client.recv().unwrap() {
                 ControlMsg::Load(load_data, consumer, id_sender) =>
                     self.resource_manager.load(load_data, consumer, id_sender, control_sender.clone()),
                 ControlMsg::WebsocketConnect(connect, connect_data) =>
                     self.resource_manager.websocket_connect(connect, connect_data),
                 ControlMsg::SetCookiesForUrl(request, cookie_list, source) =>
                     self.resource_manager.set_cookies_for_url(request, cookie_list, source),
@@ -208,25 +208,25 @@ impl ResourceChannelManager {
 pub struct CancellableResource {
     /// The receiver which receives a message on load cancellation
     cancel_receiver: Receiver<()>,
     /// The `CancellationListener` is unique to this `ResourceId`
     resource_id: ResourceId,
     /// If we haven't initiated any cancel requests, then the loaders ask
     /// the listener to remove the `ResourceId` in the `HashMap` of
     /// `ResourceManager` once they finish loading
-    resource_task: ResourceTask,
+    resource_thread: ResourceThread,
 }
 
 impl CancellableResource {
-    pub fn new(receiver: Receiver<()>, res_id: ResourceId, res_task: ResourceTask) -> CancellableResource {
+    pub fn new(receiver: Receiver<()>, res_id: ResourceId, res_thread: ResourceThread) -> CancellableResource {
         CancellableResource {
             cancel_receiver: receiver,
             resource_id: res_id,
-            resource_task: res_task,
+            resource_thread: res_thread,
         }
     }
 }
 
 /// A listener which is basically a wrapped optional receiver which looks
 /// for the load cancellation message. Some of the loading processes always keep
 /// an eye out for this message and stop loading stuff once they receive it.
 pub struct CancellationListener {
@@ -259,17 +259,17 @@ impl CancellationListener {
         }
     }
 }
 
 impl Drop for CancellationListener {
     fn drop(&mut self) {
         if let Some(ref resource) = self.cancel_resource {
             // Ensure that the resource manager stops tracking this request now that it's terminated.
-            let _ = resource.resource_task.send(ControlMsg::Cancel(resource.resource_id));
+            let _ = resource.resource_thread.send(ControlMsg::Cancel(resource.resource_id));
         }
     }
 }
 
 pub struct ResourceManager {
     user_agent: String,
     cookie_storage: Arc<RwLock<CookieStorage>>,
     mime_classifier: Arc<MIMEClassifier>,
@@ -308,17 +308,17 @@ impl ResourceManager {
             }
         }
     }
 
     fn load(&mut self,
             load_data: LoadData,
             consumer: LoadConsumer,
             id_sender: Option<IpcSender<ResourceId>>,
-            resource_task: ResourceTask) {
+            resource_thread: ResourceThread) {
 
         fn from_factory(factory: fn(LoadData, LoadConsumer, Arc<MIMEClassifier>, CancellationListener))
                         -> Box<FnBox(LoadData,
                                      LoadConsumer,
                                      Arc<MIMEClassifier>,
                                      CancellationListener) + Send> {
             box move |load_data, senders, classifier, cancel_listener| {
                 factory(load_data, senders, classifier, cancel_listener)
@@ -326,37 +326,37 @@ impl ResourceManager {
         }
 
         let cancel_resource = id_sender.map(|sender| {
             let current_res_id = self.next_resource_id;
             let _ = sender.send(current_res_id);
             let (cancel_sender, cancel_receiver) = channel();
             self.cancel_load_map.insert(current_res_id, cancel_sender);
             self.next_resource_id.0 += 1;
-            CancellableResource::new(cancel_receiver, current_res_id, resource_task)
+            CancellableResource::new(cancel_receiver, current_res_id, resource_thread)
         });
 
         let cancel_listener = CancellationListener::new(cancel_resource);
         let loader = match &*load_data.url.scheme {
             "file" => from_factory(file_loader::factory),
             "http" | "https" | "view-source" =>
                 http_loader::factory(self.user_agent.clone(),
                                      self.hsts_list.clone(),
                                      self.cookie_storage.clone(),
                                      self.devtools_chan.clone(),
                                      self.connector.clone()),
             "data" => from_factory(data_loader::factory),
             "about" => from_factory(about_loader::factory),
             _ => {
-                debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
+                debug!("resource_thread: no loader for scheme {}", load_data.url.scheme);
                 send_error(load_data.url, "no loader for scheme".to_owned(), consumer);
                 return
             }
         };
-        debug!("resource_task: loading url: {}", load_data.url.serialize());
+        debug!("resource_thread: loading url: {}", load_data.url.serialize());
 
         loader.call_box((load_data,
                          consumer,
                          self.mime_classifier.clone(),
                          cancel_listener));
     }
 
     fn websocket_connect(&self,
rename from servo/components/net/storage_task.rs
rename to servo/components/net/storage_thread.rs
--- a/servo/components/net/storage_task.rs
+++ b/servo/components/net/storage_thread.rs
@@ -1,80 +1,80 @@
 /* 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/. */
 
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
-use net_traits::storage_task::{StorageTask, StorageTaskMsg, StorageType};
+use net_traits::storage_thread::{StorageThread, StorageThreadMsg, StorageType};
 use std::borrow::ToOwned;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::sync::mpsc::channel;
 use url::Url;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 const QUOTA_SIZE_LIMIT: usize = 5 * 1024 * 1024;
 
-pub trait StorageTaskFactory {
+pub trait StorageThreadFactory {
     fn new() -> Self;
 }
 
-impl StorageTaskFactory for StorageTask {
-    /// Create a StorageTask
-    fn new() -> StorageTask {
+impl StorageThreadFactory for StorageThread {
+    /// Create a StorageThread
+    fn new() -> StorageThread {
         let (chan, port) = ipc::channel().unwrap();
         spawn_named("StorageManager".to_owned(), move || {
             StorageManager::new(port).start();
         });
         chan
     }
 }
 
 struct StorageManager {
-    port: IpcReceiver<StorageTaskMsg>,
+    port: IpcReceiver<StorageThreadMsg>,
     session_data: HashMap<String, (usize, BTreeMap<String, String>)>,
     local_data: HashMap<String, (usize, BTreeMap<String, String>)>,
 }
 
 impl StorageManager {
-    fn new(port: IpcReceiver<StorageTaskMsg>) -> StorageManager {
+    fn new(port: IpcReceiver<StorageThreadMsg>) -> StorageManager {
         StorageManager {
             port: port,
             session_data: HashMap::new(),
             local_data: HashMap::new(),
         }
     }
 }
 
 impl StorageManager {
     fn start(&mut self) {
         loop {
             match self.port.recv().unwrap() {
-                StorageTaskMsg::Length(sender, url, storage_type) => {
+                StorageThreadMsg::Length(sender, url, storage_type) => {
                     self.length(sender, url, storage_type)
                 }
-                StorageTaskMsg::Key(sender, url, storage_type, index) => {
+                StorageThreadMsg::Key(sender, url, storage_type, index) => {
                     self.key(sender, url, storage_type, index)
                 }
-                StorageTaskMsg::Keys(sender, url, storage_type) => {
+                StorageThreadMsg::Keys(sender, url, storage_type) => {
                     self.keys(sender, url, storage_type)
                 }
-                StorageTaskMsg::SetItem(sender, url, storage_type, name, value) => {
+                StorageThreadMsg::SetItem(sender, url, storage_type, name, value) => {
                     self.set_item(sender, url, storage_type, name, value)
                 }
-                StorageTaskMsg::GetItem(sender, url, storage_type, name) => {
+                StorageThreadMsg::GetItem(sender, url, storage_type, name) => {
                     self.request_item(sender, url, storage_type, name)
                 }
-                StorageTaskMsg::RemoveItem(sender, url, storage_type, name) => {
+                StorageThreadMsg::RemoveItem(sender, url, storage_type, name) => {
                     self.remove_item(sender, url, storage_type, name)
                 }
-                StorageTaskMsg::Clear(sender, url, storage_type) => {
+                StorageThreadMsg::Clear(sender, url, storage_type) => {
                     self.clear(sender, url, storage_type)
                 }
-                StorageTaskMsg::Exit => {
+                StorageThreadMsg::Exit => {
                     break
                 }
             }
         }
     }
 
     fn select_data(&self, storage_type: StorageType)
                    -> &HashMap<String, (usize, BTreeMap<String, String>)> {
--- a/servo/components/net/websocket_loader.rs
+++ b/servo/components/net/websocket_loader.rs
@@ -5,17 +5,17 @@
 use hyper::header::Host;
 use net_traits::MessageData;
 use net_traits::hosts::replace_hosts;
 use net_traits::unwrap_websocket_protocol;
 use net_traits::{WebSocketCommunicate, WebSocketConnectData, WebSocketDomAction, WebSocketNetworkEvent};
 use std::ascii::AsciiExt;
 use std::sync::{Arc, Mutex};
 use std::thread;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use websocket::client::receiver::Receiver;
 use websocket::client::request::Url;
 use websocket::client::sender::Sender;
 use websocket::header::{Headers, Origin, WebSocketProtocol};
 use websocket::message::Type;
 use websocket::result::{WebSocketError, WebSocketResult};
 use websocket::stream::WebSocketStream;
 use websocket::ws::receiver::Receiver as WSReceiver;
rename from servo/components/net_traits/image_cache_task.rs
rename to servo/components/net_traits/image_cache_thread.rs
--- a/servo/components/net_traits/image_cache_task.rs
+++ b/servo/components/net_traits/image_cache_thread.rs
@@ -66,42 +66,42 @@ pub enum ImageCacheCommand {
     /// Request an image asynchronously from the cache. Supply a channel
     /// to receive the result, and optionally an image responder
     /// that is passed to the result channel.
     RequestImage(Url, ImageCacheChan, Option<ImageResponder>),
 
     /// Synchronously check the state of an image in the cache.
     /// TODO(gw): Profile this on some real world sites and see
     /// if it's worth caching the results of this locally in each
-    /// layout / paint task.
+    /// layout / paint thread.
     GetImageIfAvailable(Url, UsePlaceholder, IpcSender<Result<Arc<Image>, ImageState>>),
 
-    /// Clients must wait for a response before shutting down the ResourceTask
+    /// Clients must wait for a response before shutting down the ResourceThread
     Exit(IpcSender<()>),
 }
 
 #[derive(Copy, Clone, PartialEq, Deserialize, Serialize)]
 pub enum UsePlaceholder {
     No,
     Yes,
 }
 
-/// The client side of the image cache task. This can be safely cloned
-/// and passed to different tasks.
+/// The client side of the image cache thread. This can be safely cloned
+/// and passed to different threads.
 #[derive(Clone, Deserialize, Serialize)]
-pub struct ImageCacheTask {
+pub struct ImageCacheThread {
     chan: IpcSender<ImageCacheCommand>,
 }
 
-/// The public API for the image cache task.
-impl ImageCacheTask {
+/// The public API for the image cache thread.
+impl ImageCacheThread {
 
     /// Construct a new image cache
-    pub fn new(chan: IpcSender<ImageCacheCommand>) -> ImageCacheTask {
-        ImageCacheTask {
+    pub fn new(chan: IpcSender<ImageCacheCommand>) -> ImageCacheThread {
+        ImageCacheThread {
             chan: chan,
         }
     }
 
     /// Asynchronously request and image. See ImageCacheCommand::RequestImage.
     pub fn request_image(&self,
                          url: Url,
                          result_chan: ImageCacheChan,
@@ -114,16 +114,16 @@ impl ImageCacheTask {
     pub fn find_image(&self, url: Url, use_placeholder: UsePlaceholder)
                                   -> Result<Arc<Image>, ImageState> {
         let (sender, receiver) = ipc::channel().unwrap();
         let msg = ImageCacheCommand::GetImageIfAvailable(url, use_placeholder, sender);
         self.chan.send(msg).unwrap();
         receiver.recv().unwrap()
     }
 
-    /// Shutdown the image cache task.
+    /// Shutdown the image cache thread.
     pub fn exit(&self) {
         let (response_chan, response_port) = ipc::channel().unwrap();
         self.chan.send(ImageCacheCommand::Exit(response_chan)).unwrap();
         response_port.recv().unwrap();
     }
 }
 
--- a/servo/components/net_traits/lib.rs
+++ b/servo/components/net_traits/lib.rs
@@ -32,20 +32,20 @@ use ipc_channel::ipc::{self, IpcReceiver
 use msg::constellation_msg::{PipelineId};
 use serde::{Deserializer, Serializer};
 use std::thread;
 use url::Url;
 use util::mem::HeapSizeOf;
 use websocket::header;
 
 pub mod hosts;
-pub mod image_cache_task;
+pub mod image_cache_thread;
 pub mod net_error_list;
 pub mod response;
-pub mod storage_task;
+pub mod storage_thread;
 
 /// Image handling.
 ///
 /// It may be surprising that this goes in the network crate as opposed to the graphics crate.
 /// However, image handling is generally very integrated with the network stack (especially where
 /// caching is involved) and as a result it must live in here.
 pub mod image {
     pub mod base;
@@ -155,18 +155,18 @@ impl AsyncResponseTarget {
 
 /// A wrapper for a network load that can either be channel or event-based.
 #[derive(Deserialize, Serialize)]
 pub enum LoadConsumer {
     Channel(IpcSender<LoadResponse>),
     Listener(AsyncResponseTarget),
 }
 
-/// Handle to a resource task
-pub type ResourceTask = IpcSender<ControlMsg>;
+/// Handle to a resource thread
+pub type ResourceThread = IpcSender<ControlMsg>;
 
 #[derive(PartialEq, Copy, Clone, Deserialize, Serialize)]
 pub enum IncludeSubdomains {
     Included,
     NotIncluded
 }
 
 #[derive(HeapSizeOf, Deserialize, Serialize)]
@@ -215,20 +215,20 @@ pub enum ControlMsg {
     Cancel(ResourceId),
     /// Synchronization message solely for knowing the state of the ResourceChannelManager loop
     Synchronize(IpcSender<()>),
     /// Break the load handler loop and exit
     Exit,
 }
 
 /// Initialized but unsent request. Encapsulates everything necessary to instruct
-/// the resource task to make a new request. The `load` method *must* be called before
-/// destruction or the task will panic.
+/// the resource thread to make a new request. The `load` method *must* be called before
+/// destruction or the thread will panic.
 pub struct PendingAsyncLoad {
-    resource_task: ResourceTask,
+    resource_thread: ResourceThread,
     url: Url,
     pipeline: Option<PipelineId>,
     guard: PendingLoadGuard,
     context: LoadContext,
 }
 
 struct PendingLoadGuard {
     loaded: bool,
@@ -244,33 +244,33 @@ impl Drop for PendingLoadGuard {
     fn drop(&mut self) {
         if !thread::panicking() {
             assert!(self.loaded)
         }
     }
 }
 
 impl PendingAsyncLoad {
-    pub fn new(context: LoadContext, resource_task: ResourceTask, url: Url, pipeline: Option<PipelineId>)
+    pub fn new(context: LoadContext, resource_thread: ResourceThread, url: Url, pipeline: Option<PipelineId>)
                -> PendingAsyncLoad {
         PendingAsyncLoad {
-            resource_task: resource_task,
+            resource_thread: resource_thread,
             url: url,
             pipeline: pipeline,
             guard: PendingLoadGuard { loaded: false, },
             context: context
         }
     }
 
     /// Initiate the network request associated with this pending load, using the provided target.
     pub fn load_async(mut self, listener: AsyncResponseTarget) {
         self.guard.neuter();
         let load_data = LoadData::new(self.context, self.url, self.pipeline);
         let consumer = LoadConsumer::Listener(listener);
-        self.resource_task.send(ControlMsg::Load(load_data, consumer, None)).unwrap();
+        self.resource_thread.send(ControlMsg::Load(load_data, consumer, None)).unwrap();
     }
 }
 
 /// Message sent in response to `Load`.  Contains metadata, and a port
 /// for receiving the data.
 ///
 /// Even if loading fails immediately, we send one of these and the
 /// progress_port will provide the error.
@@ -355,22 +355,22 @@ pub enum ProgressMsg {
     /// Binary data - there may be multiple of these
     Payload(Vec<u8>),
     /// Indicates loading is complete, either successfully or not
     Done(Result<(), String>)
 }
 
 /// Convenience function for synchronously loading a whole resource.
 pub fn load_whole_resource(context: LoadContext,
-                           resource_task: &ResourceTask,
+                           resource_thread: &ResourceThread,
                            url: Url,
                            pipeline_id: Option<PipelineId>)
         -> Result<(Metadata, Vec<u8>), String> {
     let (start_chan, start_port) = ipc::channel().unwrap();
-    resource_task.send(ControlMsg::Load(LoadData::new(context, url, pipeline_id),
+    resource_thread.send(ControlMsg::Load(LoadData::new(context, url, pipeline_id),
                        LoadConsumer::Channel(start_chan), None)).unwrap();
     let response = start_port.recv().unwrap();
 
     let mut buf = vec!();
     loop {
         match response.progress_port.recv().unwrap() {
             ProgressMsg::Payload(data) => buf.extend_from_slice(&data),
             ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)),
rename from servo/components/net_traits/storage_task.rs
rename to servo/components/net_traits/storage_thread.rs
--- a/servo/components/net_traits/storage_task.rs
+++ b/servo/components/net_traits/storage_thread.rs
@@ -8,17 +8,17 @@ use url::Url;
 #[derive(Copy, Clone, Deserialize, Serialize, HeapSizeOf)]
 pub enum StorageType {
     Session,
     Local
 }
 
 /// Request operations on the storage data associated with a particular url
 #[derive(Deserialize, Serialize)]
-pub enum StorageTaskMsg {
+pub enum StorageThreadMsg {
     /// gets the number of key/value pairs present in the associated storage data
     Length(IpcSender<usize>, Url, StorageType),
 
     /// gets the name of the key at the specified index in the associated storage data
     Key(IpcSender<Option<String>>, Url, StorageType, u32),
 
     /// Gets the available keys in the associated storage data
     Keys(IpcSender<Vec<String>>, Url, StorageType),
@@ -30,16 +30,16 @@ pub enum StorageTaskMsg {
     SetItem(IpcSender<Result<(bool, Option<String>), ()>>, Url, StorageType, String, String),
 
     /// removes the key/value pair for the given key in the associated storage data
     RemoveItem(IpcSender<Option<String>>, Url, StorageType, String),
 
     /// clears the associated storage data by removing all the key/value pairs
     Clear(IpcSender<bool>, Url, StorageType),
 
-    /// shut down this task
+    /// shut down this thread
     Exit
 }
 
-/// Handle to a storage task
-pub type StorageTask = IpcSender<StorageTaskMsg>;
+/// Handle to a storage thread
+pub type StorageThread = IpcSender<StorageThreadMsg>;
 
 
--- a/servo/components/plugins/lints/unrooted_must_root.rs
+++ b/servo/components/plugins/lints/unrooted_must_root.rs
@@ -24,17 +24,17 @@ declare_lint!(UNROOTED_MUST_ROOT, Deny,
 ///
 ///  - Not being used in a struct/enum field which is not `#[must_root]` itself
 ///  - Not being used as an argument to a function (Except onces named `new` and `new_inherited`)
 ///  - Not being bound locally in a `let` statement, assignment, `for` loop, or `match` statement.
 ///
 /// This helps catch most situations where pointers like `JS<T>` are used in a way that they can be invalidated by a
 /// GC pass.
 ///
-/// Structs which have their own mechanism of rooting their unrooted contents (e.g. `ScriptTask`)
+/// Structs which have their own mechanism of rooting their unrooted contents (e.g. `ScriptThread`)
 /// can be marked as `#[allow(unrooted_must_root)]`. Smart pointers which root their interior type
 /// can be marked as `#[allow_unrooted_interior]`
 pub struct UnrootedPass;
 
 impl UnrootedPass {
     pub fn new() -> UnrootedPass {
         UnrootedPass
     }
--- a/servo/components/profile/mem.rs
+++ b/servo/components/profile/mem.rs
@@ -7,17 +7,17 @@
 use ipc_channel::ipc::{self, IpcReceiver};
 use ipc_channel::router::ROUTER;
 use profile_traits::mem::ReportsChan;
 use profile_traits::mem::{ProfilerChan, ProfilerMsg, ReportKind, Reporter, ReporterRequest};
 use std::borrow::ToOwned;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::thread;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use util::time::duration_from_seconds;
 
 pub struct Profiler {
     /// The port through which messages are received.
     pub port: IpcReceiver<ProfilerMsg>,
 
     /// Registered memory reporters.
     reporters: HashMap<String, Reporter>,
--- a/servo/components/profile/time.rs
+++ b/servo/components/profile/time.rs
@@ -10,17 +10,17 @@ use profile_traits::energy::{energy_inte
 use profile_traits::time::{ProfilerCategory, ProfilerChan, ProfilerMsg, TimerMetadata};
 use profile_traits::time::{TimerMetadataReflowType, TimerMetadataFrameType};
 use std::borrow::ToOwned;
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::time::Duration;
 use std::{thread, f64};
 use std_time::precise_time_ns;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 use util::time::duration_from_seconds;
 
 pub trait Formattable {
     fn format(&self) -> String;
 }
 
 impl Formattable for Option<TimerMetadata> {
     fn format(&self) -> String {
--- a/servo/components/profile_traits/mem.rs
+++ b/servo/components/profile_traits/mem.rs
@@ -45,17 +45,17 @@ impl ProfilerChan {
         where F: FnOnce(),
               M: Fn(ReportsChan) -> T + Send + 'static,
               T: Send + 'static,
               C: OpaqueSender<T> + Send + 'static
     {
         // Register the memory reporter.
         let (reporter_sender, reporter_receiver) = ipc::channel().unwrap();
         ROUTER.add_route(reporter_receiver.to_opaque(), box move |message| {
-            // Just injects an appropriate event into the paint task's queue.
+            // Just injects an appropriate event into the paint thread's queue.
             let request: ReporterRequest = message.to().unwrap();
             channel_for_reporter.send(msg(request.reports_channel));
         });
         self.send(ProfilerMsg::RegisterReporter(reporter_name.clone(),
                                                 Reporter(reporter_sender)));
 
         f();
 
--- a/servo/components/script/cors.rs
+++ b/servo/components/script/cors.rs
@@ -15,25 +15,25 @@ use hyper::header::{AccessControlAllowMe
 use hyper::header::{AccessControlAllowOrigin, AccessControlMaxAge};
 use hyper::header::{ContentType, Host};
 use hyper::header::{HeaderView, Headers};
 use hyper::method::Method;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper::status::StatusClass::Success;
 use net_traits::{AsyncResponseListener, Metadata, ResponseAction};
 use network_listener::{NetworkListener, PreInvoke};
-use script_task::ScriptChan;
+use script_thread::ScriptChan;
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::sync::{Arc, Mutex};
 use time::{self, Timespec, now};
 use unicase::UniCase;
 use url::{SchemeData, Url};
 use util::mem::HeapSizeOf;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 /// Interface for network listeners concerned with CORS checks. Proper network requests
 /// should be initiated from this method, based on the response provided.
 pub trait AsyncCORSResponseListener {
     fn response_available(&self, response: CORSResponse);
 }
 
 #[derive(Clone, HeapSizeOf)]
@@ -136,17 +136,17 @@ impl CORSRequest {
             response: None,
         };
         let listener = NetworkListener {
             context: Arc::new(Mutex::new(context)),
             script_chan: script_chan,
         };
 
         // TODO: this exists only to make preflight check non-blocking
-        // perhaps should be handled by the resource task?
+        // perhaps should be handled by the resource thread?
         let req = self.clone();
         spawn_named("cors".to_owned(), move || {
             let response = req.http_fetch();
             let mut context = listener.context.lock();
             let context = context.as_mut().unwrap();
             context.response = Some(response);
             listener.notify(ResponseAction::ResponseComplete(Ok(())));
         });
--- a/servo/components/script/devtools.rs
+++ b/servo/components/script/devtools.rs
@@ -14,17 +14,17 @@ use dom::bindings::inheritance::Castable
 use dom::bindings::js::Root;
 use dom::element::Element;
 use dom::node::Node;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::{ObjectClassName, RootedObject, RootedValue};
 use js::jsval::UndefinedValue;
 use msg::constellation_msg::PipelineId;
 use page::{IterablePage, Page};
-use script_task::get_page;
+use script_thread::get_page;
 use std::ffi::CStr;
 use std::rc::Rc;
 use std::str;
 use util::str::DOMString;
 use uuid::Uuid;
 
 #[allow(unsafe_code)]
 pub fn handle_evaluate_js(global: &GlobalRef, eval: String, reply: IpcSender<EvaluateJSReply>) {
--- a/servo/components/script/document_loader.rs
+++ b/servo/components/script/document_loader.rs
@@ -2,17 +2,17 @@
  * 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/. */
 
 //! Tracking of pending loads in a document.
 //! https://html.spec.whatwg.org/multipage/#the-end
 
 use msg::constellation_msg::PipelineId;
 use net_traits::AsyncResponseTarget;
-use net_traits::{PendingAsyncLoad, ResourceTask, LoadContext};
+use net_traits::{PendingAsyncLoad, ResourceThread, LoadContext};
 use std::sync::Arc;
 use url::Url;
 
 #[derive(JSTraceable, PartialEq, Clone, Debug, HeapSizeOf)]
 pub enum LoadType {
     Image(Url),
     Script(Url),
     Subframe(Url),
@@ -38,53 +38,53 @@ impl LoadType {
             LoadType::Subframe(_) | LoadType::PageSource(_) => LoadContext::Browsing,
             LoadType::Stylesheet(_) => LoadContext::Style
         }
     }
 }
 
 #[derive(JSTraceable, HeapSizeOf)]
 pub struct DocumentLoader {
-    /// We use an `Arc<ResourceTask>` here in order to avoid file descriptor exhaustion when there
+    /// We use an `Arc<ResourceThread>` here in order to avoid file descriptor exhaustion when there
     /// are lots of iframes.
     #[ignore_heap_size_of = "channels are hard"]
-    pub resource_task: Arc<ResourceTask>,
+    pub resource_thread: Arc<ResourceThread>,
     pipeline: Option<PipelineId>,
     blocking_loads: Vec<LoadType>,
     events_inhibited: bool,
 }
 
 impl DocumentLoader {
     pub fn new(existing: &DocumentLoader) -> DocumentLoader {
-        DocumentLoader::new_with_task(existing.resource_task.clone(), None, None)
+        DocumentLoader::new_with_thread(existing.resource_thread.clone(), None, None)
     }
 
-    /// We use an `Arc<ResourceTask>` here in order to avoid file descriptor exhaustion when there
+    /// We use an `Arc<ResourceThread>` here in order to avoid file descriptor exhaustion when there
     /// are lots of iframes.
-    pub fn new_with_task(resource_task: Arc<ResourceTask>,
+    pub fn new_with_thread(resource_thread: Arc<ResourceThread>,
                          pipeline: Option<PipelineId>,
                          initial_load: Option<Url>)
                          -> DocumentLoader {
         let initial_loads = initial_load.into_iter().map(LoadType::PageSource).collect();
 
         DocumentLoader {
-            resource_task: resource_task,
+            resource_thread: resource_thread,
             pipeline: pipeline,
             blocking_loads: initial_loads,
             events_inhibited: false,
         }
     }
 
     /// Create a new pending network request, which can be initiated at some point in
     /// the future.
     pub fn prepare_async_load(&mut self, load: LoadType) -> PendingAsyncLoad {
         let context = load.to_load_context();
         let url = load.url().clone();
         self.blocking_loads.push(load);
-        PendingAsyncLoad::new(context, (*self.resource_task).clone(), url, self.pipeline)
+        PendingAsyncLoad::new(context, (*self.resource_thread).clone(), url, self.pipeline)
     }
 
     /// Create and initiate a new network request.
     pub fn load_async(&mut self, load: LoadType, listener: AsyncResponseTarget) {
         let pending = self.prepare_async_load(load);
         pending.load_async(listener)
     }
 
--- a/servo/components/script/dom/bindings/cell.rs
+++ b/servo/components/script/dom/bindings/cell.rs
@@ -2,58 +2,58 @@
  * 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/. */
 
 //! A shareable mutable container for the DOM.
 
 use dom::bindings::trace::JSTraceable;
 use js::jsapi::JSTracer;
 use std::cell::{BorrowState, Ref, RefCell, RefMut};
-use util::task_state;
-use util::task_state::SCRIPT;
+use util::thread_state;
+use util::thread_state::SCRIPT;
 
 /// A mutable field in the DOM.
 ///
 /// This extends the API of `core::cell::RefCell` to allow unsafe access in
 /// certain situations, with dynamic checking in debug builds.
 #[derive(Clone, HeapSizeOf)]
 pub struct DOMRefCell<T> {
     value: RefCell<T>,
 }
 
 // Functionality specific to Servo's `DOMRefCell` type
 // ===================================================
 
 impl<T> DOMRefCell<T> {
     /// Return a reference to the contents.
     ///
-    /// For use in the layout task only.
+    /// For use in the layout thread only.
     #[allow(unsafe_code)]
     pub unsafe fn borrow_for_layout(&self) -> &T {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         &*self.value.as_unsafe_cell().get()
     }
 
     /// Borrow the contents for the purpose of GC tracing.
     ///
     /// This succeeds even if the object is mutably borrowed,
     /// so you have to be careful in trace code!
     #[allow(unsafe_code)]
     pub unsafe fn borrow_for_gc_trace(&self) -> &T {
         // FIXME: IN_GC isn't reliable enough - doesn't catch minor GCs
         // https://github.com/servo/servo/issues/6389
-        // debug_assert!(task_state::get().contains(SCRIPT | IN_GC));
+        // debug_assert!(thread_state::get().contains(SCRIPT | IN_GC));
         &*self.value.as_unsafe_cell().get()
     }
 
     /// Borrow the contents for the purpose of script deallocation.
     ///
     #[allow(unsafe_code)]
     pub unsafe fn borrow_for_script_deallocation(&self) -> &mut T {
-        debug_assert!(task_state::get().contains(SCRIPT));
+        debug_assert!(thread_state::get().contains(SCRIPT));
         &mut *self.value.as_unsafe_cell().get()
     }
 
     /// Is the cell mutably borrowed?
     ///
     /// For safety checks in debug builds only.
     pub fn is_mutably_borrowed(&self) -> bool {
         self.value.borrow_state() == BorrowState::Writing
@@ -65,17 +65,17 @@ impl<T> DOMRefCell<T> {
     /// immutable borrows can be taken out at the same time.
     ///
     /// Returns `None` if the value is currently mutably borrowed.
     ///
     /// # Panics
     ///
     /// Panics if this is called off the script thread.
     pub fn try_borrow(&self) -> Option<Ref<T>> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         match self.value.borrow_state() {
             BorrowState::Writing => None,
             _ => Some(self.value.borrow()),
         }
     }
 
     /// Mutably borrows the wrapped value.
     ///
@@ -83,27 +83,27 @@ impl<T> DOMRefCell<T> {
     /// cannot be borrowed while this borrow is active.
     ///
     /// Returns `None` if the value is currently borrowed.
     ///
     /// # Panics
     ///
     /// Panics if this is called off the script thread.
     pub fn try_borrow_mut(&self) -> Option<RefMut<T>> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         match self.value.borrow_state() {
             BorrowState::Unused => Some(self.value.borrow_mut()),
             _ => None,
         }
     }
 
-    /// Version of the above that we use during restyle while the script task
+    /// Version of the above that we use during restyle while the script thread
     /// is blocked.
     pub fn borrow_mut_for_layout(&self) -> RefMut<T> {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         self.value.borrow_mut()
     }
 }
 
 impl<T: JSTraceable> JSTraceable for DOMRefCell<T> {
     fn trace(&self, trc: *mut JSTracer) {
         unsafe {
             (*self).borrow_for_gc_trace().trace(trc)
--- a/servo/components/script/dom/bindings/global.rs
+++ b/servo/components/script/dom/bindings/global.rs
@@ -14,19 +14,19 @@ use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflectable, Reflector};
 use dom::window::{self, ScriptHelpers};
 use dom::workerglobalscope::WorkerGlobalScope;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::GetGlobalForObjectCrossCompartment;
 use js::jsapi::{JSContext, JSObject, JS_GetClass, MutableHandleValue};
 use js::{JSCLASS_IS_DOMJSCLASS, JSCLASS_IS_GLOBAL};
 use msg::constellation_msg::{ConstellationChan, PipelineId};
-use net_traits::ResourceTask;
+use net_traits::ResourceThread;
 use profile_traits::mem;
-use script_task::{CommonScriptMsg, ScriptChan, ScriptPort, ScriptTask};
+use script_thread::{CommonScriptMsg, ScriptChan, ScriptPort, ScriptThread};
 use script_traits::{MsDuration, ScriptMsg as ConstellationMsg, TimerEventRequest};
 use timers::{ScheduledCallback, TimerHandle};
 use url::Url;
 use util::mem::HeapSizeOf;
 
 /// A freely-copyable reference to a rooted global object.
 #[derive(Copy, Clone)]
 pub enum GlobalRef<'a> {
@@ -60,34 +60,34 @@ impl<'a> GlobalRef<'a> {
     /// this global object is on.
     pub fn get_cx(&self) -> *mut JSContext {
         match *self {
             GlobalRef::Window(ref window) => window.get_cx(),
             GlobalRef::Worker(ref worker) => worker.get_cx(),
         }
     }
 
-    /// Extract a `Window`, causing task failure if the global object is not
+    /// Extract a `Window`, causing thread failure if the global object is not
     /// a `Window`.
     pub fn as_window(&self) -> &window::Window {
         match *self {
             GlobalRef::Window(window) => window,
             GlobalRef::Worker(_) => panic!("expected a Window scope"),
         }
     }
 
     /// Get the `PipelineId` for this global scope.
     pub fn pipeline(&self) -> PipelineId {
         match *self {
             GlobalRef::Window(window) => window.pipeline(),
             GlobalRef::Worker(worker) => worker.pipeline(),
         }
     }
 
-    /// Get a `mem::ProfilerChan` to send messages to the memory profiler task.
+    /// Get a `mem::ProfilerChan` to send messages to the memory profiler thread.
     pub fn mem_profiler_chan(&self) -> mem::ProfilerChan {
         match *self {
             GlobalRef::Window(window) => window.mem_profiler_chan(),
             GlobalRef::Worker(worker) => worker.mem_profiler_chan(),
         }
     }
 
     /// Get a `ConstellationChan` to send messages to the constellation channel when available.
@@ -102,34 +102,34 @@ impl<'a> GlobalRef<'a> {
     pub fn scheduler_chan(&self) -> IpcSender<TimerEventRequest> {
         match *self {
             GlobalRef::Window(window) => window.scheduler_chan(),
             GlobalRef::Worker(worker) => worker.scheduler_chan(),
         }
     }
 
     /// Get an `IpcSender<ScriptToDevtoolsControlMsg>` to send messages to Devtools
-    /// task when available.
+    /// thread when available.
     pub fn devtools_chan(&self) -> Option<IpcSender<ScriptToDevtoolsControlMsg>> {
         match *self {
             GlobalRef::Window(window) => window.devtools_chan(),
             GlobalRef::Worker(worker) => worker.devtools_chan(),
         }
     }
 
-    /// Get the `ResourceTask` for this global scope.
-    pub fn resource_task(&self) -> ResourceTask {
+    /// Get the `ResourceThread` for this global scope.
+    pub fn resource_thread(&self) -> ResourceThread {
         match *self {
             GlobalRef::Window(ref window) => {
                 let doc = window.Document();
                 let doc = doc.r();
                 let loader = doc.loader();
-                (*loader.resource_task).clone()
+                (*loader.resource_thread).clone()
             }
-            GlobalRef::Worker(ref worker) => worker.resource_task().clone(),
+            GlobalRef::Worker(ref worker) => worker.resource_thread().clone(),
         }
     }
 
     /// Get the worker's id.
     pub fn get_worker_id(&self) -> Option<WorkerId> {
         match *self {
             GlobalRef::Window(_) => None,
             GlobalRef::Worker(ref worker) => Some(worker.get_worker_id()),
@@ -149,74 +149,74 @@ impl<'a> GlobalRef<'a> {
         match *self {
             GlobalRef::Window(ref window) => window.get_url(),
             GlobalRef::Worker(ref worker) => worker.get_url().clone(),
         }
     }
 
     /// `ScriptChan` used to send messages to the event loop of this global's
     /// thread.
-    pub fn dom_manipulation_task_source(&self) -> Box<ScriptChan + Send> {
+    pub fn dom_manipulation_thread_source(&self) -> Box<ScriptChan + Send> {
         match *self {
-            GlobalRef::Window(ref window) => window.dom_manipulation_task_source(),
+            GlobalRef::Window(ref window) => window.dom_manipulation_thread_source(),
             GlobalRef::Worker(ref worker) => worker.script_chan(),
         }
     }
 
     /// `ScriptChan` used to send messages to the event loop of this global's
     /// thread.
-    pub fn user_interaction_task_source(&self) -> Box<ScriptChan + Send> {
+    pub fn user_interaction_thread_source(&self) -> Box<ScriptChan + Send> {
         match *self {
-            GlobalRef::Window(ref window) => window.user_interaction_task_source(),
+            GlobalRef::Window(ref window) => window.user_interaction_thread_source(),
             GlobalRef::Worker(ref worker) => worker.script_chan(),
         }
     }
 
     /// `ScriptChan` used to send messages to the event loop of this global's
     /// thread.
-    pub fn networking_task_source(&self) -> Box<ScriptChan + Send> {
+    pub fn networking_thread_source(&self) -> Box<ScriptChan + Send> {
         match *self {
-            GlobalRef::Window(ref window) => window.networking_task_source(),
+            GlobalRef::Window(ref window) => window.networking_thread_source(),
             GlobalRef::Worker(ref worker) => worker.script_chan(),
         }
     }
 
     /// `ScriptChan` used to send messages to the event loop of this global's
     /// thread.
-    pub fn history_traversal_task_source(&self) -> Box<ScriptChan + Send> {
+    pub fn history_traversal_thread_source(&self) -> Box<ScriptChan + Send> {
         match *self {
-            GlobalRef::Window(ref window) => window.history_traversal_task_source(),
+            GlobalRef::Window(ref window) => window.history_traversal_thread_source(),
             GlobalRef::Worker(ref worker) => worker.script_chan(),
         }
     }
 
     /// `ScriptChan` used to send messages to the event loop of this global's
     /// thread.
-    pub fn file_reading_task_source(&self) -> Box<ScriptChan + Send> {
+    pub fn file_reading_thread_source(&self) -> Box<ScriptChan + Send> {
         match *self {
-            GlobalRef::Window(ref window) => window.file_reading_task_source(),
+            GlobalRef::Window(ref window) => window.file_reading_thread_source(),
             GlobalRef::Worker(ref worker) => worker.script_chan(),
         }
     }
 
     /// Create a new sender/receiver pair that can be used to implement an on-demand
     /// event loop. Used for implementing web APIs that require blocking semantics
     /// without resorting to nested event loops.
     pub fn new_script_pair(&self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>) {
         match *self {
             GlobalRef::Window(ref window) => window.new_script_pair(),
             GlobalRef::Worker(ref worker) => worker.new_script_pair(),
         }
     }
 
-    /// Process a single event as if it were the next event in the task queue for
+    /// Process a single event as if it were the next event in the thread queue for
     /// this global.
     pub fn process_event(&self, msg: CommonScriptMsg) {
         match *self {
-            GlobalRef::Window(_) => ScriptTask::process_event(msg),
+            GlobalRef::Window(_) => ScriptThread::process_event(msg),
             GlobalRef::Worker(ref worker) => worker.process_event(msg),
         }
     }
 
     /// Evaluate the JS messages on the `RootedValue` of this global
     pub fn evaluate_js_on_global_with_result(&self, code: &str, rval: MutableHandleValue) {
         match *self {
             GlobalRef::Window(window) => window.evaluate_js_on_global_with_result(code, rval),
--- a/servo/components/script/dom/bindings/js.rs
+++ b/servo/components/script/dom/bindings/js.rs
@@ -28,25 +28,25 @@ use dom::bindings::conversions::DerivedF
 use dom::bindings::inheritance::Castable;
 use dom::bindings::reflector::{Reflectable, Reflector};
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::trace::trace_reflector;
 use dom::node::Node;
 use js::jsapi::{Heap, JSObject, JSTracer};
 use js::jsval::JSVal;
 use layout_interface::TrustedNodeAddress;
-use script_task::STACK_ROOTS;
+use script_thread::STACK_ROOTS;
 use std::cell::UnsafeCell;
 use std::default::Default;
 use std::hash::{Hash, Hasher};
 use std::mem;
 use std::ops::Deref;
 use std::ptr;
 use util::mem::HeapSizeOf;
-use util::task_state;
+use util::thread_state;
 
 /// A traced reference to a DOM object
 ///
 /// This type is critical to making garbage collection work with the DOM,
 /// but it is very dangerous; if garbage collection happens with a `JS<T>`
 /// on the stack, the `JS<T>` can point to freed memory.
 ///
 /// This should only be used as a field in other DOM objects.
@@ -61,48 +61,48 @@ impl<T> HeapSizeOf for JS<T> {
     fn heap_size_of_children(&self) -> usize {
         0
     }
 }
 
 impl<T> JS<T> {
     /// Returns `LayoutJS<T>` containing the same pointer.
     pub unsafe fn to_layout(&self) -> LayoutJS<T> {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         LayoutJS {
             ptr: self.ptr.clone(),
         }
     }
 }
 
 impl<T: Reflectable> JS<T> {
     /// Create a JS<T> from a Root<T>
     /// XXX Not a great API. Should be a call on Root<T> instead
     #[allow(unrooted_must_root)]
     pub fn from_rooted(root: &Root<T>) -> JS<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         JS {
             ptr: unsafe { NonZero::new(&**root) },
         }
     }
     /// Create a JS<T> from a &T
     #[allow(unrooted_must_root)]
     pub fn from_ref(obj: &T) -> JS<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         JS {
             ptr: unsafe { NonZero::new(&*obj) },
         }
     }
 }
 
 impl<T: Reflectable> Deref for JS<T> {
     type Target = T;
 
     fn deref(&self) -> &T {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         // We can only have &JS<T> from a rooted thing, so it's safe to deref
         // it to &T.
         unsafe { &**self.ptr }
     }
 }
 
 impl<T: Reflectable> JSTraceable for JS<T> {
     fn trace(&self, trc: *mut JSTracer) {
@@ -118,39 +118,39 @@ pub struct LayoutJS<T> {
 }
 
 impl<T: Castable> LayoutJS<T> {
     /// Cast a DOM object root upwards to one of the interfaces it derives from.
     pub fn upcast<U>(&self) -> LayoutJS<U>
         where U: Castable,
               T: DerivedFrom<U>
     {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         unsafe { mem::transmute_copy(self) }
     }
 
     /// Cast a DOM object downwards to one of the interfaces it might implement.
     pub fn downcast<U>(&self) -> Option<LayoutJS<U>>
         where U: DerivedFrom<T>
     {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         unsafe {
             if (*self.unsafe_get()).is::<U>() {
                 Some(mem::transmute_copy(self))
             } else {
                 None
             }
         }
     }
 }
 
 impl<T: Reflectable> LayoutJS<T> {
     /// Get the reflector.
     pub unsafe fn get_jsobject(&self) -> *mut JSObject {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         (**self.ptr).reflector().get_jsobject().get()
     }
 }
 
 impl<T> Copy for LayoutJS<T> {}
 
 impl<T> PartialEq for JS<T> {
     fn eq(&self, other: &JS<T>) -> bool {
@@ -179,38 +179,38 @@ impl<T> Hash for LayoutJS<T> {
         self.ptr.hash(state)
     }
 }
 
 impl <T> Clone for JS<T> {
     #[inline]
     #[allow(unrooted_must_root)]
     fn clone(&self) -> JS<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         JS {
             ptr: self.ptr.clone(),
         }
     }
 }
 
 impl <T> Clone for LayoutJS<T> {
     #[inline]
     fn clone(&self) -> LayoutJS<T> {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         LayoutJS {
             ptr: self.ptr.clone(),
         }
     }
 }
 
 impl LayoutJS<Node> {
     /// Create a new JS-owned value wrapped from an address known to be a
     /// `Node` pointer.
     pub unsafe fn from_trusted_node_address(inner: TrustedNodeAddress) -> LayoutJS<Node> {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         let TrustedNodeAddress(addr) = inner;
         LayoutJS {
             ptr: NonZero::new(addr as *const Node),
         }
     }
 }
 
 
@@ -235,35 +235,35 @@ impl<T: Reflectable> HeapGCValue for JS<
 #[derive(JSTraceable)]
 pub struct MutHeapJSVal {
     val: UnsafeCell<Heap<JSVal>>,
 }
 
 impl MutHeapJSVal {
     /// Create a new `MutHeapJSVal`.
     pub fn new() -> MutHeapJSVal {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         MutHeapJSVal {
             val: UnsafeCell::new(Heap::default()),
         }
     }
 
     /// Set this `MutHeapJSVal` to the given value, calling write barriers as
     /// appropriate.
     pub fn set(&self, val: JSVal) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             let cell = self.val.get();
             (*cell).set(val);
         }
     }
 
     /// Get the value in this `MutHeapJSVal`, calling read barriers as appropriate.
     pub fn get(&self) -> JSVal {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe { (*self.val.get()).get() }
     }
 }
 
 
 /// A holder that provides interior mutability for GC-managed values such as
 /// `JS<T>`.  Essentially a `Cell<JS<T>>`, but safer.
 ///
@@ -273,33 +273,33 @@ impl MutHeapJSVal {
 #[derive(JSTraceable)]
 pub struct MutHeap<T: HeapGCValue> {
     val: UnsafeCell<T>,
 }
 
 impl<T: Reflectable> MutHeap<JS<T>> {
     /// Create a new `MutHeap`.
     pub fn new(initial: &T) -> MutHeap<JS<T>> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         MutHeap {
             val: UnsafeCell::new(JS::from_ref(initial)),
         }
     }
 
     /// Set this `MutHeap` to the given value.
     pub fn set(&self, val: &T) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             *self.val.get() = JS::from_ref(val);
         }
     }
 
     /// Get the value in this `MutHeap`.
     pub fn get(&self) -> Root<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             Root::from_ref(&*ptr::read(self.val.get()))
         }
     }
 }
 
 impl<T: HeapGCValue> HeapSizeOf for MutHeap<T> {
     fn heap_size_of_children(&self) -> usize {
@@ -334,58 +334,58 @@ impl<T: Reflectable + PartialEq> Partial
 #[derive(JSTraceable)]
 pub struct MutNullableHeap<T: HeapGCValue> {
     ptr: UnsafeCell<Option<T>>,
 }
 
 impl<T: Reflectable> MutNullableHeap<JS<T>> {
     /// Create a new `MutNullableHeap`.
     pub fn new(initial: Option<&T>) -> MutNullableHeap<JS<T>> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         MutNullableHeap {
             ptr: UnsafeCell::new(initial.map(JS::from_ref)),
         }
     }
 
     /// Retrieve a copy of the current inner value. If it is `None`, it is
     /// initialized with the result of `cb` first.
     pub fn or_init<F>(&self, cb: F) -> Root<T>
         where F: FnOnce() -> Root<T>
     {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         match self.get() {
             Some(inner) => inner,
             None => {
                 let inner = cb();
                 self.set(Some(&inner));
                 inner
             },
         }
     }
 
     /// Retrieve a copy of the inner optional `JS<T>` as `LayoutJS<T>`.
     /// For use by layout, which can't use safe types like Temporary.
     #[allow(unrooted_must_root)]
     pub unsafe fn get_inner_as_layout(&self) -> Option<LayoutJS<T>> {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         ptr::read(self.ptr.get()).map(|js| js.to_layout())
     }
 
     /// Get a rooted value out of this object
     #[allow(unrooted_must_root)]
     pub fn get(&self) -> Option<Root<T>> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             ptr::read(self.ptr.get()).map(|o| Root::from_ref(&*o))
         }
     }
 
     /// Set this `MutNullableHeap` to the given value.
     pub fn set(&self, val: Option<&T>) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             *self.ptr.get() = val.map(|p| JS::from_ref(p));
         }
     }
 
 }
 
 impl<T: Reflectable> PartialEq for MutNullableHeap<JS<T>> {
@@ -402,17 +402,17 @@ impl<'a, T: Reflectable> PartialEq<Optio
             *self.ptr.get() == other.map(JS::from_ref)
         }
     }
 }
 
 impl<T: HeapGCValue> Default for MutNullableHeap<T> {
     #[allow(unrooted_must_root)]
     fn default() -> MutNullableHeap<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         MutNullableHeap {
             ptr: UnsafeCell::new(None),
         }
     }
 }
 
 impl<T: HeapGCValue> HeapSizeOf for MutNullableHeap<T> {
     fn heap_size_of_children(&self) -> usize {
@@ -421,17 +421,17 @@ impl<T: HeapGCValue> HeapSizeOf for MutN
     }
 }
 
 impl<T: Reflectable> LayoutJS<T> {
     /// Returns an unsafe pointer to the interior of this JS object. This is
     /// the only method that be safely accessed from layout. (The fact that
     /// this is unsafe is what necessitates the layout wrappers.)
     pub unsafe fn unsafe_get(&self) -> *const T {
-        debug_assert!(task_state::get().is_layout());
+        debug_assert!(thread_state::get().is_layout());
         *self.ptr
     }
 }
 
 /// Get an `Option<JSRef<T>>` out of an `Option<Root<T>>`
 pub trait RootedReference<T> {
     /// Obtain a safe optional reference to the wrapped JS owned-value that
     /// cannot outlive the lifetime of this root.
@@ -474,35 +474,35 @@ impl Clone for RootCollectionPtr {
     fn clone(&self) -> RootCollectionPtr {
         *self
     }
 }
 
 impl RootCollection {
     /// Create an empty collection of roots
     pub fn new() -> RootCollection {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         RootCollection {
             roots: UnsafeCell::new(vec![]),
         }
     }
 
     /// Start tracking a stack-based root
     fn root(&self, untracked_reflector: *const Reflector) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             let mut roots = &mut *self.roots.get();
             roots.push(untracked_reflector);
             assert!(!(*untracked_reflector).get_jsobject().is_null())
         }
     }
 
     /// Stop tracking a stack-based root, asserting if the reflector isn't found
     fn unroot<T: Reflectable>(&self, rooted: &Root<T>) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe {
             let mut roots = &mut *self.roots.get();
             let old_reflector = &*rooted.reflector();
             match roots.iter().rposition(|r| *r == old_reflector) {
                 Some(idx) => {
                     roots.remove(idx);
                 },
                 None => panic!("Can't remove a root that was never rooted!"),
@@ -557,17 +557,17 @@ impl<T: Castable> Root<T> {
     }
 }
 
 impl<T: Reflectable> Root<T> {
     /// Create a new stack-bounded root for the provided JS-owned value.
     /// It cannot not outlive its associated `RootCollection`, and it gives
     /// out references which cannot outlive this new `Root`.
     pub fn new(unrooted: NonZero<*const T>) -> Root<T> {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         STACK_ROOTS.with(|ref collection| {
             let RootCollectionPtr(collection) = collection.get().unwrap();
             unsafe { (*collection).root(&*(**unrooted).reflector()) }
             Root {
                 ptr: unrooted,
                 root_list: collection,
             }
         })
@@ -583,17 +583,17 @@ impl<T: Reflectable> Root<T> {
     pub fn r(&self) -> &T {
         &**self
     }
 }
 
 impl<T: Reflectable> Deref for Root<T> {
     type Target = T;
     fn deref(&self) -> &T {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         unsafe { &**self.ptr.deref() }
     }
 }
 
 impl<T: Reflectable> PartialEq for Root<T> {
     fn eq(&self, other: &Root<T>) -> bool {
         self.ptr == other.ptr
     }
--- a/servo/components/script/dom/bindings/refcounted.rs
+++ b/servo/components/script/dom/bindings/refcounted.rs
@@ -1,39 +1,39 @@
 /* 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/. */
 
 //! A generic, safe mechanism by which DOM objects can be pinned and transferred
-//! between tasks (or intra-task for asynchronous events). Akin to Gecko's
+//! between threads (or intra-thread for asynchronous events). Akin to Gecko's
 //! nsMainThreadPtrHandle, this uses thread-safe reference counting and ensures
-//! that the actual SpiderMonkey GC integration occurs on the script task via
+//! that the actual SpiderMonkey GC integration occurs on the script thread via
 //! message passing. Ownership of a `Trusted<T>` object means the DOM object of
 //! type T to which it points remains alive. Any other behaviour is undefined.
 //! To guarantee the lifetime of a DOM object when performing asynchronous operations,
 //! obtain a `Trusted<T>` from that object and pass it along with each operation.
-//! A usable pointer to the original DOM object can be obtained on the script task
+//! A usable pointer to the original DOM object can be obtained on the script thread
 //! from a `Trusted<T>` via the `to_temporary` method.
 //!
 //! The implementation of Trusted<T> is as follows:
-//! A hashtable resides in the script task, keyed on the pointer to the Rust DOM object.
+//! A hashtable resides in the script thread, keyed on the pointer to the Rust DOM object.
 //! The values in this hashtable are atomic reference counts. When a Trusted<T> object is
 //! created or cloned, this count is increased. When a Trusted<T> is dropped, the count
-//! decreases. If the count hits zero, a message is dispatched to the script task to remove
+//! decreases. If the count hits zero, a message is dispatched to the script thread to remove
 //! the entry from the hashmap if the count is still zero. The JS reflector for the DOM object
 //! is rooted when a hashmap entry is first created, and unrooted when the hashmap entry
 //! is removed.
 
 use core::nonzero::NonZero;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflectable, Reflector};
 use dom::bindings::trace::trace_reflector;
 use js::jsapi::JSTracer;
 use libc;
-use script_task::{CommonScriptMsg, ScriptChan};
+use script_thread::{CommonScriptMsg, ScriptChan};
 use std::cell::RefCell;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::collections::hash_map::HashMap;
 use std::marker::PhantomData;
 use std::sync::{Arc, Mutex};
 
 
 #[allow(missing_docs)]  // FIXME
@@ -47,23 +47,23 @@ mod dummy {  // Attributes don’t apply through the macro.
 pub use self::dummy::LIVE_REFERENCES;
 
 
 /// A pointer to a Rust DOM object that needs to be destroyed.
 pub struct TrustedReference(*const libc::c_void);
 unsafe impl Send for TrustedReference {}
 
 /// A safe wrapper around a raw pointer to a DOM object that can be
-/// shared among tasks for use in asynchronous operations. The underlying
+/// shared among threads for use in asynchronous operations. The underlying
 /// DOM object is guaranteed to live at least as long as the last outstanding
 /// `Trusted<T>` instance.
 #[allow_unrooted_interior]
 pub struct Trusted<T: Reflectable> {
     /// A pointer to the Rust DOM object of type T, but void to allow
-    /// sending `Trusted<T>` between tasks, regardless of T's sendability.
+    /// sending `Trusted<T>` between threads, regardless of T's sendability.
     ptr: *const libc::c_void,
     refcount: Arc<Mutex<usize>>,
     script_chan: Box<ScriptChan + Send>,
     owner_thread: *const libc::c_void,
     phantom: PhantomData<T>,
 }
 
 unsafe impl<T: Reflectable> Send for Trusted<T> {}
@@ -120,34 +120,34 @@ impl<T: Reflectable> Clone for Trusted<T
 }
 
 impl<T: Reflectable> Drop for Trusted<T> {
     fn drop(&mut self) {
         let mut refcount = self.refcount.lock().unwrap();
         assert!(*refcount > 0);
         *refcount -= 1;
         if *refcount == 0 {
-            // It's possible this send will fail if the script task
+            // It's possible this send will fail if the script thread
             // has already exited. There's not much we can do at this
             // point though.
             let msg = CommonScriptMsg::RefcountCleanup(TrustedReference(self.ptr));
             let _ = self.script_chan.send(msg);
         }
     }
 }
 
 /// The set of live, pinned DOM objects that are currently prevented
 /// from being garbage collected due to outstanding references.
 pub struct LiveDOMReferences {
     // keyed on pointer to Rust DOM object
     table: RefCell<HashMap<*const libc::c_void, Arc<Mutex<usize>>>>,
 }
 
 impl LiveDOMReferences {
-    /// Set up the task-local data required for storing the outstanding DOM references.
+    /// Set up the thread-local data required for storing the outstanding DOM references.
     pub fn initialize() {
         LIVE_REFERENCES.with(|ref r| {
             *r.borrow_mut() = Some(LiveDOMReferences {
                 table: RefCell::new(HashMap::new()),
             })
         });
     }
 
--- a/servo/components/script/dom/bindings/trace.rs
+++ b/servo/components/script/dom/bindings/trace.rs
@@ -53,21 +53,21 @@ use js::jsapi::{GCTraceKindToAscii, Heap
 use js::jsval::JSVal;
 use js::rust::Runtime;
 use layout_interface::{LayoutChan, LayoutRPC};
 use libc;
 use msg::constellation_msg::ConstellationChan;
 use msg::constellation_msg::{PipelineId, SubpageId, WindowSizeData};
 use net_traits::Metadata;
 use net_traits::image::base::Image;
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheTask};
-use net_traits::storage_task::StorageType;
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread};
+use net_traits::storage_thread::StorageType;
 use profile_traits::mem::ProfilerChan as MemProfilerChan;
 use profile_traits::time::ProfilerChan as TimeProfilerChan;
-use script_task::ScriptChan;
+use script_thread::ScriptChan;
 use script_traits::{LayoutMsg, ScriptMsg, TimerEventId, TimerSource, UntrustedNodeAddress};
 use selectors::parser::PseudoElement;
 use selectors::states::*;
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use std::boxed::FnBox;
 use std::cell::{Cell, UnsafeCell};
 use std::collections::hash_state::HashState;
@@ -257,17 +257,17 @@ impl<A: JSTraceable, B: JSTraceable> JST
 no_jsmanaged_fields!(bool, f32, f64, String, Url, AtomicBool, Uuid);
 no_jsmanaged_fields!(usize, u8, u16, u32, u64);
 no_jsmanaged_fields!(isize, i8, i16, i32, i64);
 no_jsmanaged_fields!(Sender<T>);
 no_jsmanaged_fields!(Receiver<T>);
 no_jsmanaged_fields!(Rect<T>);
 no_jsmanaged_fields!(Size2D<T>);
 no_jsmanaged_fields!(Arc<T>);
-no_jsmanaged_fields!(Image, ImageCacheChan, ImageCacheTask);
+no_jsmanaged_fields!(Image, ImageCacheChan, ImageCacheThread);
 no_jsmanaged_fields!(Metadata);
 no_jsmanaged_fields!(Atom, Namespace, QualName);
 no_jsmanaged_fields!(Trusted<T: Reflectable>);
 no_jsmanaged_fields!(PropertyDeclarationBlock);
 no_jsmanaged_fields!(HashSet<T>);
 // These three are interdependent, if you plan to put jsmanaged data
 // in one of these make sure it is propagated properly to containing structs
 no_jsmanaged_fields!(SubpageId, WindowSizeData, PipelineId);
--- a/servo/components/script/dom/canvasrenderingcontext2d.rs
+++ b/servo/components/script/dom/canvasrenderingcontext2d.rs
@@ -1,13 +1,13 @@
 /* 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/. */
 
-use canvas::canvas_paint_task::RectToi32;
+use canvas::canvas_paint_thread::RectToi32;
 use canvas_traits::{Canvas2dMsg, CanvasCommonMsg, CanvasMsg};
 use canvas_traits::{CompositionOrBlending, LineCapStyle, LineJoinStyle};
 use canvas_traits::{FillOrStrokeStyle, FillRule, LinearGradientStyle, RadialGradientStyle, RepetitionStyle};
 use cssparser::Color as CSSColor;
 use cssparser::{Parser, RGBA};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::CSSStyleDeclarationMethods;
 use dom::bindings::codegen::Bindings::CanvasRenderingContext2DBinding;
@@ -31,17 +31,17 @@ use dom::htmlimageelement::HTMLImageElem
 use dom::imagedata::ImageData;
 use dom::node::{Node, NodeDamage, window_from_node};
 use euclid::matrix2d::Matrix2D;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use euclid::size::Size2D;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::image::base::PixelFormat;
-use net_traits::image_cache_task::ImageResponse;
+use net_traits::image_cache_thread::ImageResponse;
 use num::{Float, ToPrimitive};
 use script_traits::ScriptMsg as ConstellationMsg;
 use std::cell::Cell;
 use std::str::FromStr;
 use std::sync::mpsc::channel;
 use std::{cmp, fmt};
 use unpremultiplytable::UNPREMULTIPLY_TABLE;
 use url::Url;
@@ -119,17 +119,17 @@ impl CanvasContextState {
 
 impl CanvasRenderingContext2D {
     fn new_inherited(global: GlobalRef,
                      canvas: &HTMLCanvasElement,
                      size: Size2D<i32>)
                      -> CanvasRenderingContext2D {
         let (sender, receiver) = ipc::channel().unwrap();
         let constellation_chan = global.constellation_chan();
-        constellation_chan.0.send(ConstellationMsg::CreateCanvasPaintTask(size, sender)).unwrap();
+        constellation_chan.0.send(ConstellationMsg::CreateCanvasPaintThread(size, sender)).unwrap();
         let (ipc_renderer, renderer_id) = receiver.recv().unwrap();
         CanvasRenderingContext2D {
             reflector_: Reflector::new(),
             global: GlobalField::from_rooted(&global),
             renderer_id: renderer_id,
             ipc_renderer: ipc_renderer,
             canvas: JS::from_ref(canvas),
             state: DOMRefCell::new(CanvasContextState::new()),
--- a/servo/components/script/dom/closeevent.rs
+++ b/servo/components/script/dom/closeevent.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::Cl
 use dom::bindings::codegen::Bindings::CloseEventBinding::CloseEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use script_task::ScriptChan;
+use script_thread::ScriptChan;
 use string_cache::Atom;
 use util::str::DOMString;
 
 #[dom_struct]
 pub struct CloseEvent {
     event: Event,
     wasClean: bool,
     code: u16,
--- a/servo/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/servo/components/script/dom/dedicatedworkerglobalscope.rs
@@ -23,27 +23,27 @@ use ipc_channel::ipc::{self, IpcReceiver
 use ipc_channel::router::ROUTER;
 use js::jsapi::{HandleValue, JSContext, RootedValue};
 use js::jsapi::{JSAutoCompartment, JSAutoRequest};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
 use msg::constellation_msg::PipelineId;
 use net_traits::{LoadContext, load_whole_resource};
 use rand::random;
-use script_task::ScriptTaskEventCategory::WorkerEvent;
-use script_task::{ScriptTask, ScriptChan, ScriptPort, StackRootTLS, CommonScriptMsg};
+use script_thread::ScriptThreadEventCategory::WorkerEvent;
+use script_thread::{ScriptThread, ScriptChan, ScriptPort, StackRootTLS, CommonScriptMsg};
 use script_traits::{TimerEvent, TimerSource};
 use std::mem::replace;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, RecvError, Select, Sender, channel};
 use url::Url;
 use util::str::DOMString;
-use util::task::spawn_named;
-use util::task_state;
-use util::task_state::{IN_WORKER, SCRIPT};
+use util::thread::spawn_named;
+use util::thread_state;
+use util::thread_state::{IN_WORKER, SCRIPT};
 
 /// Messages used to control the worker event loops
 pub enum WorkerScriptMsg {
     /// Common variants associated with the script messages
     Common(CommonScriptMsg),
     /// Message sent through Worker.postMessage
     DOMMessage(StructuredCloneData),
 }
@@ -210,34 +210,37 @@ impl DedicatedWorkerGlobalScope {
                             id: PipelineId,
                             from_devtools_receiver: IpcReceiver<DevtoolScriptControlMsg>,
                             worker: TrustedWorkerAddress,
                             parent_sender: Box<ScriptChan + Send>,
                             own_sender: Sender<(TrustedWorkerAddress, WorkerScriptMsg)>,
                             receiver: Receiver<(TrustedWorkerAddress, WorkerScriptMsg)>) {
         let serialized_worker_url = worker_url.serialize();
         spawn_named(format!("WebWorker for {}", serialized_worker_url), move || {
-            task_state::initialize(SCRIPT | IN_WORKER);
+            thread_state::initialize(SCRIPT | IN_WORKER);
 
             let roots = RootCollection::new();
             let _stack_roots_tls = StackRootTLS::new(&roots);
 
-            let (url, source) = match load_whole_resource(LoadContext::Script, &init.resource_task, worker_url, None) {
+            let (url, source) = match load_whole_resource(LoadContext::Script,
+                                                          &init.resource_thread,
+                                                          worker_url,
+                                                          None) {
                 Err(_) => {
                     println!("error loading script {}", serialized_worker_url);
                     parent_sender.send(CommonScriptMsg::RunnableMsg(WorkerEvent,
                         box SimpleWorkerErrorHandler::new(worker))).unwrap();
                     return;
                 }
                 Ok((metadata, bytes)) => {
                     (metadata.final_url, String::from_utf8(bytes).unwrap())
                 }
             };
 
-            let runtime = Rc::new(ScriptTask::new_rt_and_cx());
+            let runtime = Rc::new(ScriptThread::new_rt_and_cx());
 
             let (devtools_mpsc_chan, devtools_mpsc_port) = channel();
             ROUTER.route_ipc_receiver_to_mpsc_sender(from_devtools_receiver, devtools_mpsc_chan);
 
             let (timer_tx, timer_rx) = channel();
             let (timer_ipc_chan, timer_ipc_port) = ipc::channel().unwrap();
             let worker_for_route = worker.clone();
             ROUTER.add_route(timer_ipc_port.to_opaque(), box move |message| {
@@ -338,17 +341,17 @@ impl DedicatedWorkerGlobalScope {
             },
             WorkerScriptMsg::Common(CommonScriptMsg::RefcountCleanup(addr)) => {
                 LiveDOMReferences::cleanup(addr);
             },
             WorkerScriptMsg::Common(CommonScriptMsg::CollectReports(reports_chan)) => {
                 let scope = self.upcast::<WorkerGlobalScope>();
                 let cx = scope.get_cx();
                 let path_seg = format!("url({})", scope.get_url());
-                let reports = ScriptTask::get_reports(cx, path_seg);
+                let reports = ScriptThread::get_reports(cx, path_seg);
                 reports_chan.send(reports);
             },
         }
     }
 
     fn handle_event(&self, event: MixedMessage) {
         match event {
             MixedMessage::FromDevtools(msg) => {
--- a/servo/components/script/dom/document.rs
+++ b/servo/components/script/dom/document.rs
@@ -83,18 +83,18 @@ use layout_interface::{ReflowGoal, Reflo
 use msg::constellation_msg::{ALT, CONTROL, SHIFT, SUPER};
 use msg::constellation_msg::{AnimationState, PipelineId};
 use msg::constellation_msg::{ConstellationChan, Key, KeyModifiers, KeyState};
 use msg::constellation_msg::{MouseButton, MouseEventType, MozBrowserEvent, SubpageId};
 use net_traits::ControlMsg::{GetCookiesForUrl, SetCookiesForUrl};
 use net_traits::CookieSource::NonHTTP;
 use net_traits::{AsyncResponseTarget, PendingAsyncLoad};
 use num::ToPrimitive;
-use script_task::CSSError;
-use script_task::{MainThreadScriptMsg, Runnable};
+use script_thread::CSSError;
+use script_thread::{MainThreadScriptMsg, Runnable};
 use script_traits::{ScriptMsg as ConstellationMsg, ScriptToCompositorMsg};
 use script_traits::{TouchEventType, TouchId, UntrustedNodeAddress};
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
 use std::cell::{Cell, Ref, RefMut};
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
@@ -2313,30 +2313,30 @@ impl DocumentMethods for Document {
     // https://html.spec.whatwg.org/multipage/#dom-document-cookie
     fn GetCookie(&self) -> Fallible<DOMString> {
         // TODO: return empty string for cookie-averse Document
         let url = self.url();
         if !is_scheme_host_port_tuple(&url) {
             return Err(Error::Security);
         }
         let (tx, rx) = ipc::channel().unwrap();
-        let _ = self.window.resource_task().send(GetCookiesForUrl((*url).clone(), tx, NonHTTP));
+        let _ = self.window.resource_thread().send(GetCookiesForUrl((*url).clone(), tx, NonHTTP));
         let cookies = rx.recv().unwrap();
         Ok(cookies.map_or(DOMString::new(), DOMString::from))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-cookie
     fn SetCookie(&self, cookie: DOMString) -> ErrorResult {
         // TODO: ignore for cookie-averse Document
         let url = self.url();
         if !is_scheme_host_port_tuple(url) {
             return Err(Error::Security);
         }
         let _ = self.window
-                    .resource_task()
+                    .resource_thread()
                     .send(SetCookiesForUrl((*url).clone(), String::from(cookie), NonHTTP));
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-document-bgcolor
     fn BgColor(&self) -> DOMString {
         self.get_body_attribute(&atom!("bgcolor"))
     }
--- a/servo/components/script/dom/filereader.rs
+++ b/servo/components/script/dom/filereader.rs
@@ -17,22 +17,22 @@ use dom::domexception::{DOMErrorName, DO
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
 use dom::progressevent::ProgressEvent;
 use encoding::all::UTF_8;
 use encoding::label::encoding_from_whatwg_label;
 use encoding::types::{DecoderTrap, EncodingRef};
 use hyper::mime::{Attr, Mime};
 use rustc_serialize::base64::{CharacterSet, Config, Newline, ToBase64};
-use script_task::ScriptTaskEventCategory::FileRead;
-use script_task::{CommonScriptMsg, Runnable, ScriptChan};
+use script_thread::ScriptThreadEventCategory::FileRead;
+use script_thread::{CommonScriptMsg, Runnable, ScriptChan};
 use std::cell::Cell;
 use string_cache::Atom;
 use util::str::DOMString;
-use util::task::spawn_named;
+use util::thread::spawn_named;
 
 #[derive(PartialEq, Clone, Copy, JSTraceable, HeapSizeOf)]
 pub enum FileReaderFunction {
     ReadAsText,
     ReadAsDataUrl,
 }
 
 pub type TrustedFileReader = Trusted<FileReader>;
@@ -355,20 +355,20 @@ impl FileReader {
 
         // Step 4
         let blob_contents = blob.get_data().clone();
 
         let type_ = blob.Type();
 
         let load_data = ReadMetaData::new(String::from(type_), label.map(String::from), function);
 
-        let fr = Trusted::new(self, global.file_reading_task_source());
+        let fr = Trusted::new(self, global.file_reading_thread_source());
         let gen_id = self.generation_id.get();
 
-        let script_chan = global.file_reading_task_source();
+        let script_chan = global.file_reading_thread_source();
 
         spawn_named("file reader async operation".to_owned(), move || {
             perform_annotated_read_operation(gen_id, load_data, blob_contents, fr, script_chan)
         });
         Ok(())
     }
 
     fn change_ready_state(&self, state: FileReaderReadyState) {
@@ -399,22 +399,22 @@ impl Runnable for FileReaderEvent {
             },
             FileReaderEvent::ProcessReadEOF(filereader, gen_id, data, blob_contents) => {
                 FileReader::process_read_eof(filereader, gen_id, data, blob_contents);
             }
         }
     }
 }
 
-// https://w3c.github.io/FileAPI/#task-read-operation
+// https://w3c.github.io/FileAPI/#thread-read-operation
 fn perform_annotated_read_operation(gen_id: GenerationId, data: ReadMetaData, blob_contents: DataSlice,
     filereader: TrustedFileReader, script_chan: Box<ScriptChan + Send>) {
     let chan = &script_chan;
     // Step 4
-    let task = box FileReaderEvent::ProcessRead(filereader.clone(), gen_id);
-    chan.send(CommonScriptMsg::RunnableMsg(FileRead, task)).unwrap();
+    let thread = box FileReaderEvent::ProcessRead(filereader.clone(), gen_id);
+    chan.send(CommonScriptMsg::RunnableMsg(FileRead, thread)).unwrap();
 
-    let task = box FileReaderEvent::ProcessReadData(filereader.clone(), gen_id);
-    chan.send(CommonScriptMsg::RunnableMsg(FileRead, task)).unwrap();
+    let thread = box FileReaderEvent::ProcessReadData(filereader.clone(), gen_id);
+    chan.send(CommonScriptMsg::RunnableMsg(FileRead, thread)).unwrap();
 
-    let task = box FileReaderEvent::ProcessReadEOF(filereader, gen_id, data, blob_contents);
-    chan.send(CommonScriptMsg::RunnableMsg(FileRead, task)).unwrap();
+    let thread = box FileReaderEvent::ProcessReadEOF(filereader, gen_id, data, blob_contents);
+    chan.send(CommonScriptMsg::RunnableMsg(FileRead, thread)).unwrap();
 }
--- a/servo/components/script/dom/htmlcanvaselement.rs
+++ b/servo/components/script/dom/htmlcanvaselement.rs
@@ -327,19 +327,19 @@ impl<'a> From<&'a WebGLContextAttributes
             preserve_drawing_buffer: attrs.preserveDrawingBuffer,
         }
     }
 }
 
 pub mod utils {
     use dom::window::Window;
     use ipc_channel::ipc;
-    use net_traits::image_cache_task::{ImageCacheChan, ImageResponse};
+    use net_traits::image_cache_thread::{ImageCacheChan, ImageResponse};
     use url::Url;
 
     pub fn request_image_from_cache(window: &Window, url: Url) -> ImageResponse {
-        let image_cache = window.image_cache_task();
+        let image_cache = window.image_cache_thread();
         let (response_chan, response_port) = ipc::channel().unwrap();
         image_cache.request_image(url, ImageCacheChan(response_chan), None);
         let result = response_port.recv().unwrap();
         result.image_response
     }
 }
--- a/servo/components/script/dom/htmlformelement.rs
+++ b/servo/components/script/dom/htmlformelement.rs
@@ -27,17 +27,17 @@ use dom::htmlobjectelement::HTMLObjectEl
 use dom::htmlselectelement::HTMLSelectElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::node::{Node, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use hyper::header::ContentType;
 use hyper::method::Method;
 use hyper::mime;
 use msg::constellation_msg::LoadData;
-use script_task::{MainThreadScriptMsg, ScriptChan};
+use script_thread::{MainThreadScriptMsg, ScriptChan};
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use string_cache::Atom;
 use url::form_urlencoded::serialize;
 use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLFormElement {
--- a/servo/components/script/dom/htmlimageelement.rs
+++ b/servo/components/script/dom/htmlimageelement.rs
@@ -17,19 +17,19 @@ use dom::document::Document;
 use dom::element::AttributeMutation;
 use dom::eventtarget::EventTarget;
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use net_traits::image::base::Image;
-use net_traits::image_cache_task::{ImageResponder, ImageResponse};
-use script_task::ScriptTaskEventCategory::UpdateReplacedElement;
-use script_task::{CommonScriptMsg, Runnable, ScriptChan};
+use net_traits::image_cache_thread::{ImageResponder, ImageResponse};
+use script_thread::ScriptThreadEventCategory::UpdateReplacedElement;
+use script_thread::{CommonScriptMsg, Runnable, ScriptChan};
 use std::sync::Arc;
 use string_cache::Atom;
 use url::Url;
 use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLImageElement {
     htmlelement: HTMLElement,
@@ -84,34 +84,34 @@ impl Runnable for ImageResponseHandlerRu
 }
 
 impl HTMLImageElement {
     /// Makes the local `image` member match the status of the `src` attribute and starts
     /// prefetching the image. This method must be called after `src` is changed.
     fn update_image(&self, value: Option<(DOMString, Url)>) {
         let document = document_from_node(self);
         let window = document.window();
-        let image_cache = window.image_cache_task();
+        let image_cache = window.image_cache_thread();
         match value {
             None => {
                 *self.url.borrow_mut() = None;
                 *self.image.borrow_mut() = None;
             }
             Some((src, base_url)) => {
                 let img_url = base_url.join(&src);
                 // FIXME: handle URL parse errors more gracefully.
                 let img_url = img_url.unwrap();
                 *self.url.borrow_mut() = Some(img_url.clone());
 
-                let trusted_node = Trusted::new(self, window.networking_task_source());
+                let trusted_node = Trusted::new(self, window.networking_thread_source());
                 let (responder_sender, responder_receiver) = ipc::channel().unwrap();
-                let script_chan = window.networking_task_source();
+                let script_chan = window.networking_thread_source();
                 let wrapper = window.get_runnable_wrapper();
                 ROUTER.add_route(responder_receiver.to_opaque(), box move |message| {
-                    // Return the image via a message to the script task, which marks the element
+                    // Return the image via a message to the script thread, which marks the element
                     // as dirty and triggers a reflow.
                     let image_response = message.to().unwrap();
                     let runnable = ImageResponseHandlerRunnable::new(
                         trusted_node.clone(), image_response);
                     let runnable = wrapper.wrap_runnable(runnable);
                     let _ = script_chan.send(CommonScriptMsg::RunnableMsg(
                         UpdateReplacedElement, runnable));
                 });
--- a/servo/components/script/dom/htmlinputelement.rs
+++ b/servo/components/script/dom/htmlinputelement.rs
@@ -24,18 +24,18 @@ use dom::htmlfieldsetelement::HTMLFieldS
 use dom::htmlformelement::{FormControl, FormDatum, FormSubmitter, HTMLFormElement};
 use dom::htmlformelement::{ResetFrom, SubmittedFrom};
 use dom::keyboardevent::KeyboardEvent;
 use dom::node::{Node, NodeDamage, UnbindContext};
 use dom::node::{document_from_node, window_from_node};
 use dom::nodelist::NodeList;
 use dom::virtualmethods::VirtualMethods;
 use msg::constellation_msg::ConstellationChan;
-use script_task::ScriptTaskEventCategory::InputEvent;
-use script_task::{CommonScriptMsg, Runnable};
+use script_thread::ScriptThreadEventCategory::InputEvent;
+use script_thread::{CommonScriptMsg, Runnable};
 use script_traits::ScriptMsg as ConstellationMsg;
 use selectors::states::*;
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use string_cache::Atom;
 use textinput::KeyReaction::{DispatchInput, Nothing, RedrawSelection, TriggerDefaultAction};
 use textinput::Lines::Single;
 use textinput::TextInput;
@@ -932,17 +932,17 @@ impl Activatable for HTMLInputElement {
 pub struct ChangeEventRunnable {
     element: Trusted<Node>,
 }
 
 impl ChangeEventRunnable {
     pub fn send(node: &Node) {
         let window = window_from_node(node);
         let window = window.r();
-        let chan = window.user_interaction_task_source();
+        let chan = window.user_interaction_thread_source();
         let handler = Trusted::new(node, chan.clone());
         let dispatcher = ChangeEventRunnable {
             element: handler,
         };
         let _ = chan.send(CommonScriptMsg::RunnableMsg(InputEvent, box dispatcher));
     }
 }
 
--- a/servo/components/script/dom/htmllinkelement.rs
+++ b/servo/components/script/dom/htmllinkelement.rs
@@ -192,17 +192,17 @@ impl HTMLLinkElement {
                     Some(ref value) => &***value,
                     None => "",
                 };
                 let mut css_parser = CssParser::new(&mq_str);
                 let media = parse_media_query_list(&mut css_parser);
 
                 // TODO: #8085 - Don't load external stylesheets if the node's mq doesn't match.
                 let doc = window.Document();
-                let script_chan = window.networking_task_source();
+                let script_chan = window.networking_thread_source();
                 let elem = Trusted::new(self, script_chan.clone());
 
                 let context = Arc::new(Mutex::new(StylesheetContext {
                     elem: elem,
                     media: Some(media),
                     data: vec!(),
                     metadata: None,
                     url: url.clone(),
--- a/servo/components/script/dom/htmlscriptelement.rs
+++ b/servo/components/script/dom/htmlscriptelement.rs
@@ -29,18 +29,18 @@ use encoding::label::encoding_from_whatw
 use encoding::types::{DecoderTrap, Encoding, EncodingRef};
 use html5ever::tree_builder::NextParserState;
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use js::jsapi::RootedValue;
 use js::jsval::UndefinedValue;
 use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata};
 use network_listener::{NetworkListener, PreInvoke};
-use script_task::ScriptTaskEventCategory::ScriptEvent;
-use script_task::{CommonScriptMsg, Runnable, ScriptChan};
+use script_thread::ScriptThreadEventCategory::ScriptEvent;
+use script_thread::{CommonScriptMsg, Runnable, ScriptChan};
 use std::ascii::AsciiExt;
 use std::cell::Cell;
 use std::mem;
 use std::sync::{Arc, Mutex};
 use string_cache::Atom;
 use url::Url;
 use util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
 
@@ -267,17 +267,17 @@ impl HTMLScriptElement {
                         // Step 14.4.
                         error!("error parsing URL for script {}", &**src);
                         self.queue_error_event();
                         return NextParserState::Continue;
                     }
                     Ok(url) => {
                         // Step 14.5-7.
                         // TODO(#9186): use the fetch infrastructure.
-                        let script_chan = window.networking_task_source();
+                        let script_chan = window.networking_thread_source();
                         let elem = Trusted::new(self, script_chan.clone());
 
                         let context = Arc::new(Mutex::new(ScriptContext {
                             elem: elem,
                             data: vec!(),
                             metadata: None,
                             url: url.clone(),
                         }));
@@ -427,30 +427,30 @@ impl HTMLScriptElement {
 
         // Step 2.b.9.
         self.dispatch_after_script_execute_event();
 
         // Step 2.b.10.
         if external {
             self.dispatch_load_event();
         } else {
-            let chan = window.dom_manipulation_task_source();
+            let chan = window.dom_manipulation_thread_source();
             let handler = Trusted::new(self, chan.clone());
             let dispatcher = box EventDispatcher {
                 element: handler,
                 is_error: false,
             };
             chan.send(CommonScriptMsg::RunnableMsg(ScriptEvent, dispatcher)).unwrap();
         }
     }
 
     pub fn queue_error_event(&self) {
         let window = window_from_node(self);
         let window = window.r();
-        let chan = window.dom_manipulation_task_source();
+        let chan = window.dom_manipulation_thread_source();
         let handler = Trusted::new(self, chan.clone());
         let dispatcher = box EventDispatcher {
             element: handler,
             is_error: true,
         };
         chan.send(CommonScriptMsg::RunnableMsg(ScriptEvent, dispatcher)).unwrap();
     }
 
--- a/servo/components/script/dom/mod.rs
+++ b/servo/components/script/dom/mod.rs
@@ -30,17 +30,17 @@
 //! For more information, see:
 //!
 //! * rooting pointers on the stack:
 //!   the [`Root`](bindings/js/struct.Root.html) smart pointer;
 //! * tracing pointers in member fields: the [`JS`](bindings/js/struct.JS.html),
 //!   [`MutNullableJS`](bindings/js/struct.MutNullableJS.html) and
 //!   [`MutHeap`](bindings/js/struct.MutHeap.html) smart pointers and
 //!   [the tracing implementation](bindings/trace/index.html);
-//! * rooting pointers from across task boundaries or in channels: the
+//! * rooting pointers from across thread boundaries or in channels: the
 //!   [`Trusted`](bindings/refcounted/struct.Trusted.html) smart pointer;
 //! * extracting pointers to DOM objects from their reflectors: the
 //!   [`Unrooted`](bindings/js/struct.Unrooted.html) smart pointer.
 //!
 //! Inheritance
 //! ===========
 //!
 //! Rust does not support struct inheritance, as would be used for the
@@ -191,17 +191,17 @@
 //! More information is available in the [bindings module](bindings/index.html).
 //!
 //! Accessing DOM objects from layout
 //! =================================
 //!
 //! Layout code can access the DOM through the
 //! [`LayoutJS`](bindings/js/struct.LayoutJS.html) smart pointer. This does not
 //! keep the DOM object alive; we ensure that no DOM code (Garbage Collection
-//! in particular) runs while the layout task is accessing the DOM.
+//! in particular) runs while the layout thread is accessing the DOM.
 //!
 //! Methods accessible to layout are implemented on `LayoutJS<Foo>` using
 //! `LayoutFooHelpers` traits.
 
 #[macro_use]
 pub mod macros;
 
 pub mod types {
--- a/servo/components/script/dom/node.rs
+++ b/servo/components/script/dom/node.rs
@@ -59,17 +59,17 @@ use selectors::parser::parse_author_orig
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::cmp::max;
 use std::default::Default;
 use std::iter::{self, FilterMap, Peekable};
 use std::mem;
 use string_cache::{Atom, Namespace, QualName};
 use util::str::DOMString;
-use util::task_state;
+use util::thread_state;
 use uuid::Uuid;
 
 //
 // The basic Node structure
 //
 
 /// An HTML node.
 #[dom_struct]
@@ -108,19 +108,19 @@ pub struct Node {
     inclusive_descendants_version: Cell<u64>,
 
     /// A vector of weak references to Range instances of which the start
     /// or end containers are this node. No range should ever be found
     /// twice in this vector, even if both the start and end containers
     /// are this node.
     ranges: WeakRangeVec,
 
-    /// Style+Layout information. Only the layout task may touch this data.
+    /// Style+Layout information. Only the layout thread may touch this data.
     ///
-    /// Must be sent back to the layout task to be destroyed when this
+    /// Must be sent back to the layout thread to be destroyed when this
     /// node is finalized.
     style_and_layout_data: Cell<Option<OpaqueStyleAndLayoutData>>,
 
     unique_id: DOMRefCell<Option<Box<Uuid>>>,
 }
 
 bitflags! {
     #[doc = "Flags for node items."]
@@ -178,19 +178,19 @@ pub struct OpaqueStyleAndLayoutData {
 
 #[allow(unsafe_code)]
 unsafe impl Send for OpaqueStyleAndLayoutData {}
 
 no_jsmanaged_fields!(OpaqueStyleAndLayoutData);
 
 
 impl OpaqueStyleAndLayoutData {
-    /// Sends the style and layout data, if any, back to the layout task to be destroyed.
+    /// Sends the style and layout data, if any, back to the layout thread to be destroyed.
     pub fn dispose(self, node: &Node) {
-        debug_assert!(task_state::get().is_script());
+        debug_assert!(thread_state::get().is_script());
         let win = window_from_node(node);
         let LayoutChan(chan) = win.layout_chan();
         node.style_and_layout_data.set(None);
         chan.send(Msg::ReapStyleAndLayoutData(self)).unwrap();
     }
 }
 
 impl Node {
--- a/servo/components/script/dom/servohtmlparser.rs
+++ b/servo/components/script/dom/servohtmlparser.rs
@@ -24,17 +24,17 @@ use html5ever::tree_builder;
 use html5ever::tree_builder::{TreeBuilder, TreeBuilderOpts};
 use hyper::header::ContentType;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use js::jsapi::JSTracer;
 use msg::constellation_msg::{PipelineId, SubpageId};
 use net_traits::{AsyncResponseListener, Metadata};
 use network_listener::PreInvoke;
 use parse::Parser;
-use script_task::{ScriptChan, ScriptTask};
+use script_thread::{ScriptChan, ScriptThread};
 use std::cell::Cell;
 use std::cell::UnsafeCell;
 use std::default::Default;
 use std::ptr;
 use url::Url;
 
 #[must_root]
 #[derive(JSTraceable, HeapSizeOf)]
@@ -236,17 +236,17 @@ impl ParserContext {
         }
     }
 }
 
 impl AsyncResponseListener for ParserContext {
     fn headers_available(&mut self, metadata: Metadata) {
         let content_type = metadata.content_type.clone();
 
-        let parser = ScriptTask::page_fetch_complete(self.id.clone(), self.subpage.clone(),
+        let parser = ScriptThread::page_fetch_complete(self.id.clone(), self.subpage.clone(),
                                                      metadata);
         let parser = match parser {
             Some(parser) => parser,
             None => return,
         };
 
         let parser = parser.r();
         self.parser = Some(match parser {
@@ -361,17 +361,17 @@ impl<'a> Parser for &'a ServoHTMLParser 
         assert!(self.pending_input.borrow().is_empty());
 
         self.tokenizer.borrow_mut().end();
         debug!("finished parsing");
 
         self.document.set_current_parser(None);
 
         if let Some(pipeline) = self.pipeline {
-            ScriptTask::parsing_complete(pipeline);
+            ScriptThread::parsing_complete(pipeline);
         }
     }
 }
 
 impl ServoHTMLParser {
     #[allow(unrooted_must_root)]
     pub fn new(base_url: Option<Url>, document: &Document, pipeline: Option<PipelineId>)
                -> Root<ServoHTMLParser> {
--- a/servo/components/script/dom/servoxmlparser.rs
+++ b/servo/components/script/dom/servoxmlparser.rs
@@ -10,17 +10,17 @@ use dom::bindings::reflector::{Reflector
 use dom::bindings::trace::JSTraceable;
 use dom::document::Document;
 use dom::node::Node;
 use dom::servohtmlparser::ParserRef;
 use dom::window::Window;
 use js::jsapi::JSTracer;
 use msg::constellation_msg::PipelineId;
 use parse::Parser;
-use script_task::ScriptTask;
+use script_thread::ScriptThread;
 use std::cell::Cell;
 use url::Url;
 use xml5ever::tokenizer;
 use xml5ever::tree_builder::{self, XmlTreeBuilder};
 
 pub type Tokenizer = tokenizer::XmlTokenizer<XmlTreeBuilder<JS<Node>, Sink>>;
 
 #[must_root]
@@ -63,17 +63,17 @@ impl<'a> Parser for &'a ServoXMLParser {
         assert!(self.pending_input.borrow().is_empty());
 
         self.tokenizer.borrow_mut().end();
         debug!("finished parsing");
 
         self.document.set_current_parser(None);
 
         if let Some(pipeline) = self.pipeline {
-            ScriptTask::parsing_complete(pipeline);
+            ScriptThread::parsing_complete(pipeline);
         }
     }
 }
 
 impl ServoXMLParser {
     #[allow(unrooted_must_root)]
     pub fn new(base_url: Option<Url>, document: &Document, pipeline: Option<PipelineId>)
                -> Root<ServoXMLParser> {
--- a/servo/components/script/dom/storage.rs
+++ b/servo/components/script/dom/storage.rs
@@ -9,19 +9,19 @@ use dom::bindings::global::{GlobalField,
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::storageevent::StorageEvent;
 use dom::urlhelper::UrlHelper;
 use ipc_channel::ipc;
-use net_traits::storage_task::{StorageTask, StorageTaskMsg, StorageType};
+use net_traits::storage_thread::{StorageThread, StorageThreadMsg, StorageType};
 use page::IterablePage;
-use script_task::{MainThreadRunnable, MainThreadScriptMsg, ScriptTask};
+use script_thread::{MainThreadRunnable, MainThreadScriptMsg, ScriptThread};
 use std::sync::mpsc::channel;
 use url::Url;
 use util::str::DOMString;
 
 #[dom_struct]
 pub struct Storage {
     reflector_: Reflector,
     global: GlobalField,
@@ -42,97 +42,99 @@ impl Storage {
     }
 
     fn get_url(&self) -> Url {
         let global_root = self.global.root();
         let global_ref = global_root.r();
         global_ref.get_url()
     }
 
-    fn get_storage_task(&self) -> StorageTask {
+    fn get_storage_thread(&self) -> StorageThread {
         let global_root = self.global.root();
         let global_ref = global_root.r();
-        global_ref.as_window().storage_task()
+        global_ref.as_window().storage_thread()
     }
 
 }
 
 impl StorageMethods for Storage {
     // https://html.spec.whatwg.org/multipage/#dom-storage-length
     fn Length(&self) -> u32 {
         let (sender, receiver) = ipc::channel().unwrap();
 
-        self.get_storage_task().send(StorageTaskMsg::Length(sender, self.get_url(), self.storage_type)).unwrap();
+        self.get_storage_thread().send(StorageThreadMsg::Length(sender, self.get_url(), self.storage_type)).unwrap();
         receiver.recv().unwrap() as u32
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-storage-key
     fn Key(&self, index: u32) -> Option<DOMString> {
         let (sender, receiver) = ipc::channel().unwrap();
 
-        self.get_storage_task().send(StorageTaskMsg::Key(sender, self.get_url(), self.storage_type, index)).unwrap();
+        self.get_storage_thread()
+            .send(StorageThreadMsg::Key(sender, self.get_url(), self.storage_type, index))
+            .unwrap();
         receiver.recv().unwrap().map(DOMString::from)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-storage-getitem
     fn GetItem(&self, name: DOMString) -> Option<DOMString> {
         let (sender, receiver) = ipc::channel().unwrap();
         let name = String::from(name);
 
-        let msg = StorageTaskMsg::GetItem(sender, self.get_url(), self.storage_type, name);
-        self.get_storage_task().send(msg).unwrap();
+        let msg = StorageThreadMsg::GetItem(sender, self.get_url(), self.storage_type, name);
+        self.get_storage_thread().send(msg).unwrap();
         receiver.recv().unwrap().map(DOMString::from)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-storage-setitem
     fn SetItem(&self, name: DOMString, value: DOMString) -> ErrorResult {
         let (sender, receiver) = ipc::channel().unwrap();
         let name = String::from(name);
         let value = String::from(value);
 
-        let msg = StorageTaskMsg::SetItem(sender, self.get_url(), self.storage_type, name.clone(), value.clone());
-        self.get_storage_task().send(msg).unwrap();
+        let msg = StorageThreadMsg::SetItem(sender, self.get_url(), self.storage_type, name.clone(), value.clone());
+        self.get_storage_thread().send(msg).unwrap();
         match receiver.recv().unwrap() {
             Err(_) => Err(Error::QuotaExceeded),
             Ok((changed, old_value)) => {
               if changed {
                   self.broadcast_change_notification(Some(name), old_value, Some(value));
               }
               Ok(())
             }
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-storage-removeitem
     fn RemoveItem(&self, name: DOMString) {
         let (sender, receiver) = ipc::channel().unwrap();
         let name = String::from(name);
 
-        let msg = StorageTaskMsg::RemoveItem(sender, self.get_url(), self.storage_type, name.clone());
-        self.get_storage_task().send(msg).unwrap();
+        let msg = StorageThreadMsg::RemoveItem(sender, self.get_url(), self.storage_type, name.clone());
+        self.get_storage_thread().send(msg).unwrap();
         if let Some(old_value) = receiver.recv().unwrap() {
             self.broadcast_change_notification(Some(name), Some(old_value), None);
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-storage-clear
     fn Clear(&self) {
         let (sender, receiver) = ipc::channel().unwrap();
 
-        self.get_storage_task().send(StorageTaskMsg::Clear(sender, self.get_url(), self.storage_type)).unwrap();
+        self.get_storage_thread().send(StorageThreadMsg::Clear(sender, self.get_url(), self.storage_type)).unwrap();
         if receiver.recv().unwrap() {
             self.broadcast_change_notification(None, None, None);
         }
     }
 
     // https://html.spec.whatwg.org/multipage/#the-storage-interface:supported-property-names
     fn SupportedPropertyNames(&self) -> Vec<DOMString> {
         let (sender, receiver) = ipc::channel().unwrap();
 
-        self.get_storage_task().send(StorageTaskMsg::Keys(sender, self.get_url(), self.storage_type)).unwrap();
+        self.get_storage_thread().send(StorageThreadMsg::Keys(sender, self.get_url(), self.storage_type)).unwrap();
         receiver.recv().unwrap().iter().cloned().map(DOMString::from).collect() // FIXME: inefficient?
     }
 
     // check-tidy: no specs after this line
     fn NamedGetter(&self, name: DOMString, found: &mut bool) -> Option<DOMString> {
         let item = self.GetItem(name);
         *found = item.is_some();
         item
@@ -150,17 +152,17 @@ impl StorageMethods for Storage {
 
 impl Storage {
     /// https://html.spec.whatwg.org/multipage/#send-a-storage-notification
     fn broadcast_change_notification(&self, key: Option<String>, old_value: Option<String>,
                                      new_value: Option<String>) {
         let global_root = self.global.root();
         let global_ref = global_root.r();
         let main_script_chan = global_ref.as_window().main_thread_script_chan();
-        let script_chan = global_ref.dom_manipulation_task_source();
+        let script_chan = global_ref.dom_manipulation_thread_source();
         let trusted_storage = Trusted::new(self, script_chan);
         main_script_chan.send(MainThreadScriptMsg::MainThreadRunnableMsg(
             box StorageEventRunnable::new(trusted_storage, key, old_value, new_value))).unwrap();
     }
 }
 
 pub struct StorageEventRunnable {
     element: Trusted<Storage>,
@@ -172,17 +174,17 @@ pub struct StorageEventRunnable {
 impl StorageEventRunnable {
     fn new(storage: Trusted<Storage>, key: Option<String>, old_value: Option<String>,
            new_value: Option<String>) -> StorageEventRunnable {
         StorageEventRunnable { element: storage, key: key, old_value: old_value, new_value: new_value }
     }
 }
 
 impl MainThreadRunnable for StorageEventRunnable {
-    fn handler(self: Box<StorageEventRunnable>, script_task: &ScriptTask) {
+    fn handler(self: Box<StorageEventRunnable>, script_thread: &ScriptThread) {
         let this = *self;
         let storage_root = this.element.root();
         let storage = storage_root.r();
         let global_root = storage.global.root();
         let global_ref = global_root.r();
         let ev_window = global_ref.as_window();
         let ev_url = storage.get_url();
 
@@ -190,17 +192,17 @@ impl MainThreadRunnable for StorageEvent
             global_ref,
             atom!("storage"),
             EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             this.key.map(DOMString::from), this.old_value.map(DOMString::from), this.new_value.map(DOMString::from),
             DOMString::from(ev_url.to_string()),
             Some(storage)
         );
 
-        let root_page = script_task.root_page();
+        let root_page = script_thread.root_page();
         for it_page in root_page.iter() {
             let it_window_root = it_page.window();
             let it_window = it_window_root.r();
             assert!(UrlHelper::SameOrigin(&ev_url, &it_window.get_url()));
             // TODO: Such a Document object is not necessarily fully active, but events fired on such
             // objects are ignored by the event loop until the Document becomes fully active again.
             if ev_window.pipeline() != it_window.pipeline() {
                 storage_event.upcast::<Event>().fire(it_window.upcast());
--- a/servo/components/script/dom/webglrenderingcontext.rs
+++ b/servo/components/script/dom/webglrenderingcontext.rs
@@ -26,17 +26,17 @@ use dom::webglrenderbuffer::WebGLRenderb
 use dom::webglshader::WebGLShader;
 use dom::webgltexture::{TexParameterValue, WebGLTexture};
 use dom::webgluniformlocation::WebGLUniformLocation;
 use euclid::size::Size2D;
 use ipc_channel::ipc::{self, IpcSender};
 use js::jsapi::{JSContext, JSObject, RootedValue};
 use js::jsval::{BooleanValue, DoubleValue, Int32Value, JSVal, NullValue, UndefinedValue};
 use net_traits::image::base::PixelFormat;
-use net_traits::image_cache_task::ImageResponse;
+use net_traits::image_cache_thread::ImageResponse;
 use offscreen_gl_context::GLContextAttributes;
 use script_traits::ScriptMsg as ConstellationMsg;
 use std::cell::Cell;
 use std::sync::mpsc::channel;
 use util::str::DOMString;
 use util::vec::byte_swap;
 
 pub const MAX_UNIFORM_AND_ATTRIBUTE_LEN: usize = 256;
@@ -86,17 +86,17 @@ impl WebGLRenderingContext {
     fn new_inherited(global: GlobalRef,
                      canvas: &HTMLCanvasElement,
                      size: Size2D<i32>,
                      attrs: GLContextAttributes)
                      -> Result<WebGLRenderingContext, String> {
         let (sender, receiver) = ipc::channel().unwrap();
         let constellation_chan = global.constellation_chan();
         constellation_chan.0
-                          .send(ConstellationMsg::CreateWebGLPaintTask(size, attrs, sender))
+                          .send(ConstellationMsg::CreateWebGLPaintThread(size, attrs, sender))
                           .unwrap();
         let result = receiver.recv().unwrap();
 
         result.map(|(ipc_renderer, renderer_id)| {
             WebGLRenderingContext {
                 reflector_: Reflector::new(),
                 global: GlobalField::from_rooted(&global),
                 renderer_id: renderer_id,
@@ -609,17 +609,17 @@ impl WebGLRenderingContextMethods for We
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CompileShader(&self, shader: Option<&WebGLShader>) {
         if let Some(shader) = shader {
             shader.compile()
         }
     }
 
     // TODO(ecoal95): Probably in the future we should keep track of the
-    // generated objects, either here or in the webgl task
+    // generated objects, either here or in the webgl thread
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
     fn CreateBuffer(&self) -> Option<Root<WebGLBuffer>> {
         WebGLBuffer::maybe_new(self.global.root().r(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn CreateFramebuffer(&self) -> Option<Root<WebGLFramebuffer>> {
         WebGLFramebuffer::maybe_new(self.global.root().r(), self.ipc_renderer.clone())
--- a/servo/components/script/dom/webglshader.rs
+++ b/servo/components/script/dom/webglshader.rs
@@ -95,19 +95,19 @@ impl WebGLShader {
         }
 
         if let Some(ref source) = *self.source.borrow() {
             let validator = ShaderValidator::for_webgl(self.gl_type,
                                                        SHADER_OUTPUT_FORMAT,
                                                        &BuiltInResources::default()).unwrap();
             match validator.compile_and_translate(&[source.as_bytes()]) {
                 Ok(translated_source) => {
-                    // NOTE: At this point we should be pretty sure that the compilation in the paint task
+                    // NOTE: At this point we should be pretty sure that the compilation in the paint thread
                     // will succeed.
-                    // It could be interesting to retrieve the info log from the paint task though
+                    // It could be interesting to retrieve the info log from the paint thread though
                     let msg = CanvasWebGLMsg::CompileShader(self.id, translated_source);
                     self.renderer.send(CanvasMsg::WebGL(msg)).unwrap();
                     self.compilation_status.set(ShaderCompilationStatus::Succeeded);
                 },
                 Err(error) => {
                     self.compilation_status.set(ShaderCompilationStatus::Failed);
                     debug!("Shader {} compilation failed: {}", self.id, error);
                 },
--- a/servo/components/script/dom/websocket.rs
+++ b/servo/components/script/dom/websocket.rs
@@ -27,18 +27,18 @@ use js::jsapi::{JS_GetArrayBufferData, J
 use js::jsval::UndefinedValue;
 use libc::{uint32_t, uint8_t};
 use net_traits::ControlMsg::WebsocketConnect;
 use net_traits::MessageData;
 use net_traits::hosts::replace_hosts;
 use net_traits::unwrap_websocket_protocol;
 use net_traits::{WebSocketCommunicate, WebSocketConnectData, WebSocketDomAction, WebSocketNetworkEvent};
 use ref_slice::ref_slice;
-use script_task::ScriptTaskEventCategory::WebSocketEvent;
-use script_task::{CommonScriptMsg, Runnable};
+use script_thread::ScriptThreadEventCategory::WebSocketEvent;
+use script_thread::{CommonScriptMsg, Runnable};
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::ptr;
 use std::thread;
 use util::str::DOMString;
 use websocket::client::request::Url;
 use websocket::header::{Headers, WebSocketProtocol};
 use websocket::ws::util::url::parse_url;
@@ -134,17 +134,17 @@ mod close_code {
 
 #[dom_struct]
 pub struct WebSocket {
     eventtarget: EventTarget,
     url: Url,
     global: GlobalField,
     ready_state: Cell<WebSocketRequestState>,
     buffered_amount: Cell<u64>,
-    clearing_buffer: Cell<bool>, //Flag to tell if there is a running task to clear buffered_amount
+    clearing_buffer: Cell<bool>, //Flag to tell if there is a running thread to clear buffered_amount
     #[ignore_heap_size_of = "Defined in std"]
     sender: DOMRefCell<Option<IpcSender<WebSocketDomAction>>>,
     failed: Cell<bool>, //Flag to tell if websocket was closed due to failure
     full: Cell<bool>, //Flag to tell if websocket queue is full
     clean_close: Cell<bool>, //Flag to tell if the websocket closed cleanly (not due to full or fail)
     code: Cell<u16>, //Closing code
     reason: DOMRefCell<String>, //Closing reason
     binary_type: Cell<BinaryType>,
@@ -178,17 +178,17 @@ impl WebSocket {
     }
 
     pub fn Constructor(global: GlobalRef,
                        url: DOMString,
                        protocols: Option<DOMString>)
                        -> Fallible<Root<WebSocket>> {
         // Step 1.
         let resource_url = try!(Url::parse(&url).map_err(|_| Error::Syntax));
-        // Although we do this replace and parse operation again in the resource task,
+        // Although we do this replace and parse operation again in the resource thread,
         // we try here to be able to immediately throw a syntax error on failure.
         let _ = try!(parse_url(&replace_hosts(&resource_url)).map_err(|_| Error::Syntax));
         // Step 2: Disallow https -> ws connections.
 
         // Step 3: Potentially block access to some ports.
         let port: u16 = resource_url.port_or_default().unwrap();
 
         if BLOCKED_PORTS_LIST.iter().any(|&p| p == port) {
@@ -218,70 +218,70 @@ impl WebSocket {
                 return Err(Error::Syntax);
             }
         }
 
         // Step 6: Origin.
 
         // Step 7.
         let ws = WebSocket::new(global, resource_url.clone());
-        let address = Trusted::new(ws.r(), global.networking_task_source());
+        let address = Trusted::new(ws.r(), global.networking_thread_source());
 
         let origin = global.get_url().serialize();
         let protocols: Vec<String> = protocols.iter().map(|x| String::from(x.clone())).collect();
 
         let connect_data = WebSocketConnectData {
             resource_url: resource_url.clone(),
             origin: origin,
             protocols: protocols,
         };
 
-        // Create the interface for communication with the resource task
+        // Create the interface for communication with the resource thread
         let (dom_action_sender, resource_action_receiver):
                 (IpcSender<WebSocketDomAction>,
                 IpcReceiver<WebSocketDomAction>) = ipc::channel().unwrap();
         let (resource_event_sender, dom_event_receiver):
                 (IpcSender<WebSocketNetworkEvent>,
                 IpcReceiver<WebSocketNetworkEvent>) = ipc::channel().unwrap();
 
         let connect = WebSocketCommunicate {
             event_sender: resource_event_sender,
             action_receiver: resource_action_receiver,
         };
 
-        let resource_task = global.resource_task();
-        let _ = resource_task.send(WebsocketConnect(connect, connect_data));
+        let resource_thread = global.resource_thread();
+        let _ = resource_thread.send(WebsocketConnect(connect, connect_data));
 
         *ws.sender.borrow_mut() = Some(dom_action_sender);
 
         let moved_address = address.clone();
-        let sender = global.networking_task_source();
+        let sender = global.networking_thread_source();
         thread::spawn(move || {
             while let Ok(event) = dom_event_receiver.recv() {
                 match event {
                     WebSocketNetworkEvent::ConnectionEstablished(headers, protocols) => {
-                        let open_task = box ConnectionEstablishedTask {
+                        let open_thread = box ConnectionEstablishedTask {
                             addr: moved_address.clone(),
                             headers: headers,
                             protocols: protocols,
                         };
-                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, open_task)).unwrap();
+                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, open_thread)).unwrap();
                     },
                     WebSocketNetworkEvent::MessageReceived(message) => {
-                        let message_task = box MessageReceivedTask {
+                        let message_thread = box MessageReceivedTask {
                             address: moved_address.clone(),
                             message: message,
                         };
-                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, message_task)).unwrap();
+                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, message_thread)).unwrap();
                     },
                     WebSocketNetworkEvent::Close => {
-                        let task = box CloseTask {
+                        let thread = box CloseTask {
                             addr: moved_address.clone(),
                         };
-                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, task)).unwrap();
+                        sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, thread)).unwrap();
                     },
                 }
             }
         });
         // Step 7.
         Ok(ws)
     }
 
@@ -291,17 +291,17 @@ impl WebSocket {
             WebSocketRequestState::Connecting => {
                 return Err(Error::InvalidState);
             },
             WebSocketRequestState::Open => false,
             WebSocketRequestState::Closing | WebSocketRequestState::Closed => true,
         };
 
         let global = self.global.root();
-        let chan = global.r().networking_task_source();
+        let chan = global.r().networking_thread_source();
         let address = Trusted::new(self, chan.clone());
 
         match data_byte_len.checked_add(self.buffered_amount.get()) {
             None => panic!(),
             Some(new_amount) => self.buffered_amount.set(new_amount)
         };
 
         if return_after_buffer {
@@ -464,21 +464,21 @@ impl Runnable for ConnectionEstablishedT
     fn handler(self: Box<Self>) {
         let ws = self.addr.root();
         let global = ws.global.root();
 
         // Step 1: Protocols.
         if !self.protocols.is_empty() && self.headers.get::<WebSocketProtocol>().is_none() {
             ws.failed.set(true);
             ws.ready_state.set(WebSocketRequestState::Closing);
-            let task = box CloseTask {
+            let thread = box CloseTask {
                 addr: self.addr,
             };
-            let sender = global.r().networking_task_source();
-            sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, task)).unwrap();
+            let sender = global.r().networking_thread_source();
+            sender.send(CommonScriptMsg::RunnableMsg(WebSocketEvent, thread)).unwrap();
             return;
         }
 
         // Step 2.
         ws.ready_state.set(WebSocketRequestState::Open);
 
         // Step 3: Extensions.
         //TODO: Set extensions to extensions in use
--- a/servo/components/script/dom/window.rs
+++ b/servo/components/script/dom/window.rs
@@ -42,27 +42,27 @@ use js::rust::CompileOptionsWrapper;
 use js::rust::Runtime;
 use layout_interface::{ContentBoxResponse, ContentBoxesResponse, ResolvedStyleResponse, ScriptReflow};
 use layout_interface::{LayoutChan, LayoutRPC, Msg, Reflow, ReflowGoal, ReflowQueryType};
 use libc;
 use msg::ParseErrorReporter;
 use msg::constellation_msg::{ConstellationChan, DocumentState, LoadData};
 use msg::constellation_msg::{MozBrowserEvent, PipelineId, SubpageId, WindowSizeData};
 use msg::webdriver_msg::{WebDriverJSError, WebDriverJSResult};
-use net_traits::ResourceTask;
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheTask};
-use net_traits::storage_task::{StorageTask, StorageType};
+use net_traits::ResourceThread;
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread};
+use net_traits::storage_thread::{StorageThread, StorageType};
 use num::traits::ToPrimitive;
 use page::Page;
 use profile_traits::mem;
 use reporter::CSSErrorReporter;
 use rustc_serialize::base64::{FromBase64, STANDARD, ToBase64};
-use script_task::{DOMManipulationTaskSource, UserInteractionTaskSource, NetworkingTaskSource};
-use script_task::{HistoryTraversalTaskSource, FileReadingTaskSource, SendableMainThreadScriptChan};
-use script_task::{ScriptChan, ScriptPort, MainThreadScriptChan, MainThreadScriptMsg, RunnableWrapper};
+use script_thread::{DOMManipulationThreadSource, UserInteractionThreadSource, NetworkingThreadSource};
+use script_thread::{HistoryTraversalThreadSource, FileReadingThreadSource, SendableMainThreadScriptChan};
+use script_thread::{ScriptChan, ScriptPort, MainThreadScriptChan, MainThreadScriptMsg, RunnableWrapper};
 use script_traits::ScriptMsg as ConstellationMsg;
 use script_traits::{MsDuration, ScriptToCompositorMsg, TimerEvent, TimerEventId, TimerEventRequest, TimerSource};
 use selectors::parser::PseudoElement;
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::collections::HashSet;
 use std::default::Default;
@@ -111,31 +111,31 @@ pub enum ReflowReason {
 
 pub type ScrollPoint = Point2D<Au>;
 
 #[dom_struct]
 pub struct Window {
     eventtarget: EventTarget,
     #[ignore_heap_size_of = "trait objects are hard"]
     script_chan: MainThreadScriptChan,
-    #[ignore_heap_size_of = "task sources are hard"]
-    dom_manipulation_task_source: DOMManipulationTaskSource,
-    #[ignore_heap_size_of = "task sources are hard"]
-    user_interaction_task_source: UserInteractionTaskSource,
-    #[ignore_heap_size_of = "task sources are hard"]
-    networking_task_source: NetworkingTaskSource,
-    #[ignore_heap_size_of = "task sources are hard"]
-    history_traversal_task_source: HistoryTraversalTaskSource,
-    #[ignore_heap_size_of = "task sources are hard"]
-    file_reading_task_source: FileReadingTaskSource,
+    #[ignore_heap_size_of = "thread sources are hard"]
+    dom_manipulation_thread_source: DOMManipulationThreadSource,
+    #[ignore_heap_size_of = "thread sources are hard"]
+    user_interaction_thread_source: UserInteractionThreadSource,
+    #[ignore_heap_size_of = "thread sources are hard"]
+    networking_thread_source: NetworkingThreadSource,
+    #[ignore_heap_size_of = "thread sources are hard"]
+    history_traversal_thread_source: HistoryTraversalThreadSource,
+    #[ignore_heap_size_of = "thread sources are hard"]
+    file_reading_thread_source: FileReadingThreadSource,
     console: MutNullableHeap<JS<Console>>,
     crypto: MutNullableHeap<JS<Crypto>>,
     navigator: MutNullableHeap<JS<Navigator>>,
     #[ignore_heap_size_of = "channels are hard"]
-    image_cache_task: ImageCacheTask,
+    image_cache_thread: ImageCacheThread,
     #[ignore_heap_size_of = "channels are hard"]
     image_cache_chan: ImageCacheChan,
     #[ignore_heap_size_of = "TODO(#6911) newtypes containing unmeasurable types are hard"]
     compositor: IpcSender<ScriptToCompositorMsg>,
     browsing_context: MutNullableHeap<JS<BrowsingContext>>,
     page: Rc<Page>,
     performance: MutNullableHeap<JS<Performance>>,
     navigation_start: u64,
@@ -180,36 +180,36 @@ pub struct Window {
 
     /// Global static data related to the DOM.
     dom_static: GlobalStaticData,
 
     /// The JavaScript runtime.
     #[ignore_heap_size_of = "Rc<T> is hard"]
     js_runtime: DOMRefCell<Option<Rc<Runtime>>>,
 
-    /// A handle for communicating messages to the layout task.
+    /// A handle for communicating messages to the layout thread.
     #[ignore_heap_size_of = "channels are hard"]
     layout_chan: LayoutChan,
 
     /// A handle to perform RPC calls into the layout, quickly.
     #[ignore_heap_size_of = "trait objects are hard"]
     layout_rpc: Box<LayoutRPC + 'static>,
 
     /// The current size of the window, in pixels.
     window_size: Cell<Option<WindowSizeData>>,
 
-    /// Associated resource task for use by DOM objects like XMLHttpRequest
+    /// Associated resource thread for use by DOM objects like XMLHttpRequest
     #[ignore_heap_size_of = "channels are hard"]
-    resource_task: Arc<ResourceTask>,
+    resource_thread: Arc<ResourceThread>,
 
-    /// A handle for communicating messages to the storage task.
+    /// A handle for communicating messages to the storage thread.
     #[ignore_heap_size_of = "channels are hard"]
-    storage_task: StorageTask,
+    storage_thread: StorageThread,
 
-    /// A handle for communicating messages to the constellation task.
+    /// A handle for communicating messages to the constellation thread.
     #[ignore_heap_size_of = "channels are hard"]
     constellation_chan: ConstellationChan<ConstellationMsg>,
 
     /// Pending scroll to fragment event, if any
     fragment_name: DOMRefCell<Option<String>>,
 
     /// An enlarged rectangle around the page contents visible in the viewport, used
     /// to prevent creating display list items for content that is far away from the viewport.
@@ -244,34 +244,34 @@ impl Window {
             self.ignore_further_async_events.store(true, Ordering::Relaxed);
         }
     }
 
     pub fn get_cx(&self) -> *mut JSContext {
         self.js_runtime.borrow().as_ref().unwrap().cx()
     }
 
-    pub fn dom_manipulation_task_source(&self) -> Box<ScriptChan + Send> {
-        self.dom_manipulation_task_source.clone()
+    pub fn dom_manipulation_thread_source(&self) -> Box<ScriptChan + Send> {
+        self.dom_manipulation_thread_source.clone()
     }
 
-    pub fn user_interaction_task_source(&self) -> Box<ScriptChan + Send> {
-        self.user_interaction_task_source.clone()
+    pub fn user_interaction_thread_source(&self) -> Box<ScriptChan + Send> {
+        self.user_interaction_thread_source.clone()
     }
 
-    pub fn networking_task_source(&self) -> Box<ScriptChan + Send> {
-        self.networking_task_source.clone()
+    pub fn networking_thread_source(&self) -> Box<ScriptChan + Send> {
+        self.networking_thread_source.clone()
     }
 
-    pub fn history_traversal_task_source(&self) -> Box<ScriptChan + Send> {
-        self.history_traversal_task_source.clone()
+    pub fn history_traversal_thread_source(&self) -> Box<ScriptChan + Send> {
+        self.history_traversal_thread_source.clone()
     }
 
-    pub fn file_reading_task_source(&self) -> Box<ScriptChan + Send> {
-        self.file_reading_task_source.clone()
+    pub fn file_reading_thread_source(&self) -> Box<ScriptChan + Send> {
+        self.file_reading_thread_source.clone()
     }
 
     pub fn main_thread_script_chan(&self) -> &Sender<MainThreadScriptMsg> {
         let MainThreadScriptChan(ref sender) = self.script_chan;
         sender
     }
 
     pub fn image_cache_chan(&self) -> ImageCacheChan {
@@ -297,34 +297,34 @@ impl Window {
         self.parent_info
     }
 
     pub fn new_script_pair(&self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>) {
         let (tx, rx) = channel();
         (box SendableMainThreadScriptChan(tx), box rx)
     }
 
-    pub fn image_cache_task(&self) -> &ImageCacheTask {
-        &self.image_cache_task
+    pub fn image_cache_thread(&self) -> &ImageCacheThread {
+        &self.image_cache_thread
     }
 
     pub fn compositor(&self) -> &IpcSender<ScriptToCompositorMsg> {
         &self.compositor
     }
 
     pub fn browsing_context(&self) -> Option<Root<BrowsingContext>> {
         self.browsing_context.get()
     }
 
     pub fn page(&self) -> &Page {
         &*self.page
     }
 
-    pub fn storage_task(&self) -> StorageTask {
-        self.storage_task.clone()
+    pub fn storage_thread(&self) -> StorageThread {
+        self.storage_thread.clone()
     }
 
     pub fn css_error_reporter(&self) -> Box<ParseErrorReporter + Send> {
         self.error_reporter.clone()
     }
 }
 
 // https://html.spec.whatwg.org/multipage/#atob
@@ -832,20 +832,20 @@ impl Window {
 
     pub fn clear_js_runtime(&self) {
         self.Document().upcast::<Node>().teardown();
 
         // The above code may not catch all DOM objects
         // (e.g. DOM objects removed from the tree that haven't
         // been collected yet). Forcing a GC here means that
         // those DOM objects will be able to call dispose()
-        // to free their layout data before the layout task
+        // to free their layout data before the layout thread
         // exits. Without this, those remaining objects try to
         // send a message to free their layout data to the
-        // layout task when the script task is dropped,
+        // layout thread when the script thread is dropped,
         // which causes a panic!
         self.Gc();
 
         self.current_state.set(WindowState::Zombie);
         *self.js_runtime.borrow_mut() = None;
         self.browsing_context.set(None);
         self.ignore_further_async_events.store(true, Ordering::Relaxed);
     }
@@ -976,17 +976,17 @@ impl Window {
 
         match join_port.try_recv() {
             Err(Empty) => {
                 info!("script: waiting on layout");
                 join_port.recv().unwrap();
             }
             Ok(_) => {}
             Err(Disconnected) => {
-                panic!("Layout task failed while script was waiting for a result.");
+                panic!("Layout thread failed while script was waiting for a result.");
             }
         }
 
         debug!("script: layout joined");
 
         self.pending_reflow_count.set(0);
 
         if let Some(marker) = marker {
@@ -1013,17 +1013,17 @@ impl Window {
         }
 
         // If writing a screenshot, check if the script has reached a state
         // where it's safe to write the image. This means that:
         // 1) The reflow is for display (otherwise it could be a query)
         // 2) The html element doesn't contain the 'reftest-wait' class
         // 3) The load event has fired.
         // When all these conditions are met, notify the constellation
-        // that this pipeline is ready to write the image (from the script task
+        // that this pipeline is ready to write the image (from the script thread
         // perspective at least).
         if opts::get().output_file.is_some() && for_display {
             let document = self.Document();
 
             // Checks if the html element has reftest-wait attribute present.
             // See http://testthewebforward.org/docs/reftests.html
             let html_element = document.GetDocumentElement();
             let reftest_wait = html_element.map_or(false, |elem| {
@@ -1121,18 +1121,18 @@ impl Window {
     pub fn window_size(&self) -> Option<WindowSizeData> {
         self.window_size.get()
     }
 
     pub fn get_url(&self) -> Url {
         (*self.Document().url()).clone()
     }
 
-    pub fn resource_task(&self) -> ResourceTask {
-        (*self.resource_task).clone()
+    pub fn resource_thread(&self) -> ResourceThread {
+        (*self.resource_thread).clone()
     }
 
     pub fn mem_profiler_chan(&self) -> mem::ProfilerChan {
         self.mem_profiler_chan.clone()
     }
 
     pub fn devtools_chan(&self) -> Option<IpcSender<ScriptToDevtoolsControlMsg>> {
         self.devtools_chan.clone()
@@ -1283,26 +1283,26 @@ impl Window {
         })
     }
 }
 
 impl Window {
     pub fn new(runtime: Rc<Runtime>,
                page: Rc<Page>,
                script_chan: MainThreadScriptChan,
-               dom_task_source: DOMManipulationTaskSource,
-               user_task_source: UserInteractionTaskSource,
-               network_task_source: NetworkingTaskSource,
-               history_task_source: HistoryTraversalTaskSource,
-               file_task_source: FileReadingTaskSource,
+               dom_thread_source: DOMManipulationThreadSource,
+               user_thread_source: UserInteractionThreadSource,
+               network_thread_source: NetworkingThreadSource,
+               history_thread_source: HistoryTraversalThreadSource,
+               file_thread_source: FileReadingThreadSource,
                image_cache_chan: ImageCacheChan,
                compositor: IpcSender<ScriptToCompositorMsg>,
-               image_cache_task: ImageCacheTask,
-               resource_task: Arc<ResourceTask>,
-               storage_task: StorageTask,
+               image_cache_thread: ImageCacheThread,
+               resource_thread: Arc<ResourceThread>,
+               storage_thread: StorageThread,
                mem_profiler_chan: mem::ProfilerChan,
                devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
                constellation_chan: ConstellationChan<ConstellationMsg>,
                scheduler_chan: IpcSender<TimerEventRequest>,
                timer_event_chan: IpcSender<TimerEvent>,
                layout_chan: LayoutChan,
                id: PipelineId,
                parent_info: Option<(PipelineId, SubpageId)>,
@@ -1313,46 +1313,46 @@ impl Window {
             let LayoutChan(ref lchan) = layout_chan;
             lchan.send(Msg::GetRPC(rpc_send)).unwrap();
             rpc_recv.recv().unwrap()
         };
         let error_reporter = CSSErrorReporter { pipelineid: id };
         let win = box Window {
             eventtarget: EventTarget::new_inherited(),
             script_chan: script_chan,
-            dom_manipulation_task_source: dom_task_source,
-            user_interaction_task_source: user_task_source,
-            networking_task_source: network_task_source,
-            history_traversal_task_source: history_task_source,
-            file_reading_task_source: file_task_source,
+            dom_manipulation_thread_source: dom_thread_source,
+            user_interaction_thread_source: user_thread_source,
+            networking_thread_source: network_thread_source,
+            history_traversal_thread_source: history_thread_source,
+            file_reading_thread_source: file_thread_source,
             image_cache_chan: image_cache_chan,
             console: Default::default(),
             crypto: Default::default(),
             compositor: compositor,
             page: page,
             navigator: Default::default(),
-            image_cache_task: image_cache_task,
+            image_cache_thread: image_cache_thread,
             mem_profiler_chan: mem_profiler_chan,
             devtools_chan: devtools_chan,
             browsing_context: Default::default(),
             performance: Default::default(),
             navigation_start: time::get_time().sec as u64,
             navigation_start_precise: time::precise_time_ns() as f64,
             screen: Default::default(),
             session_storage: Default::default(),
             local_storage: Default::default(),
             scheduler_chan: scheduler_chan.clone(),
             timers: ActiveTimers::new(timer_event_chan, scheduler_chan),
             next_worker_id: Cell::new(WorkerId(0)),
             id: id,
             parent_info: parent_info,
             dom_static: GlobalStaticData::new(),
             js_runtime: DOMRefCell::new(Some(runtime.clone())),
-            resource_task: resource_task,
-            storage_task: storage_task,
+            resource_thread: resource_thread,
+            storage_thread: storage_thread,
             constellation_chan: constellation_chan,
             page_clip_rect: Cell::new(MAX_RECT),
             fragment_name: DOMRefCell::new(None),
             resize_event: Cell::new(None),
             next_subpage_id: Cell::new(SubpageId(0)),
             layout_chan: layout_chan,
             layout_rpc: layout_rpc,
             window_size: Cell::new(window_size),
--- a/servo/components/script/dom/worker.rs
+++ b/servo/components/script/dom/worker.rs
@@ -19,17 +19,17 @@ use dom::errorevent::ErrorEvent;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
 use dom::messageevent::MessageEvent;
 use dom::workerglobalscope::WorkerGlobalScopeInit;
 use ipc_channel::ipc;
 use js::jsapi::{HandleValue, JSContext, RootedValue};
 use js::jsapi::{JSAutoCompartment, JSAutoRequest};
 use js::jsval::UndefinedValue;
-use script_task::{Runnable, ScriptChan};
+use script_thread::{Runnable, ScriptChan};
 use std::sync::mpsc::{Sender, channel};
 use util::str::DOMString;
 
 pub type TrustedWorkerAddress = Trusted<Worker>;
 
 // https://html.spec.whatwg.org/multipage/#worker
 #[dom_struct]
 pub struct Worker {
@@ -63,23 +63,23 @@ impl Worker {
     // https://html.spec.whatwg.org/multipage/#dom-worker
     pub fn Constructor(global: GlobalRef, script_url: DOMString) -> Fallible<Root<Worker>> {
         // Step 2-4.
         let worker_url = match global.get_url().join(&script_url) {
             Ok(url) => url,
             Err(_) => return Err(Error::Syntax),
         };
 
-        let resource_task = global.resource_task();
+        let resource_thread = global.resource_thread();
         let constellation_chan = global.constellation_chan();
         let scheduler_chan = global.scheduler_chan();
 
         let (sender, receiver) = channel();
         let worker = Worker::new(global, sender.clone());
-        let worker_ref = Trusted::new(worker.r(), global.dom_manipulation_task_source());
+        let worker_ref = Trusted::new(worker.r(), global.dom_manipulation_thread_source());
         let worker_id = global.get_next_worker_id();
 
         let (devtools_sender, devtools_receiver) = ipc::channel().unwrap();
         let optional_sender = match global.devtools_chan() {
             Some(ref chan) => {
                 let pipeline_id = global.pipeline();
                 let title = format!("Worker for {}", worker_url);
                 let page_info = DevtoolsPageInfo {
@@ -90,27 +90,27 @@ impl Worker {
                                                                 devtools_sender.clone(),
                                                                 page_info)).unwrap();
                 Some(devtools_sender)
             },
             None => None,
         };
 
         let init = WorkerGlobalScopeInit {
-            resource_task: resource_task,
+            resource_thread: resource_thread,
             mem_profiler_chan: global.mem_profiler_chan(),
             to_devtools_sender: global.devtools_chan(),
             from_devtools_sender: optional_sender,
             constellation_chan: constellation_chan,
             scheduler_chan: scheduler_chan,
             worker_id: worker_id,
         };
         DedicatedWorkerGlobalScope::run_worker_scope(
             init, worker_url, global.pipeline(), devtools_receiver, worker_ref,
-            global.dom_manipulation_task_source(), sender, receiver);
+            global.dom_manipulation_thread_source(), sender, receiver);
 
         Ok(worker)
     }
 
     pub fn handle_message(address: TrustedWorkerAddress,
                           data: StructuredCloneData) {
         let worker = address.root();
 
@@ -140,17 +140,17 @@ impl Worker {
         errorevent.upcast::<Event>().fire(worker.upcast());
     }
 }
 
 impl WorkerMethods for Worker {
     // https://html.spec.whatwg.org/multipage/#dom-dedicatedworkerglobalscope-postmessage
     fn PostMessage(&self, cx: *mut JSContext, message: HandleValue) -> ErrorResult {
         let data = try!(StructuredCloneData::write(cx, message));
-        let address = Trusted::new(self, self.global.root().r().dom_manipulation_task_source());
+        let address = Trusted::new(self, self.global.root().r().dom_manipulation_thread_source());
         self.sender.send((address, WorkerScriptMsg::DOMMessage(data))).unwrap();
         Ok(())
     }
 
     // https://html.spec.whatwg.org/multipage/#handler-dedicatedworkerglobalscope-onmessage
     event_handler!(message, GetOnmessage, SetOnmessage);
 
     // https://html.spec.whatwg.org/multipage/#handler-workerglobalscope-onerror
--- a/servo/components/script/dom/workerglobalscope.rs
+++ b/servo/components/script/dom/workerglobalscope.rs
@@ -16,36 +16,36 @@ use dom::dedicatedworkerglobalscope::Ded
 use dom::eventtarget::EventTarget;
 use dom::window::{base64_atob, base64_btoa};
 use dom::workerlocation::WorkerLocation;
 use dom::workernavigator::WorkerNavigator;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::{HandleValue, JSAutoRequest, JSContext};
 use js::rust::Runtime;
 use msg::constellation_msg::{ConstellationChan, PipelineId};
-use net_traits::{LoadContext, ResourceTask, load_whole_resource};
+use net_traits::{LoadContext, ResourceThread, load_whole_resource};
 use profile_traits::mem;
-use script_task::{CommonScriptMsg, ScriptChan, ScriptPort};
+use script_thread::{CommonScriptMsg, ScriptChan, ScriptPort};
 use script_traits::ScriptMsg as ConstellationMsg;
 use script_traits::{MsDuration, TimerEvent, TimerEventId, TimerEventRequest, TimerSource};
 use std::cell::Cell;
 use std::default::Default;
 use std::rc::Rc;
 use std::sync::mpsc::Receiver;
 use timers::{ActiveTimers, IsInterval, ScheduledCallback, TimerCallback, TimerHandle};
 use url::Url;
 use util::str::DOMString;
 
 #[derive(Copy, Clone, PartialEq)]
 pub enum WorkerGlobalScopeTypeId {
     DedicatedWorkerGlobalScope,
 }
 
 pub struct WorkerGlobalScopeInit {
-    pub resource_task: ResourceTask,
+    pub resource_thread: ResourceThread,
     pub mem_profiler_chan: mem::ProfilerChan,
     pub to_devtools_sender: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
     pub from_devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
     pub constellation_chan: ConstellationChan<ConstellationMsg>,
     pub scheduler_chan: IpcSender<TimerEventRequest>,
     pub worker_id: WorkerId,
 }
 
@@ -54,17 +54,17 @@ pub struct WorkerGlobalScopeInit {
 pub struct WorkerGlobalScope {
     eventtarget: EventTarget,
     worker_id: WorkerId,
     worker_url: Url,
     #[ignore_heap_size_of = "Defined in std"]
     runtime: Rc<Runtime>,
     next_worker_id: Cell<WorkerId>,
     #[ignore_heap_size_of = "Defined in std"]
-    resource_task: ResourceTask,
+    resource_thread: ResourceThread,
     location: MutNullableHeap<JS<WorkerLocation>>,
     navigator: MutNullableHeap<JS<WorkerNavigator>>,
     console: MutNullableHeap<JS<Console>>,
     crypto: MutNullableHeap<JS<Crypto>>,
     timers: ActiveTimers,
     #[ignore_heap_size_of = "Defined in std"]
     mem_profiler_chan: mem::ProfilerChan,
     #[ignore_heap_size_of = "Defined in ipc-channel"]
@@ -99,17 +99,17 @@ impl WorkerGlobalScope {
                          timer_event_chan: IpcSender<TimerEvent>)
                          -> WorkerGlobalScope {
         WorkerGlobalScope {
             eventtarget: EventTarget::new_inherited(),
             next_worker_id: Cell::new(WorkerId(0)),
             worker_id: init.worker_id,
             worker_url: worker_url,
             runtime: runtime,
-            resource_task: init.resource_task,
+            resource_thread: init.resource_thread,
             location: Default::default(),
             navigator: Default::default(),
             console: Default::default(),
             crypto: Default::default(),
             timers: ActiveTimers::new(timer_event_chan, init.scheduler_chan.clone()),
             mem_profiler_chan: init.mem_profiler_chan,
             to_devtools_sender: init.to_devtools_sender,
             from_devtools_sender: init.from_devtools_sender,
@@ -153,18 +153,18 @@ impl WorkerGlobalScope {
     pub fn unschedule_callback(&self, handle: TimerHandle) {
         self.timers.unschedule_callback(handle);
     }
 
     pub fn get_cx(&self) -> *mut JSContext {
         self.runtime.cx()
     }
 
-    pub fn resource_task(&self) -> &ResourceTask {
-        &self.resource_task
+    pub fn resource_thread(&self) -> &ResourceThread {
+        &self.resource_thread
     }
 
     pub fn get_url(&self) -> &Url {
         &self.worker_url
     }
 
     pub fn get_worker_id(&self) -> WorkerId {
         self.worker_id.clone()
@@ -198,17 +198,17 @@ impl WorkerGlobalScopeMethods for Worker
             let url = self.worker_url.join(&url);
             match url {
                 Ok(url) => urls.push(url),
                 Err(_) => return Err(Error::Syntax),
             };
         }
 
         for url in urls {
-            let (url, source) = match load_whole_resource(LoadContext::Script, &self.resource_task, url, None) {
+            let (url, source) = match load_whole_resource(LoadContext::Script, &self.resource_thread, url, None) {
                 Err(_) => return Err(Error::Network),
                 Ok((metadata, bytes)) => {
                     (metadata.final_url, String::from_utf8(bytes).unwrap())
                 }
             };
 
             match self.runtime.evaluate_script(
                 self.reflector().get_jsobject(), source, url.serialize(), 1) {
--- a/servo/components/script/dom/xmlhttprequest.rs
+++ b/servo/components/script/dom/xmlhttprequest.rs
@@ -41,21 +41,21 @@ use hyper::method::Method;
 use hyper::mime::{self, Mime};
 use ipc_channel::ipc;
 use ipc_channel::router::ROUTER;
 use js::jsapi::JS_ClearPendingException;
 use js::jsapi::{JSContext, JS_ParseJSON, RootedValue};
 use js::jsval::{JSVal, NullValue, UndefinedValue};
 use net_traits::ControlMsg::Load;
 use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata};
-use net_traits::{LoadConsumer, LoadContext, LoadData, ResourceCORSData, ResourceTask};
+use net_traits::{LoadConsumer, LoadContext, LoadData, ResourceCORSData, ResourceThread};
 use network_listener::{NetworkListener, PreInvoke};
 use parse::html::{ParseContext, parse_html};
 use parse::xml::{self, parse_xml};
-use script_task::{ScriptChan, ScriptPort};
+use script_thread::{ScriptChan, ScriptPort};
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::cell::{Cell, RefCell};
 use std::default::Default;
 use std::sync::mpsc::channel;
 use std::sync::{Arc, Mutex};
 use string_cache::Atom;
 use time;
@@ -192,23 +192,23 @@ impl XMLHttpRequest {
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<XMLHttpRequest>> {
         Ok(XMLHttpRequest::new(global))
     }
 
     fn check_cors(context: Arc<Mutex<XHRContext>>,
                   load_data: LoadData,
                   req: CORSRequest,
                   script_chan: Box<ScriptChan + Send>,
-                  resource_task: ResourceTask) {
+                  resource_thread: ResourceThread) {
         struct CORSContext {
             xhr: Arc<Mutex<XHRContext>>,
             load_data: RefCell<Option<LoadData>>,
             req: CORSRequest,
             script_chan: Box<ScriptChan + Send>,
-            resource_task: ResourceTask,
+            resource_thread: ResourceThread,
         }
 
         impl AsyncCORSResponseListener for CORSContext {
             fn response_available(&self, response: CORSResponse) {
                 if response.network_error {
                     let mut context = self.xhr.lock().unwrap();
                     let xhr = context.xhr.root();
                     xhr.process_partial_response(XHRProgress::Errored(context.gen_id, Error::Network));
@@ -218,34 +218,34 @@ impl XMLHttpRequest {
 
                 let mut load_data = self.load_data.borrow_mut().take().unwrap();
                 load_data.cors = Some(ResourceCORSData {
                     preflight: self.req.preflight_flag,
                     origin: self.req.origin.clone()
                 });
 
                 XMLHttpRequest::initiate_async_xhr(self.xhr.clone(), self.script_chan.clone(),
-                                                   self.resource_task.clone(), load_data);
+                                                   self.resource_thread.clone(), load_data);
             }
         }
 
         let cors_context = CORSContext {
             xhr: context,
             load_data: RefCell::new(Some(load_data)),
             req: req.clone(),
             script_chan: script_chan.clone(),
-            resource_task: resource_task,
+            resource_thread: resource_thread,
         };
 
         req.http_fetch_async(box cors_context, script_chan);
     }
 
     fn initiate_async_xhr(context: Arc<Mutex<XHRContext>>,
                           script_chan: Box<ScriptChan + Send>,
-                          resource_task: ResourceTask,
+                          resource_thread: ResourceThread,
                           load_data: LoadData) {
         impl AsyncResponseListener for XHRContext {
             fn headers_available(&mut self, metadata: Metadata) {
                 let xhr = self.xhr.root();
                 let rv = xhr.process_headers_available(self.cors_request.clone(),
                                                        self.gen_id,
                                                        metadata);
                 if rv.is_err() {
@@ -276,17 +276,17 @@ impl XMLHttpRequest {
             script_chan: script_chan,
         };
         let response_target = AsyncResponseTarget {
             sender: action_sender,
         };
         ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
             listener.notify(message.to().unwrap());
         });
-        resource_task.send(Load(load_data, LoadConsumer::Listener(response_target), None)).unwrap();
+        resource_thread.send(Load(load_data, LoadConsumer::Listener(response_target), None)).unwrap();
     }
 }
 
 impl XMLHttpRequestMethods for XMLHttpRequest {
     // https://xhr.spec.whatwg.org/#handler-xhr-onreadystatechange
     event_handler!(readystatechange, GetOnreadystatechange, SetOnreadystatechange);
 
     // https://xhr.spec.whatwg.org/#dom-xmlhttprequest-readystate
@@ -1021,17 +1021,17 @@ impl XMLHttpRequest {
                 }
             }
         }
 
         // Sets up the object to timeout in a given number of milliseconds
         // This will cancel all previous timeouts
         let global = self.global.root();
         let callback = ScheduledXHRTimeout {
-            xhr: Trusted::new(self, global.r().networking_task_source()),
+            xhr: Trusted::new(self, global.r().networking_thread_source()),
             generation_id: self.generation_id.get(),
         };
         let duration = Length::new(duration_ms as u64);
         *self.timeout_cancel.borrow_mut() = Some(global.r().schedule_callback(box callback, duration));
     }
 
     fn cancel_timeout(&self) {
         if let Some(handle) = self.timeout_cancel.borrow_mut().take() {
@@ -1173,40 +1173,40 @@ impl XMLHttpRequest {
                 // Happens in case of cross-origin non-http URIs
                 self.process_partial_response(XHRProgress::Errored(
                     self.generation_id.get(), Error::Network));
                 return Err(Error::Network);
             }
             Ok(req) => req,
         };
 
-        let xhr = Trusted::new(self, global.networking_task_source());
+        let xhr = Trusted::new(self, global.networking_thread_source());
 
         let context = Arc::new(Mutex::new(XHRContext {
             xhr: xhr,
             cors_request: cors_request.clone(),
             gen_id: self.generation_id.get(),
             buf: DOMRefCell::new(vec!()),
             sync_status: DOMRefCell::new(None),
         }));
 
         let (script_chan, script_port) = if self.sync.get() {
             let (tx, rx) = global.new_script_pair();
             (tx, Some(rx))
         } else {
-            (global.networking_task_source(), None)
+            (global.networking_thread_source(), None)
         };
 
-        let resource_task = global.resource_task();
+        let resource_thread = global.resource_thread();
         if let Some(req) = cors_request {
             XMLHttpRequest::check_cors(context.clone(), load_data, req.clone(),
-                                       script_chan.clone(), resource_task);
+                                       script_chan.clone(), resource_thread);
         } else {
             XMLHttpRequest::initiate_async_xhr(context.clone(), script_chan,
-                                               resource_task, load_data);
+                                               resource_thread, load_data);
         }
 
         if let Some(script_port) = script_port {
             loop {
                 global.process_event(script_port.recv());
                 let context = context.lock().unwrap();
                 let sync_status = context.sync_status.borrow();
                 if let Some(ref status) = *sync_status {
--- a/servo/components/script/layout_interface.rs
+++ b/servo/components/script/layout_interface.rs
@@ -10,17 +10,17 @@ use app_units::Au;
 use dom::node::OpaqueStyleAndLayoutData;
 use euclid::point::Point2D;
 use euclid::rect::Rect;
 use gfx_traits::LayerId;
 use ipc_channel::ipc::{IpcReceiver, IpcSender};
 use msg::compositor_msg::Epoch;
 use msg::constellation_msg::{ConstellationChan, Failure, PipelineId};
 use msg::constellation_msg::{WindowSizeData};
-use net_traits::image_cache_task::ImageCacheTask;
+use net_traits::image_cache_thread::ImageCacheThread;
 use profile_traits::mem::ReportsChan;
 use script_traits::{ConstellationControlMsg, LayoutControlMsg, LayoutMsg as ConstellationMsg};
 use script_traits::{OpaqueScriptLayoutChannel, UntrustedNodeAddress};
 use selectors::parser::PseudoElement;
 use std::any::Any;
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender, channel};
 use string_cache::Atom;
@@ -41,66 +41,66 @@ pub enum Msg {
     SetQuirksMode,
 
     /// Requests a reflow.
     Reflow(ScriptReflow),
 
     /// Get an RPC interface.
     GetRPC(Sender<Box<LayoutRPC + Send>>),
 
-    /// Requests that the layout task render the next frame of all animations.
+    /// Requests that the layout thread render the next frame of all animations.
     TickAnimations,
 
-    /// Requests that the layout task reflow with a newly-loaded Web font.
+    /// Requests that the layout thread reflow with a newly-loaded Web font.
     ReflowWithNewlyLoadedWebFont,
 
     /// Updates the layout visible rects, affecting the area that display lists will be constructed
     /// for.
     SetVisibleRects(Vec<(LayerId, Rect<Au>)>),
 
     /// Destroys layout data associated with a DOM node.
     ///
     /// TODO(pcwalton): Maybe think about batching to avoid message traffic.
     ReapStyleAndLayoutData(OpaqueStyleAndLayoutData),
 
-    /// Requests that the layout task measure its memory usage. The resulting reports are sent back
+    /// Requests that the layout thread measure its memory usage. The resulting reports are sent back
     /// via the supplied channel.
     CollectReports(ReportsChan),
 
-    /// Requests that the layout task enter a quiescent state in which no more messages are
+    /// Requests that the layout thread enter a quiescent state in which no more messages are
     /// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
     /// this happens.
     PrepareToExit(Sender<()>),
 
-    /// Requests that the layout task immediately shut down. There must be no more nodes left after
+    /// Requests that the layout thread immediately shut down. There must be no more nodes left after
     /// this, or layout will crash.
     ExitNow,
 
-    /// Get the last epoch counter for this layout task.
+    /// Get the last epoch counter for this layout thread.
     GetCurrentEpoch(IpcSender<Epoch>),
 
-    /// Asks the layout task whether any Web fonts have yet to load (if true, loads are pending;
+    /// Asks the layout thread whether any Web fonts have yet to load (if true, loads are pending;
     /// false otherwise).
     GetWebFontLoadState(IpcSender<bool>),
 
-    /// Creates a new layout task.
+    /// Creates a new layout thread.
     ///
     /// This basically exists to keep the script-layout dependency one-way.
-    CreateLayoutTask(NewLayoutTaskInfo),
+    CreateLayoutThread(NewLayoutThreadInfo),
 
     /// Set the final Url.
     SetFinalUrl(Url),
 }
 
 /// Synchronous messages that script can send to layout.
 ///
 /// In general, you should use messages to talk to Layout. Use the RPC interface
 /// if and only if the work is
 ///
-///   1) read-only with respect to LayoutTaskData,
+///   1) read-only with respect to LayoutThreadData,
 ///   2) small,
 ///   3) and really needs to be fast.
 pub trait LayoutRPC {
     /// Requests the dimensions of the content box, as in the `getBoundingClientRect()` call.
     fn content_box(&self) -> ContentBoxResponse;
     /// Requests the dimensions of all the content boxes, as in the `getClientRects()` call.
     fn content_boxes(&self) -> ContentBoxesResponse;
     /// Requests the geometry of this node. Used by APIs such as `clientTop`.
@@ -176,17 +176,17 @@ pub struct ScriptReflow {
 }
 
 impl Drop for ScriptReflow {
     fn drop(&mut self) {
         self.script_join_chan.send(()).unwrap();
     }
 }
 
-/// Encapsulates a channel to the layout task.
+/// Encapsulates a channel to the layout thread.
 #[derive(Clone)]
 pub struct LayoutChan(pub Sender<Msg>);
 
 impl LayoutChan {
     pub fn new() -> (Receiver<Msg>, LayoutChan) {
         let (chan, port) = channel();
         (port, LayoutChan(chan))
     }
@@ -212,22 +212,22 @@ impl ScriptLayoutChan for OpaqueScriptLa
     }
 
     fn receiver(self) -> Receiver<Msg> {
         let OpaqueScriptLayoutChannel((_, receiver)) = self;
         *receiver.downcast::<Receiver<Msg>>().unwrap()
     }
 }
 
-pub struct NewLayoutTaskInfo {
+pub struct NewLayoutThreadInfo {
     pub id: PipelineId,
     pub url: Url,
     pub is_parent: bool,
     pub layout_pair: OpaqueScriptLayoutChannel,
     pub pipeline_port: IpcReceiver<LayoutControlMsg>,
     pub constellation_chan: ConstellationChan<ConstellationMsg>,
     pub failure: Failure,
     pub script_chan: IpcSender<ConstellationControlMsg>,
-    pub image_cache_task: ImageCacheTask,
+    pub image_cache_thread: ImageCacheThread,
     pub paint_chan: OptionalOpaqueIpcSender,
     pub layout_shutdown_chan: IpcSender<()>,
     pub content_process_shutdown_chan: IpcSender<()>,
 }
--- a/servo/components/script/lib.rs
+++ b/servo/components/script/lib.rs
@@ -87,17 +87,17 @@ pub mod document_loader;
 pub mod dom;
 pub mod layout_interface;
 mod mem;
 mod network_listener;
 pub mod page;
 pub mod parse;
 pub mod reporter;
 #[allow(unsafe_code)]
-pub mod script_task;
+pub mod script_thread;
 pub mod textinput;
 mod timers;
 mod unpremultiplytable;
 mod webdriver_handlers;
 
 use dom::bindings::codegen::RegisterBindings;
 use js::jsapi::SetDOMProxyInformation;
 use std::ptr;
@@ -142,17 +142,17 @@ fn perform_platform_specific_initializat
 
 #[cfg(not(target_os = "linux"))]
 fn perform_platform_specific_initialization() {}
 
 #[allow(unsafe_code)]
 pub fn init() {
     unsafe {
         assert_eq!(js::jsapi::JS_Init(), true);
-        SetDOMProxyInformation(ptr::null(), 0, Some(script_task::shadow_check_callback));
+        SetDOMProxyInformation(ptr::null(), 0, Some(script_thread::shadow_check_callback));
     }
 
     // Create the global vtables used by the (generated) DOM
     // bindings to implement JS proxies.
     RegisterBindings::RegisterProxyHandlers();
 
     perform_platform_specific_initialization();
 }
--- a/servo/components/script/network_listener.rs
+++ b/servo/components/script/network_listener.rs
@@ -1,15 +1,15 @@
 /* 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/. */
 
 use net_traits::{AsyncResponseListener, ResponseAction};
-use script_task::ScriptTaskEventCategory::NetworkEvent;
-use script_task::{CommonScriptMsg, Runnable, ScriptChan};
+use script_thread::ScriptThreadEventCategory::NetworkEvent;
+use script_thread::{CommonScriptMsg, Runnable, ScriptChan};
 use std::sync::{Arc, Mutex};
 
 /// An off-thread sink for async network event runnables. All such events are forwarded to
 /// a target thread, where they are invoked on the provided context object.
 pub struct NetworkListener<T: AsyncResponseListener + PreInvoke + Send + 'static> {
     pub context: Arc<Mutex<T>>,
     pub script_chan: Box<ScriptChan + Send>,
 }
rename from servo/components/script/script_task.rs
rename to servo/components/script/script_thread.rs
--- a/servo/components/script/script_task.rs
+++ b/servo/components/script/script_thread.rs
@@ -1,25 +1,25 @@
 /* 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/. */
 
-//! The script task is the task that owns the DOM in memory, runs JavaScript, and spawns parsing
-//! and layout tasks. It's in charge of processing events for all same-origin pages in a frame
+//! The script thread is the thread that owns the DOM in memory, runs JavaScript, and spawns parsing
+//! and layout threads. It's in charge of processing events for all same-origin pages in a frame
 //! tree, and manages the entire lifetime of pages in the frame tree from initial request to
 //! teardown.
 //!
 //! Page loads follow a two-step process. When a request for a new page load is received, the
 //! network request is initiated and the relevant data pertaining to the new page is stashed.
-//! While the non-blocking request is ongoing, the script task is free to process further events,
+//! While the non-blocking request is ongoing, the script thread is free to process further events,
 //! noting when they pertain to ongoing loads (such as resizes/viewport adjustments). When the
 //! initial response is received for an ongoing load, the second phase starts - the frame tree
 //! entry is created, along with the Window and Document objects, and the appropriate parser
 //! takes over the response body. Once parsing is complete, the document lifecycle for loading
-//! a page runs its course and the script task returns to processing events in the main event
+//! a page runs its course and the script thread returns to processing events in the main event
 //! loop.
 
 use devtools;
 use devtools_traits::{DevtoolScriptControlMsg, DevtoolsPageInfo};
 use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId};
 use document_loader::DocumentLoader;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
@@ -54,39 +54,39 @@ use js::jsapi::{DOMProxyShadowsResult, H
 use js::jsapi::{DisableIncrementalGC, JS_AddExtraGCRootsTracer, JS_SetWrapObjectCallbacks};
 use js::jsapi::{GCDescription, GCProgress, JSGCInvocationKind, SetGCSliceCallback};
 use js::jsapi::{JSAutoRequest, JSGCStatus, JS_GetRuntime, JS_SetGCCallback, SetDOMCallbacks};
 use js::jsapi::{JSContext, JSRuntime, JSTracer};
 use js::jsapi::{JSObject, SetPreserveWrapperCallback};
 use js::jsval::UndefinedValue;
 use js::rust::Runtime;
 use layout_interface::{ReflowQueryType};
-use layout_interface::{self, LayoutChan, NewLayoutTaskInfo, ReflowGoal, ScriptLayoutChan};
+use layout_interface::{self, LayoutChan, NewLayoutThreadInfo, ReflowGoal, ScriptLayoutChan};
 use libc;
 use mem::heap_size_of_self_and_children;
 use msg::constellation_msg::{ConstellationChan, LoadData};
 use msg::constellation_msg::{MouseButton, MouseEventType, MozBrowserEvent, PipelineId};
 use msg::constellation_msg::{PipelineNamespace};
 use msg::constellation_msg::{SubpageId, WindowSizeData};
 use msg::webdriver_msg::WebDriverScriptCommand;
 use net_traits::LoadData as NetLoadData;
-use net_traits::image_cache_task::{ImageCacheChan, ImageCacheResult, ImageCacheTask};
-use net_traits::storage_task::StorageTask;
-use net_traits::{AsyncResponseTarget, ControlMsg, LoadConsumer, LoadContext, Metadata, ResourceTask};
+use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheResult, ImageCacheThread};
+use net_traits::storage_thread::StorageThread;
+use net_traits::{AsyncResponseTarget, ControlMsg, LoadConsumer, LoadContext, Metadata, ResourceThread};
 use network_listener::NetworkListener;
 use page::{Frame, IterablePage, Page};
 use parse::html::{ParseContext, parse_html};
 use parse::xml::{self, parse_xml};
 use profile_traits::mem::{self, OpaqueSender, Report, ReportKind, ReportsChan};
 use profile_traits::time::{self, ProfilerCategory, profile};
 use script_traits::CompositorEvent::{KeyEvent, MouseButtonEvent, MouseMoveEvent, ResizeEvent};
 use script_traits::CompositorEvent::{TouchEvent};
 use script_traits::{CompositorEvent, ConstellationControlMsg, EventResult, InitialScriptState, NewLayoutInfo};
 use script_traits::{LayoutMsg, OpaqueScriptLayoutChannel, ScriptMsg as ConstellationMsg};
-use script_traits::{ScriptTaskFactory, ScriptToCompositorMsg, TimerEvent, TimerEventRequest, TimerSource};
+use script_traits::{ScriptThreadFactory, ScriptToCompositorMsg, TimerEvent, TimerEventRequest, TimerSource};
 use script_traits::{TouchEventType, TouchId};
 use std::any::Any;
 use std::borrow::ToOwned;
 use std::cell::{Cell, RefCell};
 use std::collections::HashSet;
 use std::io::{Write, stdout};
 use std::marker::PhantomData;
 use std::mem as std_mem;
@@ -96,27 +96,27 @@ use std::rc::Rc;
 use std::result::Result;
 use std::sync::atomic::{Ordering, AtomicBool};
 use std::sync::mpsc::{Receiver, Select, Sender, channel};
 use std::sync::{Arc, Mutex};
 use time::{Tm, now};
 use url::Url;
 use util::opts;
 use util::str::DOMString;
-use util::task;
-use util::task_state;
+use util::thread;
+use util::thread_state;
 use webdriver_handlers;
 
 thread_local!(pub static STACK_ROOTS: Cell<Option<RootCollectionPtr>> = Cell::new(None));
-thread_local!(static SCRIPT_TASK_ROOT: RefCell<Option<*const ScriptTask>> = RefCell::new(None));
+thread_local!(static SCRIPT_TASK_ROOT: RefCell<Option<*const ScriptThread>> = RefCell::new(None));
 
 unsafe extern fn trace_rust_roots(tr: *mut JSTracer, _data: *mut libc::c_void) {
     SCRIPT_TASK_ROOT.with(|root| {
-        if let Some(script_task) = *root.borrow() {
-            (*script_task).trace(tr);
+        if let Some(script_thread) = *root.borrow() {
+            (*script_thread).trace(tr);
         }
     });
 
     trace_traceables(tr);
     trace_roots(tr);
 }
 
 /// A document load that is in the process of fetching the requested resource. Contains
@@ -126,17 +126,17 @@ unsafe extern fn trace_rust_roots(tr: *m
 #[derive(JSTraceable)]
 struct InProgressLoad {
     /// The pipeline which requested this load.
     pipeline_id: PipelineId,
     /// The parent pipeline and child subpage associated with this load, if any.
     parent_info: Option<(PipelineId, SubpageId)>,
     /// The current window size associated with this pipeline.
     window_size: Option<WindowSizeData>,
-    /// Channel to the layout task associated with this pipeline.
+    /// Channel to the layout thread associated with this pipeline.
     layout_chan: LayoutChan,
     /// The current viewport clipping rectangle applying to this pipeline, if any.
     clip_rect: Option<Rect<f32>>,
     /// Window is frozen (navigated away while loading for example).
     is_frozen: bool,
     /// The requested URL of the load.
     url: Url,
 }
@@ -191,40 +191,40 @@ impl<T: Runnable + Send> Runnable for Ca
 }
 
 pub trait Runnable {
     fn is_cancelled(&self) -> bool { false }
     fn handler(self: Box<Self>);
 }
 
 pub trait MainThreadRunnable {
-    fn handler(self: Box<Self>, script_task: &ScriptTask);
+    fn handler(self: Box<Self>, script_thread: &ScriptThread);
 }
 
 enum MixedMessage {
     FromConstellation(ConstellationControlMsg),
     FromScript(MainThreadScriptMsg),
     FromDevtools(DevtoolScriptControlMsg),
     FromImageCache(ImageCacheResult),
     FromScheduler(TimerEvent),
 }
 
 /// Common messages used to control the event loops in both the script and the worker
 pub enum CommonScriptMsg {
-    /// Requests that the script task measure its memory usage. The results are sent back via the
+    /// Requests that the script thread measure its memory usage. The results are sent back via the
     /// supplied channel.
     CollectReports(ReportsChan),
-    /// A DOM object's last pinned reference was removed (dispatched to all tasks).
+    /// A DOM object's last pinned reference was removed (dispatched to all threads).
     RefcountCleanup(TrustedReference),
     /// Generic message that encapsulates event handling.
-    RunnableMsg(ScriptTaskEventCategory, Box<Runnable + Send>),
+    RunnableMsg(ScriptThreadEventCategory, Box<Runnable + Send>),
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, JSTraceable, PartialEq)]
-pub enum ScriptTaskEventCategory {
+pub enum ScriptThreadEventCategory {
     AttachLayout,
     ConstellationMsg,
     DevtoolsMsg,
     DocumentEvent,
     DomEvent,
     FileRead,
     ImageCacheMsg,
     InputEvent,
@@ -241,22 +241,22 @@ pub enum ScriptTaskEventCategory {
 
 /// Messages used to control the script event loop
 pub enum MainThreadScriptMsg {
     /// Common variants associated with the script messages
     Common(CommonScriptMsg),
     /// Notify a document that all pending loads are complete.
     DocumentLoadsComplete(PipelineId),
     /// Notifies the script that a window associated with a particular pipeline
-    /// should be closed (only dispatched to ScriptTask).
+    /// should be closed (only dispatched to ScriptThread).
     ExitWindow(PipelineId),
-    /// Generic message for running tasks in the ScriptTask
+    /// Generic message for running threads in the ScriptThread
     MainThreadRunnableMsg(Box<MainThreadRunnable + Send>),
     /// Begins a content-initiated load on the specified pipeline (only
-    /// dispatched to ScriptTask).
+    /// dispatched to ScriptThread).
     Navigate(PipelineId, LoadData),
 }
 
 /// A cloneable interface for communicating with an event loop.
 pub trait ScriptChan {
     /// Send a message to the associated event loop.
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()>;
     /// Clone this handle.
@@ -301,17 +301,17 @@ impl ScriptPort for Receiver<(TrustedWor
     fn recv(&self) -> CommonScriptMsg {
         match self.recv().unwrap().1 {
             MainThreadScriptMsg::Common(script_msg) => script_msg,
             _ => panic!("unexpected main thread event message!")
         }
     }
 }
 
-/// Encapsulates internal communication of shared messages within the script task.
+/// Encapsulates internal communication of shared messages within the script thread.
 #[derive(JSTraceable)]
 pub struct SendableMainThreadScriptChan(pub Sender<CommonScriptMsg>);
 
 impl ScriptChan for SendableMainThreadScriptChan {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
         let SendableMainThreadScriptChan(ref chan) = *self;
         chan.send(msg).map_err(|_| ())
     }
@@ -325,17 +325,17 @@ impl ScriptChan for SendableMainThreadSc
 impl SendableMainThreadScriptChan {
     /// Creates a new script chan.
     pub fn new() -> (Receiver<CommonScriptMsg>, Box<SendableMainThreadScriptChan>) {
         let (chan, port) = channel();
         (port, box SendableMainThreadScriptChan(chan))
     }
 }
 
-/// Encapsulates internal communication of main thread messages within the script task.
+/// Encapsulates internal communication of main thread messages within the script thread.
 #[derive(JSTraceable)]
 pub struct MainThreadScriptChan(pub Sender<MainThreadScriptMsg>);
 
 impl ScriptChan for MainThreadScriptChan {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
         let MainThreadScriptChan(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
@@ -349,109 +349,109 @@ impl ScriptChan for MainThreadScriptChan
 impl MainThreadScriptChan {
     /// Creates a new script chan.
     pub fn new() -> (Receiver<MainThreadScriptMsg>, Box<MainThreadScriptChan>) {
         let (chan, port) = channel();
         (port, box MainThreadScriptChan(chan))
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct DOMManipulationTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct DOMManipulationThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for DOMManipulationTaskSource {
+impl ScriptChan for DOMManipulationThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let DOMManipulationTaskSource(ref chan) = *self;
+        let DOMManipulationThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let DOMManipulationTaskSource(ref chan) = *self;
-        box DOMManipulationTaskSource((*chan).clone())
+        let DOMManipulationThreadSource(ref chan) = *self;
+        box DOMManipulationThreadSource((*chan).clone())
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct UserInteractionTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct UserInteractionThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for UserInteractionTaskSource {
+impl ScriptChan for UserInteractionThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let UserInteractionTaskSource(ref chan) = *self;
+        let UserInteractionThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let UserInteractionTaskSource(ref chan) = *self;
-        box UserInteractionTaskSource((*chan).clone())
+        let UserInteractionThreadSource(ref chan) = *self;
+        box UserInteractionThreadSource((*chan).clone())
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct NetworkingTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct NetworkingThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for NetworkingTaskSource {
+impl ScriptChan for NetworkingThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let NetworkingTaskSource(ref chan) = *self;
+        let NetworkingThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let NetworkingTaskSource(ref chan) = *self;
-        box NetworkingTaskSource((*chan).clone())
+        let NetworkingThreadSource(ref chan) = *self;
+        box NetworkingThreadSource((*chan).clone())
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct HistoryTraversalTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct HistoryTraversalThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for HistoryTraversalTaskSource {
+impl ScriptChan for HistoryTraversalThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let HistoryTraversalTaskSource(ref chan) = *self;
+        let HistoryTraversalThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let HistoryTraversalTaskSource(ref chan) = *self;
-        box HistoryTraversalTaskSource((*chan).clone())
+        let HistoryTraversalThreadSource(ref chan) = *self;
+        box HistoryTraversalThreadSource((*chan).clone())
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct FileReadingTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct FileReadingThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for FileReadingTaskSource {
+impl ScriptChan for FileReadingThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let FileReadingTaskSource(ref chan) = *self;
+        let FileReadingThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let FileReadingTaskSource(ref chan) = *self;
-        box FileReadingTaskSource((*chan).clone())
+        let FileReadingThreadSource(ref chan) = *self;
+        box FileReadingThreadSource((*chan).clone())
     }
 }
 
-// FIXME: Use a task source specific message instead of MainThreadScriptMsg
+// FIXME: Use a thread source specific message instead of MainThreadScriptMsg
 #[derive(JSTraceable)]
-pub struct ProfilerTaskSource(pub Sender<MainThreadScriptMsg>);
+pub struct ProfilerThreadSource(pub Sender<MainThreadScriptMsg>);
 
-impl ScriptChan for ProfilerTaskSource {
+impl ScriptChan for ProfilerThreadSource {
     fn send(&self, msg: CommonScriptMsg) -> Result<(), ()> {
-        let ProfilerTaskSource(ref chan) = *self;
+        let ProfilerThreadSource(ref chan) = *self;
         chan.send(MainThreadScriptMsg::Common(msg)).map_err(|_| ())
     }
 
     fn clone(&self) -> Box<ScriptChan + Send> {
-        let ProfilerTaskSource(ref chan) = *self;
-        box ProfilerTaskSource((*chan).clone())
+        let ProfilerThreadSource(ref chan) = *self;
+        box ProfilerThreadSource((*chan).clone())
     }
 }
 
 pub struct StackRootTLS<'a>(PhantomData<&'a u32>);
 
 impl<'a> StackRootTLS<'a> {
     pub fn new(roots: &'a RootCollection) -> StackRootTLS<'a> {
         STACK_ROOTS.with(|ref r| {
@@ -466,51 +466,51 @@ impl<'a> Drop for StackRootTLS<'a> {
         STACK_ROOTS.with(|ref r| r.set(None));
     }
 }
 
 
 /// Information for an entire page. Pages are top-level browsing contexts and can contain multiple
 /// frames.
 #[derive(JSTraceable)]
-// ScriptTask instances are rooted on creation, so this is okay
+// ScriptThread instances are rooted on creation, so this is okay
 #[allow(unrooted_must_root)]
-pub struct ScriptTask {
+pub struct ScriptThread {
     /// A handle to the information pertaining to page layout
     page: DOMRefCell<Option<Rc<Page>>>,
     /// A list of data pertaining to loads that have not yet received a network response
     incomplete_loads: DOMRefCell<Vec<InProgressLoad>>,
-    /// A handle to the image cache task.
-    image_cache_task: ImageCacheTask,
-    /// A handle to the resource task. This is an `Arc` to avoid running out of file descriptors if
+    /// A handle to the image cache thread.
+    image_cache_thread: ImageCacheThread,
+    /// A handle to the resource thread. This is an `Arc` to avoid running out of file descriptors if
     /// there are many iframes.
-    resource_task: Arc<ResourceTask>,
-    /// A handle to the storage task.
-    storage_task: StorageTask,
+    resource_thread: Arc<ResourceThread>,
+    /// A handle to the storage thread.
+    storage_thread: StorageThread,
 
-    /// The port on which the script task receives messages (load URL, exit, etc.)
+    /// The port on which the script thread receives messages (load URL, exit, etc.)
     port: Receiver<MainThreadScriptMsg>,
-    /// A channel to hand out to script task-based entities that need to be able to enqueue
+    /// A channel to hand out to script thread-based entities that need to be able to enqueue
     /// events in the event queue.
     chan: MainThreadScriptChan,
-    dom_manipulation_task_source: DOMManipulationTaskSource,
+    dom_manipulation_thread_source: DOMManipulationThreadSource,
 
-    user_interaction_task_source: UserInteractionTaskSource,
+    user_interaction_thread_source: UserInteractionThreadSource,
 
-    networking_task_source: NetworkingTaskSource,
+    networking_thread_source: NetworkingThreadSource,
 
-    history_traversal_task_source: HistoryTraversalTaskSource,
+    history_traversal_thread_source: HistoryTraversalThreadSource,
 
-    file_reading_task_source: FileReadingTaskSource,
+    file_reading_thread_source: FileReadingThreadSource,
 
-    /// A channel to hand out to tasks that need to respond to a message from the script task.
+    /// A channel to hand out to threads that need to respond to a message from the script thread.
     control_chan: IpcSender<ConstellationControlMsg>,
 
-    /// The port on which the constellation and layout tasks can communicate with the
-    /// script task.
+    /// The port on which the constellation and layout threads can communicate with the
+    /// script thread.
     control_port: Receiver<ConstellationControlMsg>,
 
     /// For communicating load url messages to the constellation
     constellation_chan: ConstellationChan<ConstellationMsg>,
 
     /// For communicating layout messages to the constellation
     layout_to_constellation_chan: ConstellationChan<LayoutMsg>,
 
@@ -536,40 +536,40 @@ pub struct ScriptTask {
     devtools_port: Receiver<DevtoolScriptControlMsg>,
     devtools_sender: IpcSender<DevtoolScriptControlMsg>,
 
     /// The JavaScript runtime.
     js_runtime: Rc<Runtime>,
 
     mouse_over_targets: DOMRefCell<Vec<JS<Element>>>,
 
-    /// List of pipelines that have been owned and closed by this script task.
+    /// List of pipelines that have been owned and closed by this script thread.
     closed_pipelines: DOMRefCell<HashSet<PipelineId>>,
 
     scheduler_chan: IpcSender<TimerEventRequest>,
     timer_event_chan: Sender<TimerEvent>,
     timer_event_port: Receiver<TimerEvent>,
 
     content_process_shutdown_chan: IpcSender<()>,
 }
 
-/// In the event of task failure, all data on the stack runs its destructor. However, there
+/// In the event of thread failure, all data on the stack runs its destructor. However, there
 /// are no reachable, owning pointers to the DOM memory, so it never gets freed by default
-/// when the script task fails. The ScriptMemoryFailsafe uses the destructor bomb pattern
-/// to forcibly tear down the JS compartments for pages associated with the failing ScriptTask.
+/// when the script thread fails. The ScriptMemoryFailsafe uses the destructor bomb pattern
+/// to forcibly tear down the JS compartments for pages associated with the failing ScriptThread.
 struct ScriptMemoryFailsafe<'a> {
-    owner: Option<&'a ScriptTask>,
+    owner: Option<&'a ScriptThread>,
 }
 
 impl<'a> ScriptMemoryFailsafe<'a> {
     fn neuter(&mut self) {
         self.owner = None;
     }
 
-    fn new(owner: &'a ScriptTask) -> ScriptMemoryFailsafe<'a> {
+    fn new(owner: &'a ScriptThread) -> ScriptMemoryFailsafe<'a> {
         ScriptMemoryFailsafe {
             owner: Some(owner),
         }
     }
 }
 
 impl<'a> Drop for ScriptMemoryFailsafe<'a> {
     #[allow(unrooted_must_root)]
@@ -584,68 +584,68 @@ impl<'a> Drop for ScriptMemoryFailsafe<'
                     }
                 }
             }
             None => (),
         }
     }
 }
 
-impl ScriptTaskFactory for ScriptTask {
-    fn create_layout_channel(_phantom: Option<&mut ScriptTask>) -> OpaqueScriptLayoutChannel {
+impl ScriptThreadFactory for ScriptThread {
+    fn create_layout_channel(_phantom: Option<&mut ScriptThread>) -> OpaqueScriptLayoutChannel {
         let (chan, port) = channel();
         ScriptLayoutChan::new(chan, port)
     }
 
-    fn clone_layout_channel(_phantom: Option<&mut ScriptTask>, pair: &OpaqueScriptLayoutChannel)
+    fn clone_layout_channel(_phantom: Option<&mut ScriptThread>, pair: &OpaqueScriptLayoutChannel)
                             -> Box<Any + Send> {
         box pair.sender() as Box<Any + Send>
     }
 
-    fn create(_phantom: Option<&mut ScriptTask>,
+    fn create(_phantom: Option<&mut ScriptThread>,
               state: InitialScriptState,
               layout_chan: &OpaqueScriptLayoutChannel,
               load_data: LoadData) {
         let ConstellationChan(const_chan) = state.constellation_chan.clone();
         let (script_chan, script_port) = channel();
         let layout_chan = LayoutChan(layout_chan.sender());
         let failure_info = state.failure_info;
-        task::spawn_named_with_send_on_failure(format!("ScriptTask {:?}", state.id),
-                                               task_state::SCRIPT,
+        thread::spawn_named_with_send_on_failure(format!("ScriptThread {:?}", state.id),
+                                               thread_state::SCRIPT,
                                                move || {
             PipelineNamespace::install(state.pipeline_namespace_id);
             let roots = RootCollection::new();
             let _stack_roots_tls = StackRootTLS::new(&roots);
             let chan = MainThreadScriptChan(script_chan.clone());
             let channel_for_reporter = chan.clone();
             let id = state.id;
             let parent_info = state.parent_info;
             let mem_profiler_chan = state.mem_profiler_chan.clone();
             let window_size = state.window_size;
-            let script_task = ScriptTask::new(state,
+            let script_thread = ScriptThread::new(state,
                                               script_port,
                                               script_chan);
 
             SCRIPT_TASK_ROOT.with(|root| {
-                *root.borrow_mut() = Some(&script_task as *const _);
+                *root.borrow_mut() = Some(&script_thread as *const _);
             });
 
-            let mut failsafe = ScriptMemoryFailsafe::new(&script_task);
+            let mut failsafe = ScriptMemoryFailsafe::new(&script_thread);
 
             let new_load = InProgressLoad::new(id, parent_info, layout_chan, window_size,
                                                load_data.url.clone());
-            script_task.start_page_load(new_load, load_data);
+            script_thread.start_page_load(new_load, load_data);
 
             let reporter_name = format!("script-reporter-{}", id);
             mem_profiler_chan.run_with_memory_reporting(|| {
-                script_task.start();
-                let _ = script_task.content_process_shutdown_chan.send(());
+                script_thread.start();
+                let _ = script_thread.content_process_shutdown_chan.send(());
             }, reporter_name, channel_for_reporter, CommonScriptMsg::CollectReports);
 
-            // This must always be the very last operation performed before the task completes
+            // This must always be the very last operation performed before the thread completes
             failsafe.neuter();
         }, ConstellationMsg::Failure(failure_info), const_chan);
     }
 }
 
 thread_local!(static GC_CYCLE_START: Cell<Option<Tm>> = Cell::new(None));
 thread_local!(static GC_SLICE_START: Cell<Option<Tm>> = Cell::new(None));
 
@@ -686,18 +686,18 @@ unsafe extern "C" fn gc_slice_callback(_
         };
         println!("  isCompartment={}, invocationKind={}", desc.isCompartment_, invocationKind);
     }
     let _ = stdout().flush();
 }
 
 unsafe extern "C" fn debug_gc_callback(_rt: *mut JSRuntime, status: JSGCStatus, _data: *mut libc::c_void) {
     match status {
-        JSGCStatus::JSGC_BEGIN => task_state::enter(task_state::IN_GC),
-        JSGCStatus::JSGC_END   => task_state::exit(task_state::IN_GC),
+        JSGCStatus::JSGC_BEGIN => thread_state::enter(thread_state::IN_GC),
+        JSGCStatus::JSGC_END   => thread_state::exit(thread_state::IN_GC),
     }
 }
 
 pub unsafe extern "C" fn shadow_check_callback(_cx: *mut JSContext,
     _object: HandleObject, _id: HandleId) -> DOMProxyShadowsResult {
     // XXX implement me
     DOMProxyShadowsResult::ShadowCheckFailed
 }
@@ -705,85 +705,85 @@ pub unsafe extern "C" fn shadow_check_ca
 #[derive(JSTraceable, HeapSizeOf)]
 pub struct CSSError {
     filename: String,
     line: usize,
     column: usize,
     msg: String
 }
 
-impl ScriptTask {
+impl ScriptThread {
     pub fn page_fetch_complete(id: PipelineId, subpage: Option<SubpageId>, metadata: Metadata)
                                -> Option<ParserRoot> {
         SCRIPT_TASK_ROOT.with(|root| {
-            let script_task = unsafe { &*root.borrow().unwrap() };
-            script_task.handle_page_fetch_complete(id, subpage, metadata)
+            let script_thread = unsafe { &*root.borrow().unwrap() };
+            script_thread.handle_page_fetch_complete(id, subpage, metadata)
         })
     }
 
     pub fn parsing_complete(id: PipelineId) {
         SCRIPT_TASK_ROOT.with(|root| {
-            let script_task = unsafe { &*root.borrow().unwrap() };
-            script_task.handle_parsing_complete(id);
+            let script_thread = unsafe { &*root.borrow().unwrap() };
+            script_thread.handle_parsing_complete(id);
         });
     }
 
     pub fn process_event(msg: CommonScriptMsg) {
         SCRIPT_TASK_ROOT.with(|root| {
-            if let Some(script_task) = *root.borrow() {
-                let script_task = unsafe { &*script_task };
-                script_task.handle_msg_from_script(MainThreadScriptMsg::Common(msg));
+            if let Some(script_thread) = *root.borrow() {
+                let script_thread = unsafe { &*script_thread };
+                script_thread.handle_msg_from_script(MainThreadScriptMsg::Common(msg));
             }
         });
     }
 
-    /// Creates a new script task.
+    /// Creates a new script thread.
     pub fn new(state: InitialScriptState,
                port: Receiver<MainThreadScriptMsg>,
                chan: Sender<MainThreadScriptMsg>)
-               -> ScriptTask {
-        let runtime = ScriptTask::new_rt_and_cx();
+               -> ScriptThread {
+        let runtime = ScriptThread::new_rt_and_cx();
 
         unsafe {
             JS_SetWrapObjectCallbacks(runtime.rt(),
                                       &WRAP_CALLBACKS);
         }
 
         // Ask the router to proxy IPC messages from the devtools to us.
         let (ipc_devtools_sender, ipc_devtools_receiver) = ipc::channel().unwrap();
         let devtools_port = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_devtools_receiver);
 
-        // Ask the router to proxy IPC messages from the image cache task to us.
+        // Ask the router to proxy IPC messages from the image cache thread to us.
         let (ipc_image_cache_channel, ipc_image_cache_port) = ipc::channel().unwrap();
         let image_cache_port =
             ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_image_cache_port);
 
         let (timer_event_chan, timer_event_port) = channel();
 
         // Ask the router to proxy IPC messages from the control port to us.
         let control_port = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(state.control_port);
 
-        ScriptTask {
+        ScriptThread {
             page: DOMRefCell::new(None),
             incomplete_loads: DOMRefCell::new(vec!()),
 
-            image_cache_task: state.image_cache_task,
+            image_cache_thread: state.image_cache_thread,
             image_cache_channel: ImageCacheChan(ipc_image_cache_channel),
             image_cache_port: image_cache_port,
 
-            resource_task: Arc::new(state.resource_task),
-            storage_task: state.storage_task,
+            resource_thread: Arc::new(state.resource_thread),
+            storage_thread: state.storage_thread,
 
             port: port,
             chan: MainThreadScriptChan(chan.clone()),
-            dom_manipulation_task_source: DOMManipulationTaskSource(chan.clone()),
-            user_interaction_task_source: UserInteractionTaskSource(chan.clone()),
-            networking_task_source: NetworkingTaskSource(chan.clone()),
-            history_traversal_task_source: HistoryTraversalTaskSource(chan.clone()),
-            file_reading_task_source: FileReadingTaskSource(chan),
+            dom_manipulation_thread_source: DOMManipulationThreadSource(chan.clone()),
+            user_interaction_thread_source: UserInteractionThreadSource(chan.clone()),
+            networking_thread_source: NetworkingThreadSource(chan.clone()),
+            history_traversal_thread_source: HistoryTraversalThreadSource(chan.clone()),
+            file_reading_thread_source: FileReadingThreadSource(chan),
 
             control_chan: state.control_chan,
             control_port: control_port,
             constellation_chan: state.constellation_chan,
             layout_to_constellation_chan: state.layout_to_constellation_chan,
             compositor: DOMRefCell::new(state.compositor),
             time_profiler_chan: state.time_profiler_chan,
             mem_profiler_chan: state.mem_profiler_chan,
@@ -846,17 +846,17 @@ impl ScriptTask {
     fn find_subpage(&self, pipeline_id: PipelineId) -> Option<Rc<Page>> {
         self.page.borrow().as_ref().and_then(|page| page.find(pipeline_id))
     }
 
     pub fn get_cx(&self) -> *mut JSContext {
         self.js_runtime.cx()
     }
 
-    /// Starts the script task. After calling this method, the script task will loop receiving
+    /// Starts the script thread. After calling this method, the script thread will loop receiving
     /// messages on its port.
     pub fn start(&self) {
         while self.handle_msgs() {
             // Go on...
         }
     }
 
     /// Handle incoming control messages.
@@ -927,27 +927,27 @@ impl ScriptTask {
         let mut animation_ticks = HashSet::new();
         loop {
             match event {
                 // This has to be handled before the ResizeMsg below,
                 // otherwise the page may not have been added to the
                 // child list yet, causing the find() to fail.
                 FromConstellation(ConstellationControlMsg::AttachLayout(
                         new_layout_info)) => {
-                    self.profile_event(ScriptTaskEventCategory::AttachLayout, || {
+                    self.profile_event(ScriptThreadEventCategory::AttachLayout, || {
                         self.handle_new_layout(new_layout_info);
                     })
                 }
                 FromConstellation(ConstellationControlMsg::Resize(id, size)) => {
-                    self.profile_event(ScriptTaskEventCategory::Resize, || {
+                    self.profile_event(ScriptThreadEventCategory::Resize, || {
                         self.handle_resize(id, size);
                     })
                 }
                 FromConstellation(ConstellationControlMsg::Viewport(id, rect)) => {
-                    self.profile_event(ScriptTaskEventCategory::SetViewport, || {
+                    self.profile_event(ScriptThreadEventCategory::SetViewport, || {
                         self.handle_viewport(id, rect);
                     })
                 }
                 FromConstellation(ConstellationControlMsg::TickAllAnimations(
                         pipeline_id)) => {
                     if !animation_ticks.contains(&pipeline_id) {
                         animation_ticks.insert(pipeline_id);
                         sequential.push(event);
@@ -1032,62 +1032,62 @@ impl ScriptTask {
                                   ReflowReason::ImageLoaded);
                 }
             }
         }
 
         true
     }
 
-    fn categorize_msg(&self, msg: &MixedMessage) -> ScriptTaskEventCategory {
+    fn categorize_msg(&self, msg: &MixedMessage) -> ScriptThreadEventCategory {
         match *msg {
             MixedMessage::FromConstellation(ref inner_msg) => {
                 match *inner_msg {
                     ConstellationControlMsg::SendEvent(_, _) =>
-                        ScriptTaskEventCategory::DomEvent,
-                    _ => ScriptTaskEventCategory::ConstellationMsg
+                        ScriptThreadEventCategory::DomEvent,
+                    _ => ScriptThreadEventCategory::ConstellationMsg
                 }
             },
-            MixedMessage::FromDevtools(_) => ScriptTaskEventCategory::DevtoolsMsg,
-            MixedMessage::FromImageCache(_) => ScriptTaskEventCategory::ImageCacheMsg,
+            MixedMessage::FromDevtools(_) => ScriptThreadEventCategory::DevtoolsMsg,
+            MixedMessage::FromImageCache(_) => ScriptThreadEventCategory::ImageCacheMsg,
             MixedMessage::FromScript(ref inner_msg) => {
                 match *inner_msg {
                     MainThreadScriptMsg::Common(CommonScriptMsg::RunnableMsg(ref category, _)) =>
                         *category,
-                    _ => ScriptTaskEventCategory::ScriptEvent
+                    _ => ScriptThreadEventCategory::ScriptEvent
                 }
             },
-            MixedMessage::FromScheduler(_) => ScriptTaskEventCategory::TimerEvent,
+            MixedMessage::FromScheduler(_) => ScriptThreadEventCategory::TimerEvent,
         }
     }
 
-    fn profile_event<F, R>(&self, category: ScriptTaskEventCategory, f: F) -> R
+    fn profile_event<F, R>(&self, category: ScriptThreadEventCategory, f: F) -> R
         where F: FnOnce() -> R {
 
         if opts::get().profile_script_events {
             let profiler_cat = match category {
-                ScriptTaskEventCategory::AttachLayout => ProfilerCategory::ScriptAttachLayout,
-                ScriptTaskEventCategory::ConstellationMsg => ProfilerCategory::ScriptConstellationMsg,
-                ScriptTaskEventCategory::DevtoolsMsg => ProfilerCategory::ScriptDevtoolsMsg,
-                ScriptTaskEventCategory::DocumentEvent => ProfilerCategory::ScriptDocumentEvent,
-                ScriptTaskEventCategory::DomEvent => ProfilerCategory::ScriptDomEvent,
-                ScriptTaskEventCategory::FileRead => ProfilerCategory::ScriptFileRead,
-                ScriptTaskEventCategory::ImageCacheMsg => ProfilerCategory::ScriptImageCacheMsg,
-                ScriptTaskEventCategory::InputEvent => ProfilerCategory::ScriptInputEvent,
-                ScriptTaskEventCategory::NetworkEvent => ProfilerCategory::ScriptNetworkEvent,
-                ScriptTaskEventCategory::Resize => ProfilerCategory::ScriptResize,
-                ScriptTaskEventCategory::ScriptEvent => ProfilerCategory::ScriptEvent,
-                ScriptTaskEventCategory::UpdateReplacedElement => {
+                ScriptThreadEventCategory::AttachLayout => ProfilerCategory::ScriptAttachLayout,
+                ScriptThreadEventCategory::ConstellationMsg => ProfilerCategory::ScriptConstellationMsg,
+                ScriptThreadEventCategory::DevtoolsMsg => ProfilerCategory::ScriptDevtoolsMsg,
+                ScriptThreadEventCategory::DocumentEvent => ProfilerCategory