Bug 1447286 - Update Cargo lockfiles and re-vendor rust dependencies. r?jrmuizel draft
authorKartikaya Gupta <kgupta@mozilla.com>
Thu, 22 Mar 2018 10:28:33 -0400
changeset 771134 f708a8ce461d54056a06c43c698341ab5eb11fc6
parent 771133 525be13e782cddd7619a97c1fe303678742acb27
child 771135 a93b06905b70bab64e907525360149d4891b3214
push id103574
push userkgupta@mozilla.com
push dateThu, 22 Mar 2018 14:29:33 +0000
reviewersjrmuizel
bugs1447286
milestone61.0a1
Bug 1447286 - Update Cargo lockfiles and re-vendor rust dependencies. r?jrmuizel MozReview-Commit-ID: 1gpB9n4dNHG
Cargo.lock
third_party/rust/bincode/.cargo-checksum.json
third_party/rust/bincode/.travis.yml
third_party/rust/bincode/Cargo.toml
third_party/rust/bincode/changelist.org
third_party/rust/bincode/examples/basic.rs
third_party/rust/bincode/logo.png
third_party/rust/bincode/readme.dev.md
third_party/rust/bincode/readme.md
third_party/rust/bincode/src/config.rs
third_party/rust/bincode/src/de/mod.rs
third_party/rust/bincode/src/de/read.rs
third_party/rust/bincode/src/error.rs
third_party/rust/bincode/src/internal.rs
third_party/rust/bincode/src/lib.rs
third_party/rust/bincode/src/ser/mod.rs
third_party/rust/bincode/tests/test.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -112,25 +112,16 @@ dependencies = [
 
 [[package]]
 name = "binary-space-partition"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "bincode"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "bincode"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -2020,17 +2011,17 @@ dependencies = [
  "url 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "webrender"
 version = "0.57.0"
 dependencies = [
  "app_units 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bincode 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-graphics 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-text 9.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "dwrote 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "freetype 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2049,17 +2040,17 @@ dependencies = [
  "webrender_api 0.57.0",
 ]
 
 [[package]]
 name = "webrender_api"
 version = "0.57.0"
 dependencies = [
  "app_units 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bincode 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-foundation 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "core-graphics 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "dwrote 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.27 (git+https://github.com/gankro/serde?branch=deserialize_from_enums4)",
@@ -2190,17 +2181,16 @@ dependencies = [
 "checksum aho-corasick 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)" = "500909c4f87a9e52355b26626d890833e9e1d53ac566db76c36faa984b889699"
 "checksum ansi_term 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6b3568b48b7cefa6b8ce125f9bb4989e52fbcc29ebea88df04cc7c5f12f70455"
 "checksum app_units 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "29069a9b483f7780aebb55dafb360c6225eefdc1f98c8d336a65148fd10c37b1"
 "checksum arrayvec 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2f0ef4a9820019a0c91d918918c93dc71d469f581a49b47ddc1d285d4270bbe2"
 "checksum atomic_refcell 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fb2dcb6e6d35f20276943cc04bb98e538b348d525a04ac79c10021561d202f21"
 "checksum atty 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d912da0db7fa85514874458ca3651fe2cddace8d0b0505571dbdcd41ab490159"
 "checksum base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "96434f987501f0ed4eb336a411e0631ecd1afa11574fe148587adc4ff96143c9"
 "checksum binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "88ceb0d16c4fd0e42876e298d7d3ce3780dd9ebdcbe4199816a32c77e08597ff"
-"checksum bincode 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9d3fb369af639822830328794eba2501b3479652fcd021b2aeb1ed4984202afd"
 "checksum bincode 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bda13183df33055cbb84b847becce220d392df502ebe7a4a78d7021771ed94d0"
 "checksum bindgen 0.33.2 (registry+https://github.com/rust-lang/crates.io-index)" = "603ed8d8392ace9581e834e26bd09799bf1e989a79bd1aedbb893e72962bdc6e"
 "checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
 "checksum bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b3c30d3802dfb7281680d6285f2ccdaa8c2d8fee41f93805dba5c4cf50dc23cf"
 "checksum bitreader 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "80b13e2ab064ff3aa0bdbf1eff533f9822dc37899821f5f98c67f263eab51707"
 "checksum boxfnonce 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8380105befe91099e6f69206164072c05bc92427ff6aa8a5171388317346dd75"
 "checksum build_const 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e90dc84f5e62d2ebe7676b83c22d33b6db8bd27340fb6ffbff0a364efa0cb9c9"
 "checksum byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "652805b7e73fada9d85e9a6682a4abd490cb52d96aeecc12e33a0de34dfd0d23"
--- a/third_party/rust/bincode/.cargo-checksum.json
+++ b/third_party/rust/bincode/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"f84aff9184ddcf55e949223d373eb6e25bd50a15d62cda08967c001997658239","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"936b58455e1c221539b73b5250302dcd96baa04a5d8536199d3351142addad57","examples/basic.rs":"6c897fac722343138db14911da8d08c65cfd8d9a8143a5169845914897af8e21","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"a0cf9077393f746baa131934b53780d78e7807f8ce3f71d97347c657aebf5a0a","src/de/mod.rs":"be66fad5844a0b89025a089ab114540ab7ca6fa867cd2d72383af06c9ee30345","src/de/read.rs":"7ad8a1ae881ce135c3a56af66a3c83dad3f66722a3d21ad5c7addf0460d0edf3","src/internal.rs":"60e1c3fac7d8e6b01dc362b3171e2b4d2d8809fcbc98dc2431fffa01da6b63ae","src/lib.rs":"5bb0c0be61c8a7d9c1ef6209e05e25d44ae23e0b9b4a2adc0ae4264d35ea849b","src/ser/mod.rs":"0eeb467eeb8189fb935e4996cd45d1f292c401f92b00793907bd428f1bde421d","tests/test.rs":"a0116953ec3a3d6b9a9fc202d1bc886c5bb95110f2a3d4ac52e5945e4f6d182e"},"package":"9d3fb369af639822830328794eba2501b3479652fcd021b2aeb1ed4984202afd"}
\ No newline at end of file
+{"files":{"Cargo.toml":"eda034c33e46b4b2ec6e6af6f1ddbcbf6642eaa88b46a1692ecc8acc7df9bf53","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","readme.md":"2ff3f54e6efd24b38f981b539be77438c10b9b8f67cad41ca2188396f95bcde8","src/config.rs":"2a6da0f5f95794add175c0a37e2a293f6d4c5932fc43f41492f646a98bf58aa9","src/de/mod.rs":"1da6149812e2d2c4ae8f9fdf7fc5bf85376d2f82da9a9311b0c45eff4033b71d","src/de/read.rs":"f8c5f2466c632f062e6fe55734d27c8fc7566c0894b610f012d8835af1810628","src/error.rs":"00a7a4de5cf1cc4a28dcf44c5c3ff607887baf41d5410b76468088963257b783","src/internal.rs":"6c827579a325e02bc7df8403965616b970b0f9b9763896ed938e719309a681b4","src/lib.rs":"9af9d73dcc1fc19240b8855ed521d38ae963e6685627e5d3eebf9acf40424aa3","src/ser/mod.rs":"b544c335a39a9b702772d586caa44f0e6febae3a0a109625fcee8ac68fc95645"},"package":"bda13183df33055cbb84b847becce220d392df502ebe7a4a78d7021771ed94d0"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/bincode/.travis.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-language: rust
-rust:
-    - stable
-    - beta
-    - nightly
--- a/third_party/rust/bincode/Cargo.toml
+++ b/third_party/rust/bincode/Cargo.toml
@@ -7,27 +7,29 @@
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
 # editing this file be aware that the upstream Cargo.toml
 # will likely look very different (and much more reasonable)
 
 [package]
 name = "bincode"
-version = "0.9.1"
+version = "1.0.0"
 authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>", "David Tolnay <dtolnay@gmail.com>", "Daniel Griffen"]
-exclude = ["./logo.png"]
+exclude = ["logo.png", "tests/*", "examples/*", ".gitignore", ".travis.yml", "changelist.org"]
 publish = true
 description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!"
 documentation = "https://docs.rs/bincode"
+readme = "./readme.md"
 keywords = ["binary", "encode", "decode", "serialize", "deserialize"]
+categories = ["network-programming"]
 license = "MIT"
 repository = "https://github.com/TyOverby/bincode"
 [dependencies.byteorder]
-version = "1.0.0"
+version = "1.2.0"
 
 [dependencies.serde]
-version = "1.*.*"
+version = "^1.0.27"
 [dev-dependencies.serde_bytes]
-version = "0.10.*"
+version = "^0.10.3"
 
 [dev-dependencies.serde_derive]
-version = "1.*.*"
+version = "^1.0.27"
deleted file mode 100644
--- a/third_party/rust/bincode/changelist.org
+++ /dev/null
@@ -1,27 +0,0 @@
-* 1.0.0
-** Removed depricated rustc-serialize support
- Rustc-serialize was a stopgap until projects like Serde were able to catch up.
- With macros stabilization on its way, we are able to switch to serde without any
- big user-friendliness issues.  Major congratulations to Serde for coming this far!
-
-** Moved Refbox, Strbox and Slicebox into a "refbox" module
- Refbox, Strbox and Slicebox are still an integral piece of bincode, but since
- they are mainly used by power-users, this move will make the crate API more organized
- and easier for new users to understand.
-
-** Upgraded to Serde 0.9.*
- Serde 0.9.* gives us a better API surface area and allows use of procedural macros for
- deriving serialize and deserialize implemenetations.
-
-** Moved serde functions into global module
- 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.
deleted file mode 100644
--- a/third_party/rust/bincode/examples/basic.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-extern crate bincode;
-
-use bincode::{serialize, deserialize, Infinite};
-
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
-struct Entity {
-    x: f32,
-    y: f32,
-}
-
-#[derive(Serialize, Deserialize, PartialEq, Debug)]
-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, Infinite).unwrap();
-
-    // 8 bytes for the length of the vector (usize), 4 bytes per float.
-    assert_eq!(encoded.len(), 8 + 4 * 4);
-
-    let decoded: World = deserialize(&encoded[..]).unwrap();
-
-    assert_eq!(world, decoded);
-}
deleted file mode 100644
index b2c454d1f2103b1a9279c9c6acc6e6a23bb7b76d..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
GIT binary patch
literal 0
Hc$@<O00001
deleted file mode 100644
--- a/third_party/rust/bincode/readme.dev.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# 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)
-
-A compact encoder / decoder pair that uses an 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 funcitons 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.
-
-[Api Documentation](http://tyoverby.github.io/bincode/bincode/)
-
-## Example
-
-^code(./examples/basic.rs)
-
-
-## Details
-
-The encoding (and thus decoding) proceeds unsurprisingly -- primitive
-types are encoded according to the underlying `Writer`, tuples and
-structs are encoded by encoding their fields one-by-one, and enums are
-encoded by first writing out the tag representing the variant and
-then the contents.
-
-However, there are some implementation details to be aware of:
-
-* `isize`/`usize` are encoded as `i64`/`u64`, for portability.
-* enums variants are encoded as a `u32` instead that as a `uint`.
-  `u32` is enough for all practical uses.
-* `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of
-  bytes contained in the encoded string.
--- a/third_party/rust/bincode/readme.md
+++ b/third_party/rust/bincode/readme.md
@@ -1,14 +1,14 @@
 # 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://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 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
 (one that encodes to `Vec<u8>`, and one that decodes from `&[u8]`),
new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/config.rs
@@ -0,0 +1,312 @@
+use super::internal::{Bounded, Infinite, SizeLimit};
+use ::error::Result;
+use byteorder::{BigEndian, ByteOrder, LittleEndian, NativeEndian};
+use {DeserializerAcceptor, SerializerAcceptor};
+use serde;
+use std::io::{Write, Read};
+use std::marker::PhantomData;
+use de::read::BincodeRead;
+
+use self::LimitOption::*;
+use self::EndianOption::*;
+
+struct DefaultOptions(Infinite);
+
+pub(crate) trait Options {
+    type Limit: SizeLimit + 'static;
+    type Endian: ByteOrder + 'static;
+
+    fn limit(&mut self) -> &mut Self::Limit;
+}
+
+pub(crate) trait OptionsExt: Options + Sized {
+    fn with_no_limit(self) -> WithOtherLimit<Self, Infinite> {
+        WithOtherLimit::new(self, Infinite)
+    }
+
+    fn with_limit(self, limit: u64) -> WithOtherLimit<Self, Bounded> {
+        WithOtherLimit::new(self, Bounded(limit))
+    }
+
+    fn with_little_endian(self) -> WithOtherEndian<Self, LittleEndian> {
+        WithOtherEndian::new(self)
+    }
+
+    fn with_big_endian(self) -> WithOtherEndian<Self, BigEndian> {
+        WithOtherEndian::new(self)
+    }
+
+    fn with_native_endian(self) -> WithOtherEndian<Self, NativeEndian> {
+        WithOtherEndian::new(self)
+    }
+}
+
+impl<'a, O: Options> Options for &'a mut O {
+    type Limit = O::Limit;
+    type Endian = O::Endian;
+
+    #[inline(always)]
+    fn limit(&mut self) -> &mut Self::Limit {
+        (*self).limit()
+    }
+}
+
+impl<T: Options> OptionsExt for T {}
+
+impl DefaultOptions {
+    fn new() -> DefaultOptions {
+        DefaultOptions(Infinite)
+    }
+}
+
+impl Options for DefaultOptions {
+    type Limit = Infinite;
+    type Endian = LittleEndian;
+
+    #[inline(always)]
+    fn limit(&mut self) -> &mut Infinite {
+        &mut self.0
+    }
+}
+
+#[derive(Clone, Copy)]
+enum LimitOption {
+    Unlimited,
+    Limited(u64),
+}
+
+#[derive(Clone, Copy)]
+enum EndianOption {
+    Big,
+    Little,
+    Native,
+}
+
+/// A configuration builder whose options Bincode will use
+/// while serializing and deserializing.
+///
+/// ### Options
+/// Endianness: The endianness with which multi-byte integers will be read/written.  *default: little endian*
+/// Limit: The maximum number of bytes that will be read/written in a bincode serialize/deserialize. *default: unlimited*
+///
+/// ### Byte Limit Details
+/// The purpose of byte-limiting is to prevent Denial-Of-Service attacks whereby malicious attackers get bincode
+/// deserialization to crash your process by allocating too much memory or keeping a connection open for too long.
+///
+/// When a byte limit is set, bincode will return `Err` on any deserialization that goes over the limit, or any
+/// serialization that goes over the limit.
+pub struct Config {
+    limit: LimitOption,
+    endian: EndianOption,
+}
+
+pub(crate) struct WithOtherLimit<O: Options, L: SizeLimit> {
+    _options: O,
+    pub(crate) new_limit: L,
+}
+
+pub(crate) struct WithOtherEndian<O: Options, E: ByteOrder> {
+    options: O,
+    _endian: PhantomData<E>,
+}
+
+
+impl<O: Options, L: SizeLimit> WithOtherLimit<O, L> {
+    #[inline(always)]
+    pub(crate) fn new(options: O, limit: L) -> WithOtherLimit<O, L> {
+        WithOtherLimit {
+            _options: options,
+            new_limit: limit,
+        }
+    }
+}
+
+impl<O: Options, E: ByteOrder> WithOtherEndian<O, E> {
+    #[inline(always)]
+    pub(crate) fn new(options: O) -> WithOtherEndian<O, E> {
+        WithOtherEndian {
+            options: options,
+            _endian: PhantomData,
+        }
+    }
+}
+
+impl<O: Options, E: ByteOrder + 'static> Options for WithOtherEndian<O, E> {
+    type Limit = O::Limit;
+    type Endian = E;
+
+    #[inline(always)]
+    fn limit(&mut self) -> &mut O::Limit {
+        self.options.limit()
+    }
+}
+
+impl<O: Options, L: SizeLimit + 'static> Options for WithOtherLimit<O, L> {
+    type Limit = L;
+    type Endian = O::Endian;
+
+    fn limit(&mut self) -> &mut L {
+        &mut self.new_limit
+    }
+}
+
+macro_rules! config_map {
+    ($self:expr, $opts:ident => $call:expr) => {
+        match ($self.limit, $self.endian) {
+            (Unlimited, Little) => {
+                let $opts = DefaultOptions::new().with_no_limit().with_little_endian();
+                $call
+            }
+            (Unlimited, Big) => {
+                let $opts = DefaultOptions::new().with_no_limit().with_big_endian();
+                $call
+            }
+            (Unlimited, Native) => {
+                let $opts = DefaultOptions::new().with_no_limit().with_native_endian();
+                $call
+            }
+
+            (Limited(l), Little) => {
+                let $opts = DefaultOptions::new().with_limit(l).with_little_endian();
+                $call
+            }
+            (Limited(l), Big) => {
+                let $opts = DefaultOptions::new().with_limit(l).with_big_endian();
+                $call
+            }
+            (Limited(l), Native) => {
+                let $opts = DefaultOptions::new().with_limit(l).with_native_endian();
+                $call
+            }
+        }
+    }
+}
+
+impl Config {
+    #[inline(always)]
+    pub(crate) fn new() -> Config {
+        Config {
+            limit: LimitOption::Unlimited,
+            endian: EndianOption::Little,
+        }
+    }
+
+    /// Sets the byte limit to be unlimited.
+    /// This is the default.
+    #[inline(always)]
+    pub fn no_limit(&mut self) -> &mut Self {
+        self.limit = LimitOption::Unlimited;
+        self
+    }
+
+    /// Sets the byte limit to `limit`.
+    #[inline(always)]
+    pub fn limit(&mut self, limit: u64) -> &mut Self {
+        self.limit = LimitOption::Limited(limit);
+        self
+    }
+
+    /// Sets the endianness to little-endian
+    /// This is the default.
+    #[inline(always)]
+    pub fn little_endian(&mut self) -> &mut Self {
+        self.endian = EndianOption::Little;
+        self
+    }
+
+    /// Sets the endianness to big-endian
+    #[inline(always)]
+    pub fn big_endian(&mut self) -> &mut Self {
+        self.endian= EndianOption::Big;
+        self
+    }
+
+    /// Sets the endianness to the the machine-native endianness
+    #[inline(always)]
+    pub fn native_endian(&mut self) -> &mut Self {
+        self.endian = EndianOption::Native;
+        self
+    }
+
+    /// Serializes a serializable object into a `Vec` of bytes using this configuration
+    #[inline(always)]
+    pub fn serialize<T: ?Sized + serde::Serialize>(&self, t: &T) -> Result<Vec<u8>> {
+        config_map!(self, opts => ::internal::serialize(t, opts))
+    }
+
+    /// Returns the size that an object would be if serialized using Bincode with this configuration
+    #[inline(always)]
+    pub fn serialized_size<T: ?Sized + serde::Serialize>(&self, t: &T) -> Result<u64> {
+        config_map!(self, opts => ::internal::serialized_size(t, opts))
+    }
+
+    /// Serializes an object directly into a `Writer` using this configuration
+    ///
+    /// If the serialization would take more bytes than allowed by the size limit, an error
+    /// is returned and *no bytes* will be written into the `Writer`
+    #[inline(always)]
+    pub fn serialize_into<W: Write, T: ?Sized + serde::Serialize>(&self, w: W, t: &T) -> Result<()> {
+        config_map!(self, opts => ::internal::serialize_into(w, t, opts))
+    }
+
+    /// Deserializes a slice of bytes into an instance of `T` using this configuration
+    #[inline(always)]
+    pub fn deserialize<'a, T: serde::Deserialize<'a>>(&self, bytes: &'a [u8]) -> Result<T> {
+        config_map!(self, opts => ::internal::deserialize(bytes, opts))
+    }
+
+    /// TODO: document
+    #[doc(hidden)]
+    #[inline(always)]
+    pub fn deserialize_in_place<'a, R, T: >(&self, reader: R, place: &mut T) -> Result<()>
+    where
+        R: BincodeRead<'a>,
+        T: serde::de::Deserialize<'a>
+    {
+        config_map!(self, opts => ::internal::deserialize_in_place(reader, opts, place))
+    }
+
+    /// Deserializes an object directly from a `Read`er using this configuration
+    ///
+    /// If this returns an `Error`, `reader` may be in an invalid state.
+    #[inline(always)]
+    pub fn deserialize_from<R: Read, T: serde::de::DeserializeOwned>(&self, reader: R) -> Result<T> {
+        config_map!(self, opts => ::internal::deserialize_from(reader, opts))
+    }
+
+    /// Deserializes an object from a custom `BincodeRead`er using the default configuration.
+    /// It is highly recommended to use `deserialize_from` unless you need to implement
+    /// `BincodeRead` for performance reasons.
+    ///
+    /// If this returns an `Error`, `reader` may be in an invalid state.
+    #[inline(always)]
+    pub fn deserialize_from_custom<'a, R: BincodeRead<'a>, T: serde::de::DeserializeOwned>(&self, reader: R) -> Result<T> {
+        config_map!(self, opts => ::internal::deserialize_from_custom(reader, opts))
+    }
+
+    /// Executes the acceptor with a serde::Deserializer instance.
+    /// NOT A PART OF THE STABLE PUBLIC API
+    #[doc(hidden)]
+    pub fn with_deserializer<'a, A,  R>(&self, reader: R, acceptor: A) -> A::Output
+    where A: DeserializerAcceptor<'a>,
+          R: BincodeRead<'a>
+    {
+        config_map!(self, opts => {
+            let mut deserializer = ::de::Deserializer::new(reader, opts);
+            acceptor.accept(&mut deserializer)
+        })
+    }
+
+    /// Executes the acceptor with a serde::Serializer instance.
+    /// NOT A PART OF THE STABLE PUBLIC API
+    #[doc(hidden)]
+    pub fn with_serializer<A, W>(&self, writer: W, acceptor: A) -> A::Output
+    where A: SerializerAcceptor,
+        W: Write
+    {
+        config_map!(self, opts => {
+            let mut serializer = ::ser::Serializer::new(writer, opts);
+            acceptor.accept(&mut serializer)
+        })
+    }
+}
--- a/third_party/rust/bincode/src/de/mod.rs
+++ b/third_party/rust/bincode/src/de/mod.rs
@@ -1,362 +1,420 @@
 use std::io::Read;
-use std::marker::PhantomData;
+use ::config::Options;
 
-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 serde;
+use byteorder::ReadBytesExt;
+use serde::de::IntoDeserializer;
+use serde::de::Error as DeError;
+use ::{Error, ErrorKind, Result};
+use ::internal::SizeLimit;
 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.
+/// In most cases, prefer the `deserialize_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> {
+pub(crate) struct Deserializer<R, O: Options> {
     reader: R,
-    size_limit: S,
-    _phantom: PhantomData<E>,
+    options: O,
 }
 
-impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E> {
+impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> {
     /// 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> {
+    pub(crate) fn new(r: R, options: O) -> Deserializer<R, O> {
         Deserializer {
             reader: r,
-            size_limit: size_limit,
-            _phantom: PhantomData
+            options: options,
         }
     }
 
     fn read_bytes(&mut self, count: u64) -> Result<()> {
-        self.size_limit.add(count)
+        self.options.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> {
         let vec = self.read_vec()?;
-        String::from_utf8(vec).map_err(|e|
-            ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
+        String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).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>());
+            let value = try!(self.reader.$reader_method::<O::Endian>());
             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 {
+impl<'de, 'a, R, O> serde::Deserializer<'de> for &'a mut Deserializer<R, O>
+where
+    R: BincodeRead<'de>,
+    O: Options,
+{
     type Error = Error;
 
     #[inline]
     fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
     }
 
     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    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::InvalidBoolEncoding(value).into())
-            }
+            value => Err(ErrorKind::InvalidBoolEncoding(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>,
+    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>,
+    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>,
+    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>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         use std::str;
 
-        let error = || {
-            ErrorKind::InvalidCharEncoding.into()
-        };
+        let error = || ErrorKind::InvalidCharEncoding.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 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()));
+        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>,
+    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>,
+    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>,
+    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>,
+    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>,
+    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 {
+        impl<'de, 'a, R: 'a, O> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, O>
+        where R: BincodeRead<'de>, O: Options {
             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>,
+    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>,
+        struct Access<'a, R: Read + 'a, O: Options + 'a> {
+            deserializer: &'a mut Deserializer<R, O>,
             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> {
+        impl<
+            'de,
+            'a,
+            'b: 'a,
+            R: BincodeRead<'de> + 'b,
+            O: Options,
+        > serde::de::SeqAccess<'de> for Access<'a, R, O> {
             type Error = Error;
 
             fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-                where T: serde::de::DeserializeSeed<'de>,
+            where
+                T: serde::de::DeserializeSeed<'de>,
             {
                 if self.len > 0 {
                     self.len -= 1;
-                    let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    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 })
+        visitor.visit_seq(Access {
+            deserializer: self,
+            len: len,
+        })
     }
 
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    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),
-            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into())
+            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()),
         }
     }
 
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    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>,
+    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>,
+        struct Access<'a, R: Read + 'a, O: Options + 'a> {
+            deserializer: &'a mut Deserializer<R, O>,
             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> {
+        impl<
+            'de,
+            'a,
+            'b: 'a,
+            R: BincodeRead<'de> + 'b,
+            O: Options,
+        > serde::de::MapAccess<'de> for Access<'a, R, O> {
             type Error = Error;
 
             fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-                where K: serde::de::DeserializeSeed<'de>,
+            where
+                K: serde::de::DeserializeSeed<'de>,
             {
                 if self.len > 0 {
                     self.len -= 1;
-                    let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    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>,
+            where
+                V: serde::de::DeserializeSeed<'de>,
             {
-                let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                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 })
+        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>,
+    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>,
+    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";
+        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>,
+    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>,
+    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>,
+    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>,
+    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";
+        let message = "Bincode does not support Deserializer::deserialize_ignored_any";
         Err(Error::custom(message))
     }
+
+    fn is_human_readable(&self) -> bool {
+        false
+    }
 }
 
-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 {
+impl<'de, 'a, R, O> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, O>
+where R: BincodeRead<'de>, O: Options{
     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>,
@@ -394,11 +452,12 @@ 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
 ];
 
+// This function is a copy of core::str::utf8_char_width
 fn utf8_char_width(b: u8) -> usize {
     UTF8_CHAR_WIDTH[b as usize] as usize
 }
--- a/third_party/rust/bincode/src/de/read.rs
+++ b/third_party/rust/bincode/src/de/read.rs
@@ -1,151 +1,184 @@
 use std::io;
-use ::Result;
-use serde_crate as serde;
+use error::Result;
+use serde;
 
-/// A byte-oriented reading trait that is specialized for
-/// slices and generic readers.
-pub trait BincodeRead<'storage>: io::Read + ::private::Sealed {
-    #[doc(hidden)]
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
-    where V: serde::de::Visitor<'storage>;
+/// An optional Read trait for advanced Bincode usage.
+///
+/// It is highly recommended to use bincode with `io::Read` or `&[u8]` before
+/// implementing a custom `BincodeRead`.
+pub trait BincodeRead<'storage>: io::Read {
+    /// Forwards reading `length` bytes of a string on to the serde reader.
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
+    where
+        V: serde::de::Visitor<'storage>;
 
-    #[doc(hidden)]
+    /// Return the first `length` bytes of the internal byte buffer.
     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>;
+    /// Forwards reading `length` bytes on to the serde reader.
+    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
+/// NOT A PART OF THE STABLE PUBLIC API
+#[doc(hidden)]
 pub struct SliceReader<'storage> {
-    slice: &'storage [u8]
+    slice: &'storage [u8],
 }
 
 /// A BincodeRead implementation for io::Readers
+/// NOT A PART OF THE STABLE PUBLIC API
+#[doc(hidden)]
 pub struct IoReader<R> {
     reader: R,
     temp_buffer: Vec<u8>,
 }
 
-impl <'storage> SliceReader<'storage> {
+impl<'storage> SliceReader<'storage> {
     /// Constructs a slice reader
     pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> {
-        SliceReader {
-            slice: bytes,
-        }
+        SliceReader { slice: bytes }
     }
 }
 
-impl <R> IoReader<R> {
+impl<R> IoReader<R> {
     /// Constructs an IoReadReader
     pub fn new(r: R) -> IoReader<R> {
         IoReader {
             reader: r,
             temp_buffer: vec![],
         }
     }
 }
 
-impl <'storage> io::Read for SliceReader<'storage> {
-    fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
+impl<'storage> io::Read for SliceReader<'storage> {
+    #[inline(always)]
+    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
         (&mut self.slice).read(out)
     }
-    fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> {
+    #[inline(always)]
+    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
         (&mut self.slice).read_exact(out)
     }
 }
 
-impl <R: io::Read> io::Read for IoReader<R> {
-    fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
+impl<R: io::Read> io::Read for IoReader<R> {
+    #[inline(always)]
+    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
         self.reader.read(out)
     }
-    fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> {
+    #[inline(always)]
+    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
         self.reader.read_exact(out)
     }
 }
 
-impl <'storage> SliceReader<'storage> {
+impl<'storage> SliceReader<'storage> {
+    #[inline(always)]
     fn unexpected_eof() -> Box<::ErrorKind> {
-        return Box::new(::ErrorKind::Io(io::Error::new(io::ErrorKind::UnexpectedEof, "")));
+        return Box::new(::ErrorKind::Io(
+            io::Error::new(io::ErrorKind::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;
+impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
+    #[inline(always)]
+    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(e) => return Err(ErrorKind::InvalidUtf8Encoding(e).into()),
         };
         let r = visitor.visit_borrowed_str(string);
         self.slice = &self.slice[length..];
         r
     }
 
+    #[inline(always)]
     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> {
+    #[inline(always)]
+    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> IoReader<R> where R: io::Read {
+impl<R> IoReader<R>
+where
+    R: io::Read,
+{
     fn fill_buffer(&mut self, length: usize) -> Result<()> {
         let current_length = self.temp_buffer.len();
-        if length > current_length{
+        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])?;
+        unsafe {
+            self.temp_buffer.set_len(length);
+        }
+
+        self.reader.read_exact(&mut self.temp_buffer)?;
         Ok(())
     }
 }
 
-impl <R> BincodeRead<'static> for IoReader<R> where R: io::Read {
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
-    where V: serde::de::Visitor<'static> {
+impl<R> BincodeRead<'static> for IoReader<R>
+where
+    R: io::Read,
+{
+    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]) {
+        let string = match ::std::str::from_utf8(&self.temp_buffer[..]) {
             Ok(s) => s,
             Err(e) => return Err(::ErrorKind::InvalidUtf8Encoding(e).into()),
         };
 
         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())
+        Ok(::std::mem::replace(&mut self.temp_buffer, Vec::new()))
     }
 
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
-    where V: serde::de::Visitor<'static> {
+    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]);
+        let r = visitor.visit_bytes(&self.temp_buffer[..]);
         r
     }
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/bincode/src/error.rs
@@ -0,0 +1,119 @@
+use std::io;
+use std::{error, fmt};
+use std::str::Utf8Error;
+use std::error::Error as StdError;
+
+use serde;
+
+/// The result of a serialization or deserialization operation.
+pub type Result<T> = ::std::result::Result<T, Error>;
+
+/// An error that can be produced during (de)serializing.
+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.
+    Io(io::Error),
+    /// Returned if the deserializer attempts to deserialize a string that is not valid utf8
+    InvalidUtf8Encoding(Utf8Error),
+    /// Returned if the deserializer attempts to deserialize a bool that was
+    /// not encoded as either a 1 or a 0
+    InvalidBoolEncoding(u8),
+    /// Returned if the deserializer attempts to deserialize a char that is not in the correct format.
+    InvalidCharEncoding,
+    /// Returned if the deserializer attempts to deserialize the tag of an enum that is
+    /// not in the expected ranges
+    InvalidTagEncoding(usize),
+    /// Serde has a deserialize_any method that lets the format hint to the
+    /// object which route to take in deserializing.
+    DeserializeAnyNotSupported,
+    /// 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 StdError for ErrorKind {
+    fn description(&self) -> &str {
+        match *self {
+            ErrorKind::Io(ref err) => error::Error::description(err),
+            ErrorKind::InvalidUtf8Encoding(_) => "string is not valid utf8",
+            ErrorKind::InvalidBoolEncoding(_) => "invalid u8 while decoding bool",
+            ErrorKind::InvalidCharEncoding => "char is not valid",
+            ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid",
+            ErrorKind::SequenceMustHaveLength =>
+                "Bincode can only encode sequences and maps that have a knowable size ahead of time",
+            ErrorKind::DeserializeAnyNotSupported => {
+                "Bincode doesn't support serde::Deserializer::deserialize_any"
+            }
+            ErrorKind::SizeLimit => "the size limit has been reached",
+            ErrorKind::Custom(ref msg) => msg,
+
+        }
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            ErrorKind::Io(ref err) => Some(err),
+            ErrorKind::InvalidUtf8Encoding(_) => None,
+            ErrorKind::InvalidBoolEncoding(_) => None,
+            ErrorKind::InvalidCharEncoding => None,
+            ErrorKind::InvalidTagEncoding(_) => None,
+            ErrorKind::SequenceMustHaveLength => None,
+            ErrorKind::DeserializeAnyNotSupported => None,
+            ErrorKind::SizeLimit => None,
+            ErrorKind::Custom(_) => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        ErrorKind::Io(err).into()
+    }
+}
+
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ErrorKind::Io(ref ioerr) => write!(fmt, "io error: {}", ioerr),
+            ErrorKind::InvalidUtf8Encoding(ref e) => write!(fmt, "{}: {}", self.description(), e),
+            ErrorKind::InvalidBoolEncoding(b) => {
+                write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b)
+            }
+            ErrorKind::InvalidCharEncoding => write!(fmt, "{}", self.description()),
+            ErrorKind::InvalidTagEncoding(tag) => {
+                write!(fmt, "{}, found {}", self.description(), tag)
+            }
+            ErrorKind::SequenceMustHaveLength => {
+                write!(fmt, "{}", self.description())
+            }
+            ErrorKind::SizeLimit => write!(fmt, "{}", self.description()),
+            ErrorKind::DeserializeAnyNotSupported => {
+                write!(
+                    fmt,
+                    "Bincode does not support the serde::Deserializer::deserialize_any method"
+                )
+            }
+            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()
+    }
+}
--- a/third_party/rust/bincode/src/internal.rs
+++ b/third_party/rust/bincode/src/internal.rs
@@ -1,249 +1,164 @@
-//! A collection of serialization and deserialization functions
-//! that use the `serde` crate for the serializable and deserializable
-//! implementation.
-
-use std::io::{self, Write, Read};
-use std::{error, fmt, result};
-use std::str::Utf8Error;
-use ::{CountSize, SizeLimit};
-use byteorder::{ByteOrder};
-use std::error::Error as StdError;
-
-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>;
+use std::io::{Read, Write};
+use serde;
 
