servo: Merge #4766 - Import the util crate as util rather than servo_util (from Ms2ger:util); r=Manishearth
authorMs2ger <ms2ger@gmail.com>
Thu, 29 Jan 2015 05:12:49 -0700
changeset 382295 041d81941981ecd4487680e052ad6bd499762e7c
parent 382294 67204436ceca453463fb8ea9c4bf65e6683da9f1
child 382296 efd11c3bff577b055308a6619db5f97634da931f
push id7198
push userjlorenzo@mozilla.com
push dateTue, 18 Apr 2017 12:07:49 +0000
treeherdermozilla-beta@d57aa49c3948 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersManishearth
servo: Merge #4766 - Import the util crate as util rather than servo_util (from Ms2ger:util); r=Manishearth This used to conflict with the util crate from the standard library, which has long since been removed. The import in layout has not been changed because of a conflict with the util mod there. Source-Repo: https://github.com/servo/servo Source-Revision: 27e0f16407629422b5e047e067d458142372c97e
servo/components/canvas/canvas_paint_task.rs
servo/components/canvas/lib.rs
servo/components/compositing/compositor.rs
servo/components/compositing/compositor_task.rs
servo/components/compositing/constellation.rs
servo/components/compositing/headless.rs
servo/components/compositing/lib.rs
servo/components/compositing/pipeline.rs
servo/components/compositing/windowing.rs
servo/components/devtools/lib.rs
servo/components/devtools_traits/lib.rs
servo/components/gfx/display_list/mod.rs
servo/components/gfx/display_list/optimizer.rs
servo/components/gfx/font.rs
servo/components/gfx/font_cache_task.rs
servo/components/gfx/font_context.rs
servo/components/gfx/lib.rs
servo/components/gfx/paint_context.rs
servo/components/gfx/paint_task.rs
servo/components/gfx/platform/freetype/font.rs
servo/components/gfx/platform/freetype/font_list.rs
servo/components/gfx/platform/macos/font.rs
servo/components/gfx/text/glyph.rs
servo/components/gfx/text/shaping/harfbuzz.rs
servo/components/gfx/text/text_run.rs
servo/components/layout_traits/lib.rs
servo/components/msg/constellation_msg.rs
servo/components/msg/lib.rs
servo/components/net/about_loader.rs
servo/components/net/file_loader.rs
servo/components/net/http_loader.rs
servo/components/net/image_cache_task.rs
servo/components/net/lib.rs
servo/components/net/local_image_cache.rs
servo/components/net/resource_task.rs
servo/components/net/storage_task.rs
servo/components/script/dom/attr.rs
servo/components/script/dom/bindings/cell.rs
servo/components/script/dom/bindings/codegen/CodegenRust.py
servo/components/script/dom/bindings/conversions.rs
servo/components/script/dom/bindings/js.rs
servo/components/script/dom/bindings/trace.rs
servo/components/script/dom/blob.rs
servo/components/script/dom/characterdata.rs
servo/components/script/dom/comment.rs
servo/components/script/dom/console.rs
servo/components/script/dom/create.rs
servo/components/script/dom/cssstyledeclaration.rs
servo/components/script/dom/customevent.rs
servo/components/script/dom/dedicatedworkerglobalscope.rs
servo/components/script/dom/document.rs
servo/components/script/dom/documentfragment.rs
servo/components/script/dom/documenttype.rs
servo/components/script/dom/domexception.rs
servo/components/script/dom/domimplementation.rs
servo/components/script/dom/domparser.rs
servo/components/script/dom/domrect.rs
servo/components/script/dom/domstringmap.rs
servo/components/script/dom/domtokenlist.rs
servo/components/script/dom/element.rs
servo/components/script/dom/errorevent.rs
servo/components/script/dom/event.rs
servo/components/script/dom/eventtarget.rs
servo/components/script/dom/file.rs
servo/components/script/dom/formdata.rs
servo/components/script/dom/htmlanchorelement.rs
servo/components/script/dom/htmlappletelement.rs
servo/components/script/dom/htmlareaelement.rs
servo/components/script/dom/htmlaudioelement.rs
servo/components/script/dom/htmlbaseelement.rs
servo/components/script/dom/htmlbodyelement.rs
servo/components/script/dom/htmlbrelement.rs
servo/components/script/dom/htmlbuttonelement.rs
servo/components/script/dom/htmlcanvaselement.rs
servo/components/script/dom/htmlcollection.rs
servo/components/script/dom/htmldataelement.rs
servo/components/script/dom/htmldatalistelement.rs
servo/components/script/dom/htmldirectoryelement.rs
servo/components/script/dom/htmldivelement.rs
servo/components/script/dom/htmldlistelement.rs
servo/components/script/dom/htmlelement.rs
servo/components/script/dom/htmlembedelement.rs
servo/components/script/dom/htmlfieldsetelement.rs
servo/components/script/dom/htmlfontelement.rs
servo/components/script/dom/htmlformelement.rs
servo/components/script/dom/htmlframeelement.rs
servo/components/script/dom/htmlframesetelement.rs
servo/components/script/dom/htmlheadelement.rs
servo/components/script/dom/htmlheadingelement.rs
servo/components/script/dom/htmlhrelement.rs
servo/components/script/dom/htmlhtmlelement.rs
servo/components/script/dom/htmliframeelement.rs
servo/components/script/dom/htmlimageelement.rs
servo/components/script/dom/htmlinputelement.rs
servo/components/script/dom/htmllabelelement.rs
servo/components/script/dom/htmllegendelement.rs
servo/components/script/dom/htmllielement.rs
servo/components/script/dom/htmllinkelement.rs
servo/components/script/dom/htmlmapelement.rs
servo/components/script/dom/htmlmediaelement.rs
servo/components/script/dom/htmlmetaelement.rs
servo/components/script/dom/htmlmeterelement.rs
servo/components/script/dom/htmlmodelement.rs
servo/components/script/dom/htmlobjectelement.rs
servo/components/script/dom/htmlolistelement.rs
servo/components/script/dom/htmloptgroupelement.rs
servo/components/script/dom/htmloptionelement.rs
servo/components/script/dom/htmloutputelement.rs
servo/components/script/dom/htmlparagraphelement.rs
servo/components/script/dom/htmlparamelement.rs
servo/components/script/dom/htmlpreelement.rs
servo/components/script/dom/htmlprogresselement.rs
servo/components/script/dom/htmlquoteelement.rs
servo/components/script/dom/htmlscriptelement.rs
servo/components/script/dom/htmlselectelement.rs
servo/components/script/dom/htmlsourceelement.rs
servo/components/script/dom/htmlspanelement.rs
servo/components/script/dom/htmlstyleelement.rs
servo/components/script/dom/htmltablecaptionelement.rs
servo/components/script/dom/htmltablecellelement.rs
servo/components/script/dom/htmltablecolelement.rs
servo/components/script/dom/htmltabledatacellelement.rs
servo/components/script/dom/htmltableelement.rs
servo/components/script/dom/htmltableheadercellelement.rs
servo/components/script/dom/htmltablerowelement.rs
servo/components/script/dom/htmltablesectionelement.rs
servo/components/script/dom/htmltemplateelement.rs
servo/components/script/dom/htmltextareaelement.rs
servo/components/script/dom/htmltimeelement.rs
servo/components/script/dom/htmltitleelement.rs
servo/components/script/dom/htmltrackelement.rs
servo/components/script/dom/htmlulistelement.rs
servo/components/script/dom/htmlunknownelement.rs
servo/components/script/dom/htmlvideoelement.rs
servo/components/script/dom/keyboardevent.rs
servo/components/script/dom/location.rs
servo/components/script/dom/messageevent.rs
servo/components/script/dom/mouseevent.rs
servo/components/script/dom/navigator.rs
servo/components/script/dom/navigatorinfo.rs
servo/components/script/dom/node.rs
servo/components/script/dom/processinginstruction.rs
servo/components/script/dom/progressevent.rs
servo/components/script/dom/servohtmlparser.rs
servo/components/script/dom/storage.rs
servo/components/script/dom/testbinding.rs
servo/components/script/dom/text.rs
servo/components/script/dom/uievent.rs
servo/components/script/dom/urlhelper.rs
servo/components/script/dom/urlsearchparams.rs
servo/components/script/dom/virtualmethods.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/workerlocation.rs
servo/components/script/dom/workernavigator.rs
servo/components/script/dom/xmlhttprequest.rs
servo/components/script/layout_interface.rs
servo/components/script/lib.rs
servo/components/script/page.rs
servo/components/script/parse/html.rs
servo/components/script/script_task.rs
servo/components/script/textinput.rs
servo/components/script/timers.rs
servo/components/script_traits/lib.rs
servo/components/servo/lib.rs
servo/components/servo/main.rs
servo/components/style/legacy.rs
servo/components/style/lib.rs
servo/components/style/media_queries.rs
servo/components/style/node.rs
servo/components/style/properties/mod.rs.mako
servo/components/style/selector_matching.rs
servo/components/style/values.rs
servo/ports/cef/browser.rs
servo/ports/cef/core.rs
servo/ports/cef/lib.rs
servo/ports/cef/window.rs
servo/ports/gonk/src/lib.rs
servo/ports/gonk/src/main.rs
servo/ports/gonk/src/window.rs
--- a/servo/components/canvas/canvas_paint_task.rs
+++ b/servo/components/canvas/canvas_paint_task.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 azure::azure_hl::{DrawTarget, Color, SurfaceFormat, BackendType, StrokeOptions, DrawOptions};
 use azure::azure_hl::{ColorPattern, PatternRef};
 use geom::rect::Rect;
 use geom::size::Size2D;
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 
 use std::borrow::ToOwned;
 use std::sync::mpsc::{channel, Sender};
 
 #[derive(Clone)]
 pub enum CanvasMsg {
     FillRect(Rect<f32>),
     ClearRect(Rect<f32>),
--- a/servo/components/canvas/lib.rs
+++ b/servo/components/canvas/lib.rs
@@ -4,11 +4,11 @@
 
 #![deny(unused_imports)]
 #![deny(unused_variables)]
 #![allow(missing_copy_implementations)]
 #![allow(unstable)]
 
 extern crate azure;
 extern crate geom;
-extern crate "util" as servo_util;
+extern crate util;
 
 pub mod canvas_paint_task;
--- a/servo/components/compositing/compositor.rs
+++ b/servo/components/compositing/compositor.rs
@@ -30,21 +30,21 @@ use gleam::gl::types::{GLint, GLsizei};
 use gleam::gl;
 use script_traits::{ConstellationControlMsg, ScriptControlChan};
 use servo_msg::compositor_msg::{Epoch, LayerId};
 use servo_msg::compositor_msg::{ReadyState, PaintState, ScrollPolicy};
 use servo_msg::constellation_msg::{ConstellationChan, NavigationDirection};
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
 use servo_msg::constellation_msg::{Key, KeyModifiers, KeyState, LoadData};
 use servo_msg::constellation_msg::{PipelineId, WindowSizeData};
-use servo_util::geometry::{PagePx, ScreenPx, ViewportPx};
-use servo_util::memory::MemoryProfilerChan;
-use servo_util::opts;
-use servo_util::time::{TimeProfilerCategory, profile, TimeProfilerChan};
-use servo_util::{memory, time};
+use util::geometry::{PagePx, ScreenPx, ViewportPx};
+use util::memory::MemoryProfilerChan;
+use util::opts;
+use util::time::{TimeProfilerCategory, profile, TimeProfilerChan};
+use util::{memory, time};
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::path::Path;
 use std::num::Float;
 use std::rc::Rc;
 use std::slice::bytes::copy_memory;
 use std::sync::mpsc::Sender;
 use time::{precise_time_ns, precise_time_s};
--- a/servo/components/compositing/compositor_task.rs
+++ b/servo/components/compositing/compositor_task.rs
@@ -17,20 +17,20 @@ use geom::rect::{Rect, TypedRect};
 use geom::size::Size2D;
 use layers::platform::surface::{NativeCompositingGraphicsContext, NativeGraphicsMetadata};
 use layers::layers::LayerBufferSet;
 use pipeline::CompositionPipeline;
 use servo_msg::compositor_msg::{Epoch, LayerId, LayerMetadata, ReadyState};
 use servo_msg::compositor_msg::{PaintListener, PaintState, ScriptListener, ScrollPolicy};
 use servo_msg::constellation_msg::{ConstellationChan, LoadData, PipelineId};
 use servo_msg::constellation_msg::{Key, KeyState, KeyModifiers};
-use servo_util::cursor::Cursor;
-use servo_util::geometry::PagePx;
-use servo_util::memory::MemoryProfilerChan;
-use servo_util::time::TimeProfilerChan;
+use util::cursor::Cursor;
+use util::geometry::PagePx;
+use util::memory::MemoryProfilerChan;
+use util::time::TimeProfilerChan;
 use std::sync::mpsc::{channel, Sender, Receiver};
 use std::fmt::{Error, Formatter, Show};
 use std::rc::Rc;
 
 /// Sends messages to the compositor. This is a trait supplied by the port because the method used
 /// to communicate with the compositor may have to kick OS event loops awake, communicate cross-
 /// process, and so forth.
 pub trait CompositorProxy : 'static + Send {
--- a/servo/components/compositing/constellation.rs
+++ b/servo/components/compositing/constellation.rs
@@ -23,21 +23,21 @@ use servo_msg::constellation_msg::{Key, 
 use servo_msg::constellation_msg::{LoadData, NavigationType};
 use servo_msg::constellation_msg::{PipelineExitType, PipelineId};
 use servo_msg::constellation_msg::{SubpageId, WindowSizeData};
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
 use servo_net::image_cache_task::{ImageCacheTask, ImageCacheTaskClient};
 use servo_net::resource_task::ResourceTask;
 use servo_net::resource_task;
 use servo_net::storage_task::{StorageTask, StorageTaskMsg};
-use servo_util::cursor::Cursor;
-use servo_util::geometry::{PagePx, ViewportPx};
-use servo_util::opts;
-use servo_util::task::spawn_named;
-use servo_util::time::TimeProfilerChan;
+use util::cursor::Cursor;
+use util::geometry::{PagePx, ViewportPx};
+use util::opts;
+use util::task::spawn_named;
+use util::time::TimeProfilerChan;
 use std::borrow::ToOwned;
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
 use std::io;
 use std::mem::replace;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, channel};
 use url::Url;
--- a/servo/components/compositing/headless.rs
+++ b/servo/components/compositing/headless.rs
@@ -4,20 +4,20 @@
 
 use compositor_task::{CompositorEventListener, CompositorReceiver, Msg};
 use windowing::WindowEvent;
 
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
 use servo_msg::constellation_msg::{ConstellationChan, WindowSizeData};
-use servo_util::memory::MemoryProfilerChan;
-use servo_util::memory;
-use servo_util::time::TimeProfilerChan;
-use servo_util::time;
+use util::memory::MemoryProfilerChan;
+use util::memory;
+use util::time::TimeProfilerChan;
+use util::time;
 
 /// Starts the compositor, which listens for messages on the specified port.
 ///
 /// This is the null compositor which doesn't draw anything to the screen.
 /// It's intended for headless testing.
 pub struct NullCompositor {
     /// The port on which we receive messages.
     pub port: Box<CompositorReceiver>,
--- a/servo/components/compositing/lib.rs
+++ b/servo/components/compositing/lib.rs
@@ -19,17 +19,17 @@ extern crate geom;
 extern crate gfx;
 extern crate layers;
 extern crate layout_traits;
 extern crate png;
 extern crate script_traits;
 extern crate "msg" as servo_msg;
 extern crate "net" as servo_net;
 #[macro_use]
-extern crate "util" as servo_util;
+extern crate util;
 extern crate gleam;
 
 extern crate libc;
 extern crate time;
 extern crate url;
 
 #[cfg(target_os="macos")]
 extern crate core_graphics;
--- a/servo/components/compositing/pipeline.rs
+++ b/servo/components/compositing/pipeline.rs
@@ -11,17 +11,17 @@ use devtools_traits::DevtoolsControlChan
 use gfx::paint_task::Msg as PaintMsg;
 use gfx::paint_task::{PaintChan, PaintTask};
 use servo_msg::constellation_msg::{ConstellationChan, Failure, PipelineId, SubpageId};
 use servo_msg::constellation_msg::{LoadData, WindowSizeData, PipelineExitType};
 use servo_net::image_cache_task::ImageCacheTask;
 use gfx::font_cache_task::FontCacheTask;
 use servo_net::resource_task::ResourceTask;
 use servo_net::storage_task::StorageTask;
-use servo_util::time::TimeProfilerChan;
+use util::time::TimeProfilerChan;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, channel};
 
 /// A uniquely-identifiable pipeline of script task, layout task, and paint task.
 pub struct Pipeline {
     pub id: PipelineId,
     pub subpage_id: Option<SubpageId>,
     pub script_chan: ScriptControlChan,
--- a/servo/components/compositing/windowing.rs
+++ b/servo/components/compositing/windowing.rs
@@ -8,18 +8,18 @@ use compositor_task::{CompositorProxy, C
 
 use geom::point::TypedPoint2D;
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
 use layers::geometry::DevicePixel;
 use layers::platform::surface::NativeGraphicsMetadata;
 use servo_msg::compositor_msg::{PaintState, ReadyState};
 use servo_msg::constellation_msg::{Key, KeyState, KeyModifiers, LoadData};
-use servo_util::cursor::Cursor;
-use servo_util::geometry::ScreenPx;
+use util::cursor::Cursor;
+use util::geometry::ScreenPx;
 use std::fmt::{Error, Formatter, Show};
 use std::rc::Rc;
 
 #[derive(Clone)]
 pub enum MouseWindowEvent {
     Click(uint, TypedPoint2D<DevicePixel, f32>),
     MouseDown(uint, TypedPoint2D<DevicePixel, f32>),
     MouseUp(uint, TypedPoint2D<DevicePixel, f32>),
--- a/servo/components/devtools/lib.rs
+++ b/servo/components/devtools/lib.rs
@@ -20,28 +20,28 @@
 extern crate log;
 
 extern crate collections;
 extern crate core;
 extern crate devtools_traits;
 extern crate "serialize" as rustc_serialize;
 extern crate serialize;
 extern crate "msg" as servo_msg;
-extern crate "util" as servo_util;
+extern crate util;
 
 use actor::{Actor, ActorRegistry};
 use actors::console::ConsoleActor;
 use actors::inspector::InspectorActor;
 use actors::root::RootActor;
 use actors::tab::TabActor;
 use protocol::JsonPacketStream;
 
 use devtools_traits::{ServerExitMsg, DevtoolsControlMsg, NewGlobal, DevtoolScriptControlMsg, DevtoolsPageInfo};
 use servo_msg::constellation_msg::PipelineId;
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 
 use std::borrow::ToOwned;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::mpsc::TryRecvError::{Disconnected, Empty};
 use std::io::{TcpListener, TcpStream};
 use std::io::{Acceptor, Listener, TimedOut};
--- a/servo/components/devtools_traits/lib.rs
+++ b/servo/components/devtools_traits/lib.rs
@@ -13,25 +13,25 @@
 
 #![allow(non_snake_case)]
 #![allow(missing_copy_implementations)]
 #![allow(unstable)]
 
 extern crate "msg" as servo_msg;
 extern crate serialize;
 extern crate url;
-extern crate "util" as servo_util;
+extern crate util;
 
 pub use self::DevtoolsControlMsg::*;
 pub use self::DevtoolScriptControlMsg::*;
 pub use self::EvaluateJSReply::*;
 
 use serialize::{Decodable, Decoder};
 use servo_msg::constellation_msg::PipelineId;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use url::Url;
 
 use std::sync::mpsc::{Sender, Receiver};
 
 pub type DevtoolsControlChan = Sender<DevtoolsControlMsg>;
 pub type DevtoolsControlPort = Receiver<DevtoolScriptControlMsg>;
 
 // Information would be attached to NewGlobal to be received and show in devtools.
--- a/servo/components/gfx/display_list/mod.rs
+++ b/servo/components/gfx/display_list/mod.rs
@@ -27,21 +27,21 @@ use text::TextRun;
 use azure::azure::AzFloat;
 use collections::dlist::{self, DList};
 use geom::{Point2D, Rect, SideOffsets2D, Size2D, Matrix2D};
 use geom::num::Zero;
 use libc::uintptr_t;
 use paint_task::PaintLayer;
 use servo_msg::compositor_msg::LayerId;
 use servo_net::image::base::Image;
-use servo_util::cursor::Cursor;
-use servo_util::dlist as servo_dlist;
-use servo_util::geometry::{self, Au, MAX_RECT, ZERO_RECT};
-use servo_util::range::Range;
-use servo_util::smallvec::{SmallVec, SmallVec8};
+use util::cursor::Cursor;
+use util::dlist as servo_dlist;
+use util::geometry::{self, Au, MAX_RECT, ZERO_RECT};
+use util::range::Range;
+use util::smallvec::{SmallVec, SmallVec8};
 use std::fmt;
 use std::slice::Iter;
 use std::sync::Arc;
 use style::ComputedValues;
 use style::computed_values::{border_style, cursor, filter, mix_blend_mode, pointer_events};
 
 // It seems cleaner to have layout code not mention Azure directly, so let's just reexport this for
 // layout to use.
--- a/servo/components/gfx/display_list/optimizer.rs
+++ b/servo/components/gfx/display_list/optimizer.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! Transforms a display list to produce a visually-equivalent, but cheaper-to-paint, one.
 
 use display_list::{DisplayItem, DisplayList, StackingContext};
 
 use collections::dlist::DList;
 use geom::rect::Rect;
-use servo_util::geometry::{self, Au};
+use util::geometry::{self, Au};
 use std::sync::Arc;
 
 /// Transforms a display list to produce a visually-equivalent, but cheaper-to-paint, one.
 pub struct DisplayListOptimizer {
     /// The visible rect in page coordinates.
     visible_rect: Rect<Au>,
 }
 
--- a/servo/components/gfx/font.rs
+++ b/servo/components/gfx/font.rs
@@ -3,26 +3,26 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use geom::{Point2D, Rect, Size2D};
 use std::borrow::ToOwned;
 use std::mem;
 use std::slice;
 use std::rc::Rc;
 use std::cell::RefCell;
-use servo_util::cache::HashCache;
-use servo_util::smallvec::{SmallVec, SmallVec8};
+use util::cache::HashCache;
+use util::smallvec::{SmallVec, SmallVec8};
 use style::computed_values::{font_stretch, font_variant, font_weight};
 use style::style_structs::Font as FontStyle;
 use std::sync::Arc;
 
 use std::hash::Hash;
 use platform::font_context::FontContextHandle;
 use platform::font::{FontHandle, FontTable};
-use servo_util::geometry::Au;
+use util::geometry::Au;
 use text::glyph::{GlyphStore, GlyphId};
 use text::shaping::ShaperMethods;
 use text::{Shaper, TextRun};
 use font_template::FontTemplateDescriptor;
 use platform::font_template::FontTemplateData;
 
 // FontHandle encapsulates access to the platform's font API,
 // e.g. quartz, FreeType. It provides access to metrics and tables
--- a/servo/components/gfx/font_cache_task.rs
+++ b/servo/components/gfx/font_cache_task.rs
@@ -11,18 +11,18 @@ use platform::font_context::FontContextH
 use collections::str::Str;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::sync::mpsc::{Sender, Receiver, channel};
 use font_template::{FontTemplate, FontTemplateDescriptor};
 use platform::font_template::FontTemplateData;
 use servo_net::resource_task::{ResourceTask, load_whole_resource};
-use servo_util::task::spawn_named;
-use servo_util::str::LowercaseString;
+use util::task::spawn_named;
+use util::str::LowercaseString;
 use style::Source;
 
 /// A list of font templates that make up a given font family.
 struct FontFamily {
     templates: Vec<FontTemplate>,
 }
 
 impl FontFamily {
--- a/servo/components/gfx/font_context.rs
+++ b/servo/components/gfx/font_context.rs
@@ -7,20 +7,20 @@ use font::SpecifiedFontStyle;
 use platform::font_context::FontContextHandle;
 use style::computed_values::{font_style, font_variant};
 
 use font_cache_task::FontCacheTask;
 use font_template::FontTemplateDescriptor;
 use platform::font_template::FontTemplateData;
 use font::FontHandleMethods;
 use platform::font::FontHandle;
-use servo_util::cache::HashCache;
-use servo_util::smallvec::{SmallVec, SmallVec8};
-use servo_util::geometry::Au;
-use servo_util::arc_ptr_eq;
+use util::cache::HashCache;
+use util::smallvec::{SmallVec, SmallVec8};
+use util::geometry::Au;
+use util::arc_ptr_eq;
 
 use std::borrow::ToOwned;
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::sync::Arc;
 
 use azure::AzFloat;
 use azure::azure_hl::BackendType;
--- a/servo/components/gfx/lib.rs
+++ b/servo/components/gfx/lib.rs
@@ -21,17 +21,17 @@ extern crate stb_image;
 extern crate png;
 extern crate script_traits;
 extern crate "serialize" as rustc_serialize;
 extern crate unicode;
 #[no_link] #[plugin]
 extern crate "plugins" as servo_plugins;
 extern crate "net" as servo_net;
 #[macro_use]
-extern crate "util" as servo_util;
+extern crate util;
 extern crate "msg" as servo_msg;
 extern crate style;
 extern crate time;
 extern crate url;
 
 // Eventually we would like the shaper to be pluggable, as many operating systems have their own
 // shapers. For now, however, this is a hard dependency.
 extern crate harfbuzz;
--- a/servo/components/gfx/paint_context.rs
+++ b/servo/components/gfx/paint_context.rs
@@ -21,19 +21,19 @@ use geom::matrix2d::Matrix2D;
 use geom::point::Point2D;
 use geom::rect::Rect;
 use geom::side_offsets::SideOffsets2D;
 use geom::size::Size2D;
 use libc::size_t;
 use libc::types::common::c99::{uint16_t, uint32_t};
 use png::PixelsByColorType;
 use servo_net::image::base::Image;
-use servo_util::geometry::{Au, MAX_RECT};
-use servo_util::opts;
-use servo_util::range::Range;
+use util::geometry::{Au, MAX_RECT};
+use util::opts;
+use util::range::Range;
 use std::default::Default;
 use std::f32;
 use std::mem;
 use std::num::Float;
 use std::ptr;
 use style::computed_values::{border_style, filter, mix_blend_mode};
 use std::sync::Arc;
 use text::TextRun;
--- a/servo/components/gfx/paint_task.rs
+++ b/servo/components/gfx/paint_task.rs
@@ -20,22 +20,22 @@ use layers::platform::surface::{NativeGr
 use layers::platform::surface::NativeSurface;
 use layers::layers::{BufferRequest, LayerBuffer, LayerBufferSet};
 use layers;
 use servo_msg::compositor_msg::{Epoch, PaintState, LayerId};
 use servo_msg::compositor_msg::{LayerMetadata, PaintListener, ScrollPolicy};
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
 use servo_msg::constellation_msg::{ConstellationChan, Failure, PipelineId};
 use servo_msg::constellation_msg::PipelineExitType;
-use servo_util::geometry::{Au, ZERO_POINT};
-use servo_util::opts;
-use servo_util::smallvec::SmallVec;
-use servo_util::task::spawn_named_with_send_on_failure;
-use servo_util::task_state;
-use servo_util::time::{TimeProfilerChan, TimeProfilerCategory, profile};
+use util::geometry::{Au, ZERO_POINT};
+use util::opts;
+use util::smallvec::SmallVec;
+use util::task::spawn_named_with_send_on_failure;
+use util::task_state;
+use util::time::{TimeProfilerChan, TimeProfilerCategory, profile};
 use std::mem;
 use std::thread::Builder;
 use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 /// Information about a hardware graphics layer that layout sends to the painting task.
 #[derive(Clone)]
 pub struct PaintLayer {
--- a/servo/components/gfx/platform/freetype/font.rs
+++ b/servo/components/gfx/platform/freetype/font.rs
@@ -1,19 +1,19 @@
 /* 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/. */
 
 extern crate freetype;
 
 use font::{FontHandleMethods, FontMetrics, FontTableMethods};
 use font::{FontTableTag, FractionalPixel};
-use servo_util::geometry::Au;
-use servo_util::geometry;
-use servo_util::str::c_str_to_string;
+use util::geometry::Au;
+use util::geometry;
+use util::str::c_str_to_string;
 use platform::font_context::FontContextHandle;
 use text::glyph::GlyphId;
 use text::util::{float_to_fixed, fixed_to_float};
 use style::computed_values::{font_stretch, font_weight};
 use platform::font_template::FontTemplateData;
 
 use freetype::freetype::{FT_Get_Char_Index, FT_Get_Postscript_Name};
 use freetype::freetype::{FT_Load_Glyph, FT_Set_Char_Size};
--- a/servo/components/gfx/platform/freetype/font_list.rs
+++ b/servo/components/gfx/platform/freetype/font_list.rs
@@ -15,17 +15,17 @@ use fontconfig::fontconfig::{
     FcNameParse, FcPatternGetString,
     FcPatternDestroy, FcFontSetDestroy,
     FcMatchPattern,
     FcPatternCreate, FcPatternAddString,
     FcFontSetList, FcObjectSetCreate, FcObjectSetDestroy,
     FcObjectSetAdd, FcPatternGetInteger
 };
 
-use servo_util::str::c_str_to_string;
+use util::str::c_str_to_string;
 
 use libc;
 use libc::{c_int, c_char};
 use std::borrow::ToOwned;
 use std::ffi::CString;
 use std::ptr;
 
 static FC_FAMILY: &'static [u8] = b"family\0";
--- a/servo/components/gfx/platform/macos/font.rs
+++ b/servo/components/gfx/platform/macos/font.rs
@@ -6,18 +6,18 @@
 
 extern crate core_foundation;
 extern crate core_graphics;
 extern crate core_text;
 
 use font::{FontHandleMethods, FontMetrics, FontTableMethods};
 use font::FontTableTag;
 use font::FractionalPixel;
-use servo_util::geometry::{Au, px_to_pt};
-use servo_util::geometry;
+use util::geometry::{Au, px_to_pt};
+use util::geometry;
 use platform::macos::font_context::FontContextHandle;
 use text::glyph::GlyphId;
 use style::computed_values::{font_stretch, font_weight};
 use platform::font_template::FontTemplateData;
 
 use core_foundation::base::CFIndex;
 use core_foundation::data::CFData;
 use core_foundation::string::UniChar;
--- a/servo/components/gfx/text/glyph.rs
+++ b/servo/components/gfx/text/glyph.rs
@@ -1,16 +1,16 @@
 /* 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 servo_util::vec::*;
-use servo_util::range;
-use servo_util::range::{Range, RangeIndex, EachIndex};
-use servo_util::geometry::Au;
+use util::vec::*;
+use util::range;
+use util::range::{Range, RangeIndex, EachIndex};
+use util::geometry::Au;
 
 use std::cmp::{Ordering, PartialOrd};
 use std::iter::repeat;
 use std::num::{ToPrimitive, NumCast};
 use std::mem;
 use std::ops::{Add, Sub, Mul, Neg, Div, Rem, BitAnd, BitOr, BitXor, Shl, Shr, Not};
 use std::u16;
 use std::vec::Vec;
--- a/servo/components/gfx/text/shaping/harfbuzz.rs
+++ b/servo/components/gfx/text/shaping/harfbuzz.rs
@@ -35,18 +35,18 @@ use harfbuzz::{hb_font_funcs_t, hb_buffe
 use harfbuzz::{RUST_hb_font_set_funcs};
 use harfbuzz::{RUST_hb_font_set_ppem};
 use harfbuzz::{RUST_hb_font_set_scale};
 use harfbuzz::{hb_glyph_info_t};
 use harfbuzz::{hb_glyph_position_t};
 use harfbuzz::{hb_position_t, hb_tag_t};
 use harfbuzz::{RUST_hb_shape, RUST_hb_buffer_get_glyph_infos};
 use libc::{c_uint, c_int, c_void, c_char};
-use servo_util::geometry::Au;
-use servo_util::range::Range;
+use util::geometry::Au;
+use util::range::Range;
 use std::char;
 use std::iter::repeat;
 use std::mem;
 use std::cmp;
 use std::ptr;
 
 macro_rules! hb_tag {
     ($t1:expr, $t2:expr, $t3:expr, $t4:expr) => (
--- a/servo/components/gfx/text/text_run.rs
+++ b/servo/components/gfx/text/text_run.rs
@@ -1,18 +1,18 @@
 /* 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::{Font, FontHandleMethods, FontMetrics, IS_WHITESPACE_SHAPING_FLAG, RunMetrics};
 use font::{ShapingOptions};
 use platform::font_template::FontTemplateData;
-use servo_util::geometry::Au;
-use servo_util::range::Range;
-use servo_util::vec::{Comparator, FullBinarySearchMethods};
+use util::geometry::Au;
+use util::range::Range;
+use util::vec::{Comparator, FullBinarySearchMethods};
 use std::cmp::Ordering;
 use std::slice::Iter;
 use std::sync::Arc;
 use text::glyph::{CharIndex, GlyphStore};
 
 /// A single "paragraph" of text in one font size and style.
 #[derive(Clone)]
 pub struct TextRun {
--- a/servo/components/layout_traits/lib.rs
+++ b/servo/components/layout_traits/lib.rs
@@ -5,29 +5,29 @@
 #![deny(unused_imports)]
 #![deny(unused_variables)]
 #![allow(missing_copy_implementations)]
 
 extern crate gfx;
 extern crate script_traits;
 extern crate "msg" as servo_msg;
 extern crate "net" as servo_net;
-extern crate "util" as servo_util;
+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::PaintChan;
 use servo_msg::constellation_msg::{ConstellationChan, Failure, PipelineId, PipelineExitType};
 use servo_net::image_cache_task::ImageCacheTask;
 use servo_net::resource_task::ResourceTask;
-use servo_util::time::TimeProfilerChan;
+use util::time::TimeProfilerChan;
 use script_traits::{ScriptControlChan, OpaqueScriptLayoutChannel};
 use std::sync::mpsc::{Sender, Receiver};
 
 /// Messages sent to the layout task from the constellation
 pub enum LayoutControlMsg {
     ExitNowMsg(PipelineExitType),
 }
 
--- a/servo/components/msg/constellation_msg.rs
+++ b/servo/components/msg/constellation_msg.rs
@@ -6,18 +6,18 @@
 //! reduce coupling between these two components.
 
 use geom::rect::Rect;
 use geom::size::TypedSize2D;
 use geom::scale_factor::ScaleFactor;
 use hyper::header::Headers;
 use hyper::method::Method;
 use layers::geometry::DevicePixel;
-use servo_util::cursor::Cursor;
-use servo_util::geometry::{PagePx, ViewportPx};
+use util::cursor::Cursor;
+use util::geometry::{PagePx, ViewportPx};
 use std::sync::mpsc::{channel, Sender, Receiver};
 use url::Url;
 
 #[derive(Clone)]
 pub struct ConstellationChan(pub Sender<Msg>);
 
 impl ConstellationChan {
     pub fn new() -> (Receiver<Msg>, ConstellationChan) {
--- a/servo/components/msg/lib.rs
+++ b/servo/components/msg/lib.rs
@@ -9,17 +9,17 @@
 #![allow(missing_copy_implementations)]
 #![allow(unstable)]
 
 extern crate azure;
 extern crate geom;
 extern crate hyper;
 extern crate layers;
 extern crate serialize;
-extern crate "util" as servo_util;
+extern crate util;
 extern crate url;
 
 #[cfg(target_os="macos")]
 extern crate core_foundation;
 #[cfg(target_os="macos")]
 extern crate io_surface;
 
 pub mod compositor_msg;
--- a/servo/components/net/about_loader.rs
+++ b/servo/components/net/about_loader.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use resource_task::{TargetedLoadResponse, Metadata, LoadData, start_sending, ResponseSenders};
 use resource_task::ProgressMsg::Done;
 use file_loader;
 
 use url::Url;
 use hyper::http::RawStatus;
-use servo_util::resource_files::resources_dir_path;
+use util::resource_files::resources_dir_path;
 
 use std::borrow::ToOwned;
 use std::io::fs::PathExtensions;
 use std::sync::mpsc::Sender;
 
 pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
     let senders = ResponseSenders {
         immediate_consumer: start_chan.clone(),
--- a/servo/components/net/file_loader.rs
+++ b/servo/components/net/file_loader.rs
@@ -4,17 +4,17 @@
 
 use resource_task::{ProgressMsg, Metadata, LoadData, start_sending, TargetedLoadResponse, ResponseSenders};
 use resource_task::ProgressMsg::{Payload, Done};
 
 use std::borrow::ToOwned;
 use std::io;
 use std::io::File;
 use std::sync::mpsc::Sender;
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 
 static READ_SIZE: uint = 8192;
 
 fn read_all(reader: &mut io::Stream, progress_chan: &Sender<ProgressMsg>)
         -> Result<(), String> {
     loop {
         let mut buf = vec!();
         match reader.push_at_least(READ_SIZE, READ_SIZE, &mut buf) {
--- a/servo/components/net/http_loader.rs
+++ b/servo/components/net/http_loader.rs
@@ -9,17 +9,17 @@ use log;
 use std::collections::HashSet;
 use hyper::client::Request;
 use hyper::header::common::{ContentLength, ContentType, Host, Location};
 use hyper::method::Method;
 use hyper::status::StatusClass;
 use std::error::Error;
 use std::io::Reader;
 use std::sync::mpsc::Sender;
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 use url::{Url, UrlParser};
 
 use std::borrow::ToOwned;
 
 pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
     spawn_named("http_loader".to_owned(), move || load(load_data, start_chan))
 }
 
--- a/servo/components/net/image_cache_task.rs
+++ b/servo/components/net/image_cache_task.rs
@@ -2,18 +2,18 @@
  * 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 image::base::{Image, load_from_memory};
 use resource_task;
 use resource_task::{LoadData, ResourceTask};
 use resource_task::ProgressMsg::{Payload, Done};
 
-use servo_util::task::spawn_named;
-use servo_util::taskpool::TaskPool;
+use util::task::spawn_named;
+use util::taskpool::TaskPool;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::mem::replace;
 use std::sync::{Arc, Mutex};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use url::Url;
 
@@ -479,17 +479,17 @@ mod tests {
     use super::ImageResponseMsg::*;
     use super::Msg::*;
 
     use resource_task;
     use resource_task::{ResourceTask, Metadata, start_sending, ResponseSenders};
     use resource_task::ProgressMsg::{Payload, Done};
     use sniffer_task;
     use image::base::test_image_bin;
-    use servo_util::taskpool::TaskPool;
+    use util::taskpool::TaskPool;
     use std::sync::mpsc::{Sender, channel, Receiver};
     use url::Url;
 
     trait Closure {
         fn invoke(&self, _response: Sender<resource_task::ProgressMsg>) { }
     }
     struct DoesNothing;
     impl Closure for DoesNothing { }
--- a/servo/components/net/lib.rs
+++ b/servo/components/net/lib.rs
@@ -13,17 +13,17 @@
 
 extern crate collections;
 extern crate geom;
 extern crate hyper;
 extern crate png;
 #[macro_use]
 extern crate log;
 extern crate serialize;
-extern crate "util" as servo_util;
+extern crate util;
 extern crate stb_image;
 extern crate time;
 extern crate url;
 
 /// 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
--- a/servo/components/net/local_image_cache.rs
+++ b/servo/components/net/local_image_cache.rs
@@ -9,17 +9,17 @@ multiple times and thus triggering reflo
 */
 
 use image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
 
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::sync::mpsc::{Receiver, channel};
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 use url::Url;
 
 pub trait ImageResponder<NodeAddress: Send> {
     fn respond(&self) -> Box<Fn(ImageResponseMsg, NodeAddress)+Send>;
 }
 
 pub struct LocalImageCache<NodeAddress> {
     image_cache_task: ImageCacheTask,
--- a/servo/components/net/resource_task.rs
+++ b/servo/components/net/resource_task.rs
@@ -6,17 +6,17 @@
 
 use about_loader;
 use data_loader;
 use file_loader;
 use http_loader;
 use sniffer_task;
 use sniffer_task::SnifferTask;
 
-use servo_util::task::spawn_named;
+use util::task::spawn_named;
 
 use hyper::header::common::UserAgent;
 use hyper::header::Headers;
 use hyper::http::RawStatus;
 use hyper::method::Method;
 use hyper::mime::{Mime, Attr};
 use url::Url;
 
--- a/servo/components/net/storage_task.rs
+++ b/servo/components/net/storage_task.rs
@@ -3,18 +3,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::BTreeMap;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use url::Url;
 
-use servo_util::str::DOMString;
-use servo_util::task::spawn_named;
+use util::str::DOMString;
+use util::task::spawn_named;
 
 /// Request operations on the storage data associated with a particular url
 pub enum StorageTaskMsg {
     /// gets the number of key/value pairs present in the associated storage data
     Length(Sender<u32>, Url),
 
     /// gets the name of the key at the specified index in the associated storage data
     Key(Sender<Option<DOMString>>, Url, u32),
--- a/servo/components/script/dom/attr.rs
+++ b/servo/components/script/dom/attr.rs
@@ -11,17 +11,17 @@ use dom::bindings::js::{JS, JSRef, Tempo
 use dom::bindings::js::{OptionalRootedRootable, RootedReference};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{Element, AttributeHandlers};
 use dom::node::Node;
 use dom::window::Window;
 use dom::virtualmethods::vtable_for;
 
 use devtools_traits::AttrInfo;
-use servo_util::str::{DOMString, split_html_space_chars};
+use util::str::{DOMString, split_html_space_chars};
 
 use string_cache::{Atom, Namespace};
 
 use std::borrow::ToOwned;
 use std::cell::Ref;
 use std::mem;
 
 pub enum AttrSettingType {
--- a/servo/components/script/dom/bindings/cell.rs
+++ b/servo/components/script/dom/bindings/cell.rs
@@ -2,18 +2,18 @@
  * 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 servo_util::task_state;
-use servo_util::task_state::{SCRIPT, IN_GC};
+use util::task_state;
+use util::task_state::{SCRIPT, IN_GC};
 
 use std::cell::{RefCell, Ref, RefMut};
 
 /// 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.
 pub struct DOMRefCell<T> {
--- a/servo/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/servo/components/script/dom/bindings/codegen/CodegenRust.py
@@ -1672,17 +1672,17 @@ def UnionTypes(descriptors, dictionaries
         'dom::bindings::conversions::ToJSValConvertible',
         'dom::bindings::conversions::unwrap_jsmanaged',
         'dom::bindings::conversions::StringificationBehavior::Default',
         'dom::bindings::error::throw_not_in_union',
         'dom::bindings::js::JS',
         'dom::types::*',
         'js::jsapi::JSContext',
         'js::jsval::JSVal',
-        'servo_util::str::DOMString',
+        'util::str::DOMString',
     ]
 
     # Now find all the things we'll need as arguments and return values because
     # we need to wrap or unwrap them.
     unionStructs = dict()
     for (t, descriptor, dictionary) in getAllTypes(descriptors, dictionaries, callbacks):
         assert not descriptor or not dictionary
         t = t.unroll()
@@ -4582,17 +4582,17 @@ class CGBindingRoot(CGThing):
             'dom::bindings::proxyhandler',
             'dom::bindings::proxyhandler::{_obj_toString, defineProperty_}',
             'dom::bindings::proxyhandler::{FillPropertyDescriptor, GetExpandoObject}',
             'dom::bindings::proxyhandler::{delete_, getPropertyDescriptor}',
             'dom::bindings::proxyhandler::{getOwnPropertyNames_, enumerate_}',
             'dom::bindings::str::ByteString',
             'page::JSPageInfo',
             'libc',
-            'servo_util::str::DOMString',
+            'util::str::DOMString',
             'std::borrow::ToOwned',
             'std::cmp',
             'std::iter::repeat',
             'std::mem',
             'std::num',
             'std::ptr',
             'std::str',
         ])
--- a/servo/components/script/dom/bindings/conversions.rs
+++ b/servo/components/script/dom/bindings/conversions.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! Conversions of Rust values to and from `JSVal`.
 
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::js::{JS, JSRef, Root};
 use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflectable, Reflector, DOMClass};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use js;
 use js::glue::{RUST_JSID_TO_STRING, RUST_JSID_IS_STRING};
 use js::glue::RUST_JS_NumberValue;
 use js::jsapi::{JSBool, JSContext, JSObject, JSString, jsid};
 use js::jsapi::{JS_ValueToUint64, JS_ValueToInt64};
 use js::jsapi::{JS_ValueToECMAUint32, JS_ValueToECMAInt32};
 use js::jsapi::{JS_ValueToUint16, JS_ValueToNumber, JS_ValueToBoolean};
--- a/servo/components/script/dom/bindings/js.rs
+++ b/servo/components/script/dom/bindings/js.rs
@@ -47,17 +47,17 @@
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::utils::{Reflector, Reflectable};
 use dom::node::Node;
 use js::jsapi::JSObject;
 use js::jsval::JSVal;
 use layout_interface::TrustedNodeAddress;
 use script_task::STACK_ROOTS;
 
-use servo_util::smallvec::{SmallVec, SmallVec16};
+use util::smallvec::{SmallVec, SmallVec16};
 use std::cell::{Cell, UnsafeCell};
 use std::default::Default;
 use std::marker::ContravariantLifetime;
 use std::mem;
 use std::ops::Deref;
 
 /// A type that represents a JS-owned value that is rooted for the lifetime of this value.
 /// Importantly, it requires explicit rooting in order to interact with the inner value.
--- a/servo/components/script/dom/bindings/trace.rs
+++ b/servo/components/script/dom/bindings/trace.rs
@@ -42,18 +42,18 @@ use js::rust::Cx;
 use layout_interface::{LayoutRPC, LayoutChan};
 use libc;
 use msg::constellation_msg::{PipelineId, SubpageId, WindowSizeData};
 use net::image_cache_task::ImageCacheTask;
 use script_traits::ScriptControlChan;
 use script_traits::UntrustedNodeAddress;
 use servo_msg::compositor_msg::ScriptListener;
 use servo_msg::constellation_msg::ConstellationChan;
-use servo_util::smallvec::{SmallVec1, SmallVec};
-use servo_util::str::{LengthOrPercentageOrAuto};
+use util::smallvec::{SmallVec1, SmallVec};
+use util::str::{LengthOrPercentageOrAuto};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::collections::hash_state::HashState;
 use std::ffi::CString;
 use std::hash::{Hash, Hasher};
 use std::io::timer::Timer;
 use std::rc::Rc;
 use std::sync::mpsc::{Receiver, Sender};
--- a/servo/components/script/dom/blob.rs
+++ b/servo/components/script/dom/blob.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::InheritTypes::FileDerived;
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::bindings::error::Fallible;
 use dom::bindings::codegen::Bindings::BlobBinding;
 use dom::bindings::codegen::Bindings::BlobBinding::BlobMethods;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::cmp::{min, max};
 use std::num::ToPrimitive;
 
 #[jstraceable]
 pub enum BlobTypeId {
--- a/servo/components/script/dom/characterdata.rs
+++ b/servo/components/script/dom/characterdata.rs
@@ -9,17 +9,17 @@ use dom::bindings::codegen::Bindings::Ch
 use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast};
 use dom::bindings::error::{Fallible, ErrorResult};
 use dom::bindings::error::Error::IndexSize;
 use dom::bindings::js::JSRef;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId};
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 use std::cell::Ref;
 
 #[dom_struct]
 pub struct CharacterData {
     node: Node,
     data: DOMRefCell<DOMString>,
--- a/servo/components/script/dom/comment.rs
+++ b/servo/components/script/dom/comment.rs
@@ -7,17 +7,17 @@ use dom::bindings::codegen::Bindings::Wi
 use dom::bindings::codegen::InheritTypes::CommentDerived;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 /// An HTML comment.
 #[dom_struct]
 pub struct Comment {
     characterdata: CharacterData,
 }
 
 impl CommentDerived for EventTarget {
--- a/servo/components/script/dom/console.rs
+++ b/servo/components/script/dom/console.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/. */
 
 use dom::bindings::codegen::Bindings::ConsoleBinding;
 use dom::bindings::codegen::Bindings::ConsoleBinding::ConsoleMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct Console {
     reflector_: Reflector
 }
 
 impl Console {
     fn new_inherited() -> Console {
--- a/servo/components/script/dom/create.rs
+++ b/servo/components/script/dom/create.rs
@@ -70,17 +70,17 @@ use dom::htmltemplateelement::HTMLTempla
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::htmltimeelement::HTMLTimeElement;
 use dom::htmltitleelement::HTMLTitleElement;
 use dom::htmltrackelement::HTMLTrackElement;
 use dom::htmlulistelement::HTMLUListElement;
 use dom::htmlunknownelement::HTMLUnknownElement;
 use dom::htmlvideoelement::HTMLVideoElement;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use string_cache::QualName;
 
 use std::borrow::ToOwned;
 
 pub fn create_element(name: QualName, prefix: Option<DOMString>,
                       document: JSRef<Document>, creator: ElementCreator)
                       -> Temporary<Element> {
--- a/servo/components/script/dom/cssstyledeclaration.rs
+++ b/servo/components/script/dom/cssstyledeclaration.rs
@@ -10,17 +10,17 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, OptionalRootedRootable, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::document::DocumentHelpers;
 use dom::element::{Element, ElementHelpers, StylePriority};
 use dom::htmlelement::HTMLElement;
 use dom::node::{window_from_node, document_from_node, NodeDamage, Node};
 use dom::window::Window;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 use style::{is_supported_property, longhands_from_shorthand, parse_style_attribute};
 use style::PropertyDeclaration;
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 
 #[dom_struct]
--- a/servo/components/script/dom/customevent.rs
+++ b/servo/components/script/dom/customevent.rs
@@ -8,17 +8,17 @@ use dom::bindings::codegen::Bindings::Ev
 use dom::bindings::codegen::InheritTypes::{EventCast, CustomEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary, MutHeap};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
 use js::jsapi::JSContext;
 use js::jsval::{JSVal, NullValue};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct CustomEvent {
     event: Event,
     detail: MutHeap<JSVal>,
 }
 
 impl CustomEventDerived for Event {
--- a/servo/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/servo/components/script/dom/dedicatedworkerglobalscope.rs
@@ -18,19 +18,19 @@ use dom::eventtarget::{EventTarget, Even
 use dom::messageevent::MessageEvent;
 use dom::worker::{TrustedWorkerAddress, WorkerMessageHandler};
 use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
 use dom::workerglobalscope::WorkerGlobalScopeTypeId;
 use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource};
 use script_task::StackRootTLS;
 
 use servo_net::resource_task::{ResourceTask, load_whole_resource};
-use servo_util::task::spawn_named;
-use servo_util::task_state;
-use servo_util::task_state::{SCRIPT, IN_WORKER};
+use util::task::spawn_named;
+use util::task_state;
+use util::task_state::{SCRIPT, IN_WORKER};
 
 use js::jsapi::JSContext;
 use js::jsval::JSVal;
 use js::rust::Cx;
 
 use std::rc::Rc;
 use std::sync::mpsc::{Sender, Receiver};
 use url::Url;
--- a/servo/components/script/dom/document.rs
+++ b/servo/components/script/dom/document.rs
@@ -50,18 +50,18 @@ use dom::messageevent::MessageEvent;
 use dom::node::{Node, NodeHelpers, NodeTypeId, CloneChildrenFlag, NodeDamage};
 use dom::nodelist::NodeList;
 use dom::text::Text;
 use dom::processinginstruction::ProcessingInstruction;
 use dom::range::Range;
 use dom::treewalker::TreeWalker;
 use dom::uievent::UIEvent;
 use dom::window::{Window, WindowHelpers};
-use servo_util::namespace;
-use servo_util::str::{DOMString, split_html_space_chars};
+use util::namespace;
+use util::str::{DOMString, split_html_space_chars};
 
 use html5ever::tree_builder::{QuirksMode, NoQuirks, LimitedQuirks, Quirks};
 use layout_interface::{LayoutChan, Msg};
 use string_cache::{Atom, QualName};
 use url::Url;
 
 use std::borrow::ToOwned;
 use std::collections::HashMap;
--- a/servo/components/script/dom/documentfragment.rs
+++ b/servo/components/script/dom/documentfragment.rs
@@ -10,17 +10,17 @@ use dom::bindings::js::{JSRef, Temporary
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::document::Document;
 use dom::element::Element;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::HTMLCollection;
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::nodelist::NodeList;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct DocumentFragment {
     node: Node,
 }
 
 impl DocumentFragmentDerived for EventTarget {
     fn is_documentfragment(&self) -> bool {
--- a/servo/components/script/dom/documenttype.rs
+++ b/servo/components/script/dom/documenttype.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::codegen::Bindings::DocumentTypeBinding;
 use dom::bindings::codegen::Bindings::DocumentTypeBinding::DocumentTypeMethods;
 use dom::bindings::codegen::InheritTypes::{DocumentTypeDerived, NodeCast};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 
 /// The `DOCTYPE` tag.
 #[dom_struct]
 pub struct DocumentType {
     node: Node,
     name: DOMString,
--- a/servo/components/script/dom/domexception.rs
+++ b/servo/components/script/dom/domexception.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::codegen::Bindings::DOMExceptionBinding;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionConstants;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionMethods;
 use dom::bindings::error::Error;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 
 #[repr(uint)]
 #[derive(Copy, Show)]
 #[jstraceable]
 pub enum DOMErrorName {
     IndexSizeError = DOMExceptionConstants::INDEX_SIZE_ERR as uint,
--- a/servo/components/script/dom/domimplementation.rs
+++ b/servo/components/script/dom/domimplementation.rs
@@ -18,17 +18,17 @@ use dom::document::{Document, DocumentHe
 use dom::document::DocumentSource;
 use dom::documenttype::DocumentType;
 use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlheadelement::HTMLHeadElement;
 use dom::htmlhtmlelement::HTMLHtmlElement;
 use dom::htmltitleelement::HTMLTitleElement;
 use dom::node::Node;
 use dom::text::Text;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct DOMImplementation {
     reflector_: Reflector,
     document: JS<Document>,
 }
--- a/servo/components/script/dom/domparser.rs
+++ b/servo/components/script/dom/domparser.rs
@@ -10,17 +10,17 @@ use dom::bindings::error::Fallible;
 use dom::bindings::error::Error::FailureUnknown;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
 use dom::document::DocumentSource;
 use dom::window::Window;
 use parse::html::{HTMLInput, parse_html};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct DOMParser {
     reflector_: Reflector,
     window: JS<Window>, //XXXjdm Document instead?
 }
--- a/servo/components/script/dom/domrect.rs
+++ b/servo/components/script/dom/domrect.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::DOMRectBinding;
 use dom::bindings::codegen::Bindings::DOMRectBinding::DOMRectMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::window::Window;
-use servo_util::geometry::Au;
+use util::geometry::Au;
 use std::num::Float;
 
 #[dom_struct]
 pub struct DOMRect {
     reflector_: Reflector,
     top: f32,
     bottom: f32,
     left: f32,
--- a/servo/components/script/dom/domstringmap.rs
+++ b/servo/components/script/dom/domstringmap.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::DOMStringMapBinding;
 use dom::bindings::codegen::Bindings::DOMStringMapBinding::DOMStringMapMethods;
 use dom::bindings::error::ErrorResult;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::node::window_from_node;
 use dom::htmlelement::{HTMLElement, HTMLElementCustomAttributeHelpers};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct DOMStringMap {
     reflector_: Reflector,
     element: JS<HTMLElement>,
 }
 
 impl DOMStringMap {
--- a/servo/components/script/dom/domtokenlist.rs
+++ b/servo/components/script/dom/domtokenlist.rs
@@ -8,17 +8,17 @@ use dom::bindings::codegen::Bindings::DO
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::error::Error::{InvalidCharacter, Syntax};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{Element, AttributeHandlers};
 use dom::node::window_from_node;
 
-use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
+use util::str::{DOMString, HTML_SPACE_CHARACTERS};
 use string_cache::Atom;
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct DOMTokenList {
     reflector_: Reflector,
     element: JS<Element>,
--- a/servo/components/script/dom/element.rs
+++ b/servo/components/script/dom/element.rs
@@ -47,18 +47,18 @@ use dom::htmltextareaelement::{HTMLTextA
 use dom::node::{CLICK_IN_PROGRESS, LayoutNodeHelpers, Node, NodeHelpers, NodeTypeId};
 use dom::node::{NodeIterator, document_from_node, NodeDamage};
 use dom::node::{window_from_node};
 use dom::nodelist::NodeList;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
 use devtools_traits::AttrInfo;
 use style::{self, SimpleColorAttribute, UnsignedIntegerAttribute};
 use style::{IntegerAttribute, LengthAttribute, matches};
-use servo_util::namespace;
-use servo_util::str::{DOMString, LengthOrPercentageOrAuto};
+use util::namespace;
+use util::str::{DOMString, LengthOrPercentageOrAuto};
 
 use html5ever::tree_builder::{NoQuirks, LimitedQuirks, Quirks};
 
 use cssparser::RGBA;
 use std::ascii::AsciiExt;
 use std::borrow::{IntoCow, ToOwned};
 use std::cell::{Ref, RefMut};
 use std::default::Default;
--- a/servo/components/script/dom/errorevent.rs
+++ b/servo/components/script/dom/errorevent.rs
@@ -9,17 +9,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary, MutHeap};
 use js::jsapi::JSContext;
 use dom::bindings::trace::JSTraceable;
 
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId, EventBubbles, EventCancelable};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use dom::bindings::cell::DOMRefCell;
 use std::borrow::ToOwned;
 use std::cell::{Cell};
 use js::jsval::{JSVal, NullValue};
 
 #[dom_struct]
 pub struct ErrorEvent {
--- a/servo/components/script/dom/event.rs
+++ b/servo/components/script/dom/event.rs
@@ -5,17 +5,17 @@
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventBinding;
 use dom::bindings::codegen::Bindings::EventBinding::{EventConstants, EventMethods};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::eventtarget::EventTarget;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::default::Default;
 
 use time;
 
 #[jstraceable]
--- a/servo/components/script/dom/eventtarget.rs
+++ b/servo/components/script/dom/eventtarget.rs
@@ -14,18 +14,18 @@ use dom::bindings::utils::{Reflectable, 
 use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
 use dom::node::NodeTypeId;
 use dom::workerglobalscope::WorkerGlobalScopeTypeId;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
 use dom::virtualmethods::VirtualMethods;
 use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObject};
 use js::jsapi::{JSContext, JSObject};
-use servo_util::fnv::FnvHasher;
-use servo_util::str::DOMString;
+use util::fnv::FnvHasher;
+use util::str::DOMString;
 
 use libc::{c_char, size_t};
 use std::borrow::ToOwned;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::collections::hash_state::DefaultState;
 use std::default::Default;
 use std::ffi::CString;
 use std::ptr;
--- a/servo/components/script/dom/file.rs
+++ b/servo/components/script/dom/file.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::FileBinding;
 use dom::bindings::codegen::Bindings::FileBinding::FileMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::reflect_dom_object;
 use dom::blob::{Blob, BlobTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct File {
     blob: Blob,
     name: DOMString,
 }
 
 impl File {
--- a/servo/components/script/dom/formdata.rs
+++ b/servo/components/script/dom/formdata.rs
@@ -10,17 +10,17 @@ use dom::bindings::codegen::UnionTypes::
 use dom::bindings::codegen::UnionTypes::FileOrString::{eFile, eString};
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::blob::Blob;
 use dom::file::File;
 use dom::htmlformelement::HTMLFormElement;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 
 #[derive(Clone)]
 #[jstraceable]
 #[must_root]
--- a/servo/components/script/dom/htmlanchorelement.rs
+++ b/servo/components/script/dom/htmlanchorelement.rs
@@ -17,17 +17,17 @@ use dom::element::{Element, AttributeHan
 use dom::event::Event;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use std::default::Default;
 use string_cache::Atom;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLAnchorElement {
     htmlelement: HTMLElement,
     rel_list: MutNullableJS<DOMTokenList>,
 }
 
 impl HTMLAnchorElementDerived for EventTarget {
--- a/servo/components/script/dom/htmlappletelement.rs
+++ b/servo/components/script/dom/htmlappletelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLAppletElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLAppletElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLAppletElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLAppletElementDerived for EventTarget {
     fn is_htmlappletelement(&self) -> bool {
--- a/servo/components/script/dom/htmlareaelement.rs
+++ b/servo/components/script/dom/htmlareaelement.rs
@@ -14,17 +14,17 @@ use dom::domtokenlist::DOMTokenList;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use std::default::Default;
 use string_cache::Atom;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
 #[privatize]
 pub struct HTMLAreaElement {
     htmlelement: HTMLElement,
     rel_list: MutNullableJS<DOMTokenList>,
 }
--- a/servo/components/script/dom/htmlaudioelement.rs
+++ b/servo/components/script/dom/htmlaudioelement.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::HTMLAudioElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElementTypeId;
 use dom::htmlmediaelement::{HTMLMediaElement, HTMLMediaElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLAudioElement {
     htmlmediaelement: HTMLMediaElement
 }
 
 impl HTMLAudioElementDerived for EventTarget {
     fn is_htmlaudioelement(&self) -> bool {
--- a/servo/components/script/dom/htmlbaseelement.rs
+++ b/servo/components/script/dom/htmlbaseelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLBaseElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLBaseElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLBaseElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLBaseElementDerived for EventTarget {
     fn is_htmlbaseelement(&self) -> bool {
--- a/servo/components/script/dom/htmlbodyelement.rs
+++ b/servo/components/script/dom/htmlbodyelement.rs
@@ -13,17 +13,17 @@ use dom::bindings::utils::Reflectable;
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{self, DOMString};
+use util::str::{self, DOMString};
 
 use std::borrow::ToOwned;
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLBodyElement {
     htmlelement: HTMLElement,
     background_color: Cell<Option<RGBA>>,
--- a/servo/components/script/dom/htmlbrelement.rs
+++ b/servo/components/script/dom/htmlbrelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLBRElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLBRElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLBRElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLBRElementDerived for EventTarget {
     fn is_htmlbrelement(&self) -> bool {
--- a/servo/components/script/dom/htmlbuttonelement.rs
+++ b/servo/components/script/dom/htmlbuttonelement.rs
@@ -15,17 +15,17 @@ use dom::eventtarget::{EventTarget, Even
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
 use std::ascii::OwnedAsciiExt;
 use std::borrow::ToOwned;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 #[dom_struct]
 pub struct HTMLButtonElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLButtonElementDerived for EventTarget {
--- a/servo/components/script/dom/htmlcanvaselement.rs
+++ b/servo/components/script/dom/htmlcanvaselement.rs
@@ -15,17 +15,17 @@ use dom::canvasrenderingcontext2d::{Canv
 use dom::document::Document;
 use dom::element::{Element, AttributeHandlers};
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{DOMString, parse_unsigned_integer};
+use util::str::{DOMString, parse_unsigned_integer};
 
 use geom::size::Size2D;
 
 use std::cell::Cell;
 use std::default::Default;
 use std::sync::mpsc::Sender;
 
 const DEFAULT_WIDTH: u32 = 300;
--- a/servo/components/script/dom/htmlcollection.rs
+++ b/servo/components/script/dom/htmlcollection.rs
@@ -7,18 +7,18 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::element::{Element, AttributeHandlers, ElementHelpers};
 use dom::node::{Node, NodeHelpers, TreeIterator};
 use dom::window::Window;
-use servo_util::namespace;
-use servo_util::str::{DOMString, split_html_space_chars};
+use util::namespace;
+use util::str::{DOMString, split_html_space_chars};
 
 use std::ascii::AsciiExt;
 use std::iter::{FilterMap, Skip};
 use string_cache::{Atom, Namespace};
 
 pub trait CollectionFilter : JSTraceable {
     fn filter<'a>(&self, elem: JSRef<'a, Element>, root: JSRef<'a, Node>) -> bool;
 }
--- a/servo/components/script/dom/htmldataelement.rs
+++ b/servo/components/script/dom/htmldataelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLDataElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLDataElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLDataElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLDataElementDerived for EventTarget {
     fn is_htmldataelement(&self) -> bool {
--- a/servo/components/script/dom/htmldatalistelement.rs
+++ b/servo/components/script/dom/htmldatalistelement.rs
@@ -9,17 +9,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::Element;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::{HTMLCollection, CollectionFilter};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, window_from_node};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLDataListElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLDataListElementDerived for EventTarget {
     fn is_htmldatalistelement(&self) -> bool {
--- a/servo/components/script/dom/htmldirectoryelement.rs
+++ b/servo/components/script/dom/htmldirectoryelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLDirectoryElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLDirectoryElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLDirectoryElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLDirectoryElementDerived for EventTarget {
     fn is_htmldirectoryelement(&self) -> bool {
--- a/servo/components/script/dom/htmldivelement.rs
+++ b/servo/components/script/dom/htmldivelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLDivElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLDivElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLDivElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLDivElementDerived for EventTarget {
     fn is_htmldivelement(&self) -> bool {
--- a/servo/components/script/dom/htmldlistelement.rs
+++ b/servo/components/script/dom/htmldlistelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLDListElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLDListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLDListElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLDListElementDerived for EventTarget {
     fn is_htmldlistelement(&self) -> bool {
--- a/servo/components/script/dom/htmlelement.rs
+++ b/servo/components/script/dom/htmlelement.rs
@@ -22,17 +22,17 @@ use dom::domstringmap::DOMStringMap;
 use dom::element::{Element, ElementTypeId, ActivationElementHelpers, AttributeHandlers};
 use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::htmlinputelement::HTMLInputElement;
 use dom::htmlmediaelement::HTMLMediaElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElementTypeId;
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use string_cache::Atom;
 
 use std::borrow::ToOwned;
 use std::default::Default;
 
 #[dom_struct]
 pub struct HTMLElement {
--- a/servo/components/script/dom/htmlembedelement.rs
+++ b/servo/components/script/dom/htmlembedelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLEmbedElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLEmbedElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLEmbedElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLEmbedElementDerived for EventTarget {
     fn is_htmlembedelement(&self) -> bool {
--- a/servo/components/script/dom/htmlfieldsetelement.rs
+++ b/servo/components/script/dom/htmlfieldsetelement.rs
@@ -14,17 +14,17 @@ use dom::element::{AttributeHandlers, El
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlcollection::{HTMLCollection, CollectionFilter};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{DOMString, StaticStringVec};
+use util::str::{DOMString, StaticStringVec};
 use string_cache::Atom;
 
 #[dom_struct]
 pub struct HTMLFieldSetElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLFieldSetElementDerived for EventTarget {
--- a/servo/components/script/dom/htmlfontelement.rs
+++ b/servo/components/script/dom/htmlfontelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLFontElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLFontElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLFontElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLFontElementDerived for EventTarget {
     fn is_htmlfontelement(&self) -> bool {
--- a/servo/components/script/dom/htmlformelement.rs
+++ b/servo/components/script/dom/htmlformelement.rs
@@ -18,17 +18,17 @@ use dom::event::{Event, EventHelpers, Ev
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::htmlinputelement::HTMLInputElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::node::{Node, NodeHelpers, NodeTypeId, document_from_node, window_from_node};
 use hyper::method::Method;
 use servo_msg::constellation_msg::LoadData;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use script_task::{ScriptChan, ScriptMsg};
 use std::ascii::OwnedAsciiExt;
 use url::UrlParser;
 use url::form_urlencoded::serialize;
 use string_cache::Atom;
 
 use std::borrow::ToOwned;
 use std::cell::Cell;
--- a/servo/components/script/dom/htmlframeelement.rs
+++ b/servo/components/script/dom/htmlframeelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLFrameElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLFrameElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLFrameElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLFrameElementDerived for EventTarget {
     fn is_htmlframeelement(&self) -> bool {
--- a/servo/components/script/dom/htmlframesetelement.rs
+++ b/servo/components/script/dom/htmlframesetelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLFrameSetElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLFrameSetElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLFrameSetElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLFrameSetElementDerived for EventTarget {
     fn is_htmlframesetelement(&self) -> bool {
--- a/servo/components/script/dom/htmlheadelement.rs
+++ b/servo/components/script/dom/htmlheadelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLHeadElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLHeadElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLHeadElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLHeadElementDerived for EventTarget {
     fn is_htmlheadelement(&self) -> bool {
--- a/servo/components/script/dom/htmlheadingelement.rs
+++ b/servo/components/script/dom/htmlheadingelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLHeadingElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLHeadingElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[jstraceable]
 pub enum HeadingLevel {
     Heading1,
     Heading2,
     Heading3,
     Heading4,
     Heading5,
--- a/servo/components/script/dom/htmlhrelement.rs
+++ b/servo/components/script/dom/htmlhrelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLHRElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLHRElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLHRElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLHRElementDerived for EventTarget {
     fn is_htmlhrelement(&self) -> bool {
--- a/servo/components/script/dom/htmlhtmlelement.rs
+++ b/servo/components/script/dom/htmlhtmlelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLHtmlElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLHtmlElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLHtmlElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLHtmlElementDerived for EventTarget {
     fn is_htmlhtmlelement(&self) -> bool {
--- a/servo/components/script/dom/htmliframeelement.rs
+++ b/servo/components/script/dom/htmliframeelement.rs
@@ -20,17 +20,17 @@ use dom::node::{Node, NodeHelpers, NodeT
 use dom::urlhelper::UrlHelper;
 use dom::virtualmethods::VirtualMethods;
 use dom::window::Window;
 use page::{IterablePage, Page};
 
 use servo_msg::constellation_msg::{PipelineId, SubpageId, ConstellationChan};
 use servo_msg::constellation_msg::IFrameSandboxState::{IFrameSandboxed, IFrameUnsandboxed};
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::ascii::AsciiExt;
 use std::cell::Cell;
 use url::{Url, UrlParser};
 
 enum SandboxAllowance {
     AllowNothing = 0x00,
     AllowSameOrigin = 0x01,
--- a/servo/components/script/dom/htmlimageelement.rs
+++ b/servo/components/script/dom/htmlimageelement.rs
@@ -13,18 +13,18 @@ use dom::document::{Document, DocumentHe
 use dom::element::Element;
 use dom::element::AttributeHandlers;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, NodeHelpers, NodeDamage, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use servo_net::image_cache_task;
-use servo_util::geometry::to_px;
-use servo_util::str::DOMString;
+use util::geometry::to_px;
+use util::str::DOMString;
 use string_cache::Atom;
 
 use url::{Url, UrlParser};
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct HTMLImageElement {
--- a/servo/components/script/dom/htmlinputelement.rs
+++ b/servo/components/script/dom/htmlinputelement.rs
@@ -29,17 +29,17 @@ use dom::htmlformelement::{FormSubmitter
 use dom::htmlformelement::{SubmittedFrom, ResetFrom};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
 use dom::node::{document_from_node, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use textinput::TextInput;
 use textinput::KeyReaction::{TriggerDefaultAction, DispatchInput, Nothing};
 use textinput::Lines::Single;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 use std::ascii::OwnedAsciiExt;
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::default::Default;
 
 const DEFAULT_SUBMIT_VALUE: &'static str = "Submit";
--- a/servo/components/script/dom/htmllabelelement.rs
+++ b/servo/components/script/dom/htmllabelelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLLabelElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLLabelElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLLabelElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLLabelElementDerived for EventTarget {
     fn is_htmllabelelement(&self) -> bool {
--- a/servo/components/script/dom/htmllegendelement.rs
+++ b/servo/components/script/dom/htmllegendelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLLegendElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLLegendElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLLegendElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLLegendElementDerived for EventTarget {
     fn is_htmllegendelement(&self) -> bool {
--- a/servo/components/script/dom/htmllielement.rs
+++ b/servo/components/script/dom/htmllielement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLLIElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLLIElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLLIElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLLIElementDerived for EventTarget {
     fn is_htmllielement(&self) -> bool {
--- a/servo/components/script/dom/htmllinkelement.rs
+++ b/servo/components/script/dom/htmllinkelement.rs
@@ -13,17 +13,17 @@ use dom::document::Document;
 use dom::domtokenlist::DOMTokenList;
 use dom::element::{AttributeHandlers, Element};
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use layout_interface::{LayoutChan, Msg};
-use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
+use util::str::{DOMString, HTML_SPACE_CHARACTERS};
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::default::Default;
 use url::UrlParser;
 use string_cache::Atom;
 
 #[dom_struct]
--- a/servo/components/script/dom/htmlmapelement.rs
+++ b/servo/components/script/dom/htmlmapelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLMapElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLMapElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLMapElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLMapElementDerived for EventTarget {
     fn is_htmlmapelement(&self) -> bool {
--- a/servo/components/script/dom/htmlmediaelement.rs
+++ b/servo/components/script/dom/htmlmediaelement.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::js::{JSRef};
 use dom::bindings::codegen::InheritTypes::HTMLMediaElementDerived;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::NodeTypeId;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLMediaElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLMediaElementDerived for EventTarget {
     fn is_htmlmediaelement(&self) -> bool {
--- a/servo/components/script/dom/htmlmetaelement.rs
+++ b/servo/components/script/dom/htmlmetaelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLMetaElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLMetaElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLMetaElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLMetaElementDerived for EventTarget {
     fn is_htmlmetaelement(&self) -> bool {
--- a/servo/components/script/dom/htmlmeterelement.rs
+++ b/servo/components/script/dom/htmlmeterelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLMeterElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLMeterElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLMeterElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLMeterElementDerived for EventTarget {
     fn is_htmlmeterelement(&self) -> bool {
--- a/servo/components/script/dom/htmlmodelement.rs
+++ b/servo/components/script/dom/htmlmodelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLModElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLModElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLModElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLModElementDerived for EventTarget {
     fn is_htmlmodelement(&self) -> bool {
--- a/servo/components/script/dom/htmlobjectelement.rs
+++ b/servo/components/script/dom/htmlobjectelement.rs
@@ -17,17 +17,17 @@ use dom::eventtarget::{EventTarget, Even
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, NodeHelpers, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
 use servo_net::image_cache_task;
 use servo_net::image_cache_task::ImageCacheTask;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 use url::Url;
 
 #[dom_struct]
 pub struct HTMLObjectElement {
     htmlelement: HTMLElement,
 }
--- a/servo/components/script/dom/htmlolistelement.rs
+++ b/servo/components/script/dom/htmlolistelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLOListElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLOListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLOListElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLOListElementDerived for EventTarget {
     fn is_htmlolistelement(&self) -> bool {
--- a/servo/components/script/dom/htmloptgroupelement.rs
+++ b/servo/components/script/dom/htmloptgroupelement.rs
@@ -12,17 +12,17 @@ use dom::bindings::js::{JSRef, Temporary
 use dom::document::Document;
 use dom::element::AttributeHandlers;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 #[dom_struct]
 pub struct HTMLOptGroupElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLOptGroupElementDerived for EventTarget {
--- a/servo/components/script/dom/htmloptionelement.rs
+++ b/servo/components/script/dom/htmloptionelement.rs
@@ -16,17 +16,17 @@ use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::element::{AttributeHandlers, Element, ElementHelpers};
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{DOMString, split_html_space_chars};
+use util::str::{DOMString, split_html_space_chars};
 use string_cache::Atom;
 
 #[dom_struct]
 pub struct HTMLOptionElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLOptionElementDerived for EventTarget {
--- a/servo/components/script/dom/htmloutputelement.rs
+++ b/servo/components/script/dom/htmloutputelement.rs
@@ -7,17 +7,17 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::HTMLOutputElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLOutputElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLOutputElementDerived for EventTarget {
     fn is_htmloutputelement(&self) -> bool {
--- a/servo/components/script/dom/htmlparagraphelement.rs
+++ b/servo/components/script/dom/htmlparagraphelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLParagraphElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLParagraphElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLParagraphElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLParagraphElementDerived for EventTarget {
     fn is_htmlparagraphelement(&self) -> bool {
--- a/servo/components/script/dom/htmlparamelement.rs
+++ b/servo/components/script/dom/htmlparamelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLParamElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLParamElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLParamElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLParamElementDerived for EventTarget {
     fn is_htmlparamelement(&self) -> bool {
--- a/servo/components/script/dom/htmlpreelement.rs
+++ b/servo/components/script/dom/htmlpreelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLPreElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLPreElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLPreElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLPreElementDerived for EventTarget {
     fn is_htmlpreelement(&self) -> bool {
--- a/servo/components/script/dom/htmlprogresselement.rs
+++ b/servo/components/script/dom/htmlprogresselement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLProgressElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLProgressElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLProgressElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLProgressElementDerived for EventTarget {
     fn is_htmlprogresselement(&self) -> bool {
--- a/servo/components/script/dom/htmlquoteelement.rs
+++ b/servo/components/script/dom/htmlquoteelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLQuoteElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLQuoteElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLQuoteElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLQuoteElementDerived for EventTarget {
     fn is_htmlquoteelement(&self) -> bool {
--- a/servo/components/script/dom/htmlscriptelement.rs
+++ b/servo/components/script/dom/htmlscriptelement.rs
@@ -25,17 +25,17 @@ use dom::htmlelement::{HTMLElement, HTML
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node, CloneChildrenFlag};
 use dom::virtualmethods::VirtualMethods;
 use dom::window::ScriptHelpers;
 use script_task::{ScriptMsg, Runnable};
 
 use encoding::all::UTF_8;
 use encoding::types::{Encoding, DecoderTrap};
 use servo_net::resource_task::load_whole_resource;
-use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
+use util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use string_cache::Atom;
 use url::UrlParser;
 
 #[dom_struct]
 pub struct HTMLScriptElement {
     htmlelement: HTMLElement,
--- a/servo/components/script/dom/htmlselectelement.rs
+++ b/servo/components/script/dom/htmlselectelement.rs
@@ -15,17 +15,17 @@ use dom::document::Document;
 use dom::element::{AttributeHandlers, Element};
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::validitystate::ValidityState;
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct HTMLSelectElement {
     htmlelement: HTMLElement
 }
--- a/servo/components/script/dom/htmlsourceelement.rs
+++ b/servo/components/script/dom/htmlsourceelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLSourceElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLSourceElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLSourceElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLSourceElementDerived for EventTarget {
     fn is_htmlsourceelement(&self) -> bool {
--- a/servo/components/script/dom/htmlspanelement.rs
+++ b/servo/components/script/dom/htmlspanelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLSpanElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLSpanElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLSpanElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLSpanElementDerived for EventTarget {
     fn is_htmlspanelement(&self) -> bool {
--- a/servo/components/script/dom/htmlstyleelement.rs
+++ b/servo/components/script/dom/htmlstyleelement.rs
@@ -8,17 +8,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 use layout_interface::{LayoutChan, Msg};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use style::{StylesheetOrigin, Stylesheet};
 
 #[dom_struct]
 pub struct HTMLStyleElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLStyleElementDerived for EventTarget {
--- a/servo/components/script/dom/htmltablecaptionelement.rs
+++ b/servo/components/script/dom/htmltablecaptionelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLTableCaptionElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLTableCaptionElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTableCaptionElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLTableCaptionElementDerived for EventTarget {
     fn is_htmltablecaptionelement(&self) -> bool {
--- a/servo/components/script/dom/htmltablecellelement.rs
+++ b/servo/components/script/dom/htmltablecellelement.rs
@@ -8,17 +8,17 @@ use dom::bindings::js::JSRef;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::NodeTypeId;
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{self, DOMString, LengthOrPercentageOrAuto};
+use util::str::{self, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[derive(Copy, PartialEq, Show)]
 #[jstraceable]
 pub enum HTMLTableCellElementTypeId {
     HTMLTableDataCellElement,
     HTMLTableHeaderCellElement,
 }
--- a/servo/components/script/dom/htmltablecolelement.rs
+++ b/servo/components/script/dom/htmltablecolelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLTableColElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLTableColElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTableColElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLTableColElementDerived for EventTarget {
     fn is_htmltablecolelement(&self) -> bool {
--- a/servo/components/script/dom/htmltabledatacellelement.rs
+++ b/servo/components/script/dom/htmltabledatacellelement.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::HTMLTableDataCellElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::HTMLElementTypeId;
 use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTableDataCellElement {
     htmltablecellelement: HTMLTableCellElement,
 }
 
 impl HTMLTableDataCellElementDerived for EventTarget {
     fn is_htmltabledatacellelement(&self) -> bool {
--- a/servo/components/script/dom/htmltableelement.rs
+++ b/servo/components/script/dom/htmltableelement.rs
@@ -13,17 +13,17 @@ use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::htmltablecaptionelement::HTMLTableCaptionElement;
 use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{self, DOMString, LengthOrPercentageOrAuto};
+use util::str::{self, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableElement {
     htmlelement: HTMLElement,
     background_color: Cell<Option<RGBA>>,
     border: Cell<Option<u32>>,
     width: Cell<LengthOrPercentageOrAuto>,
--- a/servo/components/script/dom/htmltableheadercellelement.rs
+++ b/servo/components/script/dom/htmltableheadercellelement.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::HTMLTableHeaderCellElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::htmlelement::HTMLElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTableHeaderCellElement {
     htmltablecellelement: HTMLTableCellElement,
 }
 
 impl HTMLTableHeaderCellElementDerived for EventTarget {
     fn is_htmltableheadercellelement(&self) -> bool {
--- a/servo/components/script/dom/htmltablerowelement.rs
+++ b/servo/components/script/dom/htmltablerowelement.rs
@@ -9,17 +9,17 @@ use dom::bindings::js::{JSRef, Temporary
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{self, DOMString};
+use util::str::{self, DOMString};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableRowElement {
     htmlelement: HTMLElement,
     background_color: Cell<Option<RGBA>>,
 }
 
--- a/servo/components/script/dom/htmltablesectionelement.rs
+++ b/servo/components/script/dom/htmltablesectionelement.rs
@@ -9,17 +9,17 @@ use dom::bindings::js::{JSRef, Temporary
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
 use cssparser::RGBA;
-use servo_util::str::{self, DOMString};
+use util::str::{self, DOMString};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableSectionElement {
     htmlelement: HTMLElement,
     background_color: Cell<Option<RGBA>>,
 }
 
--- a/servo/components/script/dom/htmltemplateelement.rs
+++ b/servo/components/script/dom/htmltemplateelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLTemplateElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTemplateElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLTemplateElementDerived for EventTarget {
     fn is_htmltemplateelement(&self) -> bool {
--- a/servo/components/script/dom/htmltextareaelement.rs
+++ b/servo/components/script/dom/htmltextareaelement.rs
@@ -21,17 +21,17 @@ use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::htmlformelement::FormControl;
 use dom::keyboardevent::KeyboardEvent;
 use dom::node::{DisabledStateHelpers, Node, NodeHelpers, NodeDamage, NodeTypeId};
 use dom::node::{document_from_node};
 use textinput::{TextInput, Lines, KeyReaction};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use string_cache::Atom;
 
 use std::borrow::ToOwned;
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTextAreaElement {
     htmlelement: HTMLElement,
--- a/servo/components/script/dom/htmltimeelement.rs
+++ b/servo/components/script/dom/htmltimeelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLTimeElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLTimeElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTimeElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLTimeElementDerived for EventTarget {
     fn is_htmltimeelement(&self) -> bool {
--- a/servo/components/script/dom/htmltitleelement.rs
+++ b/servo/components/script/dom/htmltitleelement.rs
@@ -10,17 +10,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::{Document, DocumentHelpers};
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId};
 use dom::text::Text;
 use dom::virtualmethods::VirtualMethods;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTitleElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLTitleElementDerived for EventTarget {
     fn is_htmltitleelement(&self) -> bool {
--- a/servo/components/script/dom/htmltrackelement.rs
+++ b/servo/components/script/dom/htmltrackelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLTrackElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLTrackElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLTrackElement {
     htmlelement: HTMLElement,
 }
 
 impl HTMLTrackElementDerived for EventTarget {
     fn is_htmltrackelement(&self) -> bool {
--- a/servo/components/script/dom/htmlulistelement.rs
+++ b/servo/components/script/dom/htmlulistelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLUListElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLUListElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLUListElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLUListElementDerived for EventTarget {
     fn is_htmlulistelement(&self) -> bool {
--- a/servo/components/script/dom/htmlunknownelement.rs
+++ b/servo/components/script/dom/htmlunknownelement.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::HTMLUnknownElementBinding;
 use dom::bindings::codegen::InheritTypes::HTMLUnknownElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLUnknownElement {
     htmlelement: HTMLElement
 }
 
 impl HTMLUnknownElementDerived for EventTarget {
     fn is_htmlunknownelement(&self) -> bool {
--- a/servo/components/script/dom/htmlvideoelement.rs
+++ b/servo/components/script/dom/htmlvideoelement.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::HT
 use dom::bindings::codegen::InheritTypes::HTMLVideoElementDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::ElementTypeId;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::htmlelement::HTMLElementTypeId;
 use dom::htmlmediaelement::{HTMLMediaElement, HTMLMediaElementTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct HTMLVideoElement {
     htmlmediaelement: HTMLMediaElement
 }
 
 impl HTMLVideoElementDerived for EventTarget {
     fn is_htmlvideoelement(&self) -> bool {
--- a/servo/components/script/dom/keyboardevent.rs
+++ b/servo/components/script/dom/keyboardevent.rs
@@ -9,17 +9,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary, RootedReference};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::event::{Event, EventTypeId};
 use dom::uievent::UIEvent;
 use dom::window::Window;
 use servo_msg::constellation_msg;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 use std::cell::{RefCell, Cell};
 
 #[jstraceable]
 #[must_root]
 pub struct KeyboardEvent {
     uievent: UIEvent,
--- a/servo/components/script/dom/location.rs
+++ b/servo/components/script/dom/location.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::Lo
 use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::urlhelper::UrlHelper;
 use dom::window::Window;
 use page::Page;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::rc::Rc;
 
 #[dom_struct]
 pub struct Location {
     reflector_: Reflector,
     page: Rc<Page>,
 }
--- a/servo/components/script/dom/messageevent.rs
+++ b/servo/components/script/dom/messageevent.rs
@@ -8,17 +8,17 @@ use dom::bindings::codegen::Bindings::Me
 use dom::bindings::codegen::InheritTypes::{EventCast, MessageEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
 use dom::eventtarget::{EventTarget, EventTargetHelpers};
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use js::jsapi::JSContext;
 use js::jsval::{JSVal, UndefinedValue};
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct MessageEvent {
--- a/servo/components/script/dom/mouseevent.rs
+++ b/servo/components/script/dom/mouseevent.rs
@@ -9,17 +9,17 @@ use dom::bindings::codegen::InheritTypes
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
 use dom::eventtarget::EventTarget;
 use dom::uievent::UIEvent;
 use dom::window::Window;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use std::cell::Cell;
 use std::default::Default;
 
 #[dom_struct]
 pub struct MouseEvent {
     uievent: UIEvent,
     screen_x: Cell<i32>,
     screen_y: Cell<i32>,
--- a/servo/components/script/dom/navigator.rs
+++ b/servo/components/script/dom/navigator.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::codegen::Bindings::NavigatorBinding;
 use dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::navigatorinfo;
 use dom::window::Window;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct Navigator {
     reflector_: Reflector,
 }
 
 impl Navigator {
     fn new_inherited() -> Navigator {
--- a/servo/components/script/dom/navigatorinfo.rs
+++ b/servo/components/script/dom/navigatorinfo.rs
@@ -1,14 +1,14 @@
 /* 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 servo_util::str::DOMString;
-use servo_util::opts;
+use util::str::DOMString;
+use util::opts;
 
 use std::borrow::ToOwned;
 
 pub fn Product() -> DOMString {
     "Gecko".to_owned()
 }
 
 pub fn TaintEnabled() -> bool {
--- a/servo/components/script/dom/node.rs
+++ b/servo/components/script/dom/node.rs
@@ -41,18 +41,18 @@ use dom::nodelist::NodeList;
 use dom::processinginstruction::ProcessingInstruction;
 use dom::text::Text;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
 use dom::window::Window;
 use geom::rect::Rect;
 use layout_interface::{LayoutChan, Msg};
 use devtools_traits::NodeInfo;
 use script_traits::UntrustedNodeAddress;
-use servo_util::geometry::Au;
-use servo_util::str::{DOMString, null_str_as_empty};
+use util::geometry::Au;
+use util::str::{DOMString, null_str_as_empty};
 use style::{matches, SelectorList};
 
 use js::jsapi::{JSContext, JSObject, JSTracer, JSRuntime};
 use js::jsfriendapi;
 use core::nonzero::NonZero;
 use libc;
 use libc::{uintptr_t, c_void};
 use std::borrow::ToOwned;
--- a/servo/components/script/dom/processinginstruction.rs
+++ b/servo/components/script/dom/processinginstruction.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::ProcessingInstructionBinding;
 use dom::bindings::codegen::Bindings::ProcessingInstructionBinding::ProcessingInstructionMethods;
 use dom::bindings::codegen::InheritTypes::ProcessingInstructionDerived;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 /// An HTML processing instruction node.
 #[dom_struct]
 pub struct ProcessingInstruction {
     characterdata: CharacterData,
     target: DOMString,
 }
 
--- a/servo/components/script/dom/progressevent.rs
+++ b/servo/components/script/dom/progressevent.rs
@@ -6,17 +6,17 @@ use dom::bindings::codegen::Bindings::Ev
 use dom::bindings::codegen::Bindings::ProgressEventBinding;
 use dom::bindings::codegen::Bindings::ProgressEventBinding::ProgressEventMethods;
 use dom::bindings::codegen::InheritTypes::{EventCast, ProgressEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct ProgressEvent {
     event: Event,
     length_computable: bool,
     loaded: u64,
     total: u64
 }
--- a/servo/components/script/dom/servohtmlparser.rs
+++ b/servo/components/script/dom/servohtmlparser.rs
@@ -10,17 +10,17 @@ use dom::bindings::codegen::Bindings::Se
 use dom::bindings::global::GlobalRef;
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::node::TrustedNodeAddress;
 use dom::document::{Document, DocumentHelpers};
 use parse::Parser;
 
-use servo_util::task_state;
+use util::task_state;
 
 use std::default::Default;
 use url::Url;
 use js::jsapi::JSTracer;
 use html5ever::tokenizer;
 use html5ever::tree_builder;
 use html5ever::tree_builder::{TreeBuilder, TreeBuilderOpts};
 
--- a/servo/components/script/dom/storage.rs
+++ b/servo/components/script/dom/storage.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::bindings::error::Fallible;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 use servo_net::storage_task::StorageTask;
 use servo_net::storage_task::StorageTaskMsg;
 use std::sync::mpsc::channel;
 use url::Url;
 
 #[dom_struct]
 pub struct Storage {
     reflector_: Reflector,
--- a/servo/components/script/dom/testbinding.rs
+++ b/servo/components/script/dom/testbinding.rs
@@ -12,17 +12,17 @@ use dom::bindings::codegen::UnionTypes::
 use dom::bindings::codegen::UnionTypes::EventOrString::eString;
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::eLong;
 use dom::bindings::global::GlobalField;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflector, Reflectable};
 use dom::blob::Blob;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use js::jsapi::{JSContext, JSObject};
 use js::jsval::{JSVal, NullValue};
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct TestBinding {
--- a/servo/components/script/dom/text.rs
+++ b/servo/components/script/dom/text.rs
@@ -7,17 +7,17 @@ use dom::bindings::codegen::Bindings::Wi
 use dom::bindings::codegen::InheritTypes::TextDerived;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::node::{Node, NodeTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 /// An HTML text node.
 #[dom_struct]
 pub struct Text {
     characterdata: CharacterData,
 }
 
 impl TextDerived for EventTarget {
--- a/servo/components/script/dom/uievent.rs
+++ b/servo/components/script/dom/uievent.rs
@@ -8,17 +8,17 @@ use dom::bindings::codegen::Bindings::UI
 use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary};
 
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
 use dom::window::Window;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::cell::Cell;
 use std::default::Default;
 
 #[dom_struct]
 pub struct UIEvent {
     event: Event,
     view: MutNullableJS<Window>,
--- a/servo/components/script/dom/urlhelper.rs
+++ b/servo/components/script/dom/urlhelper.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 servo_util::str::DOMString;
+use util::str::DOMString;
 use url::Url;
 
 use std::borrow::ToOwned;
 
 pub struct UrlHelper;
 
 impl UrlHelper {
     pub fn Href(url: &Url) -> DOMString {
--- a/servo/components/script/dom/urlsearchparams.rs
+++ b/servo/components/script/dom/urlsearchparams.rs
@@ -7,17 +7,17 @@ use dom::bindings::codegen::Bindings::UR
 use dom::bindings::codegen::Bindings::URLSearchParamsBinding::URLSearchParamsMethods;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eURLSearchParams, eString};
 use dom::bindings::error::{Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use encoding::all::UTF_8;
 use encoding::types::{EncodingRef, EncoderTrap};
 
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::fmt::radix;
 use std::ascii::OwnedAsciiExt;
--- a/servo/components/script/dom/virtualmethods.rs
+++ b/servo/components/script/dom/virtualmethods.rs
@@ -52,17 +52,17 @@ use dom::htmlstyleelement::HTMLStyleElem
 use dom::htmltableelement::HTMLTableElement;
 use dom::htmltablecellelement::HTMLTableCellElement;
 use dom::htmltablerowelement::HTMLTableRowElement;
 use dom::htmltablesectionelement::HTMLTableSectionElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::htmltitleelement::HTMLTitleElement;
 use dom::node::{Node, NodeHelpers, NodeTypeId, CloneChildrenFlag};
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use string_cache::Atom;
 
 /// Trait to allow DOM nodes to opt-in to overriding (or adding to) common
 /// behaviours. Replicates the effect of C++ virtual methods.
 pub trait VirtualMethods {
     /// Returns self as the superclass of the implementation for this trait,
     /// if any.
--- a/servo/components/script/dom/websocket.rs
+++ b/servo/components/script/dom/websocket.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::codegen::Bindings::WebSocketBinding;
 use dom::bindings::codegen::Bindings::WebSocketBinding::WebSocketMethods;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Temporary, JSRef};
 use dom::bindings::utils::reflect_dom_object;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct WebSocket {
     eventtarget: EventTarget,
     url: DOMString
 }
 
 impl WebSocket {
--- a/servo/components/script/dom/window.rs
+++ b/servo/components/script/dom/window.rs
@@ -29,17 +29,17 @@ use script_task::{TimerSource, ScriptCha
 use script_task::ScriptMsg;
 use script_traits::ScriptControlChan;
 use timers::{IsInterval, TimerId, TimerManager, TimerCallback};
 
 use servo_msg::compositor_msg::ScriptListener;
 use servo_msg::constellation_msg::LoadData;
 use servo_net::image_cache_task::ImageCacheTask;
 use servo_net::storage_task::StorageTask;
-use servo_util::str::{DOMString,HTML_SPACE_CHARACTERS};
+use util::str::{DOMString,HTML_SPACE_CHARACTERS};
 
 use js::jsapi::JS_EvaluateUCScript;
 use js::jsapi::JSContext;
 use js::jsapi::{JS_GC, JS_GetRuntime};
 use js::jsval::{JSVal, UndefinedValue};
 use js::rust::with_compartment;
 use url::{Url, UrlParser};
 
--- a/servo/components/script/dom/worker.rs
+++ b/servo/components/script/dom/worker.rs
@@ -14,17 +14,17 @@ use dom::bindings::refcounted::Trusted;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::bindings::trace::JSTraceable;
 use dom::bindings::utils::{Reflectable, reflect_dom_object};
 use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
 use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::messageevent::MessageEvent;
 use script_task::{ScriptChan, ScriptMsg, Runnable};
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use js::jsapi::JSContext;
 use js::jsval::JSVal;
 use url::UrlParser;
 
 use std::cell::Cell;
 use std::sync::mpsc::{channel, Sender};
 
--- a/servo/components/script/dom/workerglobalscope.rs
+++ b/servo/components/script/dom/workerglobalscope.rs
@@ -15,17 +15,17 @@ use dom::dedicatedworkerglobalscope::{De
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::workerlocation::WorkerLocation;
 use dom::workernavigator::WorkerNavigator;
 use dom::window::{base64_atob, base64_btoa};
 use script_task::{ScriptChan, TimerSource};
 use timers::{IsInterval, TimerId, TimerManager, TimerCallback};
 
 use servo_net::resource_task::{ResourceTask, load_whole_resource};
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use js::jsapi::JSContext;
 use js::jsval::JSVal;
 use js::rust::Cx;
 
 use std::default::Default;
 use std::rc::Rc;
 use url::{Url, UrlParser};
--- a/servo/components/script/dom/workerlocation.rs
+++ b/servo/components/script/dom/workerlocation.rs
@@ -5,17 +5,17 @@
 use dom::bindings::codegen::Bindings::WorkerLocationBinding;
 use dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocationMethods;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::urlhelper::UrlHelper;
 use dom::workerglobalscope::WorkerGlobalScope;
 
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use url::Url;
 
 #[dom_struct]
 pub struct WorkerLocation {
     reflector_: Reflector,
     url: Url,
 }
--- a/servo/components/script/dom/workernavigator.rs
+++ b/servo/components/script/dom/workernavigator.rs
@@ -4,17 +4,17 @@
 
 use dom::bindings::codegen::Bindings::WorkerNavigatorBinding;
 use dom::bindings::codegen::Bindings::WorkerNavigatorBinding::WorkerNavigatorMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::navigatorinfo;
 use dom::workerglobalscope::WorkerGlobalScope;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 #[dom_struct]
 pub struct WorkerNavigator {
     reflector_: Reflector,
 }
 
 impl WorkerNavigator {
     fn new_inherited() -> WorkerNavigator {
--- a/servo/components/script/dom/xmlhttprequest.rs
+++ b/servo/components/script/dom/xmlhttprequest.rs
@@ -42,18 +42,18 @@ use hyper::method::Method;
 use js::jsapi::{JS_ParseJSON, JSContext};
 use js::jsapi::JS_ClearPendingException;
 use js::jsval::{JSVal, NullValue, UndefinedValue};
 
 use net::resource_task::{ResourceTask, ResourceCORSData, LoadData, LoadResponse};
 use net::resource_task::ControlMsg::Load;
 use net::resource_task::ProgressMsg::{Payload, Done};
 use cors::{allow_cross_origin_request, CORSRequest, RequestMode};
-use servo_util::str::DOMString;
-use servo_util::task::spawn_named;
+use util::str::DOMString;
+use util::task::spawn_named;
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::sync::mpsc::{Sender, Receiver, channel};
 use std::default::Default;
 use std::io::Timer;
 use std::str::FromStr;
--- a/servo/components/script/layout_interface.rs
+++ b/servo/components/script/layout_interface.rs
@@ -7,17 +7,17 @@
 /// from layout.
 
 use dom::node::LayoutDataRef;
 
 use geom::point::Point2D;
 use geom::rect::Rect;
 use script_traits::{ScriptControlChan, OpaqueScriptLayoutChannel, UntrustedNodeAddress};
 use servo_msg::constellation_msg::{PipelineExitType, WindowSizeData};
-use servo_util::geometry::Au;
+use util::geometry::Au;
 use std::any::Any;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::boxed::BoxAny;
 use style::Stylesheet;
 use url::Url;
 
 pub use dom::node::TrustedNodeAddress;
 
--- a/servo/components/script/lib.rs
+++ b/servo/components/script/lib.rs
@@ -31,17 +31,17 @@ extern crate msg;
 extern crate net;
 extern crate serialize;
 extern crate time;
 extern crate canvas;
 extern crate script_traits;
 #[no_link] #[plugin] #[macro_use]
 extern crate "plugins" as servo_plugins;
 extern crate "net" as servo_net;
-extern crate "util" as servo_util;
+extern crate util;
 #[macro_use]
 extern crate style;
 extern crate "msg" as servo_msg;
 extern crate url;
 extern crate uuid;
 extern crate string_cache;
 #[no_link] #[macro_use] #[plugin]
 extern crate string_cache_macros;
--- a/servo/components/script/page.rs
+++ b/servo/components/script/page.rs
@@ -21,20 +21,20 @@ use script_traits::{UntrustedNodeAddress
 
 use geom::{Point2D, Rect, Size2D};
 use js::rust::Cx;
 use servo_msg::compositor_msg::ScriptListener;
 use servo_msg::constellation_msg::{ConstellationChan, WindowSizeData};
 use servo_msg::constellation_msg::{PipelineId, SubpageId};
 use servo_net::resource_task::ResourceTask;
 use servo_net::storage_task::StorageTask;
-use servo_util::geometry::{Au, MAX_RECT};
-use servo_util::geometry;
-use servo_util::str::DOMString;
-use servo_util::smallvec::SmallVec;
+use util::geometry::{Au, MAX_RECT};
+use util::geometry;
+use util::str::DOMString;
+use util::smallvec::SmallVec;
 use std::cell::{Cell, Ref, RefMut};
 use std::sync::mpsc::{channel, Receiver};
 use std::sync::mpsc::TryRecvError::{Empty, Disconnected};
 use std::mem::replace;
 use std::num::Float;
 use std::rc::Rc;
 use url::Url;
 
--- a/servo/components/script/parse/html.rs
+++ b/servo/components/script/parse/html.rs
@@ -19,18 +19,18 @@ use dom::servohtmlparser;
 use dom::servohtmlparser::ServoHTMLParser;
 use dom::text::Text;
 use parse::Parser;
 
 use encoding::all::UTF_8;
 use encoding::types::{Encoding, DecoderTrap};
 
 use servo_net::resource_task::{ProgressMsg, LoadResponse};
-use servo_util::task_state;
-use servo_util::task_state::IN_HTML_PARSER;
+use util::task_state;
+use util::task_state::IN_HTML_PARSER;
 use std::ascii::AsciiExt;
 use std::string::CowString;
 use url::Url;
 use html5ever::Attribute;
 use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText};
 use string_cache::QualName;
 
 pub enum HTMLInput {
--- a/servo/components/script/script_task.rs
+++ b/servo/components/script/script_task.rs
@@ -56,20 +56,20 @@ use servo_msg::constellation_msg::{LoadD
 use servo_msg::constellation_msg::{Failure, Msg, WindowSizeData, Key, KeyState};
 use servo_msg::constellation_msg::{KeyModifiers, SUPER, SHIFT, CONTROL, ALT};
 use servo_msg::constellation_msg::{PipelineExitType};
 use servo_msg::constellation_msg::Msg as ConstellationMsg;
 use servo_net::image_cache_task::ImageCacheTask;
 use servo_net::resource_task::{ResourceTask, ControlMsg};
 use servo_net::resource_task::LoadData as NetLoadData;
 use servo_net::storage_task::StorageTask;
-use servo_util::geometry::to_frac_px;
-use servo_util::smallvec::SmallVec;
-use servo_util::task::spawn_named_with_send_on_failure;
-use servo_util::task_state;
+use util::geometry::to_frac_px;
+use util::smallvec::SmallVec;
+use util::task::spawn_named_with_send_on_failure;
+use util::task_state;
 
 use geom::point::Point2D;
 use hyper::header::{Header, HeaderFormat};
 use hyper::header::shared::util as header_util;
 use js::jsapi::{JS_SetWrapObjectCallbacks, JS_SetGCZeal, JS_DEFAULT_ZEAL_FREQ, JS_GC};
 use js::jsapi::{JSContext, JSRuntime, JSObject};
 use js::jsapi::{JS_SetGCParameter, JSGC_MAX_BYTES};
 use js::jsapi::{JS_SetGCCallback, JSGCStatus, JSGC_BEGIN, JSGC_END};
--- a/servo/components/script/textinput.rs
+++ b/servo/components/script/textinput.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/. */
 
 //! Common handling of keyboard input and state management for text input controls
 
 use dom::bindings::codegen::Bindings::KeyboardEventBinding::KeyboardEventMethods;
 use dom::bindings::js::JSRef;
 use dom::keyboardevent::KeyboardEvent;
-use servo_util::str::DOMString;
+use util::str::DOMString;
 
 use std::borrow::ToOwned;
 use std::cmp::{min, max};
 use std::default::Default;
 use std::num::SignedInt;
 
 #[derive(Copy, PartialEq)]
 enum Selection {
--- a/servo/components/script/timers.rs
+++ b/servo/components/script/timers.rs
@@ -7,18 +7,18 @@ use dom::bindings::callback::ExceptionHa
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::js::JSRef;
 use dom::bindings::utils::Reflectable;
 
 use dom::window::ScriptHelpers;
 
 use script_task::{ScriptChan, ScriptMsg, TimerSource};
 
-use servo_util::task::spawn_named;
-use servo_util::str::DOMString;
+use util::task::spawn_named;
+use util::str::DOMString;
 
 use js::jsval::JSVal;
 
 use std::borrow::ToOwned;
 use std::cell::Cell;
 use std::cmp;
 use std::collections::HashMap;
 use std::sync::mpsc::{channel, Sender};
--- a/servo/components/script_traits/lib.rs
+++ b/servo/components/script_traits/lib.rs
@@ -9,17 +9,17 @@
 #![allow(missing_copy_implementations)]
 #![allow(unstable)]
 
 extern crate devtools_traits;
 extern crate geom;
 extern crate libc;
 extern crate "msg" as servo_msg;
 extern crate "net" as servo_net;
-extern crate "util" as servo_util;
+extern crate util;
 extern crate url;
 extern crate serialize;
 
 // This module contains traits in script used generically
 //   in the rest of Servo.
 // The traits are here instead of in script so
 //   that these modules won't have to depend on script.
 
@@ -27,17 +27,17 @@ use devtools_traits::DevtoolsControlChan
 use libc::c_void;
 use servo_msg::constellation_msg::{ConstellationChan, PipelineId, Failure, WindowSizeData};
 use servo_msg::constellation_msg::{LoadData, SubpageId, Key, KeyState, KeyModifiers};
 use servo_msg::constellation_msg::PipelineExitType;
 use servo_msg::compositor_msg::ScriptListener;
 use servo_net::image_cache_task::ImageCacheTask;
 use servo_net::resource_task::ResourceTask;
 use servo_net::storage_task::StorageTask;
-use servo_util::smallvec::SmallVec1;
+use util::smallvec::SmallVec1;
 use std::any::Any;
 use std::sync::mpsc::{Sender, Receiver};
 
 use geom::point::Point2D;
 use geom::rect::Rect;
 
 /// The address of a node. Layout sends these back. They must be validated via
 /// `from_untrusted_node_address` before they can be used, because we do not trust layout.
--- a/servo/components/servo/lib.rs
+++ b/servo/components/servo/lib.rs
@@ -12,17 +12,17 @@
 #[macro_use]
 extern crate log;
 
 extern crate compositing;
 extern crate devtools;
 extern crate "net" as servo_net;
 extern crate "msg" as servo_msg;
 #[macro_use]
-extern crate "util" as servo_util;
+extern crate util;
 extern crate script;
 extern crate layout;
 extern crate gfx;
 extern crate libc;
 extern crate url;
 
 use compositing::CompositorEventListener;
 use compositing::windowing::{WindowEvent, WindowMethods};
@@ -40,23 +40,23 @@ use script::dom::bindings::codegen::Regi
 use servo_net::image_cache_task::ImageCacheTask;
 #[cfg(not(test))]
 use servo_net::resource_task::new_resource_task;
 #[cfg(not(test))]
 use servo_net::storage_task::{StorageTaskFactory, StorageTask};
 #[cfg(not(test))]
 use gfx::font_cache_task::FontCacheTask;
 #[cfg(not(test))]
-use servo_util::time::TimeProfiler;
+use util::time::TimeProfiler;
 #[cfg(not(test))]
-use servo_util::memory::MemoryProfiler;
+use util::memory::MemoryProfiler;
 #[cfg(not(test))]
-use servo_util::opts;
+use util::opts;
 #[cfg(not(test))]
-use servo_util::taskpool::TaskPool;
+use util::taskpool::TaskPool;
 
 #[cfg(not(test))]
 use std::os;
 #[cfg(not(test))]
 use std::rc::Rc;
 #[cfg(not(test))]
 use std::sync::mpsc::channel;
 #[cfg(not(test))]
@@ -64,17 +64,17 @@ use std::thread::Builder;
 
 pub struct Browser<Window> {
     compositor: Box<CompositorEventListener + 'static>,
 }
 
 impl<Window> Browser<Window> where Window: WindowMethods + 'static {
     #[cfg(not(test))]
     pub fn new(window: Option<Rc<Window>>) -> Browser<Window> {
-        ::servo_util::opts::set_experimental_enabled(opts::get().enable_experimental);
+        ::util::opts::set_experimental_enabled(opts::get().enable_experimental);
         let opts = opts::get();
         RegisterBindings::RegisterProxyHandlers();
 
         let shared_task_pool = TaskPool::new(8);
 
         let (compositor_proxy, compositor_receiver) =
             WindowMethods::create_compositor_channel(&window);
         let time_profiler_chan = TimeProfiler::create(opts.time_profiler_period);
--- a/servo/components/servo/main.rs
+++ b/servo/components/servo/main.rs
@@ -6,17 +6,17 @@
 #![deny(unused_variables)]
 #![allow(unstable)]
 
 #[cfg(target_os="android")]
 extern crate libc;
 
 extern crate servo;
 extern crate time;
-extern crate "util" as servo_util;
+extern crate util;
 
 #[cfg(all(feature = "glutin_app",not(test)))]
 extern crate "glutin_app" as app;
 #[cfg(all(feature = "glfw",not(test)))]
 extern crate "glfw_app" as app;
 
 #[cfg(not(test))]
 extern crate compositing;
@@ -24,17 +24,17 @@ extern crate compositing;
 #[cfg(target_os="android")]
 #[macro_use]
 extern crate android_glue;
 
 #[cfg(target_os="android")]
 use libc::c_int;
 
 #[cfg(not(test))]
-use servo_util::opts;
+use util::opts;
 
 #[cfg(not(test))]
 use servo::Browser;
 #[cfg(not(test))]
 use compositing::windowing::WindowEvent;
 
 #[cfg(target_os="android")]
 use std::borrow::ToOwned;
@@ -69,17 +69,17 @@ struct FilePtr(*mut libc::types::common:
 #[cfg(target_os="android")]
 unsafe impl Send for FilePtr {}
 
 #[cfg(target_os="android")]
 fn redirect_output(file_no: c_int) {
     use libc::funcs::posix88::unistd::{pipe, dup2};
     use libc::funcs::posix88::stdio::fdopen;
     use libc::funcs::c95::stdio::fgets;
-    use servo_util::task::spawn_named;
+    use util::task::spawn_named;
     use std::mem;
     use std::ffi::CString;
     use std::str::from_utf8;
 
     unsafe {
         let mut pipes: [c_int; 2] = [ 0, 0 ];
         pipe(pipes.as_mut_ptr());
         dup2(pipes[1], file_no);
--- a/servo/components/style/legacy.rs
+++ b/servo/components/style/legacy.rs
@@ -8,19 +8,19 @@
 use node::{TElement, TElementAttributes, TNode};
 use values::specified::CSSColor;
 use values::{CSSFloat, specified};
 use properties::DeclaredValue::SpecifiedValue;
 use properties::PropertyDeclaration;
 use selector_matching::{DeclarationBlock, Stylist};
 
 use cssparser::Color;
-use servo_util::geometry::Au;
-use servo_util::smallvec::VecLike;
-use servo_util::str::LengthOrPercentageOrAuto;
+use util::geometry::Au;
+use util::smallvec::VecLike;
+use util::str::LengthOrPercentageOrAuto;
 
 /// Legacy presentational attributes that take a length as defined in HTML5 § 2.4.4.4.
 #[derive(Copy, PartialEq, Eq)]
 pub enum LengthAttribute {
     /// `<td width>`
     Width,
 }
 
--- a/servo/components/style/lib.rs
+++ b/servo/components/style/lib.rs
@@ -27,17 +27,17 @@ extern crate cssparser;
 extern crate matches;
 
 extern crate encoding;
 extern crate string_cache;
 
 #[macro_use]
 extern crate lazy_static;
 
-extern crate "util" as servo_util;
+extern crate util;
 
 
 pub use media_queries::{Device, MediaType};
 pub use stylesheets::{Stylesheet, iter_font_face_rules};
 pub use selector_matching::{Stylist};
 pub use selector_matching::{DeclarationBlock, CommonStyleAffectingAttributes};
 pub use selector_matching::{CommonStyleAffectingAttributeInfo, CommonStyleAffectingAttributeMode};
 pub use selector_matching::{matches, matches_simple_selector, common_style_affecting_attributes};
--- a/servo/components/style/media_queries.rs
+++ b/servo/components/style/media_queries.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/. */
 
 use std::ascii::AsciiExt;
 use cssparser::{Token, Parser, Delimiter};
 
 use geom::size::TypedSize2D;
 use properties::longhands;
-use servo_util::geometry::{Au, ViewportPx};
+use util::geometry::{Au, ViewportPx};
 use values::{computed, specified};
 
 
 #[derive(Show, PartialEq)]
 pub struct MediaQueryList {
     media_queries: Vec<MediaQuery>
 }
 
@@ -210,17 +210,17 @@ impl MediaQueryList {
             }
         })
     }
 }
 
 #[cfg(test)]
 mod tests {
     use geom::size::TypedSize2D;
-    use servo_util::geometry::Au;
+    use util::geometry::Au;
     use stylesheets::{iter_stylesheet_media_rules, iter_stylesheet_style_rules, Stylesheet};
     use stylesheets::Origin;
     use super::*;
     use url::Url;
     use std::borrow::ToOwned;
 
     fn test_media_rule<F>(css: &str, callback: F) where F: Fn(&MediaQueryList, &str) {
         let url = Url::parse("http://localhost").unwrap();
--- a/servo/components/style/node.rs
+++ b/servo/components/style/node.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! Traits that nodes must implement. Breaks the otherwise-cyclic dependency between layout and
 //! style.
 
 use cssparser::RGBA;
 use legacy::{IntegerAttribute, LengthAttribute, SimpleColorAttribute, UnsignedIntegerAttribute};
 use selectors::AttrSelector;
-use servo_util::str::LengthOrPercentageOrAuto;
+use util::str::LengthOrPercentageOrAuto;
 use string_cache::{Atom, Namespace};
 
 pub trait TNode<'a, E: TElement<'a>> : Clone + Copy {
     fn parent_node(self) -> Option<Self>;
     fn first_child(self) -> Option<Self>;
     fn last_child(self) -> Option<Self>;
     fn prev_sibling(self) -> Option<Self>;
     fn next_sibling(self) -> Option<Self>;
--- a/servo/components/style/properties/mod.rs.mako
+++ b/servo/components/style/properties/mod.rs.mako
@@ -5,18 +5,18 @@
 // This file is a Mako template: http://www.makotemplates.org/
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
 use std::fmt;
 use std::fmt::Show;
 use std::sync::Arc;
 
-use servo_util::logical_geometry::{WritingMode, LogicalMargin};
-use servo_util::geometry::Au;
+use util::logical_geometry::{WritingMode, LogicalMargin};
+use util::geometry::Au;
 use url::Url;
 use cssparser::{Parser, Color, RGBA, AtRuleParser, DeclarationParser,
                 DeclarationListParser, parse_important};
 use geom::SideOffsets2D;
 
 use values::specified::BorderStyle;
 use values::computed;
 use selector_matching::DeclarationBlock;
@@ -178,17 +178,17 @@ pub mod longhands {
             // The computed value is the same as the specified value.
             pub use super::computed_as_specified as to_computed_value;
         </%self:single_keyword_computed>
     </%def>
 
     <%def name="predefined_type(name, type, initial_value, parse_method='parse')">
         <%self:longhand name="${name}">
             #[allow(unused_imports)]
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             pub use values::computed::compute_${type} as to_computed_value;
             pub type SpecifiedValue = specified::${type};
             pub mod computed_value {
                 pub use values::computed::${type} as T;
             }
             #[inline] pub fn get_initial_value() -> computed_value::T { ${initial_value} }
             #[inline] pub fn parse(_context: &ParserContext, input: &mut Parser)
                                    -> Result<SpecifiedValue, ()> {
@@ -222,25 +222,25 @@ pub mod longhands {
     % endfor
 
     % for side in ["top", "right", "bottom", "left"]:
         ${predefined_type("border-%s-style" % side, "BorderStyle", "computed::BorderStyle::none")}
     % endfor
 
     % for side in ["top", "right", "bottom", "left"]:
         <%self:longhand name="border-${side}-width">
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             #[inline]
             pub fn parse(_context: &ParserContext, input: &mut Parser)
                                    -> Result<SpecifiedValue, ()> {
                 specified::parse_border_width(input)
             }
             pub type SpecifiedValue = specified::Length;
             pub mod computed_value {
-                use servo_util::geometry::Au;
+                use util::geometry::Au;
                 pub type T = Au;
             }
             #[inline] pub fn get_initial_value() -> computed_value::T {
                 Au::from_px(3)  // medium
             }
             #[inline]
             pub fn to_computed_value(value: SpecifiedValue, context: &computed::Context)
                                   -> computed_value::T {
@@ -280,17 +280,17 @@ pub mod longhands {
         }
     </%self:longhand>
 
     <%self:longhand name="outline-width">
         pub use super::border_top_width::{get_initial_value, parse};
         pub use values::computed::compute_Au as to_computed_value;
         pub type SpecifiedValue = super::border_top_width::SpecifiedValue;
         pub mod computed_value {
-            pub use servo_util::geometry::Au as T;
+            pub use util::geometry::Au as T;
         }
     </%self:longhand>
 
     ${predefined_type("outline-offset", "Length", "Au(0)")}
 
     ${new_style_struct("PositionOffsets", is_inherited=False)}
 
     % for side in ["top", "right", "bottom", "left"]:
@@ -486,17 +486,17 @@ pub mod longhands {
                 Token::Ident(ref value) if value.as_slice().eq_ignore_ascii_case("normal") => {
                     Ok(SpecifiedValue::Normal)
                 }
                 _ => Err(()),
             }
         }
         pub mod computed_value {
             use values::CSSFloat;
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             use std::fmt;
             #[derive(PartialEq, Copy, Clone)]
             pub enum T {
                 Normal,
                 Length(Au),
                 Number(CSSFloat),
             }
             impl fmt::Show for T {
@@ -568,17 +568,17 @@ pub mod longhands {
                         "${keyword}" => Ok(SpecifiedValue::${to_rust_ident(keyword)})
                     % endfor
                     _ => Err(())
                 }
             })
         }
         pub mod computed_value {
             use values::CSSFloat;
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             use std::fmt;
             #[allow(non_camel_case_types)]
             #[derive(PartialEq, Copy, Clone)]
             pub enum T {
                 % for keyword in vertical_align_keywords:
                     ${to_rust_ident(keyword)},
                 % endfor
                 Length(Au),
@@ -1101,20 +1101,20 @@ pub mod longhands {
                     computed_value::T::Weight800 => computed_value::T::Weight700,
                     computed_value::T::Weight900 => computed_value::T::Weight700,
                 },
             }
         }
     </%self:longhand>
 
     <%self:longhand name="font-size">
-        use servo_util::geometry::Au;
+        use util::geometry::Au;
         pub type SpecifiedValue = specified::Length;  // Percentages are the same as em.
         pub mod computed_value {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             pub type T = Au;
         }
         const MEDIUM_PX: int = 16;
         #[inline] pub fn get_initial_value() -> computed_value::T {
             Au::from_px(MEDIUM_PX)
         }
         #[inline]
         pub fn to_computed_value(_value: SpecifiedValue, context: &computed::Context)
@@ -1157,17 +1157,17 @@ pub mod longhands {
     ${new_style_struct("InheritedText", is_inherited=True)}
 
     // TODO: initial value should be 'start' (CSS Text Level 3, direction-dependent.)
     ${single_keyword("text-align", "left right center justify")}
 
     <%self:longhand name="letter-spacing">
         pub type SpecifiedValue = Option<specified::Length>;
         pub mod computed_value {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             pub type T = Option<Au>;
         }
         #[inline]
         pub fn get_initial_value() -> computed_value::T {
             None
         }
         #[inline]
         pub fn to_computed_value(value: SpecifiedValue, context: &computed::Context)
@@ -1181,17 +1181,17 @@ pub mod longhands {
                 specified::Length::parse_non_negative(input).map(Some)
             }
         }
     </%self:longhand>
 
     <%self:longhand name="word-spacing">
         pub type SpecifiedValue = Option<specified::Length>;
         pub mod computed_value {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             pub type T = Option<Au>;
         }
         #[inline]
         pub fn get_initial_value() -> computed_value::T {
             None
         }
         #[inline]
         pub fn to_computed_value(value: SpecifiedValue, context: &computed::Context)
@@ -1405,22 +1405,22 @@ pub mod longhands {
     // http://dev.w3.org/csswg/css-ui/
     ${switch_to_style_struct("Box")}
 
     ${single_keyword("box-sizing", "content-box border-box")}
 
     ${new_style_struct("Pointing", is_inherited=True)}
 
     <%self:longhand name="cursor">
-        use servo_util::cursor as util_cursor;
+        use util::cursor as util_cursor;
         pub use super::computed_as_specified as to_computed_value;
         pub use self::computed_value::T as SpecifiedValue;
 
         pub mod computed_value {
-            use servo_util::cursor::Cursor;
+            use util::cursor::Cursor;
             #[derive(Clone, PartialEq, Eq, Copy, Show)]
             pub enum T {
                 AutoCursor,
                 SpecifiedCursor(Cursor),
             }
         }
         #[inline]
         pub fn get_initial_value() -> computed_value::T {
@@ -1499,17 +1499,17 @@ pub mod longhands {
                 if let Some(ref color) = self.color {
                     let _ = write!(f, "{:?}", color);
                 }
                 Ok(())
             }
         }
 
         pub mod computed_value {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             use values::computed;
             use std::fmt;
 
             pub type T = Vec<BoxShadow>;
 
             #[derive(Clone, PartialEq, Copy)]
             pub struct BoxShadow {
                 pub offset_x: Au,
@@ -1560,17 +1560,17 @@ pub mod longhands {
                 color: value.color
                             .map(|color| color.parsed)
                             .unwrap_or(cssparser::Color::CurrentColor),
                 inset: value.inset,
             }
         }
 
         pub fn parse_one_box_shadow(input: &mut Parser) -> Result<SpecifiedBoxShadow, ()> {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             let mut lengths = [specified::Length::Au(Au(0)); 4];
             let mut lengths_parsed = false;
             let mut color = None;
             let mut inset = false;
 
             loop {
                 if !inset {
                     if input.try(|input| input.expect_ident_matching("inset")).is_ok() {
@@ -1624,17 +1624,17 @@ pub mod longhands {
             })
         }
     </%self:longhand>
 
     <%self:longhand name="clip">
         // NB: `top` and `left` are 0 if `auto` per CSS 2.1 11.1.2.
 
         pub mod computed_value {
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
 
             #[derive(Clone, PartialEq, Eq, Copy, Show)]
             pub struct ClipRect {
                 pub top: Au,
                 pub right: Option<Au>,
                 pub bottom: Option<Au>,
                 pub left: Au,
             }
@@ -1664,17 +1664,17 @@ pub mod longhands {
                 right: value.right.map(|right| computed::compute_Au(right, context)),
                 bottom: value.bottom.map(|bottom| computed::compute_Au(bottom, context)),
                 left: computed::compute_Au(value.left, context),
             })
         }
 
         pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
             use std::ascii::AsciiExt;
-            use servo_util::geometry::Au;
+            use util::geometry::Au;
             use values::specified::Length;
 
             if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
                 return Ok(None)
             }
             if !try!(input.expect_function()).eq_ignore_ascii_case("rect") {
                 return Err(())
             }
@@ -2026,17 +2026,17 @@ pub mod shorthands {
             % endfor
         })
     </%self:shorthand>
 
     <%self:shorthand name="border-radius" sub_properties="${' '.join(
         'border-%s-radius' % (corner)
          for corner in ['top-left', 'top-right', 'bottom-right', 'bottom-left']
     )}">
-        use servo_util::geometry::Au;
+        use util::geometry::Au;
         use values::specified::{Length, LengthOrPercentage};
         let _ignored = context;
 
         fn parse_one_set_of_border_radii(mut input: &mut Parser)
                                          -> Result<[LengthOrPercentage; 4], ()> {
             let mut count = 0;
             let mut values = [LengthOrPercentage::Length(Length::Au(Au(0))); 4];
             while count < 4 {
@@ -2498,17 +2498,17 @@ impl PropertyDeclaration {
 
     pub fn parse(name: &str, context: &ParserContext, input: &mut Parser,
                  result_list: &mut Vec<PropertyDeclaration>) -> PropertyDeclarationParseResult {
         match_ignore_ascii_case! { name,
             % for property in LONGHANDS:
                 % if property.derived_from is None:
                     "${property.name}" => {
                         % if property.experimental:
-                            if !::servo_util::opts::experimental_enabled() {
+                            if !::util::opts::experimental_enabled() {
                                 return PropertyDeclarationParseResult::ExperimentalProperty
                             }
                         % endif
                         match longhands::${property.ident}::parse_declared(context, input) {
                             Ok(value) => {
                                 result_list.push(PropertyDeclaration::${property.camel_case}(value));
                                 PropertyDeclarationParseResult::ValidOrIgnoredDeclaration
                             },
@@ -2711,17 +2711,17 @@ impl ComputedValues {
             &*self.${style_struct.ident}
         }
     % endfor
 }
 
 
 /// Return a WritingMode bitflags from the relevant CSS properties.
 fn get_writing_mode(inheritedbox_style: &style_structs::InheritedBox) -> WritingMode {
-    use servo_util::logical_geometry;
+    use util::logical_geometry;
     let mut flags = WritingMode::empty();
     match inheritedbox_style.direction {
         computed_values::direction::T::ltr => {},
         computed_values::direction::T::rtl => {
             flags.insert(logical_geometry::FLAG_RTL);
         },
     }
     match inheritedbox_style.writing_mode {
--- a/servo/components/style/selector_matching.rs
+++ b/servo/components/style/selector_matching.rs
@@ -5,20 +5,20 @@
 use std::ascii::AsciiExt;
 use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::sync::Arc;
 
 use url::Url;
 
-use servo_util::bloom::BloomFilter;
-use servo_util::resource_files::read_resource_file;
-use servo_util::smallvec::VecLike;
-use servo_util::sort;
+use util::bloom::BloomFilter;
+use util::resource_files::read_resource_file;
+use util::smallvec::VecLike;
+use util::sort;
 use string_cache::Atom;
 
 use legacy::PresentationalHintSynthesis;
 use media_queries::Device;
 use node::{TElement, TElementAttributes, TNode};
 use properties::{PropertyDeclaration, PropertyDeclarationBlock};
 use selectors::{CaseSensitivity, Combinator, CompoundSelector, LocalName};
 use selectors::{PseudoElement, SelectorList, SimpleSelector};
--- a/servo/components/style/values.rs
+++ b/servo/components/style/values.rs
@@ -51,17 +51,17 @@ pub mod specified {
     use std::ascii::AsciiExt;
     use std::f64::consts::PI;
     use std::fmt;
     use std::fmt::{Formatter, Show};
     use url::Url;
     use cssparser::{self, Token, Parser, ToCss, CssStringWriter};
     use parser::ParserContext;
     use text_writer::{self, TextWriter};
-    use servo_util::geometry::Au;
+    use util::geometry::Au;
     use super::CSSFloat;
     use super::computed;
 
     #[derive(Clone, PartialEq)]
     pub struct CSSColor {
         pub parsed: cssparser::Color,
         pub authored: Option<String>,
     }
@@ -670,17 +670,17 @@ pub mod specified {
 pub mod computed {
     pub use super::specified::BorderStyle;
     use super::specified::{AngleOrCorner};
     use super::{specified, CSSFloat};
     pub use cssparser::Color as CSSColor;
     use properties::longhands;
     use std::fmt;
     use url::Url;
-    use servo_util::geometry::Au;
+    use util::geometry::Au;
 
     #[allow(missing_copy_implementations)]  // It’s kinda big
     pub struct Context {
         pub inherited_font_weight: longhands::font_weight::computed_value::T,
         pub inherited_font_size: longhands::font_size::computed_value::T,
         pub inherited_text_decorations_in_effect:
             longhands::_servo_text_decorations_in_effect::computed_value::T,
         pub inherited_height: longhands::height::computed_value::T,
--- a/servo/ports/cef/browser.rs
+++ b/servo/ports/cef/browser.rs
@@ -10,17 +10,17 @@ use interfaces::{cef_browser_t, cef_brow
 use interfaces::{cef_request_context_t};
 use servo::Browser;
 use types::{cef_browser_settings_t, cef_string_t, cef_window_info_t};
 use window;
 
 use compositing::windowing::{WindowNavigateMsg, WindowEvent};
 use glutin_app;
 use libc::c_int;
-use servo_util::opts;
+use util::opts;
 use std::borrow::ToOwned;
 use std::cell::{Cell, RefCell};
 use std::sync::atomic::{AtomicInt, Ordering};
 
 thread_local!(pub static ID_COUNTER: AtomicInt = AtomicInt::new(0));
 thread_local!(pub static BROWSERS: RefCell<Vec<CefBrowser>> = RefCell::new(vec!()));
 
 pub enum ServoBrowser {
--- a/servo/ports/cef/core.rs
+++ b/servo/ports/cef/core.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use command_line::command_line_init;
 use interfaces::cef_app_t;
 use types::{cef_main_args_t, cef_settings_t};
 
 use geom::size::TypedSize2D;
 use libc::{c_char, c_int, c_void};
-use servo_util::opts;
+use util::opts;
 use std::borrow::ToOwned;
 use std::ffi;
 use std::str;
 use browser;
 
 const MAX_RENDERING_THREADS: uint = 128;
 
 // TODO(pcwalton): Get the home page via the CEF API.
--- a/servo/ports/cef/lib.rs
+++ b/servo/ports/cef/lib.rs
@@ -22,17 +22,17 @@ extern crate gleam;
 extern crate glutin_app;
 extern crate js;
 extern crate layers;
 extern crate png;
 extern crate script;
 
 extern crate "net" as servo_net;
 extern crate "msg" as servo_msg;
-extern crate "util" as servo_util;
+extern crate util;
 extern crate style;
 extern crate stb_image;
 
 extern crate libc;
 extern crate "url" as std_url;
 
 #[cfg(target_os="macos")]
 extern crate cgl;
--- a/servo/ports/cef/window.rs
+++ b/servo/ports/cef/window.rs
@@ -19,18 +19,18 @@ use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
 use gleam::gl;
 use layers::geometry::DevicePixel;
 use layers::platform::surface::NativeGraphicsMetadata;
 use libc::{c_char, c_void};
 use servo_msg::constellation_msg::{Key, KeyModifiers};
 use servo_msg::compositor_msg::{ReadyState, PaintState};
 use servo_msg::constellation_msg::LoadData;
-use servo_util::cursor::Cursor;
-use servo_util::geometry::ScreenPx;
+use util::cursor::Cursor;
+use util::geometry::ScreenPx;
 use std::cell::RefCell;
 use std::ffi::CString;
 use std::rc::Rc;
 use std::sync::mpsc::{Sender, channel};
 
 #[cfg(target_os="macos")]
 use std::ptr;
 
--- a/servo/ports/gonk/src/lib.rs
+++ b/servo/ports/gonk/src/lib.rs
@@ -10,17 +10,17 @@
 #[macro_use]
 extern crate log;
 
 extern crate compositing;
 extern crate devtools;
 extern crate "net" as servo_net;
 extern crate "msg" as servo_msg;
 #[macro_use]
-extern crate "util" as servo_util;
+extern crate util;
 extern crate script;
 extern crate layout;
 extern crate gfx;
 extern crate libc;
 extern crate rustrt;
 extern crate url;
 
 use compositing::CompositorEventListener;
@@ -39,39 +39,39 @@ use script::dom::bindings::codegen::Regi
 use servo_net::image_cache_task::ImageCacheTask;
 #[cfg(not(test))]
 use servo_net::storage_task::StorageTaskFactory;
 #[cfg(not(test))]
 use servo_net::resource_task::new_resource_task;
 #[cfg(not(test))]
 use gfx::font_cache_task::FontCacheTask;
 #[cfg(not(test))]
-use servo_util::time::TimeProfiler;
+use util::time::TimeProfiler;
 #[cfg(not(test))]
-use servo_util::memory::MemoryProfiler;
+use util::memory::MemoryProfiler;
 #[cfg(not(test))]
-use servo_util::opts;
+use util::opts;
 #[cfg(not(test))]
-use servo_util::taskpool::TaskPool;
+use util::taskpool::TaskPool;
 
 #[cfg(not(test))]
 use std::os;
 #[cfg(not(test))]
 use std::rc::Rc;
 #[cfg(not(test))]
 use std::task::TaskBuilder;
 
 pub struct Browser<Window> {
     compositor: Box<CompositorEventListener + 'static>,
 }
 
 impl<Window> Browser<Window> where Window: WindowMethods + 'static {
     #[cfg(not(test))]
     pub fn new(window: Option<Rc<Window>>) -> Browser<Window> {
-        ::servo_util::opts::set_experimental_enabled(opts::get().enable_experimental);
+        ::util::opts::set_experimental_enabled(opts::get().enable_experimental);
         let opts = opts::get();
         RegisterBindings::RegisterProxyHandlers();
 
         let shared_task_pool = TaskPool::new(8);
 
         let (compositor_proxy, compositor_receiver) =
             WindowMethods::create_compositor_channel(&window);
         let time_profiler_chan = TimeProfiler::create(opts.time_profiler_period);
--- a/servo/ports/gonk/src/main.rs
+++ b/servo/ports/gonk/src/main.rs
@@ -2,28 +2,28 @@
  * 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/. */
 
 #![deny(unused_imports)]
 #![deny(unused_variables)]
 
 extern crate servo;
 extern crate time;
-extern crate "util" as servo_util;
+extern crate util;
 
 extern crate compositing;
 
 extern crate geom;
 extern crate libc;
 extern crate msg;
 extern crate gleam;
 extern crate layers;
 extern crate egl;
 
-use servo_util::opts;
+use util::opts;
 use servo::Browser;
 use compositing::windowing::WindowEvent;
 
 use std::os;
 
 mod window;
 mod input;
 
--- a/servo/ports/gonk/src/window.rs
+++ b/servo/ports/gonk/src/window.rs
@@ -16,18 +16,18 @@ use msg::constellation_msg::{Key, KeyMod
 use msg::constellation_msg::LoadData;
 use std::cell::Cell;
 use std::comm::Receiver;
 use std::rc::Rc;
 use std::mem::transmute;
 use std::mem::size_of;
 use std::mem::zeroed;
 use std::ptr;
-use servo_util::cursor::Cursor;
-use servo_util::geometry::ScreenPx;
+use util::cursor::Cursor;
+use util::geometry::ScreenPx;
 use gleam::gl;
 
 use egl::egl::EGLConfig;
 use egl::egl::EGLDisplay;
 use egl::egl::EGLContext;
 use egl::egl::EGLSurface;
 use egl::egl::EGLint;
 use egl::egl;