Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update serde to 0.9 (fixes #15325)

Browse source
This commit is contained in:
Anthony Ramine 2017-02-10 02:35:26 +01:00
parent 26d6c96b18
commit fe3f4ff0c2
73 changed files with 630 additions and 604 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/layout/Cargo.toml
View file

@ -10,18 +10,18 @@ name = "layout"
path = "lib.rs"
[dependencies]
app_units = "0.3"
app_units = "0.4"
atomic_refcell = "0.1"
bitflags = "0.7"
canvas_traits = {path = "../canvas_traits"}
cssparser = {version = "0.9", features = ["heap_size", "serde-serialization"]}
euclid = "0.10.1"
cssparser = {version = "0.10", features = ["heapsize", "serde"]}
euclid = "0.11"
fnv = "1.0"
gfx = {path = "../gfx"}
gfx_traits = {path = "../gfx_traits"}
heapsize = "0.3.0"
html5ever-atoms = "0.1"
ipc-channel = "0.6.3"
html5ever-atoms = "0.2"
ipc-channel = "0.7"
libc = "0.2"
log = "0.3.5"
msg = {path = "../msg"}
@ -35,10 +35,10 @@ rayon = "0.6"
script_layout_interface = {path = "../script_layout_interface"}
script_traits = {path = "../script_traits"}
selectors = { path = "../selectors" }
serde = "0.8"
serde_derive = "0.8"
serde = "0.9"
serde_derive = "0.9"
servo_geometry = {path = "../geometry"}
serde_json = "0.8"
serde_json = "0.9"
servo_config = {path = "../config"}
servo_url = {path = "../url"}
smallvec = "0.1"

2
components/layout/block.rs
View file

@ -524,7 +524,7 @@ bitflags! {
}
impl Serialize for BlockFlowFlags {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.bits().serialize(serializer)
}
}

22
components/layout/flow.rs
View file

@ -42,7 +42,7 @@ use inline::InlineFlow;
use model::{CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo};
use multicol::MulticolFlow;
use parallel::FlowParallelInfo;
use serde::{Serialize, Serializer};
use serde::ser::{Serialize, SerializeStruct, Serializer};
use servo_geometry::{au_rect_to_f32_rect, f32_rect_to_au_rect};
use std::{fmt, mem, raw};
use std::iter::Zip;
@ -1013,16 +1013,16 @@ impl fmt::Debug for BaseFlow {
}
impl Serialize for BaseFlow {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
let mut state = try!(serializer.serialize_struct("base", 5));
try!(serializer.serialize_struct_elt(&mut state, "id", self.debug_id()));
try!(serializer.serialize_struct_elt(&mut state, "stacking_relative_position",
&self.stacking_relative_position));
try!(serializer.serialize_struct_elt(&mut state, "intrinsic_inline_sizes",
&self.intrinsic_inline_sizes));
try!(serializer.serialize_struct_elt(&mut state, "position", &self.position));
try!(serializer.serialize_struct_elt(&mut state, "children", &self.children));
serializer.serialize_struct_end(state)
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut serializer = try!(serializer.serialize_struct("base", 5));
try!(serializer.serialize_field("id", &self.debug_id()));
try!(serializer.serialize_field("stacking_relative_position",
&self.stacking_relative_position));
try!(serializer.serialize_field("intrinsic_inline_sizes",
&self.intrinsic_inline_sizes));
try!(serializer.serialize_field("position", &self.position));
try!(serializer.serialize_field("children", &self.children));
serializer.end()
}
}

48
components/layout/flow_list.rs
View file

@ -4,9 +4,8 @@
use flow::{Flow, FlowClass};
use flow_ref::FlowRef;
use serde::{Serialize, Serializer};
use serde_json::{to_value, Value};
use serde_json::builder::ObjectBuilder;
use serde::ser::{Serialize, SerializeSeq, Serializer};
use serde_json::{Map, Value, to_value};
use std::collections::{LinkedList, linked_list};
use std::sync::Arc;
@ -24,30 +23,29 @@ pub struct FlowList {
}
impl Serialize for FlowList {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
let mut state = try!(serializer.serialize_seq(Some(self.len())));
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut serializer = try!(serializer.serialize_seq(Some(self.len())));
for f in self.iter() {
let flow_val = ObjectBuilder::new()
.insert("class", f.class())
.insert("data", match f.class() {
FlowClass::Block => to_value(f.as_block()),
FlowClass::Inline => to_value(f.as_inline()),
FlowClass::Table => to_value(f.as_table()),
FlowClass::TableWrapper => to_value(f.as_table_wrapper()),
FlowClass::TableRowGroup => to_value(f.as_table_rowgroup()),
FlowClass::TableRow => to_value(f.as_table_row()),
FlowClass::TableCell => to_value(f.as_table_cell()),
FlowClass::Flex => to_value(f.as_flex()),
FlowClass::ListItem | FlowClass::TableColGroup | FlowClass::TableCaption |
FlowClass::Multicol | FlowClass::MulticolColumn => {
Value::Null // Not implemented yet
}
})
.build();
try!(serializer.serialize_seq_elt(&mut state, flow_val));
let mut flow_val = Map::new();
flow_val.insert("class".to_owned(), to_value(f.class()).unwrap());
let data = match f.class() {
FlowClass::Block => to_value(f.as_block()).unwrap(),
FlowClass::Inline => to_value(f.as_inline()).unwrap(),
FlowClass::Table => to_value(f.as_table()).unwrap(),
FlowClass::TableWrapper => to_value(f.as_table_wrapper()).unwrap(),
FlowClass::TableRowGroup => to_value(f.as_table_rowgroup()).unwrap(),
FlowClass::TableRow => to_value(f.as_table_row()).unwrap(),
FlowClass::TableCell => to_value(f.as_table_cell()).unwrap(),
FlowClass::Flex => to_value(f.as_flex()).unwrap(),
FlowClass::ListItem | FlowClass::TableColGroup | FlowClass::TableCaption |
FlowClass::Multicol | FlowClass::MulticolColumn => {
Value::Null // Not implemented yet
}
};
flow_val.insert("data".to_owned(), data);
try!(serializer.serialize_element(&flow_val));
}
serializer.serialize_seq_end(state)
serializer.end()
}
}

18
components/layout/fragment.rs
View file

@ -32,7 +32,7 @@ use range::*;
use script_layout_interface::HTMLCanvasData;
use script_layout_interface::SVGSVGData;
use script_layout_interface::wrapper_traits::{PseudoElementType, ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use serde::{Serialize, Serializer};
use serde::ser::{Serialize, SerializeStruct, Serializer};
use servo_url::ServoUrl;
use std::{f32, fmt};
use std::borrow::ToOwned;
@ -142,12 +142,12 @@ pub struct Fragment {
}
impl Serialize for Fragment {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
let mut state = try!(serializer.serialize_struct("fragment", 3));
try!(serializer.serialize_struct_elt(&mut state, "id", &self.debug_id));
try!(serializer.serialize_struct_elt(&mut state, "border_box", &self.border_box));
try!(serializer.serialize_struct_elt(&mut state, "margin", &self.margin));
serializer.serialize_struct_end(state)
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut serializer = try!(serializer.serialize_struct("fragment", 3));
try!(serializer.serialize_field("id", &self.debug_id));
try!(serializer.serialize_field("border_box", &self.border_box));
try!(serializer.serialize_field("margin", &self.margin));
serializer.end()
}
}
@ -3179,14 +3179,14 @@ impl fmt::Display for DebugId {
#[cfg(not(debug_assertions))]
impl Serialize for DebugId {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&format!("{:p}", &self))
}
}
#[cfg(debug_assertions)]
impl Serialize for DebugId {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_u16(self.0)
}
}

8
components/layout/layout_debug.rs
View file

@ -63,7 +63,7 @@ impl Scope {
pub fn new(name: String) -> Scope {
STATE_KEY.with(|ref r| {
if let Some(ref mut state) = *r.borrow_mut() {
let flow_trace = to_value(&flow::base(&*state.flow_root));
let flow_trace = to_value(&flow::base(&*state.flow_root)).unwrap();
let data = box ScopeData::new(name.clone(), flow_trace);
state.scope_stack.push(data);
}
@ -78,7 +78,7 @@ impl Drop for Scope {
STATE_KEY.with(|ref r| {
if let Some(ref mut state) = *r.borrow_mut() {
let mut current_scope = state.scope_stack.pop().unwrap();
current_scope.post = to_value(&flow::base(&*state.flow_root));
current_scope.post = to_value(&flow::base(&*state.flow_root)).unwrap();
let previous_scope = state.scope_stack.last_mut().unwrap();
previous_scope.children.push(current_scope);
}
@ -100,7 +100,7 @@ pub fn begin_trace(flow_root: FlowRef) {
assert!(STATE_KEY.with(|ref r| r.borrow().is_none()));
STATE_KEY.with(|ref r| {
let flow_trace = to_value(&flow::base(&*flow_root));
let flow_trace = to_value(&flow::base(&*flow_root)).unwrap();
let state = State {
scope_stack: vec![box ScopeData::new("root".to_owned(), flow_trace)],
flow_root: flow_root.clone(),
@ -116,7 +116,7 @@ pub fn end_trace(generation: u32) {
let mut thread_state = STATE_KEY.with(|ref r| r.borrow_mut().take().unwrap());
assert!(thread_state.scope_stack.len() == 1);
let mut root_scope = thread_state.scope_stack.pop().unwrap();
root_scope.post = to_value(&flow::base(&*thread_state.flow_root));
root_scope.post = to_value(&flow::base(&*thread_state.flow_root)).unwrap();
let result = to_string(&root_scope).unwrap();
let mut file = File::create(format!("layout_trace-{}.json", generation)).unwrap();

6
components/layout/table_row.rs
View file

@ -69,7 +69,7 @@ pub struct TableRowFlow {
}
impl Serialize for TableRowFlow {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.block_flow.serialize(serializer)
}
}
@ -578,8 +578,8 @@ pub struct CollapsedBorder {
}
impl Serialize for CollapsedBorder {
fn serialize<S: Serializer>(&self, _: &mut S) -> Result<(), S::Error> {
Ok(())
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_unit()
}
}

2
components/layout/table_rowgroup.rs
View file

@ -45,7 +45,7 @@ pub struct TableRowGroupFlow {
}
impl Serialize for TableRowGroupFlow {
fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.block_flow.serialize(serializer)
}
}