-/// An error that can be produced during (de)serializing.
-pub type Error = Box<ErrorKind>;
+use config::{Options, OptionsExt};
+use de::read::BincodeRead;
+use {ErrorKind, Result};
 
-/// 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.
-    Io(io::Error),
-    /// Returned if the deserializer attempts to deserialize a string that is not valid utf8
-    InvalidUtf8Encoding(Utf8Error),
-    /// Returned if the deserializer attempts to deserialize a bool that was
-    /// not encoded as either a 1 or a 0
-    InvalidBoolEncoding(u8),
-    /// Returned if the deserializer attempts to deserialize a char that is not in the correct format.
-    InvalidCharEncoding,
-    /// Returned if the deserializer attempts to deserialize the tag of an enum that is
-    /// not in the expected ranges
-    InvalidTagEncoding(usize),
-    /// Serde has a deserialize_any method that lets the format hint to the
-    /// object which route to take in deserializing.
-    DeserializeAnyNotSupported,
-    /// 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)
+#[derive(Clone)]
+struct CountSize<L: SizeLimit> {
+    total: u64,
+    other_limit: L,
 }
 
-impl StdError for ErrorKind {
-    fn description(&self) -> &str {
-        match *self {
-            ErrorKind::Io(ref err) => error::Error::description(err),
-            ErrorKind::InvalidUtf8Encoding(_) => "string is not valid utf8",
-            ErrorKind::InvalidBoolEncoding(_) => "invalid u8 while decoding bool",
-            ErrorKind::InvalidCharEncoding => "char is not valid",
-            ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid",
-            ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences",
-            ErrorKind::DeserializeAnyNotSupported => "bincode doesn't support serde::Deserializer::deserialize_any",
-            ErrorKind::SizeLimit => "the size limit for decoding has been reached",
-            ErrorKind::Custom(ref msg) => msg,
-
-        }
+pub(crate) fn serialize_into<W, T: ?Sized, O>(writer: W, value: &T, mut options: O) -> Result<()>
+where
+    W: Write,
+    T: serde::Serialize,
+    O: Options,
+{
+    if options.limit().limit().is_some() {
+        // "compute" the size for the side-effect
+        // of returning Err if the bound was reached.
+        serialized_size(value, &mut options)?;
     }
 
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            ErrorKind::Io(ref err) => Some(err),
-            ErrorKind::InvalidUtf8Encoding(_) => None,
-            ErrorKind::InvalidBoolEncoding(_) => None,
-            ErrorKind::InvalidCharEncoding => None,
-            ErrorKind::InvalidTagEncoding(_) => None,
-            ErrorKind::SequenceMustHaveLength => None,
-            ErrorKind::DeserializeAnyNotSupported => None,
-            ErrorKind::SizeLimit => None,
-            ErrorKind::Custom(_) => None,
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error {
-        ErrorKind::Io(err).into()
-    }
-}
-
-impl fmt::Display for ErrorKind {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ErrorKind::Io(ref ioerr) =>
-                write!(fmt, "io error: {}", ioerr),
-            ErrorKind::InvalidUtf8Encoding(ref e) =>
-                write!(fmt, "{}: {}", self.description(), e),
-            ErrorKind::InvalidBoolEncoding(b) =>
-                write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b),
-            ErrorKind::InvalidCharEncoding =>
-                write!(fmt, "{}", self.description()),
-            ErrorKind::InvalidTagEncoding(tag) =>
-                write!(fmt, "{}, found {}", self.description(), tag),
-            ErrorKind::SequenceMustHaveLength =>
-                write!(fmt, "bincode can only encode sequences and maps that have a knowable size ahead of time."),
-            ErrorKind::SizeLimit =>
-                write!(fmt, "size limit was exceeded"),
-            ErrorKind::DeserializeAnyNotSupported=>
-                write!(fmt, "bincode does not support the serde::Deserializer::deserialize_any method"),
-            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, T: ?Sized, S, E>(writer: 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);
+    let mut serializer = ::ser::Serializer::<_, O>::new(writer, options);
     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
+pub(crate) fn serialize<T: ?Sized, O>(value: &T, mut options: O) -> Result<Vec<u8>>
+where
+    T: serde::Serialize,
+    O: Options,
 {
-    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)
-        }
+    let mut writer = {
+        let actual_size = serialized_size(value, &mut options)?;
+        Vec::with_capacity(actual_size as usize)
     };
 
-    try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite));
+    serialize_into(&mut writer, value, options.with_no_limit())?;
     Ok(writer)
 }
 
