--- a/third_party/rust/bincode/.cargo-checksum.json
+++ b/third_party/rust/bincode/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"e084df3ce631ce22082bd63f9e421e7f4d7a2408d6520de532f6a649e4d320dd",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"8988a4300b10f78e0a3affbc4530827766c80c0d9847441e42e12017b09f7854","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"90bb4036f90c3792c8294de2e3d52a54cc6230c3e5dc78013a781a9aa468f5f3","examples/basic.rs":"57aeca11d5cc5c3d5bb613e78b2ea43a2e80d66c15a2fffae303b165aa4ab41d","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"a70631b99064d77c968edf1e2f59415ff26c307589fa3767243376db44f00800","src/lib.rs":"84f115fcd9fe9a6fad489341f1134a24f178de46bfba6dab774a13212eac32ba","src/refbox.rs":"fe266cec4f9f36942a1a9a9ad094a4bb1003d0c0f3c070cfb6214790d0f21b69","src/serde/mod.rs":"5b4eaf256ec87f08bec20e0ac46184b3b336e87b2cb22f40bae6213613ae3081","src/serde/reader.rs":"8b223500017eff9eb9b634b74acefb96457db124e64fe594511abf12a4ef4207","src/serde/writer.rs":"5fd74db7389aebfd14c126dad56348ea5ad0d58bbbcc91a0757e9451c6ee977f","tests/test.rs":"8f595d83de63c0ce091626fd5875185fa29040cf77c47f3a27ceba30673d6e67"},"package":"db8831e3eb4e9ae608d826876fa422ffb15b47caa89fc1bcb96bfbe4f5ded8b2"}
\ No newline at end of file
+{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"e084df3ce631ce22082bd63f9e421e7f4d7a2408d6520de532f6a649e4d320dd",".travis.yml":"f705a11b487bf71c41ebd8223cc1f3cbde0dfdfeea96a100af55e06e93397a1b","Cargo.toml":"3268085d1b2f5a6b658d02c98188a631e81c18323dbe1af2cbcccde8664bf2a4","LICENSE.md":"90d7e062634054e6866d3c81e6a2b3058a840e6af733e98e80bdfe1a7dec6912","changelist.org":"7e1dd0a38f886c111f9a50bc5ecd8ccab0800fcc737c1c211cc5c3361648aa2b","examples/basic.rs":"ef6ab76936c8322b9f89fe8308311339c0bf7b413c5f88b5314b0035d49917a3","logo.png":"ebc5305aae938c1f834cf35302faa8be0f1b7b8c3c3beef5cf6b2f68b9628c35","readme.dev.md":"43bad3bcc13a5c057344d3ba7f64bd2b313f8c133d6afa068108df73e8e8facd","readme.md":"06e09e4e80b048416116640a8352305ceae48f775fd13786c25892cbf55c8fbd","src/lib.rs":"a4dff78a7c5af47c1dc9f240ba7ba3305dd66f638d2d326627093bb326c5fe59","src/refbox.rs":"fe266cec4f9f36942a1a9a9ad094a4bb1003d0c0f3c070cfb6214790d0f21b69","src/serde/mod.rs":"a4aaf85ac92468e246be4533f014b93b8e21059da22342155d03578a81e7f556","src/serde/reader.rs":"21db7aa79660acaa2ac39adfe273a99a27c2a1c39506e2a782f9c7f76500f866","src/serde/writer.rs":"02819f71cda1742188feb66c9ecf58bbd4e35c6d88961763667a3cde72450963","tests/test.rs":"36f7e11cc480ea9f68c4656d55e065f69998346baa8112fcde1f9c1dc4891c02"},"package":"fb0cdeac1c5d567fdb487ae5853c024e4acf1ea85ba6a6552fe084e0805fea5d"}
\ No newline at end of file
--- a/third_party/rust/bincode/Cargo.toml
+++ b/third_party/rust/bincode/Cargo.toml
@@ -1,11 +1,11 @@
[package]
name = "bincode"
-version = "1.0.0-alpha4"
+version = "1.0.0-alpha6"
authors = ["Ty Overby <ty@pre-alpha.com>", "Francesco Mazzoli <f@mazzo.li>", "David Tolnay <dtolnay@gmail.com>", "Daniel Griffen"]
repository = "https://github.com/TyOverby/bincode"
documentation = "https://docs.rs/bincode"
keywords = ["binary", "encode", "decode", "serialize", "deserialize"]
license = "MIT"
description = "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!"
--- a/third_party/rust/bincode/changelist.org
+++ b/third_party/rust/bincode/changelist.org
@@ -11,8 +11,14 @@
** 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.
--- a/third_party/rust/bincode/examples/basic.rs
+++ b/third_party/rust/bincode/examples/basic.rs
@@ -1,35 +1,27 @@
-/*
+#[macro_use]
+extern crate serde_derive;
extern crate bincode;
-extern crate
-use bincode::SizeLimit;
-use bincode::rustc_serialize::{encode, decode};
+use bincode::{serialize, deserialize, Infinite};
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Serialize, Deserialize, PartialEq)]
struct Entity {
x: f32,
y: f32,
}
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
-struct World {
- entities: Vec<Entity>
-}
+#[derive(Serialize, Deserialize, PartialEq)]
+struct World(Vec<Entity>);
fn main() {
- let world = World {
- entities: vec![Entity {x: 0.0, y: 4.0}, Entity {x: 10.0, y: 20.5}]
- };
+ let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);
- let encoded: Vec<u8> = encode(&world, SizeLimit::Infinite).unwrap();
+ let encoded: Vec<u8> = serialize(&world, Infinite).unwrap();
// 8 bytes for the length of the vector, 4 bytes per float.
assert_eq!(encoded.len(), 8 + 4 * 4);
- let decoded: World = decode(&encoded[..]).unwrap();
+ let decoded: World = deserialize(&encoded[..]).unwrap();
assert!(world == decoded);
}
- */
-
-fn main() {}
--- a/third_party/rust/bincode/readme.md
+++ b/third_party/rust/bincode/readme.md
@@ -17,52 +17,47 @@ and the [flate2-rs](https://github.com/a
library.
## [Api Documentation](http://tyoverby.github.io/bincode/bincode/)
## Bincode in the wild
* [google/tarpc](https://github.com/google/tarpc): Bincode is used to serialize and deserialize networked RPC messages.
* [servo/webrender](https://github.com/servo/webrender): Bincode records webrender API calls for record/replay-style graphics debugging.
-* [servo/icp-channel](https://github.com/servo/ipc-channel): Ipc-Channel uses Bincode to send structs between processes using a channel-like API.
+* [servo/ipc-channel](https://github.com/servo/ipc-channel): Ipc-Channel uses Bincode to send structs between processes using a channel-like API.
## Example
```rust
+#[macro_use]
+extern crate serde_derive;
extern crate bincode;
-extern crate rustc_serialize;
-use bincode::SizeLimit;
-use bincode::rustc_serialize::{encode, decode};
+use bincode::{serialize, deserialize, SizeLimit};
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Serialize, Deserialize, PartialEq)]
struct Entity {
x: f32,
y: f32,
}
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
-struct World {
- entities: Vec<Entity>
-}
+#[derive(Serialize, Deserialize, PartialEq)]
+struct World(Vec<Entity>);
fn main() {
- let world = World {
- entities: vec![Entity {x: 0.0, y: 4.0}, Entity {x: 10.0, y: 20.5}]
- };
+ let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);
- let encoded: Vec<u8> = encode(&world, SizeLimit::Infinite).unwrap();
+ let encoded: Vec<u8> = serialize(&world, SizeLimit::Infinite).unwrap();
// 8 bytes for the length of the vector, 4 bytes per float.
assert_eq!(encoded.len(), 8 + 4 * 4);
- let decoded: World = decode(&encoded[..]).unwrap();
+ let decoded: World = deserialize(&encoded[..]).unwrap();
assert!(world == decoded);
}
-
```
## 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
--- a/third_party/rust/bincode/src/lib.rs
+++ b/third_party/rust/bincode/src/lib.rs
@@ -12,22 +12,22 @@
//! corresponding modules inside of `bincode`. Both modules have exactly equivalant functions, and
//! and the only difference is whether or not the library user wants to use `rustc_serialize` or
//! `serde`.
//!
//! ### Using Basic Functions
//!
//! ```rust
//! extern crate bincode;
-//! use bincode::{serialize, deserialize};
+//! use bincode::{serialize, deserialize, Bounded};
//! fn main() {
//! // The object that we will serialize.
//! let target = Some("hello world".to_string());
//! // The maximum size of the encoded message.
-//! let limit = bincode::SizeLimit::Bounded(20);
+//! let limit = Bounded(20);
//!
//! let encoded: Vec<u8> = serialize(&target, limit).unwrap();
//! let decoded: Option<String> = deserialize(&encoded[..]).unwrap();
//! assert_eq!(target, decoded);
//! }
//! ```
#![crate_name = "bincode"]
@@ -39,22 +39,25 @@
extern crate byteorder;
extern crate num_traits;
extern crate serde as serde_crate;
pub mod refbox;
mod serde;
pub mod endian_choice {
- pub use super::serde::{serialize, serialize_into, deserialize, deserialize_from};
+ pub use super::serde::{Deserializer, Serializer, serialize, serialize_into, deserialize, deserialize_from};
}
use std::io::{Read, Write};
-pub use serde::{Deserializer, Serializer, ErrorKind, Error, Result, serialized_size, serialized_size_bounded};
+pub use serde::{ErrorKind, Error, Result, serialized_size, serialized_size_bounded};
+
+pub type Deserializer<W, S> = serde::Deserializer<W, S, byteorder::LittleEndian>;
+pub type Serializer<W> = serde::Serializer<W, byteorder::LittleEndian>;
/// Deserializes a slice of bytes into an object.
///
/// This method does not have a size-limit because if you already have the bytes
/// in memory, then you don't gain anything by having a limiter.
pub fn deserialize<T>(bytes: &[u8]) -> serde::Result<T>
where T: serde_crate::Deserialize,
{
@@ -65,45 +68,44 @@ pub fn deserialize<T>(bytes: &[u8]) -> s
///
/// If the provided `SizeLimit` is reached, the deserialization will bail immediately.
/// A SizeLimit can help prevent an attacker from flooding your server with
/// a neverending stream of values that runs your server out of memory.
///
/// If this returns an `Error`, assume that the buffer that you passed
/// in is in an invalid state, as the error could be returned during any point
/// in the reading.
-pub fn deserialize_from<R: ?Sized, T>(reader: &mut R, size_limit: SizeLimit) -> serde::Result<T>
- where R: Read,
- T: serde_crate::Deserialize,
+pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> serde::Result<T>
+ where R: Read, T: serde_crate::Deserialize, S: SizeLimit
{
- serde::deserialize_from::<_, _, byteorder::LittleEndian>(reader, size_limit)
+ serde::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit)
}
/// Serializes an object directly into a `Writer`.
///
/// If the serialization would take more bytes than allowed by `size_limit`, an error
/// is returned and *no bytes* will be written into the `Writer`.
///
/// If this returns an `Error` (other than SizeLimit), assume that the
/// writer is in an invalid state, as writing could bail out in the middle of
/// serializing.
-pub fn serialize_into<W: ?Sized, T: ?Sized>(writer: &mut W, value: &T, size_limit: SizeLimit) -> serde::Result<()>
- where W: Write, T: serde_crate::Serialize
+pub fn serialize_into<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_limit: S) -> serde::Result<()>
+ where W: Write, T: serde_crate::Serialize, S: SizeLimit
{
- serde::serialize_into::<_, _, byteorder::LittleEndian>(writer, value, size_limit)
+ serde::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit)
}
/// Serializes a serializable object into a `Vec` of bytes.
///
/// If the serialization would take more bytes than allowed by `size_limit`,
/// an error is returned.
-pub fn serialize<T: ?Sized>(value: &T, size_limit: SizeLimit) -> serde::Result<Vec<u8>>
- where T: serde_crate::Serialize
+pub fn serialize<T: ?Sized, S>(value: &T, size_limit: S) -> serde::Result<Vec<u8>>
+ where T: serde_crate::Serialize, S: SizeLimit
{
- serde::serialize::<_, byteorder::LittleEndian>(value, size_limit)
+ serde::serialize::<_, _, byteorder::LittleEndian>(value, size_limit)
}
/// A limit on the amount of bytes that can be read or written.
///
/// Size limits are an incredibly important part of both encoding and decoding.
///
/// In order to prevent DOS attacks on a decoder, it is important to limit the
/// amount of bytes that a single encoded message can be; otherwise, if you
@@ -114,13 +116,39 @@ pub fn serialize<T: ?Sized>(value: &T, s
/// during decoding, and the decoder will explicitly fail if it has to read
/// any more than that.
///
/// On the other side, you want to make sure that you aren't encoding a message
/// that is larger than your decoder expects. By supplying a size limit to an
/// encoding function, the encoder will verify that the structure can be encoded
/// within that limit. This verification occurs before any bytes are written to
/// the Writer, so recovering from an error is easy.
-#[derive(Clone, Copy, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
-pub enum SizeLimit {
- Infinite,
- Bounded(u64)
+pub trait SizeLimit {
+ fn add(&mut self, n: u64) -> Result<()>;
+ fn limit(&self) -> Option<u64>;
}
+
+#[derive(Copy, Clone)]
+pub struct Bounded(pub u64);
+
+#[derive(Copy, Clone)]
+pub struct Infinite;
+
+impl SizeLimit for Bounded {
+ #[inline(always)]
+ fn add(&mut self, n: u64) -> Result<()> {
+ if self.0 >= n {
+ self.0 -= n;
+ Ok(())
+ } else {
+ Err(Box::new(ErrorKind::SizeLimit))
+ }
+ }
+ #[inline(always)]
+ fn limit(&self) -> Option<u64> { Some(self.0) }
+}
+
+impl SizeLimit for Infinite {
+ #[inline(always)]
+ fn add(&mut self, _: u64) -> Result<()> { Ok (()) }
+ #[inline(always)]
+ fn limit(&self) -> Option<u64> { None }
+}
--- a/third_party/rust/bincode/src/serde/mod.rs
+++ b/third_party/rust/bincode/src/serde/mod.rs
@@ -104,107 +104,132 @@ impl serde::de::Error for Error {
ErrorKind::Custom(desc.to_string()).into()
}
}
impl serde::ser::Error for Error {
fn custom<T: fmt::Display>(msg: T) -> Self {
ErrorKind::Custom(msg.to_string()).into()
}
-}
+}
/// Serializes an object directly into a `Writer`.
///
/// If the serialization would take more bytes than allowed by `size_limit`, an error
/// is returned and *no bytes* will be written into the `Writer`.
///
/// If this returns an `Error` (other than SizeLimit), assume that the
/// writer is in an invalid state, as writing could bail out in the middle of
/// serializing.
-pub fn serialize_into<W: ?Sized, T: ?Sized, E>(writer: &mut W, value: &T, size_limit: SizeLimit) -> Result<()>
- where W: Write, T: serde::Serialize, E: ByteOrder
+pub fn serialize_into<W: ?Sized, T: ?Sized, S, E>(writer: &mut W, value: &T, size_limit: S) -> Result<()>
+ where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder
{
- match size_limit {
- SizeLimit::Infinite => { }
- SizeLimit::Bounded(x) => {
- let mut size_checker = SizeChecker::new(x);
- try!(value.serialize(&mut size_checker))
- }
+ if let Some(limit) = size_limit.limit() {
+ try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit));
}
let mut serializer = Serializer::<_, E>::new(writer);
serde::Serialize::serialize(value, &mut serializer)
}
/// Serializes a serializable object into a `Vec` of bytes.
///
/// If the serialization would take more bytes than allowed by `size_limit`,
/// an error is returned.
-pub fn serialize<T: ?Sized, E: ByteOrder>(value: &T, size_limit: SizeLimit) -> Result<Vec<u8>>
- where T: serde::Serialize
+pub fn serialize<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
+ where T: serde::Serialize, S: SizeLimit, E: ByteOrder
{
// Since we are putting values directly into a vector, we can do size
// computation out here and pre-allocate a buffer of *exactly*
// the right size.
- let mut writer = match size_limit {
- SizeLimit::Bounded(size_limit) => {
+ 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)
}
- SizeLimit::Infinite => Vec::new()
+ None => Vec::new()
};
- try!(serialize_into::<_, _, E>(&mut writer, value, SizeLimit::Infinite));
+ try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite));
Ok(writer)
}
+
+struct CountSize {
+ total: u64,
+ limit: Option<u64>,
+}
+
+impl SizeLimit for CountSize {
+ fn add(&mut self, c: u64) -> Result<()> {
+ self.total += c;
+ if let Some(limit) = self.limit {
+ if self.total > limit {
+ return Err(Box::new(ErrorKind::SizeLimit))
+ }
+ }
+ Ok(())
+ }
+
+ fn limit(&self) -> Option<u64> {
+ unreachable!();
+ }
+}
+
/// Returns the size that an object would be if serialized using bincode.
///
/// This is used internally as part of the check for encode_into, but it can
/// be useful for preallocating buffers if thats your style.
-pub fn serialized_size<T: ?Sized>(value: &T) -> u64
+pub fn serialized_size<T: ?Sized>(value: &T) -> u64
where T: serde::Serialize
{
- use std::u64::MAX;
- let mut size_checker = SizeChecker::new(MAX);
- value.serialize(&mut size_checker).ok();
- size_checker.written
+ let mut size_counter = SizeChecker {
+ size_limit: CountSize { total: 0, limit: None }
+ };
+
+ value.serialize(&mut size_counter).ok();
+ size_counter.size_limit.total
}
/// Given a maximum size limit, check how large an object would be if it
/// were to be serialized.
///
/// If it can be serialized in `max` or fewer bytes, that number will be returned
/// inside `Some`. If it goes over bounds, then None is returned.
pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
where T: serde::Serialize
{
- let mut size_checker = SizeChecker::new(max);
- value.serialize(&mut size_checker).ok().map(|_| size_checker.written)
+ let mut size_counter = SizeChecker {
+ size_limit: CountSize { total: 0, limit: Some(max) }
+ };
+
+ match value.serialize(&mut size_counter) {
+ Ok(_) => Some(size_counter.size_limit.total),
+ Err(_) => None,
+ }
}
/// Deserializes an object directly from a `Buffer`ed Reader.
///
/// If the provided `SizeLimit` is reached, the deserialization will bail immediately.
/// A SizeLimit can help prevent an attacker from flooding your server with
/// a neverending stream of values that runs your server out of memory.
///
/// If this returns an `Error`, assume that the buffer that you passed
/// in is in an invalid state, as the error could be returned during any point
/// in the reading.
-pub fn deserialize_from<R: ?Sized, T, E: ByteOrder>(reader: &mut R, size_limit: SizeLimit) -> Result<T>
- where R: Read,
- T: serde::Deserialize,
+pub fn deserialize_from<R: ?Sized, T, S, E>(reader: &mut R, size_limit: S) -> Result<T>
+ where R: Read, T: serde::Deserialize, S: SizeLimit, E: ByteOrder
{
- let mut deserializer = Deserializer::<_, E>::new(reader, size_limit);
+ let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit);
serde::Deserialize::deserialize(&mut deserializer)
}
/// Deserializes a slice of bytes into an object.
///
/// This method does not have a size-limit because if you already have the bytes
/// in memory, then you don't gain anything by having a limiter.
pub fn deserialize<T, E: ByteOrder>(bytes: &[u8]) -> Result<T>
where T: serde::Deserialize,
{
let mut reader = bytes;
- deserialize_from::<_, _, E>(&mut reader, SizeLimit::Infinite)
+ deserialize_from::<_, _, _, E>(&mut reader, super::Infinite)
}
--- a/third_party/rust/bincode/src/serde/reader.rs
+++ b/third_party/rust/bincode/src/serde/reader.rs
@@ -1,73 +1,79 @@
+use std::cmp;
use std::io::Read;
use std::marker::PhantomData;
use byteorder::{ReadBytesExt, ByteOrder};
use serde_crate as serde;
use serde_crate::de::value::ValueDeserializer;
use serde_crate::de::Error as DeError;
use ::SizeLimit;
use super::{Result, Error, ErrorKind};
+const BLOCK_SIZE: usize = 65536;
+
/// A Deserializer that reads bytes from a buffer.
///
/// This struct should rarely be used.
/// In most cases, prefer the `decode_from` function.
///
/// ```rust,ignore
/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
/// serde::Deserialize::deserialize(&mut deserializer);
/// let bytes_read = d.bytes_read();
/// ```
-pub struct Deserializer<R, E: ByteOrder> {
+pub struct Deserializer<R, S: SizeLimit, E: ByteOrder> {
reader: R,
- size_limit: SizeLimit,
+ size_limit: S,
read: u64,
_phantom: PhantomData<E>,
}
-impl<R: Read, E: ByteOrder> Deserializer<R, E> {
- pub fn new(r: R, size_limit: SizeLimit) -> Deserializer<R, E> {
+impl<R: Read, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E> {
+ pub fn new(r: R, size_limit: S) -> Deserializer<R, S, E> {
Deserializer {
reader: r,
size_limit: size_limit,
read: 0,
_phantom: PhantomData
}
}
/// Returns the number of bytes read from the contained Reader.
pub fn bytes_read(&self) -> u64 {
self.read
}
fn read_bytes(&mut self, count: u64) -> Result<()> {
- self.read += count;
- match self.size_limit {
- SizeLimit::Infinite => Ok(()),
- SizeLimit::Bounded(x) if self.read <= x => Ok(()),
- SizeLimit::Bounded(_) => Err(ErrorKind::SizeLimit.into())
- }
+ self.size_limit.add(count)
}
fn read_type<T>(&mut self) -> Result<()> {
use std::mem::size_of;
self.read_bytes(size_of::<T>() as u64)
}
fn read_vec(&mut self) -> Result<Vec<u8>> {
- let len = try!(serde::Deserialize::deserialize(&mut *self));
- try!(self.read_bytes(len));
+ let mut len: usize = try!(serde::Deserialize::deserialize(&mut *self));
- let len = len as usize;
- let mut bytes = Vec::with_capacity(len);
- unsafe { bytes.set_len(len); }
- try!(self.reader.read_exact(&mut bytes));
- Ok(bytes)
+ let mut result = Vec::new();
+ let mut off = 0;
+ while len > 0 {
+ let reserve = cmp::min(len, BLOCK_SIZE);
+ try!(self.read_bytes(reserve as u64));
+ unsafe {
+ result.reserve(reserve);
+ result.set_len(off + reserve);
+ }
+ try!(self.reader.read_exact(&mut result[off..]));
+ len -= reserve;
+ off += reserve;
+ }
+ Ok(result)
}
fn read_string(&mut self) -> Result<String> {
String::from_utf8(try!(self.read_vec())).map_err(|err|
ErrorKind::InvalidEncoding{
desc: "error while decoding utf8 string",
detail: Some(format!("Deserialize error: {}", err))
}.into())
@@ -82,17 +88,18 @@ macro_rules! impl_nums {
{
try!(self.read_type::<$ty>());
let value = try!(self.reader.$reader_method::<E>());
visitor.$visitor_method(value)
}
}
}
-impl<'a, R: Read, E: ByteOrder> serde::Deserializer for &'a mut Deserializer<R, E> {
+impl<'a, R, S, E> serde::Deserializer for &'a mut Deserializer<R, S, E>
+where R: Read, S: SizeLimit, E: ByteOrder {
type Error = Error;
#[inline]
fn deserialize<V>(self, _visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
let message = "bincode does not support Deserializer::deserialize";
Err(Error::custom(message))
@@ -146,46 +153,36 @@ impl<'a, R: Read, E: ByteOrder> serde::D
visitor.visit_unit()
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
use std::str;
- let error = ErrorKind::InvalidEncoding{
- desc: "Invalid char encoding",
- detail: None
- }.into();
+ let error = || {
+ ErrorKind::InvalidEncoding{
+ desc: "Invalid char encoding",
+ detail: None,
+ }.into()
+ };
- let mut buf = [0];
+ let mut buf = [0u8; 4];
- let _ = try!(self.reader.read(&mut buf[..]));
- let first_byte = buf[0];
- let width = utf8_char_width(first_byte);
- if width == 1 { return visitor.visit_char(first_byte as char) }
- if width == 0 { return Err(error)}
+ // 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())}
- let mut buf = [first_byte, 0, 0, 0];
- {
- let mut start = 1;
- while start < width {
- match try!(self.reader.read(&mut buf[start .. width])) {
- n if n == width - start => break,
- n if n < width - start => { start += n; }
- _ => return Err(error)
- }
- }
+ if self.reader.read_exact(&mut buf[1..width]).is_err() {
+ return Err(error());
}
- let res = try!(match str::from_utf8(&buf[..width]).ok() {
- Some(s) => Ok(s.chars().next().unwrap()),
- None => Err(error)
- });
-
+ let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error()));
visitor.visit_char(res)
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
visitor.visit_str(&try!(self.read_string()))
}
@@ -209,40 +206,39 @@ impl<'a, R: Read, E: ByteOrder> serde::D
}
fn deserialize_enum<V>(self,
_enum: &'static str,
_variants: &'static [&'static str],
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
- impl<'a, R: Read + 'a, E: ByteOrder> serde::de::EnumVisitor for &'a mut Deserializer<R, E> {
+ impl<'a, R: 'a, S, E> serde::de::EnumVisitor for &'a mut Deserializer<R, S, E>
+ where R: Read, S: SizeLimit, E: ByteOrder {
type Error = Error;
type Variant = Self;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
where V: serde::de::DeserializeSeed,
{
let idx: u32 = try!(serde::de::Deserialize::deserialize(&mut *self));
let val: Result<_> = seed.deserialize(idx.into_deserializer());
Ok((try!(val), self))
}
}
visitor.visit_enum(self)
}
- fn deserialize_tuple<V>(self,
- _len: usize,
- visitor: V) -> Result<V::Value>
+ fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
- struct TupleVisitor<'a, R: Read + 'a, E: ByteOrder + 'a>(&'a mut Deserializer<R, E>);
+ struct TupleVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a>(&'a mut Deserializer<R, S, E>);
- impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::SeqVisitor for TupleVisitor<'a, R, E> {
+ impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for TupleVisitor<'a, R, S, E> {
type Error = Error;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where T: serde::de::DeserializeSeed,
{
let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.0));
Ok(Some(value))
}
@@ -251,22 +247,22 @@ impl<'a, R: Read, E: ByteOrder> serde::D
visitor.visit_seq(TupleVisitor(self))
}
fn deserialize_seq_fixed_size<V>(self,
len: usize,
visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
- struct SeqVisitor<'a, R: Read + 'a, E: ByteOrder + 'a> {
- deserializer: &'a mut Deserializer<R, E>,
+ struct SeqVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
+ deserializer: &'a mut Deserializer<R, S, E>,
len: usize,
}
- impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::SeqVisitor for SeqVisitor<'a, R, E> {
+ impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqVisitor for SeqVisitor<'a, R, S, E> {
type Error = Error;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where T: serde::de::DeserializeSeed,
{
if self.len > 0 {
self.len -= 1;
let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
@@ -300,22 +296,22 @@ impl<'a, R: Read, E: ByteOrder> serde::D
let len = try!(serde::Deserialize::deserialize(&mut *self));
self.deserialize_seq_fixed_size(len, visitor)
}
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
- struct MapVisitor<'a, R: Read + 'a, E: ByteOrder + 'a> {
- deserializer: &'a mut Deserializer<R, E>,
+ struct MapVisitor<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
+ deserializer: &'a mut Deserializer<R, S, E>,
len: usize,
}
- impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::MapVisitor for MapVisitor<'a, R, E> {
+ impl<'a, 'b: 'a, R: Read + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapVisitor for MapVisitor<'a, R, S, E> {
type Error = Error;
fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
where K: serde::de::DeserializeSeed,
{
if self.len > 0 {
self.len -= 1;
let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
@@ -384,17 +380,18 @@ impl<'a, R: Read, E: ByteOrder> serde::D
_visitor: V) -> Result<V::Value>
where V: serde::de::Visitor,
{
let message = "bincode does not support Deserializer::deserialize_ignored_any";
Err(Error::custom(message))
}
}
-impl<'a, R: Read, E: ByteOrder> serde::de::VariantVisitor for &'a mut Deserializer<R, E> {
+impl<'a, R, S, E> serde::de::VariantVisitor for &'a mut Deserializer<R, S, E>
+where R: Read, S: SizeLimit, E: ByteOrder {
type Error = Error;
fn visit_unit(self) -> Result<()> {
Ok(())
}
fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value>
where T: serde::de::DeserializeSeed,
--- a/third_party/rust/bincode/src/serde/writer.rs
+++ b/third_party/rust/bincode/src/serde/writer.rs
@@ -2,16 +2,17 @@ use std::io::Write;
use std::u32;
use std::marker::PhantomData;
use serde_crate as serde;
use byteorder::{WriteBytesExt, ByteOrder};
use super::{Result, Error, ErrorKind};
+use super::super::SizeLimit;
/// An Serializer that encodes values directly into a Writer.
///
/// This struct should not be used often.
/// For most cases, prefer the `encode_into` function.
pub struct Serializer<W, E: ByteOrder> {
writer: W,
_phantom: PhantomData<E>,
@@ -188,62 +189,55 @@ impl<'a, W: Write, E: ByteOrder> serde::
fn serialize_unit_variant(self,
_name: &'static str,
variant_index: usize,
_variant: &'static str) -> Result<()> {
self.add_enum_tag(variant_index)
}
}
-pub struct SizeChecker {
- pub size_limit: u64,
- pub written: u64
+pub struct SizeChecker<S: SizeLimit> {
+ pub size_limit: S,
}
-impl SizeChecker {
- pub fn new(limit: u64) -> SizeChecker {
+impl <S: SizeLimit> SizeChecker<S> {
+ pub fn new(size_limit: S) -> SizeChecker<S> {
SizeChecker {
- size_limit: limit,
- written: 0
+ size_limit: size_limit
}
}
- fn add_raw(&mut self, size: usize) -> Result<()> {
- self.written += size as u64;
- if self.written <= self.size_limit {
- Ok(())
- } else {
- Err(ErrorKind::SizeLimit.into())
- }
+ fn add_raw(&mut self, size: u64) -> Result<()> {
+ self.size_limit.add(size)
}
fn add_value<T>(&mut self, t: T) -> Result<()> {
use std::mem::size_of_val;
- self.add_raw(size_of_val(&t))
+ self.add_raw(size_of_val(&t) as u64)
}
fn add_enum_tag(&mut self, tag: usize) -> Result<()> {
if tag > u32::MAX as usize {
panic!("Variant tag doesn't fit in a u32")
}
self.add_value(tag as u32)
}
}
-impl<'a> serde::Serializer for &'a mut SizeChecker {
+impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
type Ok = ();
type Error = Error;
- type SerializeSeq = SizeCompound<'a>;
- type SerializeTuple = SizeCompound<'a>;
- type SerializeTupleStruct = SizeCompound<'a>;
- type SerializeTupleVariant = SizeCompound<'a>;
- type SerializeMap = SizeCompound<'a>;
- type SerializeStruct = SizeCompound<'a>;
- type SerializeStructVariant = SizeCompound<'a>;
+ type SerializeSeq = SizeCompound<'a, S>;
+ type SerializeTuple = SizeCompound<'a, S>;
+ type SerializeTupleStruct = SizeCompound<'a, S>;
+ type SerializeTupleVariant = SizeCompound<'a, S>;
+ type SerializeMap = SizeCompound<'a, S>;
+ type SerializeStruct = SizeCompound<'a, S>;
+ type SerializeStructVariant = SizeCompound<'a, S>;
fn serialize_unit(self) -> Result<()> { Ok(()) }
fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) }
fn serialize_bool(self, _: bool) -> Result<()> {
self.add_value(0 as u8)
}
@@ -285,26 +279,26 @@ impl<'a> serde::Serializer for &'a mut S
}
fn serialize_f64(self, v: f64) -> Result<()> {
self.add_value(v)
}
fn serialize_str(self, v: &str) -> Result<()> {
try!(self.add_value(0 as u64));
- self.add_raw(v.len())
+ self.add_raw(v.len() as u64)
}
fn serialize_char(self, c: char) -> Result<()> {
- self.add_raw(encode_utf8(c).as_slice().len())
+ self.add_raw(encode_utf8(c).as_slice().len() as u64)
}
fn serialize_bytes(self, v: &[u8]) -> Result<()> {
try!(self.add_value(0 as u64));
- self.add_raw(v.len())
+ 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,
@@ -527,21 +521,21 @@ impl<'a, W, E> serde::ser::SerializeStru
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
#[doc(hidden)]
-pub struct SizeCompound<'a> {
- ser: &'a mut SizeChecker,
+pub struct SizeCompound<'a, S: SizeLimit + 'a> {
+ ser: &'a mut SizeChecker<S>,
}
-impl<'a> serde::ser::SerializeSeq for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
@@ -549,17 +543,17 @@ impl<'a> serde::ser::SerializeSeq for Si
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeTuple for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
@@ -567,17 +561,17 @@ impl<'a> serde::ser::SerializeTuple for
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeTupleStruct for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
@@ -585,17 +579,17 @@ impl<'a> serde::ser::SerializeTupleStruc
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeTupleVariant for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
@@ -603,17 +597,17 @@ impl<'a> serde::ser::SerializeTupleVaria
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeMap for SizeCompound<'a>
+impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
where K: serde::ser::Serialize
{
@@ -628,17 +622,17 @@ impl<'a> serde::ser::SerializeMap for Si
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeStruct for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
@@ -646,34 +640,33 @@ impl<'a> serde::ser::SerializeStruct for
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-impl<'a> serde::ser::SerializeStructVariant for SizeCompound<'a>
+impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S>
{
type Ok = ();
type Error = Error;
#[inline]
fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
where T: serde::ser::Serialize
{
value.serialize(&mut *self.ser)
}
#[inline]
fn end(self) -> Result<()> {
Ok(())
}
}
-
const TAG_CONT: u8 = 0b1000_0000;
const TAG_TWO_B: u8 = 0b1100_0000;
const TAG_THREE_B: u8 = 0b1110_0000;
const TAG_FOUR_B: u8 = 0b1111_0000;
const MAX_ONE_B: u32 = 0x80;
const MAX_TWO_B: u32 = 0x800;
const MAX_THREE_B: u32 = 0x10000;
--- a/third_party/rust/bincode/tests/test.rs
+++ b/third_party/rust/bincode/tests/test.rs
@@ -6,17 +6,17 @@ extern crate serde;
extern crate byteorder;
use std::fmt::Debug;
use std::collections::HashMap;
use std::ops::Deref;
use bincode::refbox::{RefBox, StrBox, SliceBox};
-use bincode::SizeLimit::{Infinite, Bounded};
+use bincode::{Infinite, Bounded};
use bincode::{serialized_size, ErrorKind, Result};
use bincode::endian_choice::{serialize, deserialize};
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)
@@ -29,30 +29,29 @@ fn the_same<V>(element: V)
let rf = RefBox::new(v);
let encoded = serialize_little(&rf, Infinite).unwrap();
let decoded: RefBox<'static, V> = deserialize_little(&encoded[..]).unwrap();
decoded.take().deref() == v
}
let size = serialized_size(&element);
-
{
let encoded = serialize_little(&element, Infinite);
let encoded = encoded.unwrap();
let decoded = deserialize_little(&encoded[..]);
let decoded = decoded.unwrap();
assert_eq!(element, decoded);
assert_eq!(size, encoded.len() as u64);
assert!(ref_box_correct(&element));
}
{
- let encoded = serialize::<_, byteorder::BigEndian>(&element, Infinite);
+ let encoded = serialize::<_, _, byteorder::BigEndian>(&element, Infinite);
let encoded = encoded.unwrap();
let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]);
let decoded = decoded.unwrap();
assert_eq!(element, decoded);
assert_eq!(size, encoded.len() as u64);
assert!(ref_box_correct(&element));
}
@@ -230,38 +229,38 @@ fn deserializing_errors() {
};
isize_invalid_deserialize(deserialize_little::<Test>(&vec![0, 0, 0, 5][..]));
isize_invalid_deserialize(deserialize_little::<Option<u8>>(&vec![5, 0][..]));
}
#[test]
fn too_big_deserialize() {
let serialized = vec![0,0,0,3];
- let deserialized: Result<u32> = deserialize_from_little::<_, _>(&mut &serialized[..], Bounded(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));
+ 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));
+ 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());
@@ -399,11 +398,11 @@ fn bytes() {
assert_eq!(s[..], s2[8..]);
}
#[test]
fn endian_difference() {
let x = 10u64;
let little = serialize_little(&x, Infinite).unwrap();
- let big = serialize::<_, byteorder::BigEndian>(&x, Infinite).unwrap();
+ let big = serialize::<_, _, byteorder::BigEndian>(&x, Infinite).unwrap();
assert_ne!(little, big);
}
--- a/third_party/rust/gleam/.cargo-checksum.json
+++ b/third_party/rust/gleam/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"c1e953ee360e77de57f7b02f1b7880bd6a3dc22d1a69e953c2ac2c52cc52d247",".travis.yml":"29b74b95210896ce634c11a9037638668473b5a1b3b1716c505cb04dbb6341fa","COPYING":"ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a","Cargo.toml":"5fd8124cb3073a87b04271d343b8bb73c749f97bfef800d5ccb2b461a1a84354","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","README.md":"2de24b7458d6b88f20324303a48acf64a4f2bbfb83d2ec4d6ff2b4f4a1fd2275","build.rs":"16a89f28717ffeae75219889d6560aa8b089adff46f821a724e28e20fddafb81","src/gl.rs":"ed01b1c8e5cb31de68dde54a857722f3d5b2bdeb8e30bfb2a95b500e3bf5f98a","src/gl_fns.rs":"d6eb7dd171030fe1b350f1616cd2c2e33d9051f70f5edcdd85f146b2745418a0","src/gles_fns.rs":"91c15619b8fbabe2324358d3c6ada27559acc42b0a21c64cc37ccd3729a9582a","src/lib.rs":"16610c19b45a3f26d56b379a3591aa2e4fc9477e7bd88f86b31c6ea32e834861"},"package":"2958396a0a358d2de747b31329f5ae2229070602b0f51edd5d682f92c307c332"}
\ No newline at end of file
+{"files":{".cargo-ok":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",".gitignore":"c1e953ee360e77de57f7b02f1b7880bd6a3dc22d1a69e953c2ac2c52cc52d247",".travis.yml":"29b74b95210896ce634c11a9037638668473b5a1b3b1716c505cb04dbb6341fa","COPYING":"ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a","Cargo.toml":"93d5d180a0ae7c983db41e3127e58b642ed1d512a9a31c23e358969678098edf","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3","README.md":"2de24b7458d6b88f20324303a48acf64a4f2bbfb83d2ec4d6ff2b4f4a1fd2275","build.rs":"859937a7a48ae13485b1c82ebf5ab0d4f71d93a0cdd835dd0b2851929648f269","src/gl.rs":"ed01b1c8e5cb31de68dde54a857722f3d5b2bdeb8e30bfb2a95b500e3bf5f98a","src/gl_fns.rs":"d6eb7dd171030fe1b350f1616cd2c2e33d9051f70f5edcdd85f146b2745418a0","src/gles_fns.rs":"d00ba76795721c9136f770bb7135db67c95bb714bfa5a00952226b41519e68d7","src/lib.rs":"16610c19b45a3f26d56b379a3591aa2e4fc9477e7bd88f86b31c6ea32e834861"},"package":"3232655dbe4fc5ab688c05024f2c816b5d20c19ad8216d5c7d85cf915b24e005"}
\ No newline at end of file
--- a/third_party/rust/gleam/Cargo.toml
+++ b/third_party/rust/gleam/Cargo.toml
@@ -1,11 +1,11 @@
[package]
name = "gleam"
-version = "0.4.1"
+version = "0.4.2"
license = "Apache-2.0/MIT"
authors = ["The Servo Project Developers"]
build = "build.rs"
documentation = "http://doc.servo.org/gleam/"
repository = "https://github.com/servo/gleam"
description = "Generated OpenGL bindings and wrapper for Servo."
[build-dependencies]
--- a/third_party/rust/gleam/build.rs
+++ b/third_party/rust/gleam/build.rs
@@ -14,17 +14,17 @@ fn main() {
// OpenGL 3.3 bindings
let gl_extensions = ["GL_ARB_texture_rectangle", "GL_EXT_debug_marker"];
let gl_reg = Registry::new(Api::Gl, (3, 3), Profile::Core, Fallbacks::All, gl_extensions);
gl_reg.write_bindings(gl_generator::StructGenerator, &mut file_gl)
.unwrap();
// GLES 2.0 bindings
- let gles_extensions = ["GL_EXT_texture_format_BGRA8888"];
+ let gles_extensions = ["GL_EXT_texture_format_BGRA8888", "GL_OES_EGL_image"];
let gles_reg = Registry::new(Api::Gles2, (3, 0), Profile::Core, Fallbacks::All, gles_extensions);
gles_reg.write_bindings(gl_generator::StructGenerator, &mut file_gles)
.unwrap();
// OpenGL 3.3 + GLES 2.0 bindings. Used to get all enums
let gl_reg = gl_reg + gles_reg;
gl_reg.write_bindings(gl_generator::StructGenerator, &mut file_gl_and_gles)
.unwrap();
--- a/third_party/rust/gleam/src/gles_fns.rs
+++ b/third_party/rust/gleam/src/gles_fns.rs
@@ -16,21 +16,16 @@ impl GlesFns
pub unsafe fn load_with<'a, F>(loadfn: F) -> Rc<Gl> where F: FnMut(&str) -> *const c_void {
let ffi_gl_ = GlesFfi::load_with(loadfn);
Rc::new(GlesFns {
ffi_gl_: ffi_gl_,
}) as Rc<Gl>
}
}
-#[cfg(target_os="android")]
-extern {
- fn glEGLImageTargetTexture2DOES(target: GLenum, image: GLeglImageOES);
-}
-
impl Gl for GlesFns {
fn get_type(&self) -> GlType {
GlType::Gles
}
fn buffer_data_untyped(&self, target: GLenum, size: GLsizeiptr, data: *const GLvoid, usage: GLenum) {
unsafe {
self.ffi_gl_.BufferData(target,
@@ -1274,17 +1269,17 @@ impl Gl for GlesFns {
#[cfg(not(target_os="android"))]
fn egl_image_target_texture2d_oes(&self, target: GLenum, image: GLeglImageOES) {
panic!("not supported")
}
#[cfg(target_os="android")]
fn egl_image_target_texture2d_oes(&self, target: GLenum, image: GLeglImageOES) {
unsafe {
- glEGLImageTargetTexture2DOES(target, image);
+ self.ffi_gl_.EGLImageTargetTexture2DOES(target, image);
}
}
fn generate_mipmap(&self, target: GLenum) {
unsafe {
self.ffi_gl_.GenerateMipmap(target)
}
}