deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"12cc0f91b51fedf41ae1670d1624ee1d78a284bdb101645b60a06a12de16c069",".travis.yml":"6b96b2c6bfd7e1acef4b825a2813fc4277859eb9400a16800db8835c25e4087d","Cargo.toml":"e8e47fdafc02dca1094469954c142173859165ac583ff702500d6feef5b7cd3f","README.md":"9f048d969f9f8333cdcdb892744cd0816e4f2922c8817fa5e9e07f9472fe1050","src/app_unit.rs":"da3c29a2fa7fc357f41df76f29a5f6983d878a5050cf07443a20c00fe46094fd","src/lib.rs":"2df7d863c47d8b22f9af66caeafa87e6a206ee713a8aeaa55c5a80a42a92513b"},"package":"c89beb28482985f88b312de4021d748f45b3eecec6cc8dbaf0c2b3c3d1ce6da5"}
\ No newline at end of file

deleted file mode 100644

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-target/
-Cargo.lock

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/.travis.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-language: rust
-notifications:
-  webhooks: http://build.servo.org:54856/travis
-
-rust:
-  - stable
-  - beta
-  - nightly

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "app_units"
-version = "0.4.1"
-authors = ["The Servo Project Developers"]
-description = "Servo app units type (Au)"
-documentation = "http://doc.servo.org/app_units/"
-repository = "https://github.com/servo/app_units"
-license = "MPL-2.0"
-
-[dependencies]
-heapsize = "0.3"
-num-traits = "0.1.32"
-rustc-serialize = "0.3"
-serde = "0.9"

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# app-units
-
-[Documentation](http://doc.servo.org/app_units/index.html)

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/src/app_unit.rs
+++ /dev/null
@@ -1,379 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use heapsize::HeapSizeOf;
-use num_traits::Zero;
-use rustc_serialize::{Encodable, Encoder};
-use serde::de::{Deserialize, Deserializer};
-use serde::ser::{Serialize, Serializer};
-use std::default::Default;
-use std::fmt;
-use std::i32;
-use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, SubAssign};
-
-/// The number of app units in a pixel.
-pub const AU_PER_PX: i32 = 60;
-
-#[derive(Clone, Copy, Hash, PartialEq, PartialOrd, Eq, Ord)]
-/// An App Unit, the fundamental unit of length in Servo. Usually
-/// 1/60th of a pixel (see AU_PER_PX)
-///
-/// Please ensure that the values are between MIN_AU and MAX_AU.
-/// It is safe to construct invalid Au values, but it may lead to
-/// panics and overflows.
-pub struct Au(pub i32);
-
-impl HeapSizeOf for Au {
-    fn heap_size_of_children(&self) -> usize { 0 }
-}
-
-impl Deserialize for Au {
-    fn deserialize<D: Deserializer>(deserializer: D) -> Result<Au, D::Error> {
-        Ok(Au(try!(i32::deserialize(deserializer))).clamp())
-    }
-}
-
-impl Serialize for Au {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.0.serialize(serializer)
-    }
-}
-
-impl Default for Au {
-    #[inline]
-    fn default() -> Au {
-        Au(0)
-    }
-}
-
-impl Zero for Au {
-    #[inline]
-    fn zero() -> Au {
-        Au(0)
-    }
-
-    #[inline]
-    fn is_zero(&self) -> bool {
-        self.0 == 0
-    }
-}
-
-// 1 << 30 lets us add/subtract two Au and check for overflow
-// after the operation. Gecko uses the same min/max values
-pub const MAX_AU: Au = Au(1 << 30);
-pub const MIN_AU: Au = Au(- (1 << 30));
-
-impl Encodable for Au {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        e.emit_f64(self.to_f64_px())
-    }
-}
-
-impl fmt::Debug for Au {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}px", self.to_f64_px())
-    }
-}
-
-impl Add for Au {
-    type Output = Au;
-
-    #[inline]
-    fn add(self, other: Au) -> Au {
-        Au(self.0 + other.0).clamp()
-    }
-}
-
-impl Sub for Au {
-    type Output = Au;
-
-    #[inline]
-    fn sub(self, other: Au) -> Au {
-        Au(self.0 - other.0).clamp()
-    }
-
-}
-
-impl Mul<i32> for Au {
-    type Output = Au;
-
-    #[inline]
-    fn mul(self, other: i32) -> Au {
-        if let Some(new) = self.0.checked_mul(other) {
-            Au(new).clamp()
-        } else if (self.0 > 0) ^ (other > 0) {
-            MIN_AU
-        } else {
-            MAX_AU
-        }
-    }
-}
-
-impl Div<i32> for Au {
-    type Output = Au;
-
-    #[inline]
-    fn div(self, other: i32) -> Au {
-        Au(self.0 / other)
-    }
-}
-
-impl Rem<i32> for Au {
-    type Output = Au;
-
-    #[inline]
-    fn rem(self, other: i32) -> Au {
-        Au(self.0 % other)
-    }
-}
-
-impl Neg for Au {
-    type Output = Au;
-
-    #[inline]
-    fn neg(self) -> Au {
-        Au(-self.0)
-    }
-}
-
-impl AddAssign for Au {
-    #[inline]
-    fn add_assign(&mut self, other: Au) {
-        *self = *self + other;
-        self.clamp_self();
-    }
-}
-
-impl SubAssign for Au {
-    #[inline]
-    fn sub_assign(&mut self, other: Au) {
-        *self = *self - other;
-        self.clamp_self();
-    }
-}
-
-impl MulAssign<i32> for Au {
-    #[inline]
-    fn mul_assign(&mut self, other: i32) {
-        *self = *self * other;
-        self.clamp_self();
-    }
-}
-
-impl DivAssign<i32> for Au {
-    #[inline]
-    fn div_assign(&mut self, other: i32) {
-        *self = *self / other;
-        self.clamp_self();
-    }
-}
-
-impl Au {
-    /// FIXME(pcwalton): Workaround for lack of cross crate inlining of newtype structs!
-    #[inline]
-    pub fn new(value: i32) -> Au {
-        Au(value).clamp()
-    }
-
-    #[inline]
-    fn clamp(self) -> Self {
-        if self.0 > MAX_AU.0 {
-            MAX_AU
-        } else if self.0 < MIN_AU.0 {
-            MIN_AU
-        } else {
-            self
-        }
-    }
-
-    #[inline]
-    fn clamp_self(&mut self) {
-        *self = self.clamp()
-    }
-
-    #[inline]
-    pub fn scale_by(self, factor: f32) -> Au {
-        let new_float = ((self.0 as f32) * factor).round();
-        if new_float > MAX_AU.0 as f32 {
-            MAX_AU
-        } else if new_float < MIN_AU.0 as f32 {
-            MIN_AU
-        } else {
-            Au(new_float as i32)
-        }
-    }
-
-    #[inline]
-    pub fn from_px(px: i32) -> Au {
-        Au(px) * AU_PER_PX
-    }
-
-    /// Rounds this app unit down to the pixel towards zero and returns it.
-    #[inline]
-    pub fn to_px(self) -> i32 {
-        self.0 / AU_PER_PX
-    }
-
-    /// Ceil this app unit to the appropriate pixel boundary and return it.
-    #[inline]
-    pub fn ceil_to_px(self) -> i32 {
-        ((self.0 as f64) / (AU_PER_PX as f64)).ceil() as i32
-    }
-
-    #[inline]
-    pub fn to_nearest_px(self) -> i32 {
-        ((self.0 as f64) / (AU_PER_PX as f64)).round() as i32
-    }
-
-    #[inline]
-    pub fn to_nearest_pixel(self, pixels_per_px: f32) -> f32 {
-        ((self.0 as f32) / (AU_PER_PX as f32) * pixels_per_px).round() / pixels_per_px
-    }
-
-    #[inline]
-    pub fn to_f32_px(self) -> f32 {
-        (self.0 as f32) / (AU_PER_PX as f32)
-    }
-
-    #[inline]
-    pub fn to_f64_px(self) -> f64 {
-        (self.0 as f64) / (AU_PER_PX as f64)
-    }
-
-    #[inline]
-    pub fn from_f32_px(px: f32) -> Au {
-        let float = (px * AU_PER_PX as f32).round();
-        if float > MAX_AU.0 as f32 {
-            MAX_AU
-        } else if float < MIN_AU.0 as f32 {
-            MIN_AU
-        } else {
-            Au(float as i32)
-        }
-    }
-
-    #[inline]
-    pub fn from_f64_px(px: f64) -> Au {
-        let float = (px * AU_PER_PX as f64).round();
-        if float > MAX_AU.0 as f64 {
-            MAX_AU
-        } else if float < MIN_AU.0 as f64 {
-            MIN_AU
-        } else {
-            Au(float as i32)
-        }
-    }
-}
-
-#[test]
-fn create() {
-    assert_eq!(Au::zero(), Au(0));
-    assert_eq!(Au::default(), Au(0));
-    assert_eq!(Au::new(7), Au(7));
-}
-
-#[test]
-fn operations() {
-    assert_eq!(Au(7) + Au(5), Au(12));
-    assert_eq!(MAX_AU + Au(1), MAX_AU);
-
-    assert_eq!(Au(7) - Au(5), Au(2));
-    assert_eq!(MIN_AU - Au(1), MIN_AU);
-
-    assert_eq!(Au(7) * 5, Au(35));
-    assert_eq!(MAX_AU * -1, MIN_AU);
-    assert_eq!(MIN_AU * -1, MAX_AU);
-
-    assert_eq!(Au(35) / 5, Au(7));
-    assert_eq!(Au(35) % 6, Au(5));
-
-    assert_eq!(-Au(7), Au(-7));
-}
-
-#[test]
-fn saturate() {
-    let half = MAX_AU / 2;
-    assert_eq!(half + half + half + half + half, MAX_AU);
-    assert_eq!(-half - half - half - half - half, MIN_AU);
-    assert_eq!(half * -10, MIN_AU);
-    assert_eq!(-half * 10, MIN_AU);
-    assert_eq!(half * 10, MAX_AU);
-    assert_eq!(-half * -10, MAX_AU);
-}
-
-#[test]
-fn scale() {
-    assert_eq!(Au(12).scale_by(1.5), Au(18));
-    assert_eq!(Au(12).scale_by(1.7), Au(20));
-    assert_eq!(Au(12).scale_by(1.8), Au(22));
-}
-
-#[test]
-fn convert() {
-    assert_eq!(Au::from_px(5), Au(300));
-
-    assert_eq!(Au(300).to_px(), 5);
-    assert_eq!(Au(330).to_px(), 5);
-    assert_eq!(Au(350).to_px(), 5);
-    assert_eq!(Au(360).to_px(), 6);
-
-    assert_eq!(Au(300).ceil_to_px(), 5);
-    assert_eq!(Au(310).ceil_to_px(), 6);
-    assert_eq!(Au(330).ceil_to_px(), 6);
-    assert_eq!(Au(350).ceil_to_px(), 6);
-    assert_eq!(Au(360).ceil_to_px(), 6);
-
-    assert_eq!(Au(300).to_nearest_px(), 5);
-    assert_eq!(Au(310).to_nearest_px(), 5);
-    assert_eq!(Au(330).to_nearest_px(), 6);
-    assert_eq!(Au(350).to_nearest_px(), 6);
-    assert_eq!(Au(360).to_nearest_px(), 6);
-
-    assert_eq!(Au(60).to_nearest_pixel(2.), 1.);
-    assert_eq!(Au(70).to_nearest_pixel(2.), 1.);
-    assert_eq!(Au(80).to_nearest_pixel(2.), 1.5);
-    assert_eq!(Au(90).to_nearest_pixel(2.), 1.5);
-    assert_eq!(Au(100).to_nearest_pixel(2.), 1.5);
-    assert_eq!(Au(110).to_nearest_pixel(2.), 2.);
-    assert_eq!(Au(120).to_nearest_pixel(2.), 2.);
-
-    assert_eq!(Au(300).to_f32_px(), 5.);
-    assert_eq!(Au(312).to_f32_px(), 5.2);
-    assert_eq!(Au(330).to_f32_px(), 5.5);
-    assert_eq!(Au(348).to_f32_px(), 5.8);
-    assert_eq!(Au(360).to_f32_px(), 6.);
-    assert_eq!((Au(367).to_f32_px() * 1000.).round(), 6_117.);
-    assert_eq!((Au(368).to_f32_px() * 1000.).round(), 6_133.);
-
-    assert_eq!(Au(300).to_f64_px(), 5.);
-    assert_eq!(Au(312).to_f64_px(), 5.2);
-    assert_eq!(Au(330).to_f64_px(), 5.5);
-    assert_eq!(Au(348).to_f64_px(), 5.8);
-    assert_eq!(Au(360).to_f64_px(), 6.);
-    assert_eq!((Au(367).to_f64_px() * 1000.).round(), 6_117.);
-    assert_eq!((Au(368).to_f64_px() * 1000.).round(), 6_133.);
-
-    assert_eq!(Au::from_f32_px(5.), Au(300));
-    assert_eq!(Au::from_f32_px(5.2), Au(312));
-    assert_eq!(Au::from_f32_px(5.5), Au(330));
-    assert_eq!(Au::from_f32_px(5.8), Au(348));
-    assert_eq!(Au::from_f32_px(6.), Au(360));
-    assert_eq!(Au::from_f32_px(6.12), Au(367));
-    assert_eq!(Au::from_f32_px(6.13), Au(368));
-
-    assert_eq!(Au::from_f64_px(5.), Au(300));
-    assert_eq!(Au::from_f64_px(5.2), Au(312));
-    assert_eq!(Au::from_f64_px(5.5), Au(330));
-    assert_eq!(Au::from_f64_px(5.8), Au(348));
-    assert_eq!(Au::from_f64_px(6.), Au(360));
-    assert_eq!(Au::from_f64_px(6.12), Au(367));
-    assert_eq!(Au::from_f64_px(6.13), Au(368));
-}
-
-#[test]
-fn heapsize() {
-    use heapsize::HeapSizeOf;
-    fn f<T: HeapSizeOf>(_: T) {}
-    f(Au::new(0));
-}