-impl SizeLimit for CountSize {
+impl<L: SizeLimit> SizeLimit for CountSize<L> {
     fn add(&mut self, c: u64) -> Result<()> {
+        self.other_limit.add(c)?;
         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
+pub(crate) fn serialized_size<T: ?Sized, O: Options>(value: &T, mut options: O) -> Result<u64>
+where
+    T: serde::Serialize,
 {
-    let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: None }
+    let old_limiter = options.limit().clone();
+    let mut size_counter = ::ser::SizeChecker {
+        options: ::config::WithOtherLimit::new(
+            options,
+            CountSize {
+                total: 0,
+                other_limit: old_limiter,
+            },
+        ),
     };
 
-    value.serialize(&mut size_counter).ok();
-    size_counter.size_limit.total
+    let result = value.serialize(&mut size_counter);
+    result.map(|_| size_counter.options.new_limit.total)
+}
+
+pub(crate) fn deserialize_from<R, T, O>(reader: R, options: O) -> Result<T>
+where
+    R: Read,
+    T: serde::de::DeserializeOwned,
+    O: Options,
+{
+    let reader = ::de::read::IoReader::new(reader);
+    let mut deserializer = ::de::Deserializer::<_, O>::new(reader, options);
+    serde::Deserialize::deserialize(&mut deserializer)
+}
+
+pub(crate) fn deserialize_from_custom<'a, R, T, O>(reader: R, options: O) -> Result<T>
+where
+    R: BincodeRead<'a>,
+    T: serde::de::DeserializeOwned,
+    O: Options,
+{
+    let mut deserializer = ::de::Deserializer::<_, O>::new(reader, options);
+    serde::Deserialize::deserialize(&mut deserializer)
 }
 
-/// 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
+pub(crate) fn deserialize_in_place<'a, R, T, O>(reader: R, options: O, place: &mut T) -> Result<()>
+where
+    R: BincodeRead<'a>,
+    T: serde::de::Deserialize<'a>,
+    O: Options,
+{
+    let mut deserializer = ::de::Deserializer::<_, _>::new(reader, options);
+    serde::Deserialize::deserialize_in_place(&mut deserializer, place)
+}
+
+pub(crate) fn deserialize<'a, T, O>(bytes: &'a [u8], options: O) -> Result<T>
+where
+    T: serde::de::Deserialize<'a>,
+    O: Options,
 {
-    let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: Some(max) }
-    };
+    let reader = ::de::read::SliceReader::new(bytes);
+    let options = ::config::WithOtherLimit::new(options, Infinite);
+    let mut deserializer = ::de::Deserializer::new(reader, options);
+    serde::Deserialize::deserialize(&mut deserializer)
+}
+
+
+pub(crate) trait SizeLimit: Clone {
+    /// 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>;
+}
+
 
-    match value.serialize(&mut size_counter) {
-        Ok(_) => Some(size_counter.size_limit.total),
-        Err(_) => None,
+/// 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)
     }
 }
 
-/// Deserializes an object directly from a `Read`er.
-///
-/// 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, T, S, E>(reader: R, size_limit: S) -> Result<T>
-    where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder
-{
-    let reader = ::de::read::IoReader::new(reader);
-    let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit);
-    serde::Deserialize::deserialize(&mut deserializer)
+impl SizeLimit for Infinite {
+    #[inline(always)]
+    fn add(&mut self, _: u64) -> Result<()> {
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn limit(&self) -> Option<u64> {
+        None
+    }
 }
-
-/// 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,181 +1,165 @@
 #![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 `serialize_into` and `deserialize_from`
-//! functions which respectively allow encoding into any `std::io::Write`
-//! or decode from any `std::io::Read`.
-//!
-//! ## Modules
-//! 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.
+//! Bincode is a crate for encoding and decoding using a tiny binary
+//! serialization strategy.  Using it, you can easily go from having
+//! an object in memory, quickly serialize it to bytes, and then
+//! deserialize it back just as fast!
 //!
 //! ### Using Basic Functions
 //!
 //! ```rust
 //! extern crate bincode;
-//! use bincode::{serialize, deserialize, Bounded};
+//! use bincode::{serialize, deserialize};
 //! fn main() {
 //!     // The object that we will serialize.
-//!     let target = Some("hello world".to_string());
-//!     // The maximum size of the encoded message.
-//!     let limit = Bounded(20);
+//!     let target: Option<String>  = Some("hello world".to_string());
 //!
-//!     let encoded: Vec<u8>        = serialize(&target, limit).unwrap();
+//!     let encoded: Vec<u8>        = serialize(&target).unwrap();
 //!     let decoded: Option<String> = deserialize(&encoded[..]).unwrap();
 //!     assert_eq!(target, decoded);
 //! }
 //! ```
 
 #![crate_name = "bincode"]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 
 extern crate byteorder;
-extern crate serde as serde_crate;
-
-mod ser;
-mod de;
-pub mod internal;
+extern crate serde;
 
-pub mod read_types {
-    //! The types that the deserializer uses for optimizations
-    pub use ::de::read::{SliceReader, BincodeRead, IoReader};
-}
-
-use std::io::{Read, Write};
+mod config;
+mod ser;
+mod error;
+mod de;
+mod internal;
 
-pub use internal::{ErrorKind, Error, Result, serialized_size, serialized_size_bounded};
-
-/// 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>;
+pub use error::{Error, ErrorKind, Result};
+pub use config::Config;
+pub use de::read::{BincodeRead, IoReader, SliceReader};
 
-/// Deserializes a slice of bytes into an object.
+/// An object that implements this trait can be passed a
+/// serde::Deserializer without knowing its concrete type.
 ///
-/// 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>(bytes: &'a [u8]) -> internal::Result<T>
-    where T: serde_crate::de::Deserialize<'a>,
-{
-    internal::deserialize::<_, byteorder::LittleEndian>(bytes)
+/// This trait should be used only for `with_deserializer` functions.
+#[doc(hidden)]
+pub trait DeserializerAcceptor<'a> {
+    /// The return type for the accept method
+    type Output;
+    /// Accept a serde::Deserializer and do whatever you want with it.
+    fn accept<T: serde::Deserializer<'a>>(self, T) -> Self::Output;
 }
 
-/// 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.
+/// An object that implements this trait can be passed a
+/// serde::Serializer without knowing its concrete type.
 ///
-/// 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) -> internal::Result<T>
-    where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit
-{
-    internal::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit)
+/// This trait should be used only for `with_serializer` functions.
+#[doc(hidden)]
+pub trait SerializerAcceptor {
+    /// The return type for the accept method
+    type Output;
+    /// Accept a serde::Serializer and do whatever you want with it.
+    fn accept<T: serde::Serializer>(self, T) -> Self::Output;
 }
 
-/// Serializes an object directly into a `Writer`.
+/// Get a default configuration object.
 ///
-/// 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`.
+/// ### Default Configuration:
 ///
-/// 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) -> internal::Result<()>
-    where W: Write, T: serde_crate::Serialize, S: SizeLimit
-{
-    internal::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit)
+/// | Byte limit | Endianness |
+/// |------------|------------|
+/// | Unlimited  | Little     |
+pub fn config() -> Config {
+    Config::new()
 }
 
-/// Serializes a serializable object into a `Vec` of bytes.
+/// Serializes an object directly into a `Writer` using the default configuration.
 ///
-/// 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) -> internal::Result<Vec<u8>>
-    where T: serde_crate::Serialize, S: SizeLimit
+/// If the serialization would take more bytes than allowed by the size limit, an error
+/// is returned and *no bytes* will be written into the `Writer`.
+pub fn serialize_into<W, T: ?Sized>(writer: W, value: &T) -> Result<()>
+where
+    W: std::io::Write,
+    T: serde::Serialize,
 {
-    internal::serialize::<_, _, byteorder::LittleEndian>(value, size_limit)
+    config().serialize_into(writer, value)
+}
+
+/// Serializes a serializable object into a `Vec` of bytes using the default configuration.
+pub fn serialize<T: ?Sized>(value: &T) -> Result<Vec<u8>>
+where
+    T: serde::Serialize,
+{
+    config().serialize(value)
 }
 
-/// A limit on the amount of bytes that can be read or written.
+/// Deserializes an object directly from a `Read`er using the default configuration.
 ///
-/// Size limits are an incredibly important part of both encoding and decoding.
+/// If this returns an `Error`, `reader` may be in an invalid state.
+pub fn deserialize_from<R, T>(reader: R) -> Result<T>
+where
+    R: std::io::Read,
+    T: serde::de::DeserializeOwned,
+{
+    config().deserialize_from(reader)
+}
+
+/// Deserializes an object from a custom `BincodeRead`er using the default configuration.
+/// It is highly recommended to use `deserialize_from` unless you need to implement
+/// `BincodeRead` for performance reasons.
 ///
-/// 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
-/// are decoding bytes right off of a TCP stream for example, it would be
-/// possible for an attacker to flood your server with a 3TB vec, causing the
-/// decoder to run out of memory and crash your application!
-/// Because of this, you can provide a maximum-number-of-bytes that can be read
-/// during decoding, and the decoder will explicitly fail if it has to read
-/// any more than that.
+/// If this returns an `Error`, `reader` may be in an invalid state.
+pub fn deserialize_from_custom<'a, R, T>(reader: R) -> Result<T>
+where
+    R: de::read::BincodeRead<'a>,
+    T: serde::de::DeserializeOwned,
+{
+    config().deserialize_from_custom(reader)
+}
+
+/// Only use this if you know what you're doing.
 ///
-/// 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: private::Sealed {
-    /// 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>;
+/// This is part of the public API.
+#[doc(hidden)]
+pub fn deserialize_in_place<'a, R, T>(reader: R, place: &mut T) -> Result<()>
+where
+    T: serde::de::Deserialize<'a>,
+    R: BincodeRead<'a>
+{
+    config().deserialize_in_place(reader, place)
 }
 
-/// A SizeLimit that restricts serialized or deserialized messages from
-/// exceeding a certain byte length.
-#[derive(Copy, Clone)]
-pub struct Bounded(pub u64);
+/// Deserializes a slice of bytes into an instance of `T` using the default configuration.
+pub fn deserialize<'a, T>(bytes: &'a [u8]) -> Result<T>
+where
+    T: serde::de::Deserialize<'a>,
+{
+    config().deserialize(bytes)
+}
 
-/// 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;
-
-struct CountSize {
-    total: u64,
-    limit: Option<u64>,
+/// Returns the size that an object would be if serialized using Bincode with the default configuration.
+pub fn serialized_size<T: ?Sized>(value: &T) -> Result<u64>
+where
+    T: serde::Serialize,
+{
+    config().serialized_size(value)
 }
 
-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) }
+/// Executes the acceptor with a serde::Deserializer instance.
+/// NOT A PART OF THE STABLE PUBLIC API
+#[doc(hidden)]
+pub fn with_deserializer<'a, A,  R>(reader: R, acceptor: A) -> A::Output
+where A: DeserializerAcceptor<'a>,
+        R: BincodeRead<'a>
+{
+    config().with_deserializer(reader, acceptor)
 }
 
-impl SizeLimit for Infinite {
-    #[inline(always)]
-    fn add(&mut self, _: u64) -> Result<()> { Ok (()) }
-
-    #[inline(always)]
-    fn limit(&self) -> Option<u64> { None }
+/// Executes the acceptor with a serde::Serializer instance.
+/// NOT A PART OF THE STABLE PUBLIC API
+#[doc(hidden)]
+pub fn with_serializer<A, W>(writer: W, acceptor: A) -> A::Output
+where A: SerializerAcceptor,
+    W: std::io::Write
+{
+    config().with_serializer(writer, acceptor)
 }
-
-mod private {
-    pub trait Sealed {}
-
-    impl<'a> Sealed for super::de::read::SliceReader<'a> {}
-    impl<R> Sealed for super::de::read::IoReader<R> {}
-    impl Sealed for super::Infinite {}
-    impl Sealed for super::Bounded {}
-    impl Sealed for super::CountSize {}
-}
--- a/third_party/rust/bincode/src/ser/mod.rs
+++ b/third_party/rust/bincode/src/ser/mod.rs
@@ -1,231 +1,256 @@
 use std::io::Write;
 use std::u32;
-use std::marker::PhantomData;
 
-use serde_crate as serde;
+use serde;
 
-use byteorder::{WriteBytesExt, ByteOrder};
+use byteorder::WriteBytesExt;
 
 use super::{Result, Error, ErrorKind};
-use super::SizeLimit;
+use ::config::Options;
+use super::internal::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> {
+pub(crate) struct Serializer<W, O: Options> {
     writer: W,
-    _phantom: PhantomData<E>,
+    _options: O,
 }
 
-impl<W: Write, E: ByteOrder> Serializer<W, E> {
+impl<W: Write, O: Options> Serializer<W, O> {
     /// Creates a new Serializer with the given `Write`r.
-    pub fn new(w: W) -> Serializer<W, E> {
+    pub fn new(w: W, options: O) -> Serializer<W, O> {
         Serializer {
             writer: w,
-            _phantom: PhantomData,
+            _options: options,
         }
     }
 }
 
-impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E> {
+impl<'a, W: Write, O: Options> serde::Serializer for &'a mut Serializer<W, O> {
     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>;
+    type SerializeSeq = Compound<'a, W, O>;
+    type SerializeTuple = Compound<'a, W, O>;
+    type SerializeTupleStruct = Compound<'a, W, O>;
+    type SerializeTupleVariant = Compound<'a, W, O>;
+    type SerializeMap = Compound<'a, W, O>;
+    type SerializeStruct = Compound<'a, W, O>;
+    type SerializeStructVariant = Compound<'a, W, O>;
 
-    fn serialize_unit(self) -> Result<()> { Ok(()) }
+    fn serialize_unit(self) -> Result<()> {
+        Ok(())
+    }
 
-    fn serialize_unit_struct(self, _: &'static str) -> 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)
+        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)
+        self.writer.write_u16::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_u32(self, v: u32) -> Result<()> {
-        self.writer.write_u32::<E>(v).map_err(Into::into)
+        self.writer.write_u32::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_u64(self, v: u64) -> Result<()> {
-        self.writer.write_u64::<E>(v).map_err(Into::into)
+        self.writer.write_u64::<O::Endian>(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)
+        self.writer.write_i16::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_i32(self, v: i32) -> Result<()> {
-        self.writer.write_i32::<E>(v).map_err(Into::into)
+        self.writer.write_i32::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_i64(self, v: i64) -> Result<()> {
-        self.writer.write_i64::<E>(v).map_err(Into::into)
+        self.writer.write_i64::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_f32(self, v: f32) -> Result<()> {
-        self.writer.write_f32::<E>(v).map_err(Into::into)
+        self.writer.write_f32::<O::Endian>(v).map_err(Into::into)
     }
 
     fn serialize_f64(self, v: f64) -> Result<()> {
-        self.writer.write_f64::<E>(v).map_err(Into::into)
+        self.writer.write_f64::<O::Endian>(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)
+        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,
+    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})
+        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})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_tuple_variant(self,
-                              _name: &'static str,
-                              variant_index: u32,
-                              _variant: &'static str,
-                              _len: usize) -> Result<Self::SerializeTupleVariant>
-    {
+    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})
+        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})
+        Ok(Compound { ser: self })
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_struct_variant(self,
-                               _name: &'static str,
-                               variant_index: u32,
-                               _variant: &'static str,
-                               _len: usize) -> Result<Self::SerializeStructVariant>
-    {
+    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})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self,
-                               _name: &'static str,
-                               value: &T) -> Result<()>
-        where T: serde::ser::Serialize,
+    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,
+    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<()> {
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<()> {
         self.serialize_u32(variant_index)
     }
+
+    fn is_human_readable(&self) -> bool {
+        false
+    }
 }
 
-pub struct SizeChecker<S: SizeLimit> {
-    pub size_limit: S,
+pub(crate) struct SizeChecker<O: Options> {
+    pub options: O,
 }
 
-impl <S: SizeLimit> SizeChecker<S> {
-    pub fn new(size_limit: S) -> SizeChecker<S> {
-        SizeChecker {
-            size_limit: size_limit
-        }
+impl<O: Options> SizeChecker<O> {
+    pub fn new(options: O) -> SizeChecker<O> {
+        SizeChecker { options: options }
     }
 
     fn add_raw(&mut self, size: u64) -> Result<()> {
-        self.size_limit.add(size)
+        self.options.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> {
+impl<'a, O: Options> serde::Serializer for &'a mut SizeChecker<O> {
     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>;
+    type SerializeSeq = SizeCompound<'a, O>;
+    type SerializeTuple = SizeCompound<'a, O>;
+    type SerializeTupleStruct = SizeCompound<'a, O>;
+    type SerializeTupleVariant = SizeCompound<'a, O>;
+    type SerializeMap = SizeCompound<'a, O>;
+    type SerializeStruct = SizeCompound<'a, O>;
+    type SerializeStructVariant = SizeCompound<'a, O>;
 
-    fn serialize_unit(self) -> Result<()> { Ok(()) }
+    fn serialize_unit(self) -> Result<()> {
+        Ok(())
+    }
 
-    fn serialize_unit_struct(self, _: &'static str) -> 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)
     }
@@ -280,400 +305,438 @@ impl<'a, S: SizeLimit> serde::Serializer
         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,
+    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})
+        Ok(SizeCompound { ser: self })
     }
 
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
-        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>
-    {
+    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})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>
-    {
+    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})
+        Ok(SizeCompound { ser: self })
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_struct_variant(self,
-                               _name: &'static str,
-                               variant_index: u32,
-                               _variant: &'static str,
-                               _len: usize) -> Result<Self::SerializeStructVariant>
-    {
+    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})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(self, _name: &'static str, v: &V) -> Result<()> {
+    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<()> {
+    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<()>
-    {
+    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)
     }
+
+    fn is_human_readable(&self) -> bool {
+        false
+    }
 }
 
-#[doc(hidden)]
-pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> {
-    ser: &'a mut Serializer<W, E>,
+pub(crate) struct Compound<'a, W: 'a, O: Options + 'a> {
+    ser: &'a mut Serializer<W, O>,
 }
 
-impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+impl<'a, W, O> serde::ser::SerializeSeq for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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
+impl<'a, W, O> serde::ser::SerializeTuple for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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
+impl<'a, W, O> serde::ser::SerializeTupleStruct for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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
+impl<'a, W, O> serde::ser::SerializeTupleVariant for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     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
+    where
+        T: 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
+impl<'a, W, O> serde::ser::SerializeMap for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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::SerializeStructVariant for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+impl<'a, W, O> serde::ser::SerializeStruct for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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>
+impl<'a, W, O> serde::ser::SerializeStructVariant for Compound<'a, W, O>
+where
+    W: Write,
+    O: Options,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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::SerializeTuple for SizeCompound<'a, S>
-{
+pub(crate) struct SizeCompound<'a, S: Options + 'a> {
+    ser: &'a mut SizeChecker<S>,
+}
+
+impl<'a, O: Options> serde::ser::SerializeSeq for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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>
-{
+impl<'a, O: Options> serde::ser::SerializeTuple for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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::SerializeTupleVariant for SizeCompound<'a, S>
-{
+impl<'a, O: Options> serde::ser::SerializeTupleStruct for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
+    {
+        value.serialize(&mut *self.ser)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a, O: Options> serde::ser::SerializeTupleVariant for SizeCompound<'a, O> {
+    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>
-{
+impl<'a, O: Options+ 'a> serde::ser::SerializeMap for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
-    where K: serde::ser::Serialize
+    where
+        K: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
 
-        #[inline]
+    #[inline]
     fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
-    where V: serde::ser::Serialize
+    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>
-{
+impl<'a, O: Options> serde::ser::SerializeStruct for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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>
-{
+impl<'a, O: Options> serde::ser::SerializeStructVariant for SizeCompound<'a, O> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    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_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;
+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[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[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],
deleted file mode 100644
--- a/third_party/rust/bincode/tests/test.rs
+++ /dev/null
@@ -1,426 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate bincode;
-extern crate serde;
-extern crate serde_bytes;
-extern crate byteorder;
-
-use std::fmt::Debug;
-use std::collections::HashMap;
-use std::borrow::Cow;
-
-use bincode::{Infinite, Bounded};
-use bincode::{serialized_size, ErrorKind, Result};
-use bincode::internal::{serialize, deserialize, deserialize_from};
-
-use bincode::serialize as serialize_little;
-use bincode::deserialize as deserialize_little;
-use bincode::deserialize_from as deserialize_from_little;
-
-fn the_same<V>(element: V)
-    where V: serde::Serialize+serde::de::DeserializeOwned+PartialEq+Debug+'static
-{
-    let size = serialized_size(&element);
-
-    {
-        let encoded = serialize_little(&element, Infinite).unwrap();
-        let decoded = deserialize_little(&encoded[..]).unwrap();
-
-        assert_eq!(element, decoded);
-        assert_eq!(size, encoded.len() as u64);
-    }
-
-    {
-        let encoded = serialize::<_, _, byteorder::BigEndian>(&element, Infinite).unwrap();
-        let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]).unwrap();
-        let decoded_reader = deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap();
-
-        assert_eq!(element, decoded);
-        assert_eq!(element, decoded_reader);
-        assert_eq!(size, encoded.len() as u64);
-    }
-}
-
-#[test]
-fn test_numbers() {
-    // unsigned positive
-    the_same(5u8);
-    the_same(5u16);
-    the_same(5u32);
-    the_same(5u64);
-    the_same(5usize);
-    // signed positive
-    the_same(5i8);
-    the_same(5i16);
-    the_same(5i32);
-    the_same(5i64);
-    the_same(5isize);
-    // signed negative
-    the_same(-5i8);
-    the_same(-5i16);
-    the_same(-5i32);
-    the_same(-5i64);
-    the_same(-5isize);
-    // floating
-    the_same(-100f32);
-    the_same(0f32);
-    the_same(5f32);
-    the_same(-100f64);
-    the_same(5f64);
-}
-
-#[test]
-fn test_string() {
-    the_same("".to_string());
-    the_same("a".to_string());
-}
-
-#[test]
-fn test_tuple() {
-    the_same((1isize,));
-    the_same((1isize,2isize,3isize));
-    the_same((1isize,"foo".to_string(),()));
-}
-
-#[test]
-fn test_basic_struct() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Easy {
-        x: isize,
-        s: String,
-        y: usize
-    }
-    the_same(Easy{x: -4, s: "foo".to_string(), y: 10});
-}
-
-#[test]
-fn test_nested_struct() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Easy {
-        x: isize,
-        s: String,
-        y: usize
-    }
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct Nest {
-        f: Easy,
-        b: usize,
-        s: Easy
-    }
-
-    the_same(Nest {
-        f: Easy {x: -1, s: "foo".to_string(), y: 20},
-        b: 100,
-        s: Easy {x: -100, s: "bar".to_string(), y: 20}
-    });
-}
-
-#[test]
-fn test_struct_newtype() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct NewtypeStr(usize);
-
-    the_same(NewtypeStr(5));
-}
-
-#[test]
-fn test_struct_tuple() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct TubStr(usize, String, f32);
-
-    the_same(TubStr(5, "hello".to_string(), 3.2));
-}
-
-#[test]
-fn test_option() {
-    the_same(Some(5usize));
-    the_same(Some("foo bar".to_string()));
-    the_same(None::<usize>);
-}
-
-#[test]
-fn test_enum() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    enum TestEnum {
-        NoArg,
-        OneArg(usize),
-        Args(usize, usize),
-        AnotherNoArg,
-        StructLike{x: usize, y: f32}
-    }
-    the_same(TestEnum::NoArg);
-    the_same(TestEnum::OneArg(4));
-    //the_same(TestEnum::Args(4, 5));
-    the_same(TestEnum::AnotherNoArg);
-    the_same(TestEnum::StructLike{x: 4, y: 3.14159});
-    the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg,
-                  TestEnum::StructLike{x: 4, y:1.4}]);
-}
-
-#[test]
-fn test_vec() {
-    let v: Vec<u8> = vec![];
-    the_same(v);
-    the_same(vec![1u64]);
-    the_same(vec![1u64,2,3,4,5,6]);
-}
-
-#[test]
-fn test_map() {
-    let mut m = HashMap::new();
-    m.insert(4u64, "foo".to_string());
-    m.insert(0u64, "bar".to_string());
-    the_same(m);
-}
-
-#[test]
-fn test_bool() {
-    the_same(true);
-    the_same(false);
-}
-
-#[test]
-fn test_unicode() {
-    the_same("å".to_string());
-    the_same("aåååååååa".to_string());
-}
-
-#[test]
-fn test_fixed_size_array() {
-    the_same([24u32; 32]);
-    the_same([1u64, 2, 3, 4, 5, 6, 7, 8]);
-    the_same([0u8; 19]);
-}
-
-#[test]
-fn deserializing_errors() {
-
-    match *deserialize_little::<bool>(&vec![0xA][..]).unwrap_err() {
-        ErrorKind::InvalidBoolEncoding(0xA) => {},
-        _ => panic!(),
-    }
-    match *deserialize_little::<String>(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..]).unwrap_err() {
-        ErrorKind::InvalidUtf8Encoding(_) => {},
-        _ => panic!(),
-    }
-
-    // Out-of-bounds variant
-    #[derive(Serialize, Deserialize, Debug)]
-    enum Test {
-        One,
-        Two,
-    };
-
-    match *deserialize_little::<Test>(&vec![0, 0, 0, 5][..]).unwrap_err() {
-        // Error message comes from serde
-        ErrorKind::Custom(_) => {},
-        _ => panic!(),
-    }
-    match *deserialize_little::<Option<u8>>(&vec![5, 0][..]).unwrap_err() {
-        ErrorKind::InvalidTagEncoding(_) => {},
-        _ => panic!(),
-    }
-}
-
-#[test]
-fn too_big_deserialize() {
-    let serialized = vec![0,0,0,3];
-    let deserialized: Result<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3));
-    assert!(deserialized.is_err());
-
-    let serialized = vec![0,0,0,3];
-    let deserialized: Result<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4));
-    assert!(deserialized.is_ok());
-}
-
-#[test]
-fn char_serialization() {
-    let chars = "Aa\0☺♪";
-    for c in chars.chars() {
-        let encoded = serialize_little(&c, Bounded(4)).expect("serializing char failed");
-        let decoded: char = deserialize_little(&encoded).expect("deserializing failed");
-        assert_eq!(decoded, c);
-    }
-}
-
-#[test]
-fn too_big_char_deserialize() {
-    let serialized = vec![0x41];
-    let deserialized: Result<char> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1));
-    assert!(deserialized.is_ok());
-    assert_eq!(deserialized.unwrap(), 'A');
-}
-
-#[test]
-fn too_big_serialize() {
-    assert!(serialize_little(&0u32, Bounded(3)).is_err());
-    assert!(serialize_little(&0u32, Bounded(4)).is_ok());
-
-    assert!(serialize_little(&"abcde", Bounded(8 + 4)).is_err());
-    assert!(serialize_little(&"abcde", Bounded(8 + 5)).is_ok());
-}
-
-#[test]
-fn test_proxy_encoded_size() {
-    assert!(serialized_size(&0u8) == 1);
-    assert!(serialized_size(&0u16) == 2);
-    assert!(serialized_size(&0u32) == 4);
-    assert!(serialized_size(&0u64) == 8);
-
-    // length isize stored as u64
-    assert!(serialized_size(&"") == 8);
-    assert!(serialized_size(&"a") == 8 + 1);
-
-    assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4))
-
-}
-
-#[test]
-fn test_serialized_size() {
-    assert!(serialized_size(&0u8) == 1);
-    assert!(serialized_size(&0u16) == 2);
-    assert!(serialized_size(&0u32) == 4);
-    assert!(serialized_size(&0u64) == 8);
-
-    // length isize stored as u64
-    assert!(serialized_size(&"") == 8);
-    assert!(serialized_size(&"a") == 8 + 1);
-
-    assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4))
-}
-
-#[test]
-fn encode_box() {
-    the_same(Box::new(5));
-}
-
-#[test]
-fn test_cow_serialize() {
-    let large_object = vec![1u32,2,3,4,5,6];
-    let mut large_map = HashMap::new();
-    large_map.insert(1, 2);
-
-
-    #[derive(Serialize, Deserialize, Debug)]
-    enum Message<'a> {
-        M1(Cow<'a, Vec<u32>>),
-        M2(Cow<'a, HashMap<u32, u32>>)
-    }
-
-    // Test 1
-    {
-        let serialized = serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap();
-        let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
-
-        match deserialized {
-            Message::M1(b) => assert!(&b.into_owned() == &large_object),
-            _ => assert!(false)
-        }
-    }
-
-    // Test 2
-    {
-        let serialized = serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap();
-        let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
-
-        match deserialized {
-            Message::M2(b) => assert!(&b.into_owned() == &large_map),
-            _ => assert!(false)
-        }
-    }
-}
-
-#[test]
-fn test_strbox_serialize() {
-    let strx: &'static str = "hello world";
-    let serialized = serialize_little(&Cow::Borrowed(strx), Infinite).unwrap();
-    let deserialized: Cow<'static, String> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
-    let stringx: String = deserialized.into_owned();
-    assert!(strx == &stringx[..]);
-}
-
-#[test]
-fn test_slicebox_serialize() {
-    let slice = [1u32, 2, 3 ,4, 5];
-    let serialized = serialize_little(&Cow::Borrowed(&slice[..]), Infinite).unwrap();
-    println!("{:?}", serialized);
-    let deserialized: Cow<'static, Vec<u32>> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
-    {
-        let sb: &[u32] = &deserialized;
-        assert!(slice == sb);
-    }
-    let vecx: Vec<u32> = deserialized.into_owned();
-    assert!(slice == &vecx[..]);
-}
-
-#[test]
-fn test_multi_strings_serialize() {
-    assert!(serialize_little(&("foo", "bar", "baz"), Infinite).is_ok());
-}
-
-#[test]
-fn test_oom_protection() {
-    use std::io::Cursor;
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct FakeVec {
-        len: u64,
-        byte: u8
-    }
-    let x = serialize_little(&FakeVec { len: 0xffffffffffffffffu64, byte: 1 }, Bounded(10)).unwrap();
-    let y: Result<Vec<u8>> = deserialize_from_little(&mut Cursor::new(&x[..]), Bounded(10));
-    assert!(y.is_err());
-}
-
-#[test]
-fn path_buf() {
-    use std::path::{Path, PathBuf};
-    let path = Path::new("foo").to_path_buf();
-    let serde_encoded = serialize_little(&path, Infinite).unwrap();
-    let decoded: PathBuf = deserialize_little(&serde_encoded).unwrap();
-    assert!(path.to_str() == decoded.to_str());
-}
-
-#[test]
-fn bytes() {
-    use serde_bytes::Bytes;
-
-    let data = b"abc\0123";
-    let s = serialize_little(&data[..], Infinite).unwrap();
-    let s2 = serialize_little(&Bytes::new(data), Infinite).unwrap();
-    assert_eq!(s[..], s2[..]);
-}
-
-#[test]
-fn serde_bytes() {
-    use serde_bytes::ByteBuf;
-    the_same(ByteBuf::from(vec![1,2,3,4,5]));
-}
-
-
-#[test]
-fn endian_difference() {
-    let x = 10u64;
-    let little = serialize_little(&x, Infinite).unwrap();
-    let big = serialize::<_, _, byteorder::BigEndian>(&x, Infinite).unwrap();
-    assert_ne!(little, big);
-}
-
-#[test]
-fn test_zero_copy_parse() {
-    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
-    struct Foo<'a> {
-        borrowed_str: &'a str,
-        borrowed_bytes: &'a [u8],
-    }
-
-    let f = Foo {
-        borrowed_str: "hi",
-        borrowed_bytes: &[0, 1, 2, 3],
-    };
-    {
-        let encoded = serialize_little(&f, Infinite).unwrap();
-        let out: Foo = deserialize_little(&encoded[..]).unwrap();
-        assert_eq!(out, f);
-    }
-}