deleted file mode 100644
--- a/third_party/rust/app_units-0.4.1/src/lib.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! An Au is an "App Unit" and represents 1/60th of a CSS pixel. It was
-//! originally proposed in 2002 as a standard unit of measure in Gecko.
-//! See https://bugzilla.mozilla.org/show_bug.cgi?id=177805 for more info.
-
-extern crate heapsize;
-extern crate num_traits;
-extern crate rustc_serialize;
-extern crate serde;
-
-mod app_unit;
-
-pub use app_unit::{Au, MIN_AU, MAX_AU, AU_PER_PX};

--- a/third_party/rust/bincode/.cargo-checksum.json
+++ b/third_party/rust/bincode/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"e084df3ce631ce22082bd63f9e421e7f4d7a2408d6520de532f6a649e4d320dd",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"3268085d1b2f5a6b658d02c98188a631e81c18323dbe1af2cbcccde8664bf2a4","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"7e1dd0a38f886c111f9a50bc5ecd8ccab0800fcc737c1c211cc5c3361648aa2b","examples/basic.rs":"ef6ab76936c8322b9f89fe8308311339c0bf7b413c5f88b5314b0035d49917a3","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"06e09e4e80b048416116640a8352305ceae48f775fd13786c25892cbf55c8fbd","src/lib.rs":"a4dff78a7c5af47c1dc9f240ba7ba3305dd66f638d2d326627093bb326c5fe59","src/refbox.rs":"fe266cec4f9f36942a1a9a9ad094a4bb1003d0c0f3c070cfb6214790d0f21b69","src/serde/mod.rs":"a4aaf85ac92468e246be4533f014b93b8e21059da22342155d03578a81e7f556","src/serde/reader.rs":"21db7aa79660acaa2ac39adfe273a99a27c2a1c39506e2a782f9c7f76500f866","src/serde/writer.rs":"02819f71cda1742188feb66c9ecf58bbd4e35c6d88961763667a3cde72450963","tests/test.rs":"36f7e11cc480ea9f68c4656d55e065f69998346baa8112fcde1f9c1dc4891c02"},"package":"fb0cdeac1c5d567fdb487ae5853c024e4acf1ea85ba6a6552fe084e0805fea5d"}
\ No newline at end of file
+{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"e084df3ce631ce22082bd63f9e421e7f4d7a2408d6520de532f6a649e4d320dd",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"b3ef32df664d22cfe4526f0022c8789e8976970b9e0982e1dd52f4f811134515","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"936b58455e1c221539b73b5250302dcd96baa04a5d8536199d3351142addad57","examples/basic.rs":"ef6ab76936c8322b9f89fe8308311339c0bf7b413c5f88b5314b0035d49917a3","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"ca48b4a712089d792d449ef6e0e399efaf227dbcfcb141540684a16a2763583b","src/de/mod.rs":"8651e00130bd062e2305dcce8b68d777fff9877688e776b239778e18046dddaf","src/de/read.rs":"5abca51c6f0d93cc144914ed30bf2cfd0074ced09a0de8c3983997aaa471562d","src/internal.rs":"d9448e8467caf4cf24703626dab9e0d9420e98419e323ad7e611e4aeab525e4a","src/lib.rs":"998b85e103f8f5480ffeef43bd8430a66c061011055a053377f37dce32bf9088","src/ser/mod.rs":"0eeb467eeb8189fb935e4996cd45d1f292c401f92b00793907bd428f1bde421d","tests/test.rs":"26598b882a691caa5301a569e56e31567bfba5ffeab6f0ca67ebd95bfae679b0"},"package":"e103c8b299b28a9c6990458b7013dc4a8356a9b854c51b9883241f5866fac36e"}
\ No newline at end of file

--- a/third_party/rust/bincode/Cargo.toml
+++ b/third_party/rust/bincode/Cargo.toml
@@ -1,21 +1,20 @@
 [package]
 name = "bincode"
-version = "1.0.0-alpha6"
+version = "0.8.0"
 authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>", "David Tolnay <dtolnay@gmail.com>", "Daniel Griffen"]
 
 repository = "https://github.com/TyOverby/bincode"
 documentation = "https://docs.rs/bincode"
 keywords = ["binary", "encode", "decode", "serialize", "deserialize"]
 
 license = "MIT"
 description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!"
 
 [dependencies]
 byteorder = "1.0.0"
 num-traits = "0.1.32"
-
-[dependencies.serde]
-version = "0.9.*"
+serde = "1.*.*"
 
 [dev-dependencies]
-serde_derive = "0.9.*"
+serde_bytes = "0.10.*"
+serde_derive = "1.*.*"

--- a/third_party/rust/bincode/changelist.org
+++ b/third_party/rust/bincode/changelist.org
@@ -17,8 +17,11 @@
  Since serde is the only supported serialization mechanism, it makes sense to have these
  functions available at the top level.
 
 ** Added the ability to chose your own endian encoding.
  This functionality is located in the endian_choice module.
 
 ** Changed SizeLimit to be a trait instead of an enum
  Mostly for performance reasons.
+
+** Removed RefBox / StrBox / SliceBox
+ Since rustc-serialize support was phased out, you can use `Cow<T>` with serde.

--- a/third_party/rust/bincode/readme.md
+++ b/third_party/rust/bincode/readme.md
@@ -1,17 +1,17 @@
 # Bincode
 
 <img align="right" src="./logo.png" />
 
 [![Build Status](https://travis-ci.org/TyOverby/bincode.svg)](https://travis-ci.org/TyOverby/bincode)
 [![](http://meritbadge.herokuapp.com/bincode)](https://crates.io/crates/bincode)
 [![](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
 
-A compact encoder / decoder pair that uses an binary zero-fluff encoding scheme.
+A compact encoder / decoder pair that uses a binary zero-fluff encoding scheme.
 The size of the encoded object will be the same or smaller than the size that
 the object takes up in memory in a running Rust program.
 
 In addition to exposing two simple functions that encode to Vec<u8> and decode
 from Vec<u8>, binary-encode exposes a Reader/Writer API that makes it work
 perfectly with other stream-based apis such as rust files, network streams,
 and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression
 library.
@@ -25,31 +25,31 @@ library.
 * [servo/ipc-channel](https://github.com/servo/ipc-channel): Ipc-Channel uses Bincode to send structs between processes using a channel-like API.
 
 ## Example
 ```rust
 #[macro_use]
 extern crate serde_derive;
 extern crate bincode;
 
-use bincode::{serialize, deserialize, SizeLimit};
+use bincode::{serialize, deserialize, Infinite};
 
 #[derive(Serialize, Deserialize, PartialEq)]
 struct Entity {
     x: f32,
     y: f32,
 }
 
 #[derive(Serialize, Deserialize, PartialEq)]
 struct World(Vec<Entity>);
 
 fn main() {
     let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);
 
-    let encoded: Vec<u8> = serialize(&world, SizeLimit::Infinite).unwrap();
+    let encoded: Vec<u8> = serialize(&world, Infinite).unwrap();
 
     // 8 bytes for the length of the vector, 4 bytes per float.
     assert_eq!(encoded.len(), 8 + 4 * 4);
 
     let decoded: World = deserialize(&encoded[..]).unwrap();
 
     assert!(world == decoded);
 }

new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/de/mod.rs
@@ -0,0 +1,416 @@
+use std::io::Read;
+use std::marker::PhantomData;
+
+use byteorder::{ReadBytesExt, ByteOrder};
+use serde_crate as serde;
+use serde_crate::de::IntoDeserializer;
+use serde_crate::de::Error as DeError;
+use ::SizeLimit;
+use super::{Result, Error, ErrorKind};
+use self::read::BincodeRead;
+
+pub mod read;
+
+/// A Deserializer that reads bytes from a buffer.
+///
+/// This struct should rarely be used.
+/// In most cases, prefer the `decode_from` function.
+///
+/// The ByteOrder that is chosen will impact the endianness that
+/// is used to read integers out of the reader.
+///
+/// ```rust,ignore
+/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
+/// serde::Deserialize::deserialize(&mut deserializer);
+/// let bytes_read = d.bytes_read();
+/// ```
+pub struct Deserializer<R, S: SizeLimit, E: ByteOrder> {
+    reader: R,
+    size_limit: S,
+    _phantom: PhantomData<E>,
+}
+
+impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E> {
+    /// Creates a new Deserializer with a given `Read`er and a size_limit.
+    pub fn new(r: R, size_limit: S) -> Deserializer<R, S, E> {
+        Deserializer {
+            reader: r,
+            size_limit: size_limit,
+            _phantom: PhantomData
+        }
+    }
+
+    fn read_bytes(&mut self, count: u64) -> Result<()> {
+        self.size_limit.add(count)
+    }
+
+    fn read_type<T>(&mut self) -> Result<()> {
+        use std::mem::size_of;
+        self.read_bytes(size_of::<T>() as u64)
+    }
+
+    fn read_vec(&mut self) -> Result<Vec<u8>> {
+        let len: usize = try!(serde::Deserialize::deserialize(&mut *self));
+        self.read_bytes(len as u64)?;
+        self.reader.get_byte_buffer(len)
+    }
+
+    fn read_string(&mut self) -> Result<String> {
+        String::from_utf8(try!(self.read_vec())).map_err(|err|
+            ErrorKind::InvalidEncoding{
+                desc: "error while decoding utf8 string",
+                detail: Some(format!("Deserialize error: {}", err))
+            }.into())
+    }
+}
+
+macro_rules! impl_nums {
+    ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
+        #[inline]
+        fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
+            where V: serde::de::Visitor<'de>,
+        {
+            try!(self.read_type::<$ty>());
+            let value = try!(self.reader.$reader_method::<E>());
+            visitor.$visitor_method(value)
+        }
+    }
+}
+
+impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer<R, S, E>
+where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let message = "bincode does not support Deserializer::deserialize";
+        Err(Error::custom(message))
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let value: u8 = try!(serde::Deserialize::deserialize(self));
+        match value {
+            1 => visitor.visit_bool(true),
+            0 => visitor.visit_bool(false),
+            value => {
+                Err(ErrorKind::InvalidEncoding{
+                    desc: "invalid u8 when decoding bool",
+                    detail: Some(format!("Expected 0 or 1, got {}", value))
+                }.into())
+            }
+        }
+    }
+
+    impl_nums!(u16, deserialize_u16, visit_u16, read_u16);
+    impl_nums!(u32, deserialize_u32, visit_u32, read_u32);
+    impl_nums!(u64, deserialize_u64, visit_u64, read_u64);
+    impl_nums!(i16, deserialize_i16, visit_i16, read_i16);
+    impl_nums!(i32, deserialize_i32, visit_i32, read_i32);
+    impl_nums!(i64, deserialize_i64, visit_i64, read_i64);
+    impl_nums!(f32, deserialize_f32, visit_f32, read_f32);
+    impl_nums!(f64, deserialize_f64, visit_f64, read_f64);
+
+
+    #[inline]
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        try!(self.read_type::<u8>());
+        visitor.visit_u8(try!(self.reader.read_u8()))
+    }
+
+    #[inline]
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        try!(self.read_type::<i8>());
+        visitor.visit_i8(try!(self.reader.read_i8()))
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        use std::str;
+
+        let error = || {
+            ErrorKind::InvalidEncoding{
+                desc: "Invalid char encoding",
+                detail: None,
+            }.into()
+        };
+
+        let mut buf = [0u8; 4];
+
+        // Look at the first byte to see how many bytes must be read
+        let _ = try!(self.reader.read_exact(&mut buf[..1]));
+        let width = utf8_char_width(buf[0]);
+        if width == 1 { return visitor.visit_char(buf[0] as char) }
+        if width == 0 { return Err(error())}
+
+        if self.reader.read_exact(&mut buf[1..width]).is_err() {
+            return Err(error());
+        }
+
+        let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error()));
+        visitor.visit_char(res)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let len: usize = try!(serde::Deserialize::deserialize(&mut *self));
+        try!(self.read_bytes(len as u64));
+        self.reader.forward_read_str(len, visitor)
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_string(try!(self.read_string()))
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let len: usize = try!(serde::Deserialize::deserialize(&mut *self));
+        try!(self.read_bytes(len as u64));
+        self.reader.forward_read_bytes(len, visitor)
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_byte_buf(try!(self.read_vec()))
+    }
+
+    fn deserialize_enum<V>(self,
+                     _enum: &'static str,
+                     _variants: &'static [&'static str],
+                     visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, S, E>
+        where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
+            type Error = Error;
+            type Variant = Self;
+
+            fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
+                where V: serde::de::DeserializeSeed<'de>,
+            {
+                let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self));
+                let val: Result<_> = seed.deserialize(idx.into_deserializer());
+                Ok((try!(val), self))
+            }
+        }
+
+        visitor.visit_enum(self)
+    }
+
+    fn deserialize_tuple<V>(self,
+                            len: usize,
+                            visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
+            deserializer: &'a mut Deserializer<R, S, E>,
+            len: usize,
+        }
+
+        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de>+ 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqAccess<'de> for Access<'a, R, S, E> {
+            type Error = Error;
+
+            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+                where T: serde::de::DeserializeSeed<'de>,
+            {
+                if self.len > 0 {
+                    self.len -= 1;
+                    let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    Ok(Some(value))
+                } else {
+                    Ok(None)
+                }
+            }
+
+            fn size_hint(&self) -> Option<usize> {
+                Some(self.len)
+            }
+        }
+
+        visitor.visit_seq(Access { deserializer: self, len: len })
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self));
+        match value {
+            0 => visitor.visit_none(),
+            1 => visitor.visit_some(&mut *self),
+            _ => Err(ErrorKind::InvalidEncoding{
+                desc: "invalid tag when decoding Option",
+                detail: Some(format!("Expected 0 or 1, got {}", value))
+            }.into()),
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let len = try!(serde::Deserialize::deserialize(&mut *self));
+
+        self.deserialize_tuple(len, visitor)
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
+            deserializer: &'a mut Deserializer<R, S, E>,
+            len: usize,
+        }
+
+        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapAccess<'de> for Access<'a, R, S, E> {
+            type Error = Error;
+
+            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+                where K: serde::de::DeserializeSeed<'de>,
+            {
+                if self.len > 0 {
+                    self.len -= 1;
+                    let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    Ok(Some(key))
+                } else {
+                    Ok(None)
+                }
+            }
+
+            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+                where V: serde::de::DeserializeSeed<'de>,
+            {
+                let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                Ok(value)
+            }
+
+            fn size_hint(&self) -> Option<usize> {
+                Some(self.len)
+            }
+        }
+
+        let len = try!(serde::Deserialize::deserialize(&mut *self));
+
+        visitor.visit_map(Access { deserializer: self, len: len })
+    }
+
+    fn deserialize_struct<V>(self,
+                       _name: &str,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        self.deserialize_tuple(fields.len(), visitor)
+    }
+
+    fn deserialize_identifier<V>(self,
+                                   _visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let message = "bincode does not support Deserializer::deserialize_identifier";
+        Err(Error::custom(message))
+    }
+
+    fn deserialize_newtype_struct<V>(self,
+                               _name: &str,
+                               visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_unit_struct<V>(self,
+                                  _name: &'static str,
+                                  visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_tuple_struct<V>(self,
+                                   _name: &'static str,
+                                   len: usize,
+                                   visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        self.deserialize_tuple(len, visitor)
+    }
+
+    fn deserialize_ignored_any<V>(self,
+                                  _visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        let message = "bincode does not support Deserializer::deserialize_ignored_any";
+        Err(Error::custom(message))
+    }
+}
+
+impl<'de, 'a, R, S, E> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, S, E>
+where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<()> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
+        where T: serde::de::DeserializeSeed<'de>,
+    {
+        serde::de::DeserializeSeed::deserialize(seed, self)
+    }
+
+    fn tuple_variant<V>(self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
+    }
+
+    fn struct_variant<V>(self,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value>
+        where V: serde::de::Visitor<'de>,
+    {
+        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
+    }
+}
+static UTF8_CHAR_WIDTH: [u8; 256] = [
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x3F
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x5F
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x7F
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0x9F
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xBF
+0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // 0xDF
+3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, // 0xEF
+4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF
+];
+
+fn utf8_char_width(b: u8) -> usize {
+    UTF8_CHAR_WIDTH[b as usize] as usize
+}

new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/de/read.rs
@@ -0,0 +1,151 @@
+use std::io::{Read as IoRead, Result as IoResult, Error as IoError, ErrorKind as IoErrorKind};
+use ::Result;
+use serde_crate as serde;
+
+/// A byte-oriented reading trait that is specialized for
+/// slices and generic readers.
+pub trait BincodeRead<'storage>: IoRead {
+    #[doc(hidden)]
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'storage>;
+
+    #[doc(hidden)]
+    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>>;
+
+    #[doc(hidden)]
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'storage>;
+}
+
+/// A BincodeRead implementation for byte slices
+pub struct SliceReader<'storage> {
+    slice: &'storage [u8]
+}
+
+/// A BincodeRead implementation for io::Readers
+pub struct IoReadReader<R> {
+    reader: R,
+    temp_buffer: Vec<u8>,
+}
+
+impl <'storage> SliceReader<'storage> {
+    /// Constructs a slice reader
+    pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> {
+        SliceReader {
+            slice: bytes,
+        }
+    }
+}
+
+impl <R> IoReadReader<R> {
+    /// Constructs an IoReadReader
+    pub fn new(r: R) -> IoReadReader<R> {
+        IoReadReader {
+            reader: r,
+            temp_buffer: vec![],
+        }
+    }
+}
+
+impl <'storage> IoRead for SliceReader<'storage> {
+    fn read(&mut self, out: & mut [u8]) -> IoResult<usize> {
+        (&mut self.slice).read(out)
+    }
+}
+
+impl <R: IoRead> IoRead for IoReadReader<R> {
+    fn read(&mut self, out: & mut [u8]) -> IoResult<usize> {
+        self.reader.read(out)
+    }
+}
+
+impl <'storage> SliceReader<'storage> {
+    fn unexpected_eof() -> Box<::ErrorKind> {
+        return Box::new(::ErrorKind::IoError(IoError::new(IoErrorKind::UnexpectedEof, "")));
+    }
+}
+
+impl <'storage> BincodeRead<'storage> for SliceReader<'storage> {
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'storage> {
+        use ::ErrorKind;
+        if length > self.slice.len() {
+            return Err(SliceReader::unexpected_eof());
+        }
+
+        let string = match ::std::str::from_utf8(&self.slice[..length]) {
+            Ok(s) => s,
+            Err(_) => return Err(Box::new(ErrorKind::InvalidEncoding {
+                desc: "string was not valid utf8",
+                detail: None,
+            })),
+        };
+        let r = visitor.visit_borrowed_str(string);
+        self.slice = &self.slice[length..];
+        r
+    }
+
+    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
+        if length > self.slice.len() {
+            return Err(SliceReader::unexpected_eof());
+        }
+
+        let r = &self.slice[..length];
+        self.slice = &self.slice[length..];
+        Ok(r.to_vec())
+    }
+
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'storage> {
+        if length > self.slice.len() {
+            return Err(SliceReader::unexpected_eof());
+        }
+
+        let r = visitor.visit_borrowed_bytes(&self.slice[..length]);
+        self.slice = &self.slice[length..];
+        r
+    }
+}
+
+impl <R> IoReadReader<R> where R: IoRead {
+    fn fill_buffer(&mut self, length: usize) -> Result<()> {
+        let current_length = self.temp_buffer.len();
+        if length > current_length{
+            self.temp_buffer.reserve_exact(length - current_length);
+            unsafe { self.temp_buffer.set_len(length); }
+        }
+
+        self.reader.read_exact(&mut self.temp_buffer[..length])?;
+        Ok(())
+    }
+}
+
+impl <R> BincodeRead<'static> for IoReadReader<R> where R: IoRead {
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'static> {
+        self.fill_buffer(length)?;
+
+        let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) {
+            Ok(s) => s,
+            Err(_) => return Err(Box::new(::ErrorKind::InvalidEncoding {
+                desc: "string was not valid utf8",
+                detail: None,
+            })),
+        };
+
+        let r = visitor.visit_str(string);
+        r
+    }
+
+    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
+        self.fill_buffer(length)?;
+        Ok(self.temp_buffer[..length].to_vec())
+    }
+
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    where V: serde::de::Visitor<'static> {
+        self.fill_buffer(length)?;
+        let r = visitor.visit_bytes(&self.temp_buffer[..length]);
+        r
+    }
+}

new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/internal.rs
@@ -0,0 +1,240 @@
+//! A collection of serialization and deserialization functions
+//! that use the `serde` crate for the serializable and deserializable
+//! implementation.
+
+use std::io::{Write, Read};
+use std::io::Error as IoError;
+use std::{error, fmt, result};
+use ::SizeLimit;
+use byteorder::{ByteOrder};
+
+pub use super::de::{
+    Deserializer,
+};
+
+pub use super::ser::{
+    Serializer,
+};
+
+use super::ser::SizeChecker;
+
+use serde_crate as serde;
+
+/// The result of a serialization or deserialization operation.
+pub type Result<T> = result::Result<T, Error>;
+
+/// An error that can be produced during (de)serializing.
+///
+/// If decoding from a Buffer, assume that the buffer has been left
+/// in an invalid state.
+pub type Error = Box<ErrorKind>;
+
+/// The kind of error that can be produced during a serialization or deserialization.
+#[derive(Debug)]
+pub enum ErrorKind {
+    /// If the error stems from the reader/writer that is being used
+    /// during (de)serialization, that error will be stored and returned here.
+    IoError(IoError),
+    /// If the bytes in the reader are not decodable because of an invalid
+    /// encoding, this error will be returned.  This error is only possible
+    /// if a stream is corrupted.  A stream produced from `encode` or `encode_into`
+    /// should **never** produce an InvalidEncoding error.
+    InvalidEncoding {
+        #[allow(missing_docs)]
+        desc: &'static str,
+        #[allow(missing_docs)]
+        detail: Option<String>
+    },
+    /// If (de)serializing a message takes more than the provided size limit, this
+    /// error is returned.
+    SizeLimit,
+    /// Bincode can not encode sequences of unknown length (like iterators).
+    SequenceMustHaveLength,
+    /// A custom error message from Serde.
+    Custom(String)
+}
+
+impl error::Error for ErrorKind {
+    fn description(&self) -> &str {
+        match *self {
+            ErrorKind::IoError(ref err) => error::Error::description(err),
+            ErrorKind::InvalidEncoding{desc, ..} => desc,
+            ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences",
+            ErrorKind::SizeLimit => "the size limit for decoding has been reached",
+            ErrorKind::Custom(ref msg) => msg,
+
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            ErrorKind::IoError(ref err) => err.cause(),
+            ErrorKind::InvalidEncoding{..} => None,
+            ErrorKind::SequenceMustHaveLength => None,
+            ErrorKind::SizeLimit => None,
+            ErrorKind::Custom(_) => None,
+        }
+    }
+}
+
+impl From<IoError> for Error {
+    fn from(err: IoError) -> Error {
+        ErrorKind::IoError(err).into()
+    }
+}
+
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ErrorKind::IoError(ref ioerr) =>
+                write!(fmt, "IoError: {}", ioerr),
+            ErrorKind::InvalidEncoding{desc, detail: None}=>
+                write!(fmt, "InvalidEncoding: {}", desc),
+            ErrorKind::InvalidEncoding{desc, detail: Some(ref detail)}=>
+                write!(fmt, "InvalidEncoding: {} ({})", desc, detail),
+            ErrorKind::SequenceMustHaveLength =>
+                write!(fmt, "Bincode can only encode sequences and maps that have a knowable size ahead of time."),
+            ErrorKind::SizeLimit =>
+                write!(fmt, "SizeLimit"),
+            ErrorKind::Custom(ref s) =>
+                s.fmt(fmt),
+        }
+    }
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: fmt::Display>(desc: T) -> Error {
+        ErrorKind::Custom(desc.to_string()).into()
+    }
+}
+
+impl serde::ser::Error for Error {
+    fn custom<T: fmt::Display>(msg: T) -> Self {
+        ErrorKind::Custom(msg.to_string()).into()
+    }
+}
+
+/// Serializes an object directly into a `Writer`.
+///
+/// If the serialization would take more bytes than allowed by `size_limit`, an error
+/// is returned and *no bytes* will be written into the `Writer`.
+///
+/// If this returns an `Error` (other than SizeLimit), assume that the
+/// writer is in an invalid state, as writing could bail out in the middle of
+/// serializing.
+pub fn serialize_into<W: ?Sized, T: ?Sized, S, E>(writer: &mut W, value: &T, size_limit: S) -> Result<()>
+    where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder
+{
+    if let Some(limit) = size_limit.limit() {
+        try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit));
+    }
+
+    let mut serializer = Serializer::<_, E>::new(writer);
+    serde::Serialize::serialize(value, &mut serializer)
+}
+
+/// Serializes a serializable object into a `Vec` of bytes.
+///
+/// If the serialization would take more bytes than allowed by `size_limit`,
+/// an error is returned.
+pub fn serialize<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
+    where T: serde::Serialize, S: SizeLimit, E: ByteOrder
+{
+    let mut writer = match size_limit.limit() {
+        Some(size_limit) => {
+            let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(ErrorKind::SizeLimit));
+            Vec::with_capacity(actual_size as usize)
+        }
+        None => {
+            let size = serialized_size(value) as usize;
+            Vec::with_capacity(size)
+        }
+    };
+
+    try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite));
+    Ok(writer)
+}
+
+
+struct CountSize {
+    total: u64,
+    limit: Option<u64>,
+}
+
+impl SizeLimit for CountSize {
+    fn add(&mut self, c: u64) -> Result<()> {
+        self.total += c;
+        if let Some(limit) = self.limit {
+            if self.total > limit {
+                return Err(Box::new(ErrorKind::SizeLimit))
+            }
+        }
+        Ok(())
+    }
+
+    fn limit(&self) -> Option<u64> {
+        unreachable!();
+    }
+}
+
+/// Returns the size that an object would be if serialized using bincode.
+///
+/// This is used internally as part of the check for encode_into, but it can
+/// be useful for preallocating buffers if thats your style.
+pub fn serialized_size<T: ?Sized>(value: &T) -> u64
+    where T: serde::Serialize
+{
+    let mut size_counter = SizeChecker {
+        size_limit: CountSize { total: 0, limit: None }
+    };
+
+    value.serialize(&mut size_counter).ok();
+    size_counter.size_limit.total
+}
+
+/// Given a maximum size limit, check how large an object would be if it
+/// were to be serialized.
+///
+/// If it can be serialized in `max` or fewer bytes, that number will be returned
+/// inside `Some`.  If it goes over bounds, then None is returned.
+pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
+    where T: serde::Serialize
+{
+    let mut size_counter = SizeChecker {
+        size_limit: CountSize { total: 0, limit: Some(max) }
+    };
+
+    match value.serialize(&mut size_counter) {
+        Ok(_) => Some(size_counter.size_limit.total),
+        Err(_) => None,
+    }
+}
+
+/// Deserializes an object directly from a `Buffer`ed Reader.
+///
+/// If the provided `SizeLimit` is reached, the deserialization will bail immediately.
+/// A SizeLimit can help prevent an attacker from flooding your server with
+/// a neverending stream of values that runs your server out of memory.
+///
+/// If this returns an `Error`, assume that the buffer that you passed
+/// in is in an invalid state, as the error could be returned during any point
+/// in the reading.
+pub fn deserialize_from<R: ?Sized, T, S, E>(reader: &mut R, size_limit: S) -> Result<T>
+    where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder
+{
+    let reader = ::de::read::IoReadReader::new(reader);
+    let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit);
+    serde::Deserialize::deserialize(&mut deserializer)
+}
+
+/// Deserializes a slice of bytes into an object.
+///
+/// This method does not have a size-limit because if you already have the bytes
+/// in memory, then you don't gain anything by having a limiter.
+pub fn deserialize<'a, T, E: ByteOrder>(bytes: &'a [u8]) -> Result<T>
+    where T: serde::de::Deserialize<'a>,
+{
+    let reader = ::de::read::SliceReader::new(bytes);
+    let mut deserializer = Deserializer::<_, _, E>::new(reader, super::Infinite);
+    serde::Deserialize::deserialize(&mut deserializer)
+}

--- a/third_party/rust/bincode/src/lib.rs
+++ b/third_party/rust/bincode/src/lib.rs
@@ -1,22 +1,24 @@
+#![deny(missing_docs)]
+
 //! `bincode` is a crate for encoding and decoding using a tiny binary
 //! serialization strategy.
 //!
 //! There are simple functions for encoding to `Vec<u8>` and decoding from
 //! `&[u8]`, but the meat of the library is the `encode_into` and `decode_from`
 //! functions which respectively allow encoding into a `std::io::Writer`
 //! and decoding from a `std::io::Buffer`.
 //!
 //! ## Modules
-//! There are two ways to encode and decode structs using `bincode`, either using `rustc_serialize`
-//! or the `serde` crate.  `rustc_serialize` and `serde` are crates and and also the names of their
-//! corresponding modules inside of `bincode`.  Both modules have exactly equivalant functions, and
-//! and the only difference is whether or not the library user wants to use `rustc_serialize` or
-//! `serde`.
+//! Until "default type parameters" lands, we have an extra module called `endian_choice`
+//! that duplicates all of the core bincode functionality but with the option to choose
+//! which endianness the integers are encoded using.
+//!
+//! The default endianness is little.
 //!
 //! ### Using Basic Functions
 //!
 //! ```rust
 //! extern crate bincode;
 //! use bincode::{serialize, deserialize, Bounded};
 //! fn main() {
 //!     // The object that we will serialize.
@@ -29,83 +31,85 @@
 //!     assert_eq!(target, decoded);
 //! }
 //! ```
 
 #![crate_name = "bincode"]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 
-#![doc(html_logo_url = "./icon.png")]
-
 extern crate byteorder;
 extern crate num_traits;
 extern crate serde as serde_crate;
 
-pub mod refbox;
-mod serde;
+mod ser;
+mod de;
+pub mod internal;
 
-pub mod endian_choice {
-    pub use super::serde::{Deserializer, Serializer, serialize, serialize_into, deserialize, deserialize_from};
+pub mod read_types {
+    //! The types that the deserializer uses for optimizations
+    pub use ::de::read::{SliceReader, BincodeRead, IoReadReader};
 }
 
 use std::io::{Read, Write};
 
-pub use serde::{ErrorKind, Error, Result, serialized_size, serialized_size_bounded};
+pub use internal::{ErrorKind, Error, Result, serialized_size, serialized_size_bounded};
 
-pub type Deserializer<W, S> = serde::Deserializer<W, S, byteorder::LittleEndian>;
-pub type Serializer<W> = serde::Serializer<W, byteorder::LittleEndian>;
+/// A Deserializer that uses LittleEndian byteorder
+pub type Deserializer<W, S> = internal::Deserializer<W, S, byteorder::LittleEndian>;
+/// A Serializer that uses LittleEndian byteorder
+pub type Serializer<W> = internal::Serializer<W, byteorder::LittleEndian>;
 
 /// Deserializes a slice of bytes into an object.
 ///
 /// This method does not have a size-limit because if you already have the bytes
 /// in memory, then you don't gain anything by having a limiter.
-pub fn deserialize<T>(bytes: &[u8]) -> serde::Result<T>
-    where T: serde_crate::Deserialize,
+pub fn deserialize<'a, T>(bytes: &'a [u8]) -> internal::Result<T>
+    where T: serde_crate::de::Deserialize<'a>,
 {
-    serde::deserialize::<_, byteorder::LittleEndian>(bytes)
+    internal::deserialize::<_, byteorder::LittleEndian>(bytes)
 }
 
 /// Deserializes an object directly from a `Buffer`ed Reader.
 ///
 /// If the provided `SizeLimit` is reached, the deserialization will bail immediately.
 /// A SizeLimit can help prevent an attacker from flooding your server with
 /// a neverending stream of values that runs your server out of memory.
 ///
 /// If this returns an `Error`, assume that the buffer that you passed
 /// in is in an invalid state, as the error could be returned during any point
 /// in the reading.
-pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> serde::Result<T>
-    where R: Read, T: serde_crate::Deserialize, S: SizeLimit
+pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> internal::Result<T>
+    where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit
 {
-    serde::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit)
+    internal::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit)
 }
 
 /// Serializes an object directly into a `Writer`.
 ///
 /// If the serialization would take more bytes than allowed by `size_limit`, an error
 /// is returned and *no bytes* will be written into the `Writer`.
 ///
 /// If this returns an `Error` (other than SizeLimit), assume that the
 /// writer is in an invalid state, as writing could bail out in the middle of
 /// serializing.
-pub fn serialize_into<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_limit: S) -> serde::Result<()>
+pub fn serialize_into<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_limit: S) -> internal::Result<()>
     where W: Write, T: serde_crate::Serialize, S: SizeLimit
 {
-    serde::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit)
+    internal::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit)
 }
 
 /// Serializes a serializable object into a `Vec` of bytes.
 ///
 /// If the serialization would take more bytes than allowed by `size_limit`,
 /// an error is returned.
-pub fn serialize<T: ?Sized, S>(value: &T, size_limit: S) -> serde::Result<Vec<u8>>
+pub fn serialize<T: ?Sized, S>(value: &T, size_limit: S) -> internal::Result<Vec<u8>>
     where T: serde_crate::Serialize, S: SizeLimit
 {
-    serde::serialize::<_, _, byteorder::LittleEndian>(value, size_limit)
+    internal::serialize::<_, _, byteorder::LittleEndian>(value, size_limit)
 }
 
 /// A limit on the amount of bytes that can be read or written.
 ///
 /// Size limits are an incredibly important part of both encoding and decoding.
 ///
 /// In order to prevent DOS attacks on a decoder, it is important to limit the
 /// amount of bytes that a single encoded message can be; otherwise, if you
@@ -117,38 +121,47 @@ pub fn serialize<T: ?Sized, S>(value: &T
 /// any more than that.
 ///
 /// On the other side, you want to make sure that you aren't encoding a message
 /// that is larger than your decoder expects.  By supplying a size limit to an
 /// encoding function, the encoder will verify that the structure can be encoded
 /// within that limit.  This verification occurs before any bytes are written to
 /// the Writer, so recovering from an error is easy.
 pub trait SizeLimit {
+    /// Tells the SizeLimit that a certain number of bytes has been
+    /// read or written.  Returns Err if the limit has been exceeded.
     fn add(&mut self, n: u64) -> Result<()>;
+    /// Returns the hard limit (if one exists)
     fn limit(&self) -> Option<u64>;
 }
 
+/// A SizeLimit that restricts serialized or deserialized messages from
+/// exceeding a certain byte length.
 #[derive(Copy, Clone)]
 pub struct Bounded(pub u64);
 
+/// A SizeLimit without a limit!
+/// Use this if you don't care about the size of encoded or decoded messages.
 #[derive(Copy, Clone)]
 pub struct Infinite;
 
 impl SizeLimit for Bounded {
     #[inline(always)]
     fn add(&mut self, n: u64) -> Result<()> {
         if self.0 >= n {
             self.0 -= n;
             Ok(())
         } else {
             Err(Box::new(ErrorKind::SizeLimit))
         }
     }
+
     #[inline(always)]
     fn limit(&self) -> Option<u64> { Some(self.0) }
 }
 
 impl SizeLimit for Infinite {
     #[inline(always)]
     fn add(&mut self, _: u64) -> Result<()> { Ok (()) }
+
     #[inline(always)]
     fn limit(&self) -> Option<u64> { None }
 }

deleted file mode 100644
--- a/third_party/rust/bincode/src/refbox.rs
+++ /dev/null
@@ -1,363 +0,0 @@
-use std::boxed::Box;
-use std::ops::Deref;
-
-use serde_crate as serde;
-
-/// A struct for encoding nested reference types.
-///
-/// Encoding large objects by reference is really handy.  For example,
-/// `encode(&large_hashmap, ...)` encodes the large structure without having to
-/// own the hashmap.  However, it is impossible to serialize a reference if that
-/// reference is inside of a struct.
-///
-/// ```ignore rust
-/// // Not possible, rustc can not decode the reference.
-/// #[derive(RustcEncoding, RustcDecoding)]
-/// struct Message<'a>  {
-///   big_map: &'a HashMap<u32, u32>,
-///   message_type: String,
-/// }
-/// ```
-///
-/// This is because on the decoding side, you can't create the Message struct
-/// because it needs to have a reference to a HashMap, which is impossible because
-/// during deserialization, all members need to be owned by the deserialized
-/// object.
-///
-/// This is where RefBox comes in.  During serialization, it serializs a reference,
-/// but during deserialization, it puts that sub-object into a box!
-///
-/// ```ignore rust
-/// // This works!
-/// #[derive(RustcEncoding, RustcDecoding)]
-/// struct Message<'a> {
-///     big_map: RefBox<'a, HashMap<u32, u32>>,
-///     message_type: String
-/// }
-/// ```
-///
-/// Now we can write
-///
-/// ```ignore rust
-/// let my_map = HashMap::new();
-/// let my_msg = Message {
-///     big_map: RefBox::new(&my_map),
-///     message_type: "foo".to_string()
-/// };
-///
-/// let encoded = encode(&my_msg, ...).unwrap();
-/// let decoded: Message<'static> = decode(&encoded[]).unwrap();
-/// ```
-///
-/// Notice that we managed to encode and decode a struct with a nested reference
-/// and that the decoded message has the lifetime `'static` which shows us
-/// that the message owns everything inside it completely.
-///
-/// Please don't stick RefBox inside deep data structures.  It is much better
-/// suited in the outermost layer of whatever it is that you are encoding.
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]
-pub struct RefBox<'a, T: 'a> {
-    inner:  RefBoxInner<'a, T, Box<T>>
-}
-
-/// Like a RefBox, but encoding from a `str` and decoedes to a `String`.
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]
-pub struct StrBox<'a> {
-    inner: RefBoxInner<'a, str, String>
-}
-
-/// Like a RefBox, but encodes from a `[T]` and encodes to a `Vec<T>`.
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]
-pub struct SliceBox<'a, T: 'a> {
-    inner: RefBoxInner<'a, [T], Vec<T>>
-}
-
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
-enum RefBoxInner<'a, A: 'a + ?Sized, B> {
-    Ref(&'a A),
-    Box(B)
-}
-
-impl<'a, T> Clone for RefBoxInner<'a, T, Box<T>> where T: Clone {
-    fn clone(&self) -> RefBoxInner<'a, T, Box<T>> {
-        match *self {
-            RefBoxInner::Ref(reff) => RefBoxInner::Box(Box::new(reff.clone())),
-            RefBoxInner::Box(ref boxed) => RefBoxInner::Box(boxed.clone())
-        }
-    }
-}
-
-impl<'a> Clone for RefBoxInner<'a, str, String> {
-    fn clone(&self) -> RefBoxInner<'a, str, String> {
-        match *self {
-            RefBoxInner::Ref(reff) => RefBoxInner::Box(String::from(reff)),
-            RefBoxInner::Box(ref boxed) => RefBoxInner::Box(boxed.clone())
-        }
-    }
-}
-
-impl<'a, T> Clone for RefBoxInner<'a, [T], Vec<T>> where T: Clone {
-    fn clone(&self) -> RefBoxInner<'a, [T], Vec<T>> {
-        match *self {
-            RefBoxInner::Ref(reff) => RefBoxInner::Box(Vec::from(reff)),
-            RefBoxInner::Box(ref boxed) => RefBoxInner::Box(boxed.clone())
-        }
-    }
-}
-
-impl <'a, T> RefBox<'a, T> {
-    /// Creates a new RefBox that looks at a borrowed value.
-    pub fn new(v: &'a T) -> RefBox<'a, T> {
-        RefBox {
-            inner: RefBoxInner::Ref(v)
-        }
-    }
-}
-
-impl <T> RefBox<'static, T>  {
-    /// Takes the value out of this refbox.
-    ///
-    /// Fails if this refbox was not created out of a deserialization.
-    ///
-    /// Unless you are doing some really weird things with static references,
-    /// this function will never fail.
-    pub fn take(self) -> Box<T> {
-        match self.inner {
-            RefBoxInner::Box(b) => b,
-            _ => unreachable!()
-        }
-    }
-
-    /// Tries to take the value out of this refbox.
-    pub fn try_take(self) -> Result<Box<T>, RefBox<'static, T>> {
-        match self.inner {
-            RefBoxInner::Box(b) => Ok(b),
-            o => Err(RefBox{ inner: o})
-        }
-    }
-}
-
-impl<'a, T> serde::Serialize for RefBox<'a, T>
-    where T: serde::Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: serde::Serializer
-    {
-        serde::Serialize::serialize(&self.inner, serializer)
-    }
-}
-
-impl<'a, T: serde::Deserialize> serde::Deserialize for RefBox<'a, T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: serde::Deserializer
-    {
-        let inner = try!(serde::Deserialize::deserialize(deserializer));
-        Ok(RefBox{ inner: inner })
-    }
-}
-
-impl<'a> StrBox<'a> {
-    /// Creates a new StrBox that looks at a borrowed value.
-    pub fn new(s: &'a str) -> StrBox<'a> {
-        StrBox {
-            inner: RefBoxInner::Ref(s)
-        }
-    }
-
-    /// Extract a String from a StrBox.
-    pub fn into_string(self) -> String {
-        match self.inner {
-            RefBoxInner::Ref(s) => String::from(s),
-            RefBoxInner::Box(s) => s
-        }
-    }
-
-    /// Convert to an Owned `SliceBox`.
-    pub fn to_owned(self) -> StrBox<'static> {
-        match self.inner {
-            RefBoxInner::Ref(s) => StrBox::boxed(String::from(s)),
-            RefBoxInner::Box(s) => StrBox::boxed(s)
-        }
-    }
-}
-
-impl<'a> AsRef<str> for StrBox<'a> {
-    fn as_ref(&self) -> &str {
-        match self.inner {
-            RefBoxInner::Ref(ref s) => s,
-            RefBoxInner::Box(ref s) => s
-        }
-    }
-}
-
-impl StrBox<'static>  {
-    /// Creates a new StrBox made from an allocated String.
-    pub fn boxed(s: String) -> StrBox<'static> {
-        StrBox { inner: RefBoxInner::Box(s) }
-    }
-
-    /// Takes the value out of this refbox.
-    ///
-    /// Fails if this refbox was not created out of a deserialization.
-    ///
-    /// Unless you are doing some really weird things with static references,
-    /// this function will never fail.
-    pub fn take(self) -> String {
-        match self.inner {
-            RefBoxInner::Box(b) => b,
-            RefBoxInner::Ref(b) => String::from(b)
-        }
-    }
-
-    /// Tries to take the value out of this refbox.
-    pub fn try_take(self) -> Result<String, StrBox<'static>> {
-        match self.inner {
-            RefBoxInner::Box(b) => Ok(b),
-            o => Err(StrBox{ inner: o})
-        }
-    }
-}
-
-
-impl<'a> serde::Serialize for StrBox<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: serde::Serializer
-    {
-        serde::Serialize::serialize(&self.inner, serializer)
-    }
-}
-
-impl serde::Deserialize for StrBox<'static> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: serde::Deserializer
-    {
-        let inner = try!(serde::Deserialize::deserialize(deserializer));
-        Ok(StrBox{ inner: inner })
-    }
-}
-
-//
-// SliceBox
-//
-
-impl <'a, T> SliceBox<'a, T> {
-    /// Creates a new RefBox that looks at a borrowed value.
-    pub fn new(v: &'a [T]) -> SliceBox<'a, T> {
-        SliceBox {
-            inner: RefBoxInner::Ref(v)
-        }
-    }
-
-    /// Extract a `Vec<T>` from a `SliceBox`.
-    pub fn into_vec(self) -> Vec<T> where T: Clone {
-        match self.inner {
-            RefBoxInner::Ref(s) => s.to_vec(),
-            RefBoxInner::Box(s) => s
-        }
-    }
-
-    /// Convert to an Owned `SliceBox`.
-    pub fn to_owned(self) -> SliceBox<'static, T> where T: Clone {
-        match self.inner {
-            RefBoxInner::Ref(s) => SliceBox::boxed(s.to_vec()),
-            RefBoxInner::Box(s) => SliceBox::boxed(s)
-        }
-    }
-}
-
-impl <T> SliceBox<'static, T>  {
-    /// Creates a new SliceBox made from an allocated `Vec<T>`.
-    pub fn boxed(s: Vec<T>) -> SliceBox<'static, T> {
-        SliceBox { inner: RefBoxInner::Box(s) }
-    }
-
-    /// Takes the value out of this refbox.
-    ///
-    /// Fails if this refbox was not created out of a deserialization.
-    ///
-    /// Unless you are doing some really weird things with static references,
-    /// this function will never fail.
-    pub fn take(self) -> Vec<T> {
-        match self.inner {
-            RefBoxInner::Box(b) => b,
-            _ => unreachable!()
-        }
-    }
-
-    /// Tries to take the value out of this refbox.
-    pub fn try_take(self) -> Result<Vec<T>, SliceBox<'static, T>> {
-        match self.inner {
-            RefBoxInner::Box(b) => Ok(b),
-            o => Err(SliceBox{ inner: o})
-        }
-    }
-}
-
-
-impl<'a, T> serde::Serialize for SliceBox<'a, T>
-    where T: serde::Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: serde::Serializer
-    {
-        serde::Serialize::serialize(&self.inner, serializer)
-    }
-}
-
-impl<'a, T: serde::Deserialize> serde::Deserialize for SliceBox<'a, T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: serde::Deserializer
-    {
-        let inner = try!(serde::Deserialize::deserialize(deserializer));
-        Ok(SliceBox{ inner: inner })
-    }
-}
-
-
-impl<'a, A: ?Sized, B> serde::Serialize for RefBoxInner<'a, A, B>
-    where A: serde::Serialize,
-          B: serde::Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where S: serde::Serializer
-    {
-        match self {
-            &RefBoxInner::Ref(ref r) => serde::Serialize::serialize(r, serializer),
-            &RefBoxInner::Box(ref b) => serde::Serialize::serialize(b, serializer),
-        }
-    }
-}
-
-
-impl<'a, A: ?Sized, B> serde::Deserialize for RefBoxInner<'a, A, B>
-    where B: serde::Deserialize,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where D: serde::Deserializer
-    {
-        let deserialized = try!(serde::Deserialize::deserialize(deserializer));
-        Ok(RefBoxInner::Box(deserialized))
-    }
-}
-
-impl <'a, T> Deref for RefBox<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        match &self.inner {
-            &RefBoxInner::Ref(ref t) => t,
-            &RefBoxInner::Box(ref b) => b.deref()
-        }
-    }
-}
-
-impl <'a, T> Deref for SliceBox<'a, T> {
-    type Target = [T];
-
-    fn deref(&self) -> &[T] {
-        match &self.inner {
-            &RefBoxInner::Ref(ref t) => t,
-            &RefBoxInner::Box(ref b) => b.deref()
-        }
-    }
-}

new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/ser/mod.rs
@@ -0,0 +1,687 @@
+use std::io::Write;
+use std::u32;
+use std::marker::PhantomData;
+
+use serde_crate as serde;
+
+use byteorder::{WriteBytesExt, ByteOrder};
+
+use super::{Result, Error, ErrorKind};
+use super::SizeLimit;
+
+/// An Serializer that encodes values directly into a Writer.
+///
+/// The specified byte-order will impact the endianness that is
+/// used during the encoding.
+///
+/// This struct should not be used often.
+/// For most cases, prefer the `encode_into` function.
+pub struct Serializer<W, E: ByteOrder> {
+    writer: W,
+    _phantom: PhantomData<E>,
+}
+
+impl<W: Write, E: ByteOrder> Serializer<W, E> {
+    /// Creates a new Serializer with the given `Write`r.
+    pub fn new(w: W) -> Serializer<W, E> {
+        Serializer {
+            writer: w,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E> {
+    type Ok = ();
+    type Error = Error;
+    type SerializeSeq = Compound<'a, W, E>;
+    type SerializeTuple = Compound<'a, W, E>;
+    type SerializeTupleStruct = Compound<'a, W, E>;
+    type SerializeTupleVariant = Compound<'a, W, E>;
+    type SerializeMap = Compound<'a, W, E>;
+    type SerializeStruct = Compound<'a, W, E>;
+    type SerializeStructVariant = Compound<'a, W, E>;
+
+    fn serialize_unit(self) -> Result<()> { Ok(()) }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) }
+
+    fn serialize_bool(self, v: bool) -> Result<()> {
+        self.writer.write_u8(if v {1} else {0}).map_err(Into::into)
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<()> {
+        self.writer.write_u8(v).map_err(Into::into)
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<()> {
+        self.writer.write_u16::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<()> {
+        self.writer.write_u32::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<()> {
+        self.writer.write_u64::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<()> {
+        self.writer.write_i8(v).map_err(Into::into)
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<()> {
+        self.writer.write_i16::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<()> {
+        self.writer.write_i32::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<()> {
+        self.writer.write_i64::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<()> {
+        self.writer.write_f32::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<()> {
+        self.writer.write_f64::<E>(v).map_err(Into::into)
+    }
+
+    fn serialize_str(self, v: &str) -> Result<()> {
+        try!(self.serialize_u64(v.len() as u64));
+        self.writer.write_all(v.as_bytes()).map_err(Into::into)
+    }
+
+    fn serialize_char(self, c: char) -> Result<()> {
+        self.writer.write_all(encode_utf8(c).as_slice()).map_err(Into::into)
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
+        try!(self.serialize_u64(v.len() as u64));
+        self.writer.write_all(v).map_err(Into::into)
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        self.writer.write_u8(0).map_err(Into::into)
+    }
+
+    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
+        where T: serde::Serialize,
+    {
+        try!(self.writer.write_u8(1));
+        v.serialize(self)
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+        let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
+        try!(self.serialize_u64(len as u64));
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_tuple_variant(self,
+                              _name: &'static str,
+                              variant_index: u32,
+                              _variant: &'static str,
+                              _len: usize) -> Result<Self::SerializeTupleVariant>
+    {
+        try!(self.serialize_u32(variant_index));
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
+        let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
+        try!(self.serialize_u64(len as u64));
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_struct_variant(self,
+                               _name: &'static str,
+                               variant_index: u32,
+                               _variant: &'static str,
+                               _len: usize) -> Result<Self::SerializeStructVariant>
+    {
+        try!(self.serialize_u32(variant_index));
+        Ok(Compound {ser: self})
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(self,
+                               _name: &'static str,
+                               value: &T) -> Result<()>
+        where T: serde::ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(self,
+                               _name: &'static str,
+                               variant_index: u32,
+                               _variant: &'static str,
+                               value: &T) -> Result<()>
+        where T: serde::ser::Serialize,
+    {
+        try!(self.serialize_u32(variant_index));
+        value.serialize(self)
+    }
+
+    fn serialize_unit_variant(self,
+                          _name: &'static str,
+                          variant_index: u32,
+                          _variant: &'static str) -> Result<()> {
+        self.serialize_u32(variant_index)
+    }
+}
+
+pub struct SizeChecker<S: SizeLimit> {
+    pub size_limit: S,
+}
+
+impl <S: SizeLimit> SizeChecker<S> {
+    pub fn new(size_limit: S) -> SizeChecker<S> {
+        SizeChecker {
+            size_limit: size_limit
+        }
+    }
+
+    fn add_raw(&mut self, size: u64) -> Result<()> {
+        self.size_limit.add(size)
+    }
+
+    fn add_value<T>(&mut self, t: T) -> Result<()> {
+        use std::mem::size_of_val;
+        self.add_raw(size_of_val(&t) as u64)
+    }
+}
+
+impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
+    type Ok = ();
+    type Error = Error;
+    type SerializeSeq = SizeCompound<'a, S>;
+    type SerializeTuple = SizeCompound<'a, S>;
+    type SerializeTupleStruct = SizeCompound<'a, S>;
+    type SerializeTupleVariant = SizeCompound<'a, S>;
+    type SerializeMap = SizeCompound<'a, S>;
+    type SerializeStruct = SizeCompound<'a, S>;
+    type SerializeStructVariant = SizeCompound<'a, S>;
+
+    fn serialize_unit(self) -> Result<()> { Ok(()) }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) }
+
+    fn serialize_bool(self, _: bool) -> Result<()> {
+        self.add_value(0 as u8)
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<()> {
+        self.add_value(v)
+    }
+
+    fn serialize_str(self, v: &str) -> Result<()> {
+        try!(self.add_value(0 as u64));
+        self.add_raw(v.len() as u64)
+    }
+
+    fn serialize_char(self, c: char) -> Result<()> {
+        self.add_raw(encode_utf8(c).as_slice().len() as u64)
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
+        try!(self.add_value(0 as u64));
+        self.add_raw(v.len() as u64)
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        self.add_value(0 as u8)
+    }
+
+    fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
+        where T: serde::Serialize,
+    {
+        try!(self.add_value(1 as u8));
+        v.serialize(self)
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+        let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
+
+        try!(self.serialize_u64(len as u64));
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_tuple_variant(self,
+                         _name: &'static str,
+                         variant_index: u32,
+                         _variant: &'static str,
+                         _len: usize) -> Result<Self::SerializeTupleVariant>
+    {
+        try!(self.add_value(variant_index));
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>
+    {
+        let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
+
+        try!(self.serialize_u64(len as u64));
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_struct_variant(self,
+                               _name: &'static str,
+                               variant_index: u32,
+                               _variant: &'static str,
+                               _len: usize) -> Result<Self::SerializeStructVariant>
+    {
+        try!(self.add_value(variant_index));
+        Ok(SizeCompound {ser: self})
+    }
+
+    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(self, _name: &'static str, v: &V) -> Result<()> {
+        v.serialize(self)
+    }
+
+    fn serialize_unit_variant(self,
+                          _name: &'static str,
+                          variant_index: u32,
+                          _variant: &'static str) -> Result<()> {
+        self.add_value(variant_index)
+    }
+
+    fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(self,
+                               _name: &'static str,
+                               variant_index: u32,
+                               _variant: &'static str,
+                               value: &V) -> Result<()>
+    {
+        try!(self.add_value(variant_index));
+        value.serialize(self)
+    }
+}
+
+#[doc(hidden)]
+pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> {
+    ser: &'a mut Serializer<W, E>,
+}
+
+impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
+    where K: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+        #[inline]
+    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
+    where V: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, W, E> serde::ser::SerializeStructVariant for Compound<'a, W, E>
+    where W: Write, E: ByteOrder
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[doc(hidden)]
+pub struct SizeCompound<'a, S: SizeLimit + 'a> {
+    ser: &'a mut SizeChecker<S>,
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
+    where K: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+        #[inline]
+    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
+    where V: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S>
+{
+    type Ok = ();
+    type Error = Error;
+
+    #[inline]
+    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
+    where T: serde::ser::Serialize
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+const TAG_CONT: u8    = 0b1000_0000;
+const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_THREE_B: u8 = 0b1110_0000;
+const TAG_FOUR_B: u8  = 0b1111_0000;
+const MAX_ONE_B: u32   =     0x80;
+const MAX_TWO_B: u32   =    0x800;
+const MAX_THREE_B: u32 =  0x10000;
+
+fn encode_utf8(c: char) -> EncodeUtf8 {
+    let code = c as u32;
+    let mut buf = [0; 4];
+    let pos = if code < MAX_ONE_B {
+        buf[3] = code as u8;
+        3
+    } else if code < MAX_TWO_B {
+        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        2
+    } else if code < MAX_THREE_B {
+        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        1
+    } else {
+        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        0
+    };
+    EncodeUtf8 { buf: buf, pos: pos }
+}
+
+struct EncodeUtf8 {
+    buf: [u8; 4],
+    pos: usize,
+}
+
+impl EncodeUtf8 {
+    fn as_slice(&self) -> &[u8] {
+        &self.buf[self.pos..]
+    }
+}

deleted file mode 100644
--- a/third_party/rust/bincode/src/serde/mod.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-//! A collection of serialization and deserialization functions
-//! that use the `serde` crate for the serializable and deserializable
-//! implementation.
-
-use std::io::{Write, Read};
-use std::io::Error as IoError;
-use std::{error, fmt, result};
-use ::SizeLimit;
-use byteorder::{ByteOrder};
-
-pub use self::reader::{
-    Deserializer,
-};
-
-pub use self::writer::{
-    Serializer,
-};
-
-use self::writer::SizeChecker;
-
-use serde_crate as serde;
-
-mod reader;
-mod writer;
-
-pub type Result<T> = result::Result<T, Error>;
-
-/// An error that can be produced during (de)serializing.
-///
-/// If decoding from a Buffer, assume that the buffer has been left
-/// in an invalid state.
-pub type Error = Box<ErrorKind>;
-
-#[derive(Debug)]
-pub enum ErrorKind {
-    /// If the error stems from the reader/writer that is being used
-    /// during (de)serialization, that error will be stored and returned here.
-    IoError(IoError),
-    /// If the bytes in the reader are not decodable because of an invalid
-    /// encoding, this error will be returned.  This error is only possible
-    /// if a stream is corrupted.  A stream produced from `encode` or `encode_into`
-    /// should **never** produce an InvalidEncoding error.
-    InvalidEncoding{
-        desc: &'static str, 
-        detail: Option<String>
-    },
-    /// If (de)serializing a message takes more than the provided size limit, this
-    /// error is returned.
-    SizeLimit,
-    SequenceMustHaveLength,
-    Custom(String)
-}
-
-impl error::Error for ErrorKind {
-    fn description(&self) -> &str {
-        match *self {
-            ErrorKind::IoError(ref err) => error::Error::description(err),
-            ErrorKind::InvalidEncoding{desc, ..} => desc,
-            ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences",
-            ErrorKind::SizeLimit => "the size limit for decoding has been reached",
-            ErrorKind::Custom(ref msg) => msg,
-
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            ErrorKind::IoError(ref err) => err.cause(),
-            ErrorKind::InvalidEncoding{..} => None,
-            ErrorKind::SequenceMustHaveLength => None,
-            ErrorKind::SizeLimit => None,
-            ErrorKind::Custom(_) => None,
-        }
-    }
-}
-
-impl From<IoError> for Error {
-    fn from(err: IoError) -> Error {
-        ErrorKind::IoError(err).into()
-    }
-}
-
-impl fmt::Display for ErrorKind {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ErrorKind::IoError(ref ioerr) =>
-                write!(fmt, "IoError: {}", ioerr),
-            ErrorKind::InvalidEncoding{desc, detail: None}=>
-                write!(fmt, "InvalidEncoding: {}", desc),
-            ErrorKind::InvalidEncoding{desc, detail: Some(ref detail)}=>
-                write!(fmt, "InvalidEncoding: {} ({})", desc, detail),
-            ErrorKind::SequenceMustHaveLength =>
-                write!(fmt, "Bincode can only encode sequences and maps that have a knowable size ahead of time."),
-            ErrorKind::SizeLimit =>
-                write!(fmt, "SizeLimit"),
-            ErrorKind::Custom(ref s) =>
-                s.fmt(fmt),
-        }
-    }
-}
-
-impl serde::de::Error for Error {
-    fn custom<T: fmt::Display>(desc: T) -> Error {
-        ErrorKind::Custom(desc.to_string()).into()
-    }
-}
-
-impl serde::ser::Error for Error {
-    fn custom<T: fmt::Display>(msg: T) -> Self {
-        ErrorKind::Custom(msg.to_string()).into()
-    }
-}
-
-/// Serializes an object directly into a `Writer`.
-///
-/// If the serialization would take more bytes than allowed by `size_limit`, an error
-/// is returned and *no bytes* will be written into the `Writer`.
-///
-/// If this returns an `Error` (other than SizeLimit), assume that the
-/// writer is in an invalid state, as writing could bail out in the middle of
-/// serializing.
-pub fn serialize_into<W: ?Sized, T: ?Sized, S, E>(writer: &mut W, value: &T, size_limit: S) -> Result<()>
-    where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder
-{
-    if let Some(limit) = size_limit.limit() {
-        try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit));
-    }
-
-    let mut serializer = Serializer::<_, E>::new(writer);
-    serde::Serialize::serialize(value, &mut serializer)
-}
-
-/// Serializes a serializable object into a `Vec` of bytes.
-///
-/// If the serialization would take more bytes than allowed by `size_limit`,
-/// an error is returned.
-pub fn serialize<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
-    where T: serde::Serialize, S: SizeLimit, E: ByteOrder
-{
-    // Since we are putting values directly into a vector, we can do size
-    // computation out here and pre-allocate a buffer of *exactly*
-    // the right size.
-    let mut writer = match size_limit.limit() {
-        Some(size_limit) => {
-            let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(ErrorKind::SizeLimit));
-            Vec::with_capacity(actual_size as usize)
-        }
-        None => Vec::new()
-    };
-
-    try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite));
-    Ok(writer)
-}
-
-
-struct CountSize {
-    total: u64,
-    limit: Option<u64>,
-}
-
-impl SizeLimit for CountSize {
-    fn add(&mut self, c: u64) -> Result<()> {
-        self.total += c;
-        if let Some(limit) = self.limit {
-            if self.total > limit {
-                return Err(Box::new(ErrorKind::SizeLimit))
-            }
-        }
-        Ok(())
-    }
-
-    fn limit(&self) -> Option<u64> {
-        unreachable!();
-    }
-}
-
-/// Returns the size that an object would be if serialized using bincode.
-///
-/// This is used internally as part of the check for encode_into, but it can
-/// be useful for preallocating buffers if thats your style.
-pub fn serialized_size<T: ?Sized>(value: &T) -> u64
-    where T: serde::Serialize
-{
-    let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: None }
-    };
-
-    value.serialize(&mut size_counter).ok();
-    size_counter.size_limit.total
-}
-
-/// Given a maximum size limit, check how large an object would be if it
-/// were to be serialized.
-///
-/// If it can be serialized in `max` or fewer bytes, that number will be returned
-/// inside `Some`.  If it goes over bounds, then None is returned.
-pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64> 
-    where T: serde::Serialize
-{
-    let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: Some(max) }
-    };
-
-    match value.serialize(&mut size_counter) {
-        Ok(_) => Some(size_counter.size_limit.total),
-        Err(_) => None,
-    }
-}
-
-/// Deserializes an object directly from a `Buffer`ed Reader.
-///
-/// If the provided `SizeLimit` is reached, the deserialization will bail immediately.
-/// A SizeLimit can help prevent an attacker from flooding your server with
-/// a neverending stream of values that runs your server out of memory.
-///
-/// If this returns an `Error`, assume that the buffer that you passed
-/// in is in an invalid state, as the error could be returned during any point
-/// in the reading.
-pub fn deserialize_from<R: ?Sized, T, S, E>(reader: &mut R, size_limit: S) -> Result<T>
-    where R: Read, T: serde::Deserialize, S: SizeLimit, E: ByteOrder
-{
-    let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit);
-    serde::Deserialize::deserialize(&mut deserializer)
-}
-
-/// Deserializes a slice of bytes into an object.
-///
-/// This method does not have a size-limit because if you already have the bytes
-/// in memory, then you don't gain anything by having a limiter.
-pub fn deserialize<T, E: ByteOrder>(bytes: &[u8]) -> Result<T>
-    where T: serde::Deserialize,
-{
-    let mut reader = bytes;
-    deserialize_from::<_, _, _, E>(&mut reader, super::Infinite)
-}

deleted file mode 100644
--- a/third_party/rust/bincode/src/serde/reader.rs
+++ /dev/null
@@ -1,439 +0,0 @@
-use std::cmp;
-use std::io::Read;
-use std::marker::PhantomData;
-
-use byteorder::{ReadBytesExt, ByteOrder};
-use serde_crate as serde;
-use serde_crate::de::value::ValueDeserializer;
-use serde_crate::de::Error as DeError;
-use ::SizeLimit;
-use super::{Result, Error, ErrorKind};
-
-const BLOCK_SIZE: usize = 65536;
-
-/// A Deserializer that reads bytes from a buffer.
-///
-/// This struct should rarely be used.
-/// In most cases, prefer the `decode_from` function.
-///
-/// ```rust,ignore
-/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
-/// serde::Deserialize::deserialize(&mut deserializer);
-/// let bytes_read = d.bytes_read();
-/// ```
-pub struct Deserializer<R, S: SizeLimit, E: ByteOrder> {
-    reader: R,
-    size_limit: S,
-    read: u64,
-    _phantom: PhantomData<E>,
-}
-
-impl<R: Read, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E> {
-    pub fn new(r: R, size_limit: S) -> Deserializer<R, S, E> {
-        Deserializer {
-            reader: r,
-            size_limit: size_limit,
-            read: 0,
-            _phantom: PhantomData
-        }
-    }
-
-    /// Returns the number of bytes read from the contained Reader.
-    pub fn bytes_read(&self) -> u64 {
-        self.read
-    }
-
-    fn read_bytes(&mut self, count: u64) -> Result<()> {
-        self.size_limit.add(count)
-    }
-
-    fn read_type<T>(&mut self) -> Result<()> {
-        use std::mem::size_of;
-        self.read_bytes(size_of::<T>() as u64)
-    }
-
-    fn read_vec(&mut self) -> Result<Vec<u8>> {
-        let mut len: usize = try!(serde::Deserialize::deserialize(&mut *self));
-
-        let mut result = Vec::new();
-        let mut off = 0;
-        while len > 0 {
-            let reserve = cmp::min(len, BLOCK_SIZE);
-            try!(self.read_bytes(reserve as u64));
-            unsafe {
-                result.reserve(reserve);
-                result.set_len(off + reserve);
-            }
-            try!(self.reader.read_exact(&mut result[off..]));
-            len -= reserve;
-            off += reserve;
-        }
-        Ok(result)
-    }
-
-    fn read_string(&mut self) -> Result<String> {
-        String::from_utf8(try!(self.read_vec())).map_err(|err|
-            ErrorKind::InvalidEncoding{
-                desc: "error while decoding utf8 string",
-                detail: Some(format!("Deserialize error: {}", err))
-            }.into())
-    }
-}
-
-macro_rules! impl_nums {
-    ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
-        #[inline]
-        fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
-            where V: serde::de::Visitor,
-        {
-            try!(self.read_type::<$ty>());
-            let value = try!(self.reader.$reader_method::<E>());
-            visitor.$visitor_method(value)
-        }
-    }
-}
-
-impl<'a, R, S, E> serde::Deserializer for &'a mut Deserializer<R, S, E>
-where R: Read, S: SizeLimit, E: ByteOrder {
-    type Error = Error;
-
-    #[inline]
-    fn deserialize<V>(self, _visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let message = "bincode does not support Deserializer::deserialize";
-        Err(Error::custom(message))
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let value: u8 = try!(serde::Deserialize::deserialize(self));
-        match value {
-            1 => visitor.visit_bool(true),
-            0 => visitor.visit_bool(false),
-            value => {
-                Err(ErrorKind::InvalidEncoding{
-                    desc: "invalid u8 when decoding bool",
-                    detail: Some(format!("Expected 0 or 1, got {}", value))
-                }.into())
-            }
-        }
-    }
-
-    impl_nums!(u16, deserialize_u16, visit_u16, read_u16);
-    impl_nums!(u32, deserialize_u32, visit_u32, read_u32);
-    impl_nums!(u64, deserialize_u64, visit_u64, read_u64);
-    impl_nums!(i16, deserialize_i16, visit_i16, read_i16);
-    impl_nums!(i32, deserialize_i32, visit_i32, read_i32);
-    impl_nums!(i64, deserialize_i64, visit_i64, read_i64);
-    impl_nums!(f32, deserialize_f32, visit_f32, read_f32);
-    impl_nums!(f64, deserialize_f64, visit_f64, read_f64);
-
-
-    #[inline]
-    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        try!(self.read_type::<u8>());
-        visitor.visit_u8(try!(self.reader.read_u8()))
-    }
-
-    #[inline]
-    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        try!(self.read_type::<i8>());
-        visitor.visit_i8(try!(self.reader.read_i8()))
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        use std::str;
-
-        let error = || {
-            ErrorKind::InvalidEncoding{
-                desc: "Invalid char encoding",
-                detail: None,
-            }.into()
-        };
-
-        let mut buf = [0u8; 4];
-
-        // Look at the first byte to see how many bytes must be read
-        let _ = try!(self.reader.read_exact(&mut buf[..1]));
-        let width = utf8_char_width(buf[0]);
-        if width == 1 { return visitor.visit_char(buf[0] as char) }
-        if width == 0 { return Err(error())}
-
-        if self.reader.read_exact(&mut buf[1..width]).is_err() {
-            return Err(error());
-        }
-
-        let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error()));
-        visitor.visit_char(res)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_str(&try!(self.read_string()))
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_string(try!(self.read_string()))
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_bytes(&try!(self.read_vec()))
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_byte_buf(try!(self.read_vec()))
-    }
-
-    fn deserialize_enum<V>(self,
-                     _enum: &'static str,
-                     _variants: &'static [&'static str],
-                     visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        impl<'a, R: 'a, S, E> serde::de::EnumVisitor for &'a mut Deserializer<R, S, E>
-        where R: Read, S: SizeLimit, E: ByteOrder {
-            type Error = Error;
-            type Variant = Self;
-
-            fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
-                where V: serde::de::DeserializeSeed,
-            {
-                let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self));
-                let val: Result<_> = seed.deserialize(idx.into_deserializer());
-                Ok((try!(val), self))
-            }
-        }
-
-        visitor.visit_enum(self)
-    }
-    
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        struct TupleVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a>(&'a mut Deserializer<R, S, E>);
-
-        impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for TupleVisitor<'a, R, S, E> {
-            type Error = Error;
-
-            fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-                where T: serde::de::DeserializeSeed,
-            {
-                let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.0));
-                Ok(Some(value))
-            }
-        }
-
-        visitor.visit_seq(TupleVisitor(self))
-    }
-
-    fn deserialize_seq_fixed_size<V>(self,
-                            len: usize,
-                            visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        struct SeqVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
-            deserializer: &'a mut Deserializer<R, S, E>,
-            len: usize,
-        }
-
-        impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for SeqVisitor<'a, R, S, E> {
-            type Error = Error;
-
-            fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-                where T: serde::de::DeserializeSeed,
-            {
-                if self.len > 0 {
-                    self.len -= 1;
-                    let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
-                    Ok(Some(value))
-                } else {
-                    Ok(None)
-                }
-            }
-        }
-
-        visitor.visit_seq(SeqVisitor { deserializer: self, len: len })
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self));
-        match value {
-            0 => visitor.visit_none(),
-            1 => visitor.visit_some(&mut *self),
-            _ => Err(ErrorKind::InvalidEncoding{
-                desc: "invalid tag when decoding Option",
-                detail: Some(format!("Expected 0 or 1, got {}", value))
-            }.into()),
-        }
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let len = try!(serde::Deserialize::deserialize(&mut *self));
-
-        self.deserialize_seq_fixed_size(len, visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        struct MapVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
-            deserializer: &'a mut Deserializer<R, S, E>,
-            len: usize,
-        }
-
-        impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapVisitor for MapVisitor<'a, R, S, E> {
-            type Error = Error;
-
-            fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-                where K: serde::de::DeserializeSeed,
-            {
-                if self.len > 0 {
-                    self.len -= 1;
-                    let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
-                    Ok(Some(key))
-                } else {
-                    Ok(None)
-                }
-            }
-
-            fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-                where V: serde::de::DeserializeSeed,
-            {
-                let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
-                Ok(value)
-            }
-        }
-
-        let len = try!(serde::Deserialize::deserialize(&mut *self));
-
-        visitor.visit_map(MapVisitor { deserializer: self, len: len })
-    }
-
-    fn deserialize_struct<V>(self,
-                       _name: &str,
-                       fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        self.deserialize_tuple(fields.len(), visitor)
-    }
-
-    fn deserialize_struct_field<V>(self,
-                                   _visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let message = "bincode does not support Deserializer::deserialize_struct_field";
-        Err(Error::custom(message))
-    }
-
-    fn deserialize_newtype_struct<V>(self,
-                               _name: &str,
-                               visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_unit_struct<V>(self,
-                                  _name: &'static str,
-                                  visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_tuple_struct<V>(self,
-                                   _name: &'static str,
-                                   len: usize,
-                                   visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        self.deserialize_tuple(len, visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self,
-                                  _visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        let message = "bincode does not support Deserializer::deserialize_ignored_any";
-        Err(Error::custom(message))
-    }
-}
-
-impl<'a, R, S, E> serde::de::VariantVisitor for &'a mut Deserializer<R, S, E>
-where R: Read, S: SizeLimit, E: ByteOrder {
-    type Error = Error;
-
-    fn visit_unit(self) -> Result<()> {
-        Ok(())
-    }
-
-    fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value>
-        where T: serde::de::DeserializeSeed,
-    {
-        serde::de::DeserializeSeed::deserialize(seed, self)
-    }
-
-    fn visit_tuple<V>(self,
-                      len: usize,
-                      visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
-    }
-
-    fn visit_struct<V>(self,
-                       fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor,
-    {
-        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
-    }
-}
-static UTF8_CHAR_WIDTH: [u8; 256] = [
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x3F
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x5F
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x7F
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0x9F
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xBF
-0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // 0xDF
-3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, // 0xEF
-4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF
-];
-
-fn utf8_char_width(b: u8) -> usize {
-    UTF8_CHAR_WIDTH[b as usize] as usize
-}