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

Format remaining files

Browse source
This commit is contained in:
Pyfisch 2018-11-06 13:01:35 +01:00
parent bf47f90da6
commit cb07debcb6
252 changed files with 5944 additions and 3744 deletions
Download patch file Download diff file Expand all files Collapse all files

40
components/allocator/lib.rs
View file

@ -30,31 +30,23 @@ mod platform {
// The minimum alignment guaranteed by the architecture. This value is used to // The minimum alignment guaranteed by the architecture. This value is used to
// add fast paths for low alignment values. // add fast paths for low alignment values.
#[cfg( #[cfg(all(any(
all( target_arch = "arm",
any( target_arch = "mips",
target_arch = "arm", target_arch = "mipsel",
target_arch = "mips", target_arch = "powerpc"
target_arch = "mipsel", )))]
target_arch = "powerpc"
)
)
)]
const MIN_ALIGN: usize = 8; const MIN_ALIGN: usize = 8;
#[cfg( #[cfg(all(any(
all( target_arch = "x86",
any( target_arch = "x86_64",
target_arch = "x86", target_arch = "aarch64",
target_arch = "x86_64", target_arch = "powerpc64",
target_arch = "aarch64", target_arch = "powerpc64le",
target_arch = "powerpc64", target_arch = "mips64",
target_arch = "powerpc64le", target_arch = "s390x",
target_arch = "mips64", target_arch = "sparc64"
target_arch = "s390x", )))]
target_arch = "sparc64"
)
)
)]
const MIN_ALIGN: usize = 16; const MIN_ALIGN: usize = 16;
fn layout_to_flags(align: usize, size: usize) -> c_int { fn layout_to_flags(align: usize, size: usize) -> c_int {

15
components/bluetooth/lib.rs
View file

@ -74,7 +74,8 @@ impl BluetoothThreadFactory for IpcSender<BluetoothRequest> {
BluetoothAdapter::init() BluetoothAdapter::init()
} else { } else {
BluetoothAdapter::init_mock() BluetoothAdapter::init_mock()
}.ok(); }
.ok();
thread::Builder::new() thread::Builder::new()
.name("BluetoothThread".to_owned()) .name("BluetoothThread".to_owned())
.spawn(move || { .spawn(move || {
@ -465,8 +466,10 @@ impl BluetoothManager {
}; };
services.retain(|s| { services.retain(|s| {
!uuid_is_blocklisted(&s.get_uuid().unwrap_or(String::new()), Blocklist::All) && !uuid_is_blocklisted(&s.get_uuid().unwrap_or(String::new()), Blocklist::All) && self
self.allowed_services.get(device_id).map_or(false, |uuids| { .allowed_services
.get(device_id)
.map_or(false, |uuids| {
uuids.contains(&s.get_uuid().unwrap_or(String::new())) uuids.contains(&s.get_uuid().unwrap_or(String::new()))
}) })
}); });
@ -556,9 +559,9 @@ impl BluetoothManager {
} }
fn characteristic_is_cached(&self, characteristic_id: &str) -> bool { fn characteristic_is_cached(&self, characteristic_id: &str) -> bool {
self.cached_characteristics.contains_key(characteristic_id) && self.cached_characteristics.contains_key(characteristic_id) && self
self.characteristic_to_service .characteristic_to_service
.contains_key(characteristic_id) .contains_key(characteristic_id)
} }
// Descriptor // Descriptor

6
components/bluetooth/test.rs
View file

@ -294,14 +294,16 @@ fn create_generic_access_service(
NUMBER_OF_DIGITALS_UUID.to_owned(), NUMBER_OF_DIGITALS_UUID.to_owned(),
vec![49], vec![49],
)?; )?;
number_of_digitals_descriptor_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?; number_of_digitals_descriptor_1
.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
let number_of_digitals_descriptor_2 = create_descriptor_with_value( let number_of_digitals_descriptor_2 = create_descriptor_with_value(
&device_name_characteristic, &device_name_characteristic,
NUMBER_OF_DIGITALS_UUID.to_owned(), NUMBER_OF_DIGITALS_UUID.to_owned(),
vec![50], vec![50],
)?; )?;
number_of_digitals_descriptor_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?; number_of_digitals_descriptor_2
.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
// Characteristic User Description Descriptor // Characteristic User Description Descriptor
let _characteristic_user_description = create_descriptor_with_value( let _characteristic_user_description = create_descriptor_with_value(

429
components/canvas/canvas_data.rs
View file

@ -39,7 +39,7 @@ impl<'a> CanvasData<'a> {
size: Size2D<u32>, size: Size2D<u32>,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: webrender_api::RenderApiSender,
antialias: AntialiasMode, antialias: AntialiasMode,
canvas_id: CanvasId canvas_id: CanvasId,
) -> CanvasData<'a> { ) -> CanvasData<'a> {
let draw_target = CanvasData::create(size); let draw_target = CanvasData::create(size);
let path_builder = draw_target.create_path_builder(); let path_builder = draw_target.create_path_builder();
@ -63,7 +63,7 @@ impl<'a> CanvasData<'a> {
image_size: Size2D<f64>, image_size: Size2D<f64>,
dest_rect: Rect<f64>, dest_rect: Rect<f64>,
source_rect: Rect<f64>, source_rect: Rect<f64>,
smoothing_enabled: bool smoothing_enabled: bool,
) { ) {
// We round up the floating pixel values to draw the pixels // We round up the floating pixel values to draw the pixels
let source_rect = source_rect.ceil(); let source_rect = source_rect.ceil();
@ -75,14 +75,22 @@ impl<'a> CanvasData<'a> {
}; };
let writer = |draw_target: &DrawTarget| { let writer = |draw_target: &DrawTarget| {
write_image(&draw_target, image_data, source_rect.size, dest_rect, write_image(
smoothing_enabled, self.state.draw_options.composition, &draw_target,
self.state.draw_options.alpha); image_data,
source_rect.size,
dest_rect,
smoothing_enabled,
self.state.draw_options.composition,
self.state.draw_options.alpha,
);
}; };
if self.need_to_draw_shadow() { if self.need_to_draw_shadow() {
let rect = Rect::new(Point2D::new(dest_rect.origin.x as f32, dest_rect.origin.y as f32), let rect = Rect::new(
Size2D::new(dest_rect.size.width as f32, dest_rect.size.height as f32)); Point2D::new(dest_rect.origin.x as f32, dest_rect.origin.y as f32),
Size2D::new(dest_rect.size.width as f32, dest_rect.size.height as f32),
);
self.draw_with_shadow(&rect, writer); self.draw_with_shadow(&rect, writer);
} else { } else {
@ -103,7 +111,10 @@ impl<'a> CanvasData<'a> {
} }
pub fn fill_text(&self, text: String, x: f64, y: f64, max_width: Option<f64>) { pub fn fill_text(&self, text: String, x: f64, y: f64, max_width: Option<f64>) {
error!("Unimplemented canvas2d.fillText. Values received: {}, {}, {}, {:?}.", text, x, y, max_width); error!(
"Unimplemented canvas2d.fillText. Values received: {}, {}, {}, {:?}.",
text, x, y, max_width
);
} }
pub fn fill_rect(&self, rect: &Rect<f32>) { pub fn fill_rect(&self, rect: &Rect<f32>) {
@ -111,7 +122,8 @@ impl<'a> CanvasData<'a> {
return; // Paint nothing if gradient size is zero. return; // Paint nothing if gradient size is zero.
} }
let draw_rect = Rect::new(rect.origin, let draw_rect = Rect::new(
rect.origin,
match self.state.fill_style { match self.state.fill_style {
Pattern::Surface(ref surface) => { Pattern::Surface(ref surface) => {
let surface_size = surface.size(); let surface_size = surface.size();
@ -119,21 +131,29 @@ impl<'a> CanvasData<'a> {
(true, true) => rect.size, (true, true) => rect.size,
(true, false) => Size2D::new(rect.size.width, surface_size.height as f32), (true, false) => Size2D::new(rect.size.width, surface_size.height as f32),
(false, true) => Size2D::new(surface_size.width as f32, rect.size.height), (false, true) => Size2D::new(surface_size.width as f32, rect.size.height),
(false, false) => Size2D::new(surface_size.width as f32, surface_size.height as f32), (false, false) => {
Size2D::new(surface_size.width as f32, surface_size.height as f32)
},
} }
}, },
_ => rect.size, _ => rect.size,
} },
); );
if self.need_to_draw_shadow() { if self.need_to_draw_shadow() {
self.draw_with_shadow(&draw_rect, |new_draw_target: &DrawTarget| { self.draw_with_shadow(&draw_rect, |new_draw_target: &DrawTarget| {
new_draw_target.fill_rect(&draw_rect, self.state.fill_style.to_pattern_ref(), new_draw_target.fill_rect(
Some(&self.state.draw_options)); &draw_rect,
self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options),
);
}); });
} else { } else {
self.drawtarget.fill_rect(&draw_rect, self.state.fill_style.to_pattern_ref(), self.drawtarget.fill_rect(
Some(&self.state.draw_options)); &draw_rect,
self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options),
);
} }
} }
@ -148,27 +168,40 @@ impl<'a> CanvasData<'a> {
if self.need_to_draw_shadow() { if self.need_to_draw_shadow() {
self.draw_with_shadow(&rect, |new_draw_target: &DrawTarget| { self.draw_with_shadow(&rect, |new_draw_target: &DrawTarget| {
new_draw_target.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(), new_draw_target.stroke_rect(
&self.state.stroke_opts, &self.state.draw_options); rect,
self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts,
&self.state.draw_options,
);
}); });
} else if rect.size.width == 0. || rect.size.height == 0. { } else if rect.size.width == 0. || rect.size.height == 0. {
let cap = match self.state.stroke_opts.line_join { let cap = match self.state.stroke_opts.line_join {
JoinStyle::Round => CapStyle::Round, JoinStyle::Round => CapStyle::Round,
_ => CapStyle::Butt _ => CapStyle::Butt,
}; };
let stroke_opts = let stroke_opts = StrokeOptions::new(
StrokeOptions::new(self.state.stroke_opts.line_width, self.state.stroke_opts.line_width,
self.state.stroke_opts.line_join, self.state.stroke_opts.line_join,
cap, cap,
self.state.stroke_opts.miter_limit, self.state.stroke_opts.miter_limit,
self.state.stroke_opts.mDashPattern); self.state.stroke_opts.mDashPattern,
self.drawtarget.stroke_line(rect.origin, rect.bottom_right(), );
self.state.stroke_style.to_pattern_ref(), self.drawtarget.stroke_line(
&stroke_opts, &self.state.draw_options); rect.origin,
rect.bottom_right(),
self.state.stroke_style.to_pattern_ref(),
&stroke_opts,
&self.state.draw_options,
);
} else { } else {
self.drawtarget.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(), self.drawtarget.stroke_rect(
&self.state.stroke_opts, &self.state.draw_options); rect,
self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts,
&self.state.draw_options,
);
} }
} }
@ -185,9 +218,11 @@ impl<'a> CanvasData<'a> {
return; // Paint nothing if gradient size is zero. return; // Paint nothing if gradient size is zero.
} }
self.drawtarget.fill(&self.path_builder.finish(), self.drawtarget.fill(
self.state.fill_style.to_pattern_ref(), &self.path_builder.finish(),
&self.state.draw_options); self.state.fill_style.to_pattern_ref(),
&self.state.draw_options,
);
} }
pub fn stroke(&self) { pub fn stroke(&self) {
@ -195,10 +230,12 @@ impl<'a> CanvasData<'a> {
return; // Paint nothing if gradient size is zero. return; // Paint nothing if gradient size is zero.
} }
self.drawtarget.stroke(&self.path_builder.finish(), self.drawtarget.stroke(
self.state.stroke_style.to_pattern_ref(), &self.path_builder.finish(),
&self.state.stroke_opts, self.state.stroke_style.to_pattern_ref(),
&self.state.draw_options); &self.state.stroke_opts,
&self.state.draw_options,
);
} }
pub fn clip(&self) { pub fn clip(&self) {
@ -210,7 +247,7 @@ impl<'a> CanvasData<'a> {
x: f64, x: f64,
y: f64, y: f64,
_fill_rule: FillRule, _fill_rule: FillRule,
chan: IpcSender<bool> chan: IpcSender<bool>,
) { ) {
let path = self.path_builder.finish(); let path = self.path_builder.finish();
let result = path.contains_point(x, y, &self.state.transform); let result = path.contains_point(x, y, &self.state.transform);
@ -227,19 +264,22 @@ impl<'a> CanvasData<'a> {
} }
pub fn rect(&self, rect: &Rect<f32>) { pub fn rect(&self, rect: &Rect<f32>) {
self.path_builder.move_to(Point2D::new(rect.origin.x, rect.origin.y)); self.path_builder
self.path_builder.line_to(Point2D::new(rect.origin.x + rect.size.width, rect.origin.y)); .move_to(Point2D::new(rect.origin.x, rect.origin.y));
self.path_builder.line_to(Point2D::new(rect.origin.x + rect.size.width, self.path_builder
rect.origin.y + rect.size.height)); .line_to(Point2D::new(rect.origin.x + rect.size.width, rect.origin.y));
self.path_builder.line_to(Point2D::new(rect.origin.x, rect.origin.y + rect.size.height)); self.path_builder.line_to(Point2D::new(
rect.origin.x + rect.size.width,
rect.origin.y + rect.size.height,
));
self.path_builder.line_to(Point2D::new(
rect.origin.x,
rect.origin.y + rect.size.height,
));
self.path_builder.close(); self.path_builder.close();
} }
pub fn quadratic_curve_to( pub fn quadratic_curve_to(&self, cp: &Point2D<AzFloat>, endpoint: &Point2D<AzFloat>) {
&self,
cp: &Point2D<AzFloat>,
endpoint: &Point2D<AzFloat>
) {
self.path_builder.quadratic_curve_to(cp, endpoint) self.path_builder.quadratic_curve_to(cp, endpoint)
} }
@ -247,7 +287,7 @@ impl<'a> CanvasData<'a> {
&self, &self,
cp1: &Point2D<AzFloat>, cp1: &Point2D<AzFloat>,
cp2: &Point2D<AzFloat>, cp2: &Point2D<AzFloat>,
endpoint: &Point2D<AzFloat> endpoint: &Point2D<AzFloat>,
) { ) {
self.path_builder.bezier_curve_to(cp1, cp2, endpoint) self.path_builder.bezier_curve_to(cp1, cp2, endpoint)
} }
@ -258,17 +298,13 @@ impl<'a> CanvasData<'a> {
radius: AzFloat, radius: AzFloat,
start_angle: AzFloat, start_angle: AzFloat,
end_angle: AzFloat, end_angle: AzFloat,
ccw: bool ccw: bool,
) { ) {
self.path_builder.arc(*center, radius, start_angle, end_angle, ccw) self.path_builder
.arc(*center, radius, start_angle, end_angle, ccw)
} }
pub fn arc_to( pub fn arc_to(&self, cp1: &Point2D<AzFloat>, cp2: &Point2D<AzFloat>, radius: AzFloat) {
&self,
cp1: &Point2D<AzFloat>,
cp2: &Point2D<AzFloat>,
radius: AzFloat
) {
let cp0 = self.path_builder.get_current_point(); let cp0 = self.path_builder.get_current_point();
let cp1 = *cp1; let cp1 = *cp1;
let cp2 = *cp2; let cp2 = *cp2;
@ -314,9 +350,17 @@ impl<'a> CanvasData<'a> {
let angle_end = (tp2.y - cy).atan2(tp2.x - cx); let angle_end = (tp2.y - cy).atan2(tp2.x - cx);
self.line_to(&tp1); self.line_to(&tp1);
if [cx, cy, angle_start, angle_end].iter().all(|x| x.is_finite()) { if [cx, cy, angle_start, angle_end]
self.arc(&Point2D::new(cx, cy), radius, .iter()
angle_start, angle_end, anticlockwise); .all(|x| x.is_finite())
{
self.arc(
&Point2D::new(cx, cy),
radius,
angle_start,
angle_end,
anticlockwise,
);
} }
} }
@ -328,9 +372,17 @@ impl<'a> CanvasData<'a> {
rotation_angle: AzFloat, rotation_angle: AzFloat,
start_angle: AzFloat, start_angle: AzFloat,
end_angle: AzFloat, end_angle: AzFloat,
ccw: bool ccw: bool,
) { ) {
self.path_builder.ellipse(*center, radius_x, radius_y, rotation_angle, start_angle, end_angle, ccw); self.path_builder.ellipse(
*center,
radius_x,
radius_y,
rotation_angle,
start_angle,
end_angle,
ccw,
);
} }
pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) { pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) {
@ -371,7 +423,9 @@ impl<'a> CanvasData<'a> {
} }
pub fn set_global_composition(&mut self, op: CompositionOrBlending) { pub fn set_global_composition(&mut self, op: CompositionOrBlending) {
self.state.draw_options.set_composition_op(op.to_azure_style()); self.state
.draw_options
.set_composition_op(op.to_azure_style());
} }
pub fn create(size: Size2D<u32>) -> DrawTarget { pub fn create(size: Size2D<u32>) -> DrawTarget {
@ -398,7 +452,13 @@ impl<'a> CanvasData<'a> {
#[allow(unsafe_code)] #[allow(unsafe_code)]
pub fn send_pixels(&mut self, chan: IpcSender<Option<ByteBuf>>) { pub fn send_pixels(&mut self, chan: IpcSender<Option<ByteBuf>>) {
let data = unsafe { self.drawtarget.snapshot().get_data_surface().data().to_vec() }; let data = unsafe {
self.drawtarget
.snapshot()
.get_data_surface()
.data()
.to_vec()
};
chan.send(Some(data.into())).unwrap(); chan.send(Some(data.into())).unwrap();
} }
@ -414,9 +474,9 @@ impl<'a> CanvasData<'a> {
is_opaque: false, is_opaque: false,
allow_mipmaps: false, allow_mipmaps: false,
}; };
let data = webrender_api::ImageData::Raw(Arc::new( let data = webrender_api::ImageData::Raw(Arc::new(unsafe {
unsafe { self.drawtarget.snapshot().get_data_surface().data().into() }, self.drawtarget.snapshot().get_data_surface().data().into()
)); }));
let mut txn = webrender_api::Transaction::new(); let mut txn = webrender_api::Transaction::new();
@ -424,15 +484,17 @@ impl<'a> CanvasData<'a> {
Some(image_key) => { Some(image_key) => {
debug!("Updating image {:?}.", image_key); debug!("Updating image {:?}.", image_key);
txn.update_image(image_key, descriptor, data, None); txn.update_image(image_key, descriptor, data, None);
} },
None => { None => {
self.image_key = Some(self.webrender_api.generate_image_key()); self.image_key = Some(self.webrender_api.generate_image_key());
debug!("New image {:?}.", self.image_key); debug!("New image {:?}.", self.image_key);
txn.add_image(self.image_key.unwrap(), descriptor, data, None); txn.add_image(self.image_key.unwrap(), descriptor, data, None);
} },
} }
if let Some(image_key) = mem::replace(&mut self.very_old_image_key, self.old_image_key.take()) { if let Some(image_key) =
mem::replace(&mut self.very_old_image_key, self.old_image_key.take())
{
txn.delete_image(image_key); txn.delete_image(image_key);
} }
@ -449,12 +511,15 @@ impl<'a> CanvasData<'a> {
assert_eq!(imagedata.len() % 4, 0); assert_eq!(imagedata.len() % 4, 0);
assert_eq!(rect.size.area() as usize, imagedata.len() / 4); assert_eq!(rect.size.area() as usize, imagedata.len() / 4);
pixels::byte_swap_and_premultiply_inplace(&mut imagedata); pixels::byte_swap_and_premultiply_inplace(&mut imagedata);
let source_surface = self.drawtarget.create_source_surface_from_data( let source_surface = self
&imagedata, .drawtarget
rect.size.to_i32(), .create_source_surface_from_data(
rect.size.width as i32 * 4, &imagedata,
SurfaceFormat::B8G8R8A8, rect.size.to_i32(),
).unwrap(); rect.size.width as i32 * 4,
SurfaceFormat::B8G8R8A8,
)
.unwrap();
self.drawtarget.copy_surface( self.drawtarget.copy_surface(
source_surface, source_surface,
Rect::from_size(rect.size.to_i32()), Rect::from_size(rect.size.to_i32()),
@ -481,15 +546,19 @@ impl<'a> CanvasData<'a> {
// https://html.spec.whatwg.org/multipage/#when-shadows-are-drawn // https://html.spec.whatwg.org/multipage/#when-shadows-are-drawn
fn need_to_draw_shadow(&self) -> bool { fn need_to_draw_shadow(&self) -> bool {
self.state.shadow_color.a != 0.0f32 && self.state.shadow_color.a != 0.0f32 &&
(self.state.shadow_offset_x != 0.0f64 || (self.state.shadow_offset_x != 0.0f64 ||
self.state.shadow_offset_y != 0.0f64 || self.state.shadow_offset_y != 0.0f64 ||
self.state.shadow_blur != 0.0f64) self.state.shadow_blur != 0.0f64)
} }
fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> DrawTarget { fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> DrawTarget {
let draw_target = self.drawtarget.create_similar_draw_target(&Size2D::new(source_rect.size.width as i32, let draw_target = self.drawtarget.create_similar_draw_target(
source_rect.size.height as i32), &Size2D::new(
self.drawtarget.get_format()); source_rect.size.width as i32,
source_rect.size.height as i32,
),
self.drawtarget.get_format(),
);
let matrix = Transform2D::identity() let matrix = Transform2D::identity()
.pre_translate(-source_rect.origin.to_vector().cast()) .pre_translate(-source_rect.origin.to_vector().cast())
.pre_mul(&self.state.transform); .pre_mul(&self.state.transform);
@ -498,19 +567,26 @@ impl<'a> CanvasData<'a> {
} }
fn draw_with_shadow<F>(&self, rect: &Rect<f32>, draw_shadow_source: F) fn draw_with_shadow<F>(&self, rect: &Rect<f32>, draw_shadow_source: F)
where F: FnOnce(&DrawTarget) where
F: FnOnce(&DrawTarget),
{ {
let shadow_src_rect = self.state.transform.transform_rect(rect); let shadow_src_rect = self.state.transform.transform_rect(rect);
let new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect); let new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect);
draw_shadow_source(&new_draw_target); draw_shadow_source(&new_draw_target);
self.drawtarget.draw_surface_with_shadow(new_draw_target.snapshot(), self.drawtarget.draw_surface_with_shadow(
&Point2D::new(shadow_src_rect.origin.x as AzFloat, new_draw_target.snapshot(),
shadow_src_rect.origin.y as AzFloat), &Point2D::new(
&self.state.shadow_color, shadow_src_rect.origin.x as AzFloat,
&Vector2D::new(self.state.shadow_offset_x as AzFloat, shadow_src_rect.origin.y as AzFloat,
self.state.shadow_offset_y as AzFloat), ),
(self.state.shadow_blur / 2.0f64) as AzFloat, &self.state.shadow_color,
self.state.draw_options.composition); &Vector2D::new(
self.state.shadow_offset_x as AzFloat,
self.state.shadow_offset_y as AzFloat,
),
(self.state.shadow_blur / 2.0f64) as AzFloat,
self.state.draw_options.composition,
);
} }
/// It reads image data from the canvas /// It reads image data from the canvas
@ -519,11 +595,19 @@ impl<'a> CanvasData<'a> {
#[allow(unsafe_code)] #[allow(unsafe_code)]
pub fn read_pixels(&self, read_rect: Rect<u32>, canvas_size: Size2D<u32>) -> Vec<u8> { pub fn read_pixels(&self, read_rect: Rect<u32>, canvas_size: Size2D<u32>) -> Vec<u8> {
let canvas_rect = Rect::from_size(canvas_size); let canvas_rect = Rect::from_size(canvas_size);
if canvas_rect.intersection(&read_rect).map_or(true, |rect| rect.is_empty()) { if canvas_rect
.intersection(&read_rect)
.map_or(true, |rect| rect.is_empty())
{
return vec![]; return vec![];
} }
let data_surface = self.drawtarget.snapshot().get_data_surface(); let data_surface = self.drawtarget.snapshot().get_data_surface();
pixels::get_rect(unsafe { data_surface.data() }, canvas_size.to_u32(), read_rect.to_u32()).into_owned() pixels::get_rect(
unsafe { data_surface.data() },
canvas_size.to_u32(),
read_rect.to_u32(),
)
.into_owned()
} }
} }
@ -562,7 +646,13 @@ impl<'a> CanvasPaintState<'a> {
draw_options: DrawOptions::new(1.0, CompositionOp::Over, antialias), draw_options: DrawOptions::new(1.0, CompositionOp::Over, antialias),
fill_style: Pattern::Color(ColorPattern::new(Color::black())), fill_style: Pattern::Color(ColorPattern::new(Color::black())),
stroke_style: Pattern::Color(ColorPattern::new(Color::black())), stroke_style: Pattern::Color(ColorPattern::new(Color::black())),
stroke_opts: StrokeOptions::new(1.0, JoinStyle::MiterOrBevel, CapStyle::Butt, 10.0, &[]), stroke_opts: StrokeOptions::new(
1.0,
JoinStyle::MiterOrBevel,
CapStyle::Butt,
10.0,
&[],
),
transform: Transform2D::identity(), transform: Transform2D::identity(),
shadow_offset_x: 0.0, shadow_offset_x: 0.0,
shadow_offset_y: 0.0, shadow_offset_y: 0.0,
@ -594,10 +684,10 @@ fn write_image(
dest_rect: Rect<f64>, dest_rect: Rect<f64>,
smoothing_enabled: bool, smoothing_enabled: bool,
composition_op: CompositionOp, composition_op: CompositionOp,
global_alpha: f32 global_alpha: f32,
) { ) {
if image_data.is_empty() { if image_data.is_empty() {
return return;
} }
let image_rect = Rect::new(Point2D::zero(), image_size); let image_rect = Rect::new(Point2D::zero(), image_size);
@ -612,12 +702,14 @@ fn write_image(
}; };
let image_size = image_size.to_i32(); let image_size = image_size.to_i32();
let source_surface = draw_target.create_source_surface_from_data( let source_surface = draw_target
&image_data, .create_source_surface_from_data(
image_size, &image_data,
image_size.width * 4, image_size,
SurfaceFormat::B8G8R8A8, image_size.width * 4,
).unwrap(); SurfaceFormat::B8G8R8A8,
)
.unwrap();
let draw_surface_options = DrawSurfaceOptions::new(filter, true); let draw_surface_options = DrawSurfaceOptions::new(filter, true);
let draw_options = DrawOptions::new(global_alpha, composition_op, AntialiasMode::None); let draw_options = DrawOptions::new(global_alpha, composition_op, AntialiasMode::None);
draw_target.draw_surface( draw_target.draw_surface(
@ -635,8 +727,7 @@ pub trait PointToi32 {
impl PointToi32 for Point2D<f64> { impl PointToi32 for Point2D<f64> {
fn to_i32(&self) -> Point2D<i32> { fn to_i32(&self) -> Point2D<i32> {
Point2D::new(self.x.to_i32().unwrap(), Point2D::new(self.x.to_i32().unwrap(), self.y.to_i32().unwrap())
self.y.to_i32().unwrap())
} }
} }
@ -646,8 +737,7 @@ pub trait SizeToi32 {
impl SizeToi32 for Size2D<f64> { impl SizeToi32 for Size2D<f64> {
fn to_i32(&self) -> Size2D<i32> { fn to_i32(&self) -> Size2D<i32> {
Size2D::new(self.width.to_i32().unwrap(), Size2D::new(self.width.to_i32().unwrap(), self.height.to_i32().unwrap())
self.height.to_i32().unwrap())
} }
} }
@ -658,19 +748,24 @@ pub trait RectToi32 {
impl RectToi32 for Rect<f64> { impl RectToi32 for Rect<f64> {
fn to_i32(&self) -> Rect<i32> { fn to_i32(&self) -> Rect<i32> {
Rect::new(Point2D::new(self.origin.x.to_i32().unwrap(), Rect::new(
self.origin.y.to_i32().unwrap()), Point2D::new(
Size2D::new(self.size.width.to_i32().unwrap(), self.origin.x.to_i32().unwrap(),
self.size.height.to_i32().unwrap())) self.origin.y.to_i32().unwrap(),
),
Size2D::new(
self.size.width.to_i32().unwrap(),
self.size.height.to_i32().unwrap(),
),
)
} }
fn ceil(&self) -> Rect<f64> { fn ceil(&self) -> Rect<f64> {
Rect::new(Point2D::new(self.origin.x.ceil(), Rect::new(
self.origin.y.ceil()), Point2D::new(self.origin.x.ceil(), self.origin.y.ceil()),
Size2D::new(self.size.width.ceil(), Size2D::new(self.size.width.ceil(), self.size.height.ceil()),
self.size.height.ceil())) )
} }
} }
pub trait ToAzureStyle { pub trait ToAzureStyle {
@ -682,12 +777,13 @@ impl ToAzureStyle for Rect<f64> {
type Target = Rect<AzFloat>; type Target = Rect<AzFloat>;
fn to_azure_style(self) -> Rect<AzFloat> { fn to_azure_style(self) -> Rect<AzFloat> {
Rect::new(Point2D::new(self.origin.x as AzFloat, self.origin.y as AzFloat), Rect::new(
Size2D::new(self.size.width as AzFloat, self.size.height as AzFloat)) Point2D::new(self.origin.x as AzFloat, self.origin.y as AzFloat),
Size2D::new(self.size.width as AzFloat, self.size.height as AzFloat),
)
} }
} }
impl ToAzureStyle for LineCapStyle { impl ToAzureStyle for LineCapStyle {
type Target = CapStyle; type Target = CapStyle;
@ -717,17 +813,17 @@ impl ToAzureStyle for CompositionStyle {
fn to_azure_style(self) -> CompositionOp { fn to_azure_style(self) -> CompositionOp {
match self { match self {
CompositionStyle::SrcIn => CompositionOp::In, CompositionStyle::SrcIn => CompositionOp::In,
CompositionStyle::SrcOut => CompositionOp::Out, CompositionStyle::SrcOut => CompositionOp::Out,
CompositionStyle::SrcOver => CompositionOp::Over, CompositionStyle::SrcOver => CompositionOp::Over,
CompositionStyle::SrcAtop => CompositionOp::Atop, CompositionStyle::SrcAtop => CompositionOp::Atop,
CompositionStyle::DestIn => CompositionOp::DestIn, CompositionStyle::DestIn => CompositionOp::DestIn,
CompositionStyle::DestOut => CompositionOp::DestOut, CompositionStyle::DestOut => CompositionOp::DestOut,
CompositionStyle::DestOver => CompositionOp::DestOver, CompositionStyle::DestOver => CompositionOp::DestOver,
CompositionStyle::DestAtop => CompositionOp::DestAtop, CompositionStyle::DestAtop => CompositionOp::DestAtop,
CompositionStyle::Copy => CompositionOp::Source, CompositionStyle::Copy => CompositionOp::Source,
CompositionStyle::Lighter => CompositionOp::Add, CompositionStyle::Lighter => CompositionOp::Add,
CompositionStyle::Xor => CompositionOp::Xor, CompositionStyle::Xor => CompositionOp::Xor,
} }
} }
} }
@ -737,20 +833,20 @@ impl ToAzureStyle for BlendingStyle {
fn to_azure_style(self) -> CompositionOp { fn to_azure_style(self) -> CompositionOp {
match self { match self {
BlendingStyle::Multiply => CompositionOp::Multiply, BlendingStyle::Multiply => CompositionOp::Multiply,
BlendingStyle::Screen => CompositionOp::Screen, BlendingStyle::Screen => CompositionOp::Screen,
BlendingStyle::Overlay => CompositionOp::Overlay, BlendingStyle::Overlay => CompositionOp::Overlay,
BlendingStyle::Darken => CompositionOp::Darken, BlendingStyle::Darken => CompositionOp::Darken,
BlendingStyle::Lighten => CompositionOp::Lighten, BlendingStyle::Lighten => CompositionOp::Lighten,
BlendingStyle::ColorDodge => CompositionOp::ColorDodge, BlendingStyle::ColorDodge => CompositionOp::ColorDodge,
BlendingStyle::ColorBurn => CompositionOp::ColorBurn, BlendingStyle::ColorBurn => CompositionOp::ColorBurn,
BlendingStyle::HardLight => CompositionOp::HardLight, BlendingStyle::HardLight => CompositionOp::HardLight,
BlendingStyle::SoftLight => CompositionOp::SoftLight, BlendingStyle::SoftLight => CompositionOp::SoftLight,
BlendingStyle::Difference => CompositionOp::Difference, BlendingStyle::Difference => CompositionOp::Difference,
BlendingStyle::Exclusion => CompositionOp::Exclusion, BlendingStyle::Exclusion => CompositionOp::Exclusion,
BlendingStyle::Hue => CompositionOp::Hue, BlendingStyle::Hue => CompositionOp::Hue,
BlendingStyle::Saturation => CompositionOp::Saturation, BlendingStyle::Saturation => CompositionOp::Saturation,
BlendingStyle::Color => CompositionOp::Color, BlendingStyle::Color => CompositionOp::Color,
BlendingStyle::Luminosity => CompositionOp::Luminosity, BlendingStyle::Luminosity => CompositionOp::Luminosity,
} }
} }
@ -778,32 +874,49 @@ impl ToAzurePattern for FillOrStrokeStyle {
Pattern::Color(ColorPattern::new(color.to_azure_style())) Pattern::Color(ColorPattern::new(color.to_azure_style()))
}, },
FillOrStrokeStyle::LinearGradient(ref linear_gradient_style) => { FillOrStrokeStyle::LinearGradient(ref linear_gradient_style) => {
let gradient_stops: Vec<GradientStop> = linear_gradient_style.stops.iter().map(|s| { let gradient_stops: Vec<GradientStop> = linear_gradient_style
GradientStop { .stops
.iter()
.map(|s| GradientStop {
offset: s.offset as AzFloat, offset: s.offset as AzFloat,
color: s.color.to_azure_style() color: s.color.to_azure_style(),
} })
}).collect(); .collect();
Pattern::LinearGradient(LinearGradientPattern::new( Pattern::LinearGradient(LinearGradientPattern::new(
&Point2D::new(linear_gradient_style.x0 as AzFloat, linear_gradient_style.y0 as AzFloat), &Point2D::new(
&Point2D::new(linear_gradient_style.x1 as AzFloat, linear_gradient_style.y1 as AzFloat), linear_gradient_style.x0 as AzFloat,
linear_gradient_style.y0 as AzFloat,
),
&Point2D::new(
linear_gradient_style.x1 as AzFloat,
linear_gradient_style.y1 as AzFloat,
),
drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp), drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp),
&Transform2D::identity(), &Transform2D::identity(),
)) ))
}, },
FillOrStrokeStyle::RadialGradient(ref radial_gradient_style) => { FillOrStrokeStyle::RadialGradient(ref radial_gradient_style) => {
let gradient_stops: Vec<GradientStop> = radial_gradient_style.stops.iter().map(|s| { let gradient_stops: Vec<GradientStop> = radial_gradient_style
GradientStop { .stops
.iter()
.map(|s| GradientStop {
offset: s.offset as AzFloat, offset: s.offset as AzFloat,
color: s.color.to_azure_style() color: s.color.to_azure_style(),
} })
}).collect(); .collect();
Pattern::RadialGradient(RadialGradientPattern::new( Pattern::RadialGradient(RadialGradientPattern::new(
&Point2D::new(radial_gradient_style.x0 as AzFloat, radial_gradient_style.y0 as AzFloat), &Point2D::new(
&Point2D::new(radial_gradient_style.x1 as AzFloat, radial_gradient_style.y1 as AzFloat), radial_gradient_style.x0 as AzFloat,
radial_gradient_style.r0 as AzFloat, radial_gradient_style.r1 as AzFloat, radial_gradient_style.y0 as AzFloat,
),
&Point2D::new(
radial_gradient_style.x1 as AzFloat,
radial_gradient_style.y1 as AzFloat,
),
radial_gradient_style.r0 as AzFloat,
radial_gradient_style.r1 as AzFloat,
drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp), drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp),
&Transform2D::identity(), &Transform2D::identity(),
)) ))
@ -822,7 +935,7 @@ impl ToAzurePattern for FillOrStrokeStyle {
surface_style.repeat_y, surface_style.repeat_y,
&Transform2D::identity(), &Transform2D::identity(),
)) ))
} },
}) })
} }
} }
@ -831,9 +944,11 @@ impl ToAzureStyle for RGBA {
type Target = Color; type Target = Color;
fn to_azure_style(self) -> Color { fn to_azure_style(self) -> Color {
Color::rgba(self.red_f32() as AzFloat, Color::rgba(
self.green_f32() as AzFloat, self.red_f32() as AzFloat,
self.blue_f32() as AzFloat, self.green_f32() as AzFloat,
self.alpha_f32() as AzFloat) self.blue_f32() as AzFloat,
self.alpha_f32() as AzFloat,
)
} }
} }

197
components/canvas/canvas_paint_thread.rs
View file

@ -12,13 +12,13 @@ use std::collections::HashMap;
use std::thread; use std::thread;
use webrender_api; use webrender_api;
pub struct CanvasPaintThread <'a> { pub struct CanvasPaintThread<'a> {
canvases: HashMap<CanvasId, CanvasData<'a>>, canvases: HashMap<CanvasId, CanvasData<'a>>,
next_canvas_id: CanvasId, next_canvas_id: CanvasId,
} }
impl<'a> CanvasPaintThread <'a> { impl<'a> CanvasPaintThread<'a> {
fn new() -> CanvasPaintThread <'a> { fn new() -> CanvasPaintThread<'a> {
CanvasPaintThread { CanvasPaintThread {
canvases: HashMap::new(), canvases: HashMap::new(),
next_canvas_id: CanvasId(0), next_canvas_id: CanvasId(0),
@ -29,52 +29,49 @@ impl<'a> CanvasPaintThread <'a> {
/// communicate with it. /// communicate with it.
pub fn start() -> IpcSender<CanvasMsg> { pub fn start() -> IpcSender<CanvasMsg> {
let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap(); let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
thread::Builder::new().name("CanvasThread".to_owned()).spawn(move || { thread::Builder::new()
let mut canvas_paint_thread = CanvasPaintThread::new(); .name("CanvasThread".to_owned())
loop { .spawn(move || {
match receiver.recv() { let mut canvas_paint_thread = CanvasPaintThread::new();
Ok(msg) => { loop {
match msg { match receiver.recv() {
Ok(msg) => match msg {
CanvasMsg::Canvas2d(message, canvas_id) => { CanvasMsg::Canvas2d(message, canvas_id) => {
canvas_paint_thread.process_canvas_2d_message(message, canvas_id); canvas_paint_thread.process_canvas_2d_message(message, canvas_id);
}, },
CanvasMsg::Close(canvas_id) =>{ CanvasMsg::Close(canvas_id) => {
canvas_paint_thread.canvases.remove(&canvas_id); canvas_paint_thread.canvases.remove(&canvas_id);
}, },
CanvasMsg::Create(creator, size, webrenderer_api_sender, antialias) => { CanvasMsg::Create(creator, size, webrenderer_api_sender, antialias) => {
let canvas_id = canvas_paint_thread.create_canvas( let canvas_id = canvas_paint_thread.create_canvas(
size, size,
webrenderer_api_sender, webrenderer_api_sender,
antialias antialias,
); );
creator.send(canvas_id).unwrap(); creator.send(canvas_id).unwrap();
}, },
CanvasMsg::Recreate(size, canvas_id) =>{ CanvasMsg::Recreate(size, canvas_id) => {
canvas_paint_thread.canvas(canvas_id).recreate(size); canvas_paint_thread.canvas(canvas_id).recreate(size);
}, },
CanvasMsg::FromScript(message, canvas_id) => { CanvasMsg::FromScript(message, canvas_id) => match message {
match message { FromScriptMsg::SendPixels(chan) => {
FromScriptMsg::SendPixels(chan) => { canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
canvas_paint_thread.canvas(canvas_id).send_pixels(chan); },
}
}
}, },
CanvasMsg::FromLayout(message, canvas_id) => { CanvasMsg::FromLayout(message, canvas_id) => match message {
match message { FromLayoutMsg::SendData(chan) => {
FromLayoutMsg::SendData(chan) => { canvas_paint_thread.canvas(canvas_id).send_data(chan);
canvas_paint_thread.canvas(canvas_id).send_data(chan); },
}
}
}, },
CanvasMsg::Exit => break, CanvasMsg::Exit => break,
} },
}, Err(e) => {
Err(e) => { warn!("Error on CanvasPaintThread receive ({})", e);
warn!("Error on CanvasPaintThread receive ({})", e); },
} }
} }
} })
}).expect("Thread spawning failed"); .expect("Thread spawning failed");
sender sender
} }
@ -83,7 +80,7 @@ impl<'a> CanvasPaintThread <'a> {
&mut self, &mut self,
size: Size2D<u32>, size: Size2D<u32>,
webrender_api_sender: webrender_api::RenderApiSender, webrender_api_sender: webrender_api::RenderApiSender,
antialias: bool antialias: bool,
) -> CanvasId { ) -> CanvasId {
let antialias = if antialias { let antialias = if antialias {
AntialiasMode::Default AntialiasMode::Default
@ -105,33 +102,17 @@ impl<'a> CanvasPaintThread <'a> {
Canvas2dMsg::FillText(text, x, y, max_width) => { Canvas2dMsg::FillText(text, x, y, max_width) => {
self.canvas(canvas_id).fill_text(text, x, y, max_width) self.canvas(canvas_id).fill_text(text, x, y, max_width)
}, },
Canvas2dMsg::FillRect(ref rect) => { Canvas2dMsg::FillRect(ref rect) => self.canvas(canvas_id).fill_rect(rect),
self.canvas(canvas_id).fill_rect(rect) Canvas2dMsg::StrokeRect(ref rect) => self.canvas(canvas_id).stroke_rect(rect),
}, Canvas2dMsg::ClearRect(ref rect) => self.canvas(canvas_id).clear_rect(rect),
Canvas2dMsg::StrokeRect(ref rect) => { Canvas2dMsg::BeginPath => self.canvas(canvas_id).begin_path(),
self.canvas(canvas_id).stroke_rect(rect) Canvas2dMsg::ClosePath => self.canvas(canvas_id).close_path(),
}, Canvas2dMsg::Fill => self.canvas(canvas_id).fill(),
Canvas2dMsg::ClearRect(ref rect) => { Canvas2dMsg::Stroke => self.canvas(canvas_id).stroke(),
self.canvas(canvas_id).clear_rect(rect) Canvas2dMsg::Clip => self.canvas(canvas_id).clip(),
}, Canvas2dMsg::IsPointInPath(x, y, fill_rule, chan) => self
Canvas2dMsg::BeginPath => { .canvas(canvas_id)
self.canvas(canvas_id).begin_path() .is_point_in_path(x, y, fill_rule, chan),
},
Canvas2dMsg::ClosePath => {
self.canvas(canvas_id).close_path()
},
Canvas2dMsg::Fill => {
self.canvas(canvas_id).fill()
},
Canvas2dMsg::Stroke => {
self.canvas(canvas_id).stroke()
},
Canvas2dMsg::Clip => {
self.canvas(canvas_id).clip()
},
Canvas2dMsg::IsPointInPath(x, y, fill_rule, chan) => {
self.canvas(canvas_id).is_point_in_path(x, y, fill_rule, chan)
},
Canvas2dMsg::DrawImage( Canvas2dMsg::DrawImage(
imagedata, imagedata,
image_size, image_size,
@ -156,12 +137,11 @@ impl<'a> CanvasPaintThread <'a> {
image_size, image_size,
dest_rect, dest_rect,
source_rect, source_rect,
smoothing smoothing,
) => { ) => {
let image_data = self.canvas(canvas_id).read_pixels( let image_data = self
source_rect.to_u32(), .canvas(canvas_id)
image_size.to_u32(), .read_pixels(source_rect.to_u32(), image_size.to_u32());
);
self.canvas(other_canvas_id).draw_image( self.canvas(other_canvas_id).draw_image(
image_data.into(), image_data.into(),
source_rect.size, source_rect.size,
@ -170,68 +150,34 @@ impl<'a> CanvasPaintThread <'a> {
smoothing, smoothing,
); );
}, },
Canvas2dMsg::MoveTo(ref point) => { Canvas2dMsg::MoveTo(ref point) => self.canvas(canvas_id).move_to(point),
self.canvas(canvas_id).move_to(point) Canvas2dMsg::LineTo(ref point) => self.canvas(canvas_id).line_to(point),
}, Canvas2dMsg::Rect(ref rect) => self.canvas(canvas_id).rect(rect),
Canvas2dMsg::LineTo(ref point) => {
self.canvas(canvas_id).line_to(point)
},
Canvas2dMsg::Rect(ref rect) => {
self.canvas(canvas_id).rect(rect)
},
Canvas2dMsg::QuadraticCurveTo(ref cp, ref pt) => { Canvas2dMsg::QuadraticCurveTo(ref cp, ref pt) => {
self.canvas(canvas_id).quadratic_curve_to(cp, pt) self.canvas(canvas_id).quadratic_curve_to(cp, pt)
} },
Canvas2dMsg::BezierCurveTo(ref cp1, ref cp2, ref pt) => { Canvas2dMsg::BezierCurveTo(ref cp1, ref cp2, ref pt) => {
self.canvas(canvas_id).bezier_curve_to(cp1, cp2, pt) self.canvas(canvas_id).bezier_curve_to(cp1, cp2, pt)
} },
Canvas2dMsg::Arc(ref center, radius, start, end, ccw) => { Canvas2dMsg::Arc(ref center, radius, start, end, ccw) => {
self.canvas(canvas_id).arc(center, radius, start, end, ccw) self.canvas(canvas_id).arc(center, radius, start, end, ccw)
} },
Canvas2dMsg::ArcTo(ref cp1, ref cp2, radius) => { Canvas2dMsg::ArcTo(ref cp1, ref cp2, radius) => {
self.canvas(canvas_id).arc_to(cp1, cp2, radius) self.canvas(canvas_id).arc_to(cp1, cp2, radius)
}
Canvas2dMsg::Ellipse(ref center, radius_x, radius_y, rotation, start, end, ccw) => {
self.canvas(canvas_id).ellipse(
center,
radius_x,
radius_y,
rotation,
start,
end,
ccw
)
}
Canvas2dMsg::RestoreContext => {
self.canvas(canvas_id).restore_context_state()
},
Canvas2dMsg::SaveContext => {
self.canvas(canvas_id).save_context_state()
},
Canvas2dMsg::SetFillStyle(style) => {
self.canvas(canvas_id).set_fill_style(style)
},
Canvas2dMsg::SetStrokeStyle(style) => {
self.canvas(canvas_id).set_stroke_style(style)
},
Canvas2dMsg::SetLineWidth(width) => {
self.canvas(canvas_id).set_line_width(width)
},
Canvas2dMsg::SetLineCap(cap) => {
self.canvas(canvas_id).set_line_cap(cap)
},
Canvas2dMsg::SetLineJoin(join) => {
self.canvas(canvas_id).set_line_join(join)
},
Canvas2dMsg::SetMiterLimit(limit) => {
self.canvas(canvas_id).set_miter_limit(limit)
},
Canvas2dMsg::SetTransform(ref matrix) => {
self.canvas(canvas_id).set_transform(matrix)
},
Canvas2dMsg::SetGlobalAlpha(alpha) => {
self.canvas(canvas_id).set_global_alpha(alpha)
}, },
Canvas2dMsg::Ellipse(ref center, radius_x, radius_y, rotation, start, end, ccw) => self
.canvas(canvas_id)
.ellipse(center, radius_x, radius_y, rotation, start, end, ccw),
Canvas2dMsg::RestoreContext => self.canvas(canvas_id).restore_context_state(),
Canvas2dMsg::SaveContext => self.canvas(canvas_id).save_context_state(),
Canvas2dMsg::SetFillStyle(style) => self.canvas(canvas_id).set_fill_style(style),
Canvas2dMsg::SetStrokeStyle(style) => self.canvas(canvas_id).set_stroke_style(style),
Canvas2dMsg::SetLineWidth(width) => self.canvas(canvas_id).set_line_width(width),
Canvas2dMsg::SetLineCap(cap) => self.canvas(canvas_id).set_line_cap(cap),
Canvas2dMsg::SetLineJoin(join) => self.canvas(canvas_id).set_line_join(join),
Canvas2dMsg::SetMiterLimit(limit) => self.canvas(canvas_id).set_miter_limit(limit),
Canvas2dMsg::SetTransform(ref matrix) => self.canvas(canvas_id).set_transform(matrix),
Canvas2dMsg::SetGlobalAlpha(alpha) => self.canvas(canvas_id).set_global_alpha(alpha),
Canvas2dMsg::SetGlobalComposition(op) => { Canvas2dMsg::SetGlobalComposition(op) => {
self.canvas(canvas_id).set_global_composition(op) self.canvas(canvas_id).set_global_composition(op)
}, },
@ -240,7 +186,8 @@ impl<'a> CanvasPaintThread <'a> {
sender.send(&pixels).unwrap(); sender.send(&pixels).unwrap();
}, },
Canvas2dMsg::PutImageData(rect, receiver) => { Canvas2dMsg::PutImageData(rect, receiver) => {
self.canvas(canvas_id).put_image_data(receiver.recv().unwrap(), rect); self.canvas(canvas_id)
.put_image_data(receiver.recv().unwrap(), rect);
}, },
Canvas2dMsg::SetShadowOffsetX(value) => { Canvas2dMsg::SetShadowOffsetX(value) => {
self.canvas(canvas_id).set_shadow_offset_x(value) self.canvas(canvas_id).set_shadow_offset_x(value)
@ -248,12 +195,10 @@ impl<'a> CanvasPaintThread <'a> {
Canvas2dMsg::SetShadowOffsetY(value) => { Canvas2dMsg::SetShadowOffsetY(value) => {
self.canvas(canvas_id).set_shadow_offset_y(value) self.canvas(canvas_id).set_shadow_offset_y(value)
}, },
Canvas2dMsg::SetShadowBlur(value) => { Canvas2dMsg::SetShadowBlur(value) => self.canvas(canvas_id).set_shadow_blur(value),
self.canvas(canvas_id).set_shadow_blur(value) Canvas2dMsg::SetShadowColor(ref color) => self
}, .canvas(canvas_id)
Canvas2dMsg::SetShadowColor(ref color) => { .set_shadow_color(color.to_azure_style()),
self.canvas(canvas_id).set_shadow_color(color.to_azure_style())
},
} }
} }

60
components/canvas/gl_context.rs
View file

@ -48,7 +48,7 @@ impl GLContextFactory {
&self, &self,
webgl_version: WebGLVersion, webgl_version: WebGLVersion,
size: Size2D<u32>, size: Size2D<u32>,
attributes: GLContextAttributes attributes: GLContextAttributes,
) -> Result<GLContextWrapper, &'static str> { ) -> Result<GLContextWrapper, &'static str> {
Ok(match *self { Ok(match *self {
GLContextFactory::Native(ref handle, ref dispatcher) => { GLContextFactory::Native(ref handle, ref dispatcher) => {
@ -63,7 +63,7 @@ impl GLContextFactory {
Some(handle), Some(handle),
dispatcher, dispatcher,
)?) )?)
} },
GLContextFactory::OSMesa(ref handle) => { GLContextFactory::OSMesa(ref handle) => {
GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher( GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
// FIXME(nox): Why are those i32 values? // FIXME(nox): Why are those i32 values?
@ -75,7 +75,7 @@ impl GLContextFactory {
Some(handle), Some(handle),
None, None,
)?) )?)
} },
}) })
} }
@ -84,7 +84,7 @@ impl GLContextFactory {
&self, &self,
webgl_version: WebGLVersion, webgl_version: WebGLVersion,
size: Size2D<u32>, size: Size2D<u32>,
attributes: GLContextAttributes attributes: GLContextAttributes,
) -> Result<GLContextWrapper, &'static str> { ) -> Result<GLContextWrapper, &'static str> {
Ok(match *self { Ok(match *self {
GLContextFactory::Native(..) => { GLContextFactory::Native(..) => {
@ -98,7 +98,7 @@ impl GLContextFactory {
None, None,
None, None,
)?) )?)
} },
GLContextFactory::OSMesa(_) => { GLContextFactory::OSMesa(_) => {
GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher( GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
// FIXME(nox): Why are those i32 values? // FIXME(nox): Why are those i32 values?
@ -110,7 +110,7 @@ impl GLContextFactory {
None, None,
None, None,
)?) )?)
} },
}) })
} }
@ -122,7 +122,6 @@ impl GLContextFactory {
} }
} }
/// GLContextWrapper used to abstract NativeGLContext and OSMesaContext types /// GLContextWrapper used to abstract NativeGLContext and OSMesaContext types
pub enum GLContextWrapper { pub enum GLContextWrapper {
Native(GLContext<NativeGLContext>), Native(GLContext<NativeGLContext>),
@ -134,10 +133,10 @@ impl GLContextWrapper {
match *self { match *self {
GLContextWrapper::Native(ref ctx) => { GLContextWrapper::Native(ref ctx) => {
ctx.make_current().unwrap(); ctx.make_current().unwrap();
} },
GLContextWrapper::OSMesa(ref ctx) => { GLContextWrapper::OSMesa(ref ctx) => {
ctx.make_current().unwrap(); ctx.make_current().unwrap();
} },
} }
} }
@ -145,10 +144,10 @@ impl GLContextWrapper {
match *self { match *self {
GLContextWrapper::Native(ref ctx) => { GLContextWrapper::Native(ref ctx) => {
ctx.unbind().unwrap(); ctx.unbind().unwrap();
} },
GLContextWrapper::OSMesa(ref ctx) => { GLContextWrapper::OSMesa(ref ctx) => {
ctx.unbind().unwrap(); ctx.unbind().unwrap();
} },
} }
} }
@ -156,26 +155,22 @@ impl GLContextWrapper {
&self, &self,
cmd: WebGLCommand, cmd: WebGLCommand,
backtrace: WebGLCommandBacktrace, backtrace: WebGLCommandBacktrace,
state: &mut GLState state: &mut GLState,
) { ) {
match *self { match *self {
GLContextWrapper::Native(ref ctx) => { GLContextWrapper::Native(ref ctx) => {
WebGLImpl::apply(ctx, state, cmd, backtrace); WebGLImpl::apply(ctx, state, cmd, backtrace);
} },
GLContextWrapper::OSMesa(ref ctx) => { GLContextWrapper::OSMesa(ref ctx) => {
WebGLImpl::apply(ctx, state, cmd, backtrace); WebGLImpl::apply(ctx, state, cmd, backtrace);
} },
} }
} }
pub fn gl(&self) -> &gl::Gl { pub fn gl(&self) -> &gl::Gl {
match *self { match *self {
GLContextWrapper::Native(ref ctx) => { GLContextWrapper::Native(ref ctx) => ctx.gl(),
ctx.gl() GLContextWrapper::OSMesa(ref ctx) => ctx.gl(),
}
GLContextWrapper::OSMesa(ref ctx) => {
ctx.gl()
}
} }
} }
@ -184,23 +179,29 @@ impl GLContextWrapper {
GLContextWrapper::Native(ref ctx) => { GLContextWrapper::Native(ref ctx) => {
let (real_size, texture_id) = { let (real_size, texture_id) = {
let draw_buffer = ctx.borrow_draw_buffer().unwrap(); let draw_buffer = ctx.borrow_draw_buffer().unwrap();
(draw_buffer.size(), draw_buffer.get_bound_texture_id().unwrap()) (
draw_buffer.size(),
draw_buffer.get_bound_texture_id().unwrap(),
)
}; };
let limits = ctx.borrow_limits().clone(); let limits = ctx.borrow_limits().clone();
(real_size, texture_id, limits) (real_size, texture_id, limits)
} },
GLContextWrapper::OSMesa(ref ctx) => { GLContextWrapper::OSMesa(ref ctx) => {
let (real_size, texture_id) = { let (real_size, texture_id) = {
let draw_buffer = ctx.borrow_draw_buffer().unwrap(); let draw_buffer = ctx.borrow_draw_buffer().unwrap();
(draw_buffer.size(), draw_buffer.get_bound_texture_id().unwrap()) (
draw_buffer.size(),
draw_buffer.get_bound_texture_id().unwrap(),
)
}; };
let limits = ctx.borrow_limits().clone(); let limits = ctx.borrow_limits().clone();
(real_size, texture_id, limits) (real_size, texture_id, limits)
} },
} }
} }
@ -209,11 +210,11 @@ impl GLContextWrapper {
GLContextWrapper::Native(ref mut ctx) => { GLContextWrapper::Native(ref mut ctx) => {
// FIXME(nox): Why are those i32 values? // FIXME(nox): Why are those i32 values?
ctx.resize(size.to_i32()) ctx.resize(size.to_i32())
} },
GLContextWrapper::OSMesa(ref mut ctx) => { GLContextWrapper::OSMesa(ref mut ctx) => {
// FIXME(nox): Why are those i32 values? // FIXME(nox): Why are those i32 values?
ctx.resize(size.to_i32()) ctx.resize(size.to_i32())
} },
} }
} }
} }
@ -222,7 +223,7 @@ impl GLContextWrapper {
/// It's used in Windows to allow WGL GLContext sharing. /// It's used in Windows to allow WGL GLContext sharing.
#[derive(Clone)] #[derive(Clone)]
pub struct MainThreadDispatcher { pub struct MainThreadDispatcher {
compositor_proxy: Arc<Mutex<CompositorProxy>> compositor_proxy: Arc<Mutex<CompositorProxy>>,
} }
impl MainThreadDispatcher { impl MainThreadDispatcher {
@ -234,6 +235,9 @@ impl MainThreadDispatcher {
} }
impl GLContextDispatcher for MainThreadDispatcher { impl GLContextDispatcher for MainThreadDispatcher {
fn dispatch(&self, f: Box<Fn() + Send>) { fn dispatch(&self, f: Box<Fn() + Send>) {
self.compositor_proxy.lock().unwrap().send(compositor_thread::Msg::Dispatch(f)); self.compositor_proxy
.lock()
.unwrap()
.send(compositor_thread::Msg::Dispatch(f));
} }
} }

3
components/canvas/lib.rs
View file

@ -12,7 +12,8 @@ extern crate euclid;
extern crate fnv; extern crate fnv;
extern crate gleam; extern crate gleam;
extern crate ipc_channel; extern crate ipc_channel;
#[macro_use] extern crate log; #[macro_use]
extern crate log;
extern crate num_traits; extern crate num_traits;
extern crate offscreen_gl_context; extern crate offscreen_gl_context;
extern crate pixels; extern crate pixels;

1108
components/canvas/webgl_thread.rs
View file

File diff suppressed because it is too large Load diff

125
components/canvas_traits/canvas.rs
View file

@ -22,7 +22,12 @@ pub struct CanvasId(pub u64);
#[derive(Deserialize, Serialize)] #[derive(Deserialize, Serialize)]
pub enum CanvasMsg { pub enum CanvasMsg {
Canvas2d(Canvas2dMsg, CanvasId), Canvas2d(Canvas2dMsg, CanvasId),
Create(IpcSender<CanvasId>, Size2D<u32>, webrender_api::RenderApiSender, bool), Create(
IpcSender<CanvasId>,
Size2D<u32>,
webrender_api::RenderApiSender,
bool,
),
FromLayout(FromLayoutMsg, CanvasId), FromLayout(FromLayoutMsg, CanvasId),
FromScript(FromScriptMsg, CanvasId), FromScript(FromScriptMsg, CanvasId),
Recreate(Size2D<u32>, CanvasId), Recreate(Size2D<u32>, CanvasId),
@ -40,8 +45,7 @@ pub enum Canvas2dMsg {
Arc(Point2D<f32>, f32, f32, f32, bool), Arc(Point2D<f32>, f32, f32, f32, bool),
ArcTo(Point2D<f32>, Point2D<f32>, f32), ArcTo(Point2D<f32>, Point2D<f32>, f32),
DrawImage(Option<ByteBuf>, Size2D<f64>, Rect<f64>, Rect<f64>, bool), DrawImage(Option<ByteBuf>, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
DrawImageInOther( DrawImageInOther(CanvasId, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
CanvasId, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
BeginPath, BeginPath,
BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>), BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
ClearRect(Rect<f32>), ClearRect(Rect<f32>),
@ -99,12 +103,17 @@ pub struct LinearGradientStyle {
pub y0: f64, pub y0: f64,
pub x1: f64, pub x1: f64,
pub y1: f64, pub y1: f64,
pub stops: Vec<CanvasGradientStop> pub stops: Vec<CanvasGradientStop>,
} }
impl LinearGradientStyle { impl LinearGradientStyle {
pub fn new(x0: f64, y0: f64, x1: f64, y1: f64, stops: Vec<CanvasGradientStop>) pub fn new(
-> LinearGradientStyle { x0: f64,
y0: f64,
x1: f64,
y1: f64,
stops: Vec<CanvasGradientStop>,
) -> LinearGradientStyle {
LinearGradientStyle { LinearGradientStyle {
x0: x0, x0: x0,
y0: y0, y0: y0,
@ -123,12 +132,19 @@ pub struct RadialGradientStyle {
pub x1: f64, pub x1: f64,
pub y1: f64, pub y1: f64,
pub r1: f64, pub r1: f64,
pub stops: Vec<CanvasGradientStop> pub stops: Vec<CanvasGradientStop>,
} }
impl RadialGradientStyle { impl RadialGradientStyle {
pub fn new(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64, stops: Vec<CanvasGradientStop>) pub fn new(
-> RadialGradientStyle { x0: f64,
y0: f64,
r0: f64,
x1: f64,
y1: f64,
r1: f64,
stops: Vec<CanvasGradientStop>,
) -> RadialGradientStyle {
RadialGradientStyle { RadialGradientStyle {
x0: x0, x0: x0,
y0: y0, y0: y0,
@ -165,7 +181,6 @@ impl SurfaceStyle {
} }
} }
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub enum FillOrStrokeStyle { pub enum FillOrStrokeStyle {
Color(RGBA), Color(RGBA),
@ -256,18 +271,18 @@ impl FromStr for CompositionStyle {
fn from_str(string: &str) -> Result<CompositionStyle, ()> { fn from_str(string: &str) -> Result<CompositionStyle, ()> {
match string { match string {
"source-in" => Ok(CompositionStyle::SrcIn), "source-in" => Ok(CompositionStyle::SrcIn),
"source-out" => Ok(CompositionStyle::SrcOut), "source-out" => Ok(CompositionStyle::SrcOut),
"source-over" => Ok(CompositionStyle::SrcOver), "source-over" => Ok(CompositionStyle::SrcOver),
"source-atop" => Ok(CompositionStyle::SrcAtop), "source-atop" => Ok(CompositionStyle::SrcAtop),
"destination-in" => Ok(CompositionStyle::DestIn), "destination-in" => Ok(CompositionStyle::DestIn),
"destination-out" => Ok(CompositionStyle::DestOut), "destination-out" => Ok(CompositionStyle::DestOut),
"destination-over" => Ok(CompositionStyle::DestOver), "destination-over" => Ok(CompositionStyle::DestOver),
"destination-atop" => Ok(CompositionStyle::DestAtop), "destination-atop" => Ok(CompositionStyle::DestAtop),
"copy" => Ok(CompositionStyle::Copy), "copy" => Ok(CompositionStyle::Copy),
"lighter" => Ok(CompositionStyle::Lighter), "lighter" => Ok(CompositionStyle::Lighter),
"xor" => Ok(CompositionStyle::Xor), "xor" => Ok(CompositionStyle::Xor),
_ => Err(()) _ => Err(()),
} }
} }
} }
@ -275,17 +290,17 @@ impl FromStr for CompositionStyle {
impl CompositionStyle { impl CompositionStyle {
pub fn to_str(&self) -> &str { pub fn to_str(&self) -> &str {
match *self { match *self {
CompositionStyle::SrcIn => "source-in", CompositionStyle::SrcIn => "source-in",
CompositionStyle::SrcOut => "source-out", CompositionStyle::SrcOut => "source-out",
CompositionStyle::SrcOver => "source-over", CompositionStyle::SrcOver => "source-over",
CompositionStyle::SrcAtop => "source-atop", CompositionStyle::SrcAtop => "source-atop",
CompositionStyle::DestIn => "destination-in", CompositionStyle::DestIn => "destination-in",
CompositionStyle::DestOut => "destination-out", CompositionStyle::DestOut => "destination-out",
CompositionStyle::DestOver => "destination-over", CompositionStyle::DestOver => "destination-over",
CompositionStyle::DestAtop => "destination-atop", CompositionStyle::DestAtop => "destination-atop",
CompositionStyle::Copy => "copy", CompositionStyle::Copy => "copy",
CompositionStyle::Lighter => "lighter", CompositionStyle::Lighter => "lighter",
CompositionStyle::Xor => "xor", CompositionStyle::Xor => "xor",
} }
} }
} }
@ -314,22 +329,22 @@ impl FromStr for BlendingStyle {
fn from_str(string: &str) -> Result<BlendingStyle, ()> { fn from_str(string: &str) -> Result<BlendingStyle, ()> {
match string { match string {
"multiply" => Ok(BlendingStyle::Multiply), "multiply" => Ok(BlendingStyle::Multiply),
"screen" => Ok(BlendingStyle::Screen), "screen" => Ok(BlendingStyle::Screen),
"overlay" => Ok(BlendingStyle::Overlay), "overlay" => Ok(BlendingStyle::Overlay),
"darken" => Ok(BlendingStyle::Darken), "darken" => Ok(BlendingStyle::Darken),
"lighten" => Ok(BlendingStyle::Lighten), "lighten" => Ok(BlendingStyle::Lighten),
"color-dodge" => Ok(BlendingStyle::ColorDodge), "color-dodge" => Ok(BlendingStyle::ColorDodge),
"color-burn" => Ok(BlendingStyle::ColorBurn), "color-burn" => Ok(BlendingStyle::ColorBurn),
"hard-light" => Ok(BlendingStyle::HardLight), "hard-light" => Ok(BlendingStyle::HardLight),
"soft-light" => Ok(BlendingStyle::SoftLight), "soft-light" => Ok(BlendingStyle::SoftLight),
"difference" => Ok(BlendingStyle::Difference), "difference" => Ok(BlendingStyle::Difference),
"exclusion" => Ok(BlendingStyle::Exclusion), "exclusion" => Ok(BlendingStyle::Exclusion),
"hue" => Ok(BlendingStyle::Hue), "hue" => Ok(BlendingStyle::Hue),
"saturation" => Ok(BlendingStyle::Saturation), "saturation" => Ok(BlendingStyle::Saturation),
"color" => Ok(BlendingStyle::Color), "color" => Ok(BlendingStyle::Color),
"luminosity" => Ok(BlendingStyle::Luminosity), "luminosity" => Ok(BlendingStyle::Luminosity),
_ => Err(()) _ => Err(()),
} }
} }
} }
@ -337,20 +352,20 @@ impl FromStr for BlendingStyle {
impl BlendingStyle { impl BlendingStyle {
pub fn to_str(&self) -> &str { pub fn to_str(&self) -> &str {
match *self { match *self {
BlendingStyle::Multiply => "multiply", BlendingStyle::Multiply => "multiply",
BlendingStyle::Screen => "screen", BlendingStyle::Screen => "screen",
BlendingStyle::Overlay => "overlay", BlendingStyle::Overlay => "overlay",
BlendingStyle::Darken => "darken", BlendingStyle::Darken => "darken",
BlendingStyle::Lighten => "lighten", BlendingStyle::Lighten => "lighten",
BlendingStyle::ColorDodge => "color-dodge", BlendingStyle::ColorDodge => "color-dodge",
BlendingStyle::ColorBurn => "color-burn", BlendingStyle::ColorBurn => "color-burn",
BlendingStyle::HardLight => "hard-light", BlendingStyle::HardLight => "hard-light",
BlendingStyle::SoftLight => "soft-light", BlendingStyle::SoftLight => "soft-light",
BlendingStyle::Difference => "difference", BlendingStyle::Difference => "difference",
BlendingStyle::Exclusion => "exclusion", BlendingStyle::Exclusion => "exclusion",
BlendingStyle::Hue => "hue", BlendingStyle::Hue => "hue",
BlendingStyle::Saturation => "saturation", BlendingStyle::Saturation => "saturation",
BlendingStyle::Color => "color", BlendingStyle::Color => "color",
BlendingStyle::Luminosity => "luminosity", BlendingStyle::Luminosity => "luminosity",
} }
} }

10
components/canvas_traits/lib.rs
View file

@ -4,18 +4,20 @@
#![crate_name = "canvas_traits"] #![crate_name = "canvas_traits"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![deny(unsafe_code)] #![deny(unsafe_code)]
extern crate cssparser; extern crate cssparser;
extern crate euclid; extern crate euclid;
extern crate gleam; extern crate gleam;
extern crate ipc_channel; extern crate ipc_channel;
#[macro_use] extern crate lazy_static; #[macro_use]
extern crate lazy_static;
extern crate malloc_size_of; extern crate malloc_size_of;
#[macro_use] extern crate malloc_size_of_derive; #[macro_use]
extern crate malloc_size_of_derive;
extern crate offscreen_gl_context; extern crate offscreen_gl_context;
#[macro_use] extern crate serde; #[macro_use]
extern crate serde;
extern crate serde_bytes; extern crate serde_bytes;
extern crate servo_config; extern crate servo_config;
extern crate webrender_api; extern crate webrender_api;

89
components/canvas_traits/webgl.rs
View file

@ -134,13 +134,15 @@ impl WebGLMsgSender {
/// Send a WebGLCommand message /// Send a WebGLCommand message
#[inline] #[inline]
pub fn send(&self, command: WebGLCommand, backtrace: WebGLCommandBacktrace) -> WebGLSendResult { pub fn send(&self, command: WebGLCommand, backtrace: WebGLCommandBacktrace) -> WebGLSendResult {
self.sender.send(WebGLMsg::WebGLCommand(self.ctx_id, command, backtrace)) self.sender
.send(WebGLMsg::WebGLCommand(self.ctx_id, command, backtrace))
} }
/// Send a WebVRCommand message /// Send a WebVRCommand message
#[inline] #[inline]
pub fn send_vr(&self, command: WebVRCommand) -> WebGLSendResult { pub fn send_vr(&self, command: WebVRCommand) -> WebGLSendResult {
self.sender.send(WebGLMsg::WebVRCommand(self.ctx_id, command)) self.sender
.send(WebGLMsg::WebVRCommand(self.ctx_id, command))
} }
/// Send a resize message /// Send a resize message
@ -150,7 +152,8 @@ impl WebGLMsgSender {
size: Size2D<u32>, size: Size2D<u32>,
sender: WebGLSender<Result<(), String>>, sender: WebGLSender<Result<(), String>>,
) -> WebGLSendResult { ) -> WebGLSendResult {
self.sender.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender)) self.sender
.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
} }
#[inline] #[inline]
@ -160,7 +163,8 @@ impl WebGLMsgSender {
#[inline] #[inline]
pub fn send_update_wr_image(&self, sender: WebGLSender<ImageKey>) -> WebGLSendResult { pub fn send_update_wr_image(&self, sender: WebGLSender<ImageKey>) -> WebGLSendResult {
self.sender.send(WebGLMsg::UpdateWebRenderImage(self.ctx_id, sender)) self.sender
.send(WebGLMsg::UpdateWebRenderImage(self.ctx_id, sender))
} }
pub fn send_dom_to_texture(&self, command: DOMToTextureCommand) -> WebGLSendResult { pub fn send_dom_to_texture(&self, command: DOMToTextureCommand) -> WebGLSendResult {
@ -290,11 +294,34 @@ pub enum WebGLCommand {
GetTexParameterInt(u32, TexParameterInt, WebGLSender<i32>), GetTexParameterInt(u32, TexParameterInt, WebGLSender<i32>),
TexParameteri(u32, u32, i32), TexParameteri(u32, u32, i32),
TexParameterf(u32, u32, f32), TexParameterf(u32, u32, f32),
DrawArrays { mode: u32, first: i32, count: i32 }, DrawArrays {
DrawArraysInstanced { mode: u32, first: i32, count: i32, primcount: i32 }, mode: u32,
DrawElements { mode: u32, count: i32, type_: u32, offset: u32 }, first: i32,
DrawElementsInstanced { mode: u32, count: i32, type_: u32, offset: u32, primcount: i32 }, count: i32,
VertexAttribDivisor { index: u32, divisor: u32 }, },
DrawArraysInstanced {
mode: u32,
first: i32,
count: i32,
primcount: i32,
},
DrawElements {
mode: u32,
count: i32,
type_: u32,
offset: u32,
},
DrawElementsInstanced {
mode: u32,
count: i32,
type_: u32,
offset: u32,
primcount: i32,
},
VertexAttribDivisor {
index: u32,
divisor: u32,
},
GetUniformBool(WebGLProgramId, i32, WebGLSender<bool>), GetUniformBool(WebGLProgramId, i32, WebGLSender<bool>),
GetUniformBool2(WebGLProgramId, i32, WebGLSender<[bool; 2]>), GetUniformBool2(WebGLProgramId, i32, WebGLSender<[bool; 2]>),
GetUniformBool3(WebGLProgramId, i32, WebGLSender<[bool; 3]>), GetUniformBool3(WebGLProgramId, i32, WebGLSender<[bool; 3]>),
@ -309,7 +336,11 @@ pub enum WebGLCommand {
GetUniformFloat4(WebGLProgramId, i32, WebGLSender<[f32; 4]>), GetUniformFloat4(WebGLProgramId, i32, WebGLSender<[f32; 4]>),
GetUniformFloat9(WebGLProgramId, i32, WebGLSender<[f32; 9]>), GetUniformFloat9(WebGLProgramId, i32, WebGLSender<[f32; 9]>),
GetUniformFloat16(WebGLProgramId, i32, WebGLSender<[f32; 16]>), GetUniformFloat16(WebGLProgramId, i32, WebGLSender<[f32; 16]>),
InitializeFramebuffer { color: bool, depth: bool, stencil: bool }, InitializeFramebuffer {
color: bool,
depth: bool,
stencil: bool,
},
} }
macro_rules! define_resource_id_struct { macro_rules! define_resource_id_struct {
@ -329,7 +360,6 @@ macro_rules! define_resource_id_struct {
self.0.get() self.0.get()
} }
} }
}; };
} }
@ -340,7 +370,8 @@ macro_rules! define_resource_id {
#[allow(unsafe_code)] #[allow(unsafe_code)]
impl<'de> ::serde::Deserialize<'de> for $name { impl<'de> ::serde::Deserialize<'de> for $name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: ::serde::Deserializer<'de> where
D: ::serde::Deserializer<'de>,
{ {
let id = u32::deserialize(deserializer)?; let id = u32::deserialize(deserializer)?;
if id == 0 { if id == 0 {
@ -353,32 +384,33 @@ macro_rules! define_resource_id {
impl ::serde::Serialize for $name { impl ::serde::Serialize for $name {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ::serde::Serializer where
S: ::serde::Serializer,
{ {
self.get().serialize(serializer) self.get().serialize(serializer)
} }
} }
impl ::std::fmt::Debug for $name { impl ::std::fmt::Debug for $name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-> Result<(), ::std::fmt::Error> {
fmt.debug_tuple(stringify!($name)) fmt.debug_tuple(stringify!($name))
.field(&self.get()) .field(&self.get())
.finish() .finish()
} }
} }
impl ::std::fmt::Display for $name { impl ::std::fmt::Display for $name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-> Result<(), ::std::fmt::Error> {
write!(fmt, "{}", self.get()) write!(fmt, "{}", self.get())
} }
} }
impl ::malloc_size_of::MallocSizeOf for $name { impl ::malloc_size_of::MallocSizeOf for $name {
fn size_of(&self, _ops: &mut ::malloc_size_of::MallocSizeOfOps) -> usize { 0 } fn size_of(&self, _ops: &mut ::malloc_size_of::MallocSizeOfOps) -> usize {
0
}
} }
} };
} }
define_resource_id!(WebGLBufferId); define_resource_id!(WebGLBufferId);
@ -389,8 +421,9 @@ define_resource_id!(WebGLProgramId);
define_resource_id!(WebGLShaderId); define_resource_id!(WebGLShaderId);
define_resource_id!(WebGLVertexArrayId); define_resource_id!(WebGLVertexArrayId);
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, Ord)] #[derive(
#[derive(PartialEq, PartialOrd, Serialize)] Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, Ord, PartialEq, PartialOrd, Serialize,
)]
pub struct WebGLContextId(pub usize); pub struct WebGLContextId(pub usize);
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)] #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
@ -423,7 +456,7 @@ pub enum WebVRCommand {
/// Submit the frame to a VR device using the specified texture coordinates. /// Submit the frame to a VR device using the specified texture coordinates.
SubmitFrame(WebVRDeviceId, [f32; 4], [f32; 4]), SubmitFrame(WebVRDeviceId, [f32; 4], [f32; 4]),
/// Stop presenting to a VR device /// Stop presenting to a VR device
Release(WebVRDeviceId) Release(WebVRDeviceId),
} }
// Trait object that handles WebVR commands. // Trait object that handles WebVR commands.
@ -436,7 +469,13 @@ pub trait WebVRRenderHandler: Send {
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
pub enum DOMToTextureCommand { pub enum DOMToTextureCommand {
/// Attaches a HTMLIFrameElement to a WebGLTexture. /// Attaches a HTMLIFrameElement to a WebGLTexture.
Attach(WebGLContextId, WebGLTextureId, DocumentId, PipelineId, Size2D<i32>), Attach(
WebGLContextId,
WebGLTextureId,
DocumentId,
PipelineId,
Size2D<i32>,
),
/// Releases the HTMLIFrameElement to WebGLTexture attachment. /// Releases the HTMLIFrameElement to WebGLTexture attachment.
Detach(WebGLTextureId), Detach(WebGLTextureId),
/// Lock message used for a correct synchronization with WebRender GL flow. /// Lock message used for a correct synchronization with WebRender GL flow.

37
components/channel/lib.rs
View file

@ -18,43 +18,42 @@ use serde::{Deserialize, Serialize};
use std::sync::Arc; use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
pub fn route_ipc_receiver_to_new_servo_receiver<T>(ipc_receiver: IpcReceiver<T>) -> Receiver<T> pub fn route_ipc_receiver_to_new_servo_receiver<T>(ipc_receiver: IpcReceiver<T>) -> Receiver<T>
where where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static T: for<'de> Deserialize<'de> + Serialize + Send + 'static,
{ {
let (servo_sender, servo_receiver) = channel(); let (servo_sender, servo_receiver) = channel();
ROUTER.add_route( ROUTER.add_route(
ipc_receiver.to_opaque(), ipc_receiver.to_opaque(),
Box::new(move |message| { Box::new(move |message| drop(servo_sender.send(message.to::<T>().unwrap()))),
drop(servo_sender.send(message.to::<T>().unwrap()))
}),
); );
servo_receiver servo_receiver
} }
pub fn route_ipc_receiver_to_new_servo_sender<T>(ipc_receiver: IpcReceiver<T>, servo_sender: Sender<T>) pub fn route_ipc_receiver_to_new_servo_sender<T>(
where ipc_receiver: IpcReceiver<T>,
T: for<'de> Deserialize<'de> + Serialize + Send + 'static servo_sender: Sender<T>,
) where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static,
{ {
ROUTER.add_route( ROUTER.add_route(
ipc_receiver.to_opaque(), ipc_receiver.to_opaque(),
Box::new(move |message| { Box::new(move |message| drop(servo_sender.send(message.to::<T>().unwrap()))),
drop(servo_sender.send(message.to::<T>().unwrap()))
}),
) )
} }
pub fn channel<T>() -> (Sender<T>, Receiver<T>) { pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
let (base_sender, base_receiver) = crossbeam_channel::unbounded::<T>(); let (base_sender, base_receiver) = crossbeam_channel::unbounded::<T>();
let is_disconnected = Arc::new(AtomicBool::new(false)); let is_disconnected = Arc::new(AtomicBool::new(false));
(Sender::new(base_sender, is_disconnected.clone()), (
Receiver::new(base_receiver, is_disconnected)) Sender::new(base_sender, is_disconnected.clone()),
Receiver::new(base_receiver, is_disconnected),
)
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum ChannelError { pub enum ChannelError {
ChannelClosedError ChannelClosedError,
} }
pub struct Receiver<T> { pub struct Receiver<T> {
@ -78,7 +77,10 @@ impl<T> Clone for Receiver<T> {
} }
impl<T> Receiver<T> { impl<T> Receiver<T> {
pub fn new(receiver: crossbeam_channel::Receiver<T>, is_disconnected: Arc<AtomicBool>) -> Receiver<T> { pub fn new(
receiver: crossbeam_channel::Receiver<T>,
is_disconnected: Arc<AtomicBool>,
) -> Receiver<T> {
Receiver { Receiver {
receiver, receiver,
is_disconnected, is_disconnected,
@ -134,7 +136,10 @@ impl<T> Clone for Sender<T> {
} }
impl<T> Sender<T> { impl<T> Sender<T> {
pub fn new(sender: crossbeam_channel::Sender<T>, is_disconnected: Arc<AtomicBool>) -> Sender<T> { pub fn new(
sender: crossbeam_channel::Sender<T>,
is_disconnected: Arc<AtomicBool>,
) -> Sender<T> {
Sender { Sender {
sender, sender,
is_disconnected, is_disconnected,

3
components/compositing/build.rs
View file

@ -36,7 +36,8 @@ fn main() {
.find(|pkg| { .find(|pkg| {
pkg.get("name").and_then(|name| name.as_str()).unwrap_or("") == pkg.get("name").and_then(|name| name.as_str()).unwrap_or("") ==
"webrender" "webrender"
}).and_then(|pkg| pkg.get("source").and_then(|source| source.as_str())) })
.and_then(|pkg| pkg.get("source").and_then(|source| source.as_str()))
.unwrap_or("unknown"); .unwrap_or("unknown");
let parsed: Vec<&str> = source.split("#").collect(); let parsed: Vec<&str> = source.split("#").collect();

38
components/compositing/compositor.rs
View file

@ -498,7 +498,10 @@ impl<Window: WindowMethods> IOCompositor<Window> {
(Msg::GetScreenAvailSize(req), ShutdownState::NotShuttingDown) => { (Msg::GetScreenAvailSize(req), ShutdownState::NotShuttingDown) => {
if let Err(e) = req.send(self.embedder_coordinates.screen_avail) { if let Err(e) = req.send(self.embedder_coordinates.screen_avail) {
warn!("Sending response to get screen avail size failed ({:?}).", e); warn!(
"Sending response to get screen avail size failed ({:?}).",
e
);
} }
}, },
@ -839,7 +842,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
&mut self, &mut self,
delta: ScrollLocation, delta: ScrollLocation,
cursor: DeviceIntPoint, cursor: DeviceIntPoint,
phase: TouchEventType phase: TouchEventType,
) { ) {
match phase { match phase {
TouchEventType::Move => self.on_scroll_window_event(delta, cursor), TouchEventType::Move => self.on_scroll_window_event(delta, cursor),
@ -852,11 +855,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
} }
} }
fn on_scroll_window_event( fn on_scroll_window_event(&mut self, scroll_location: ScrollLocation, cursor: DeviceIntPoint) {
&mut self,
scroll_location: ScrollLocation,
cursor: DeviceIntPoint
) {
self.pending_scroll_zoom_events.push(ScrollZoomEvent { self.pending_scroll_zoom_events.push(ScrollZoomEvent {
magnification: 1.0, magnification: 1.0,
scroll_location: scroll_location, scroll_location: scroll_location,
@ -1155,15 +1154,19 @@ impl<Window: WindowMethods> IOCompositor<Window> {
pub fn composite(&mut self) { pub fn composite(&mut self) {
let target = self.composite_target; let target = self.composite_target;
match self.composite_specific_target(target) { match self.composite_specific_target(target) {
Ok(_) => if opts::get().output_file.is_some() || opts::get().exit_after_load { Ok(_) => {
println!("Shutting down the Constellation after generating an output file or exit flag specified"); if opts::get().output_file.is_some() || opts::get().exit_after_load {
self.start_shutting_down(); println!("Shutting down the Constellation after generating an output file or exit flag specified");
self.start_shutting_down();
}
}, },
Err(e) => if opts::get().is_running_problem_test { Err(e) => {
if e != UnableToComposite::NotReadyToPaintImage( if opts::get().is_running_problem_test {
NotReadyToPaint::WaitingOnConstellation, if e != UnableToComposite::NotReadyToPaintImage(
) { NotReadyToPaint::WaitingOnConstellation,
println!("not ready to composite: {:?}", e); ) {
println!("not ready to composite: {:?}", e);
}
} }
}, },
} }
@ -1255,7 +1258,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
if let Some(pipeline) = self.pipeline(*id) { if let Some(pipeline) = self.pipeline(*id) {
// and inform the layout thread with the measured paint time. // and inform the layout thread with the measured paint time.
let msg = LayoutControlMsg::PaintMetric(epoch, paint_time); let msg = LayoutControlMsg::PaintMetric(epoch, paint_time);
if let Err(e) = pipeline.layout_chan.send(msg) { if let Err(e) = pipeline.layout_chan.send(msg) {
warn!("Sending PaintMetric message to layout failed ({:?}).", e); warn!("Sending PaintMetric message to layout failed ({:?}).", e);
} }
} }
@ -1445,7 +1448,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
val.as_ref() val.as_ref()
.map(|dir| dir.join("capture_webrender").join(&capture_id)) .map(|dir| dir.join("capture_webrender").join(&capture_id))
.ok() .ok()
}).find(|val| match create_dir_all(&val) { })
.find(|val| match create_dir_all(&val) {
Ok(_) => true, Ok(_) => true,
Err(err) => { Err(err) => {
eprintln!("Unable to create path '{:?}' for capture: {:?}", &val, err); eprintln!("Unable to create path '{:?}' for capture: {:?}", &val, err);

9
components/config/opts.rs
View file

@ -814,7 +814,8 @@ pub fn from_cmdline_args(args: &[String]) -> ArgumentParsingResult {
.or_else(|error| { .or_else(|error| {
warn!("URL parsing failed ({:?}).", error); warn!("URL parsing failed ({:?}).", error);
Err(error) Err(error)
}).ok() })
.ok()
}); });
let tile_size: usize = match opt_match.opt_str("s") { let tile_size: usize = match opt_match.opt_str("s") {
@ -940,7 +941,8 @@ pub fn from_cmdline_args(args: &[String]) -> ArgumentParsingResult {
r.parse().unwrap_or_else(|err| { r.parse().unwrap_or_else(|err| {
args_fail(&format!("Error parsing option: --resolution ({})", err)) args_fail(&format!("Error parsing option: --resolution ({})", err))
}) })
}).collect(); })
.collect();
TypedSize2D::new(res[0], res[1]) TypedSize2D::new(res[0], res[1])
}, },
None => TypedSize2D::new(1024, 740), None => TypedSize2D::new(1024, 740),
@ -970,7 +972,8 @@ pub fn from_cmdline_args(args: &[String]) -> ArgumentParsingResult {
.read_to_end(&mut contents) .read_to_end(&mut contents)
.unwrap_or_else(|err| args_fail(&format!("Couldn't read {}: {}", filename, err))); .unwrap_or_else(|err| args_fail(&format!("Couldn't read {}: {}", filename, err)));
(contents, url) (contents, url)
}).collect(); })
.collect();
let do_not_use_native_titlebar = opt_match.opt_present("b") || !PREFS let do_not_use_native_titlebar = opt_match.opt_present("b") || !PREFS
.get("shell.native-titlebar.enabled") .get("shell.native-titlebar.enabled")

3
components/config/prefs.rs
View file

@ -192,7 +192,8 @@ fn init_user_prefs(path: &mut PathBuf) {
writeln!( writeln!(
&mut stderr(), &mut stderr(),
"Error opening prefs.json from config directory" "Error opening prefs.json from config directory"
).expect("failed printing to stderr"); )
.expect("failed printing to stderr");
} }
} }

265
components/constellation/constellation.rs
View file

@ -718,9 +718,8 @@ where
match reg_host(&load_data.url) { match reg_host(&load_data.url) {
None => (None, None), None => (None, None),
Some(host) => { Some(host) => {
let event_loop = self let event_loop =
.event_loops.get(&host) self.event_loops.get(&host).and_then(|weak| weak.upgrade());
.and_then(|weak| weak.upgrade());
match event_loop { match event_loop {
None => (None, Some(host)), None => (None, Some(host)),
Some(event_loop) => (Some(event_loop.clone()), None), Some(event_loop) => (Some(event_loop.clone()), None),
@ -855,7 +854,8 @@ where
is_private, is_private,
is_visible, is_visible,
); );
self.browsing_contexts.insert(browsing_context_id, browsing_context); self.browsing_contexts
.insert(browsing_context_id, browsing_context);
// If this context is a nested container, attach it to parent pipeline. // If this context is a nested container, attach it to parent pipeline.
if let Some(parent_pipeline_id) = parent_pipeline_id { if let Some(parent_pipeline_id) = parent_pipeline_id {
@ -866,7 +866,10 @@ where
} }
fn add_pending_change(&mut self, change: SessionHistoryChange) { fn add_pending_change(&mut self, change: SessionHistoryChange) {
self.handle_load_start_msg(change.top_level_browsing_context_id, change.browsing_context_id); self.handle_load_start_msg(
change.top_level_browsing_context_id,
change.browsing_context_id,
);
self.pending_changes.push(change); self.pending_changes.push(change);
} }
@ -1229,14 +1232,22 @@ where
.and_then(|pipeline| self.browsing_contexts.get(&pipeline.browsing_context_id)) .and_then(|pipeline| self.browsing_contexts.get(&pipeline.browsing_context_id))
.map(|ctx| (ctx.id, ctx.parent_pipeline_id)); .map(|ctx| (ctx.id, ctx.parent_pipeline_id));
if let Err(e) = sender.send(result) { if let Err(e) = sender.send(result) {
warn!("Sending reply to get browsing context info failed ({:?}).", e); warn!(
"Sending reply to get browsing context info failed ({:?}).",
e
);
} }
}, },
FromScriptMsg::GetTopForBrowsingContext(browsing_context_id, sender) => { FromScriptMsg::GetTopForBrowsingContext(browsing_context_id, sender) => {
let result = self.browsing_contexts.get(&browsing_context_id) let result = self
.browsing_contexts
.get(&browsing_context_id)
.and_then(|bc| Some(bc.top_level_id)); .and_then(|bc| Some(bc.top_level_id));
if let Err(e) = sender.send(result) { if let Err(e) = sender.send(result) {
warn!("Sending reply to get top for browsing context info failed ({:?}).", e); warn!(
"Sending reply to get top for browsing context info failed ({:?}).",
e
);
} }
}, },
FromScriptMsg::GetChildBrowsingContextId(browsing_context_id, index, sender) => { FromScriptMsg::GetChildBrowsingContextId(browsing_context_id, index, sender) => {
@ -1641,11 +1652,14 @@ where
fn handle_new_top_level_browsing_context( fn handle_new_top_level_browsing_context(
&mut self, &mut self,
url: ServoUrl, url: ServoUrl,
top_level_browsing_context_id: TopLevelBrowsingContextId top_level_browsing_context_id: TopLevelBrowsingContextId,
) { ) {
let window_size = self.window_size.initial_viewport; let window_size = self.window_size.initial_viewport;
let pipeline_id = PipelineId::new(); let pipeline_id = PipelineId::new();
let msg = (Some(top_level_browsing_context_id), EmbedderMsg::BrowserCreated(top_level_browsing_context_id)); let msg = (
Some(top_level_browsing_context_id),
EmbedderMsg::BrowserCreated(top_level_browsing_context_id),
);
self.embedder_proxy.send(msg); self.embedder_proxy.send(msg);
let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id); let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id);
let load_data = LoadData::new(url.clone(), None, None, None); let load_data = LoadData::new(url.clone(), None, None, None);
@ -1655,10 +1669,13 @@ where
// Register this new top-level browsing context id as a browser and set // Register this new top-level browsing context id as a browser and set
// its focused browsing context to be itself. // its focused browsing context to be itself.
self.browsers.insert(top_level_browsing_context_id, Browser { self.browsers.insert(
focused_browsing_context_id: browsing_context_id, top_level_browsing_context_id,
session_history: JointSessionHistory::new(), Browser {
}); focused_browsing_context_id: browsing_context_id,
session_history: JointSessionHistory::new(),
},
);
self.new_pipeline( self.new_pipeline(
pipeline_id, pipeline_id,
@ -1718,11 +1735,12 @@ where
}; };
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) { let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(browsing_context) => browsing_context.parent_pipeline_id, Some(browsing_context) => browsing_context.parent_pipeline_id,
None => return warn!( None => {
"Subframe {} loaded in closed browsing context {}.", return warn!(
pipeline_id, "Subframe {} loaded in closed browsing context {}.",
browsing_context_id, pipeline_id, browsing_context_id,
), )
},
}; };
let parent_pipeline_id = match parent_pipeline_id { let parent_pipeline_id = match parent_pipeline_id {
Some(parent_pipeline_id) => parent_pipeline_id, Some(parent_pipeline_id) => parent_pipeline_id,
@ -1779,7 +1797,8 @@ where
let (load_data, is_private) = { let (load_data, is_private) = {
// If no url is specified, reload. // If no url is specified, reload.
let old_pipeline = load_info.old_pipeline_id let old_pipeline = load_info
.old_pipeline_id
.and_then(|id| self.pipelines.get(&id)); .and_then(|id| self.pipelines.get(&id));
let load_data = load_info.load_data.unwrap_or_else(|| { let load_data = load_info.load_data.unwrap_or_else(|| {
let url = match old_pipeline { let url = match old_pipeline {
@ -1792,23 +1811,25 @@ where
}); });
let is_parent_private = { let is_parent_private = {
let parent_browsing_context_id = let parent_browsing_context_id = match self.pipelines.get(&parent_pipeline_id) {
match self.pipelines.get(&parent_pipeline_id) { Some(pipeline) => pipeline.browsing_context_id,
Some(pipeline) => pipeline.browsing_context_id, None => {
None => return warn!( return warn!(
"Script loaded url in iframe {} in closed parent pipeline {}.", "Script loaded url in iframe {} in closed parent pipeline {}.",
browsing_context_id, browsing_context_id, parent_pipeline_id,
parent_pipeline_id, )
), },
}; };
let is_parent_private = let is_parent_private =
match self.browsing_contexts.get(&parent_browsing_context_id) { match self.browsing_contexts.get(&parent_browsing_context_id) {
Some(ctx) => ctx.is_private, Some(ctx) => ctx.is_private,
None => return warn!( None => {
return warn!(
"Script loaded url in iframe {} in closed parent browsing context {}.", "Script loaded url in iframe {} in closed parent browsing context {}.",
browsing_context_id, browsing_context_id,
parent_browsing_context_id, parent_browsing_context_id,
), )
},
}; };
is_parent_private is_parent_private
}; };
@ -1820,10 +1841,12 @@ where
let (replace, window_size, is_visible) = { let (replace, window_size, is_visible) = {
let browsing_context = match self.browsing_contexts.get(&browsing_context_id) { let browsing_context = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx, Some(ctx) => ctx,
None => return warn!( None => {
"Script loaded url in iframe with closed browsing context {}.", return warn!(
browsing_context_id, "Script loaded url in iframe with closed browsing context {}.",
), browsing_context_id,
)
},
}; };
let replace = if replace { let replace = if replace {
Some(NeedsToReload::No(browsing_context.pipeline_id)) Some(NeedsToReload::No(browsing_context.pipeline_id))
@ -1876,19 +1899,22 @@ where
let load_data = LoadData::new(url.clone(), Some(parent_pipeline_id), None, None); let load_data = LoadData::new(url.clone(), Some(parent_pipeline_id), None, None);
let (pipeline, is_private, is_visible) = { let (pipeline, is_private, is_visible) = {
let (script_sender, parent_browsing_context_id) = let (script_sender, parent_browsing_context_id) = match self
match self.pipelines.get(&parent_pipeline_id) { .pipelines
Some(pipeline) => (pipeline.event_loop.clone(), pipeline.browsing_context_id), .get(&parent_pipeline_id)
None => return warn!("Script loaded url in closed iframe {}.", parent_pipeline_id), {
}; Some(pipeline) => (pipeline.event_loop.clone(), pipeline.browsing_context_id),
None => return warn!("Script loaded url in closed iframe {}.", parent_pipeline_id),
};
let (is_parent_private, is_parent_visible) = let (is_parent_private, is_parent_visible) =
match self.browsing_contexts.get(&parent_browsing_context_id) { match self.browsing_contexts.get(&parent_browsing_context_id) {
Some(ctx) => (ctx.is_private, ctx.is_visible), Some(ctx) => (ctx.is_private, ctx.is_visible),
None => return warn!( None => {
"New iframe {} loaded in closed parent browsing context {}.", return warn!(
browsing_context_id, "New iframe {} loaded in closed parent browsing context {}.",
parent_browsing_context_id, browsing_context_id, parent_browsing_context_id,
), )
},
}; };
let is_private = is_private || is_parent_private; let is_private = is_private || is_parent_private;
let pipeline = Pipeline::new( let pipeline = Pipeline::new(
@ -1923,9 +1949,11 @@ where
}); });
} }
fn handle_script_new_auxiliary(&mut self, fn handle_script_new_auxiliary(
load_info: AuxiliaryBrowsingContextLoadInfo, &mut self,
layout_sender: IpcSender<LayoutControlMsg>) { load_info: AuxiliaryBrowsingContextLoadInfo,
layout_sender: IpcSender<LayoutControlMsg>,
) {
let AuxiliaryBrowsingContextLoadInfo { let AuxiliaryBrowsingContextLoadInfo {
opener_pipeline_id, opener_pipeline_id,
new_top_level_browsing_context_id, new_top_level_browsing_context_id,
@ -1942,19 +1970,22 @@ where
let (script_sender, opener_browsing_context_id) = let (script_sender, opener_browsing_context_id) =
match self.pipelines.get(&opener_pipeline_id) { match self.pipelines.get(&opener_pipeline_id) {
Some(pipeline) => (pipeline.event_loop.clone(), pipeline.browsing_context_id), Some(pipeline) => (pipeline.event_loop.clone(), pipeline.browsing_context_id),
None => return warn!( None => {
"Auxiliary loaded url in closed iframe {}.", return warn!(
opener_pipeline_id "Auxiliary loaded url in closed iframe {}.",
), opener_pipeline_id
)
},
}; };
let (is_opener_private, is_opener_visible) = let (is_opener_private, is_opener_visible) =
match self.browsing_contexts.get(&opener_browsing_context_id) { match self.browsing_contexts.get(&opener_browsing_context_id) {
Some(ctx) => (ctx.is_private, ctx.is_visible), Some(ctx) => (ctx.is_private, ctx.is_visible),
None => return warn!( None => {
"New auxiliary {} loaded in closed opener browsing context {}.", return warn!(
new_browsing_context_id, "New auxiliary {} loaded in closed opener browsing context {}.",
opener_browsing_context_id, new_browsing_context_id, opener_browsing_context_id,
), )
},
}; };
let pipeline = Pipeline::new( let pipeline = Pipeline::new(
new_pipeline_id, new_pipeline_id,
@ -1966,7 +1997,7 @@ where
self.compositor_proxy.clone(), self.compositor_proxy.clone(),
url, url,
is_opener_visible, is_opener_visible,
load_data load_data,
); );
(pipeline, is_opener_private, is_opener_visible) (pipeline, is_opener_private, is_opener_visible)
@ -1974,10 +2005,13 @@ where
assert!(!self.pipelines.contains_key(&new_pipeline_id)); assert!(!self.pipelines.contains_key(&new_pipeline_id));
self.pipelines.insert(new_pipeline_id, pipeline); self.pipelines.insert(new_pipeline_id, pipeline);
self.browsers.insert(new_top_level_browsing_context_id, Browser { self.browsers.insert(
focused_browsing_context_id: new_browsing_context_id, new_top_level_browsing_context_id,
session_history: JointSessionHistory::new(), Browser {
}); focused_browsing_context_id: new_browsing_context_id,
session_history: JointSessionHistory::new(),
},
);
self.add_pending_change(SessionHistoryChange { self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: new_top_level_browsing_context_id, top_level_browsing_context_id: new_top_level_browsing_context_id,
browsing_context_id: new_browsing_context_id, browsing_context_id: new_browsing_context_id,
@ -2098,8 +2132,7 @@ where
// against future changes that might break things. // against future changes that might break things.
warn!( warn!(
"Pipeline {} loaded url in closed browsing context {}.", "Pipeline {} loaded url in closed browsing context {}.",
source_id, source_id, browsing_context_id,
browsing_context_id,
); );
return None; return None;
}, },
@ -2448,12 +2481,13 @@ where
// TODO: Save the sandbox state so it can be restored here. // TODO: Save the sandbox state so it can be restored here.
let sandbox = IFrameSandboxState::IFrameUnsandboxed; let sandbox = IFrameSandboxState::IFrameUnsandboxed;
let (top_level_id, let (
old_pipeline_id, top_level_id,
parent_pipeline_id, old_pipeline_id,
window_size, parent_pipeline_id,
is_private, window_size,
is_visible is_private,
is_visible,
) = match self.browsing_contexts.get(&browsing_context_id) { ) = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ( Some(ctx) => (
ctx.top_level_id, ctx.top_level_id,
@ -2651,18 +2685,19 @@ where
let event = CompositorEvent::KeyboardEvent(event); let event = CompositorEvent::KeyboardEvent(event);
let pipeline_id = match self.browsing_contexts.get(&browsing_context_id) { let pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx.pipeline_id, Some(ctx) => ctx.pipeline_id,
None => return warn!( None => {
"Got key event for nonexistent browsing context {}.", return warn!(
browsing_context_id, "Got key event for nonexistent browsing context {}.",
), browsing_context_id,
)
},
}; };
let msg = ConstellationControlMsg::SendEvent(pipeline_id, event); let msg = ConstellationControlMsg::SendEvent(pipeline_id, event);
let result = match self.pipelines.get(&pipeline_id) { let result = match self.pipelines.get(&pipeline_id) {
Some(pipeline) => pipeline.event_loop.send(msg), Some(pipeline) => pipeline.event_loop.send(msg),
None => return debug!( None => {
"Pipeline {:?} got key event after closure.", return debug!("Pipeline {:?} got key event after closure.", pipeline_id)
pipeline_id },
),
}; };
if let Err(e) = result { if let Err(e) = result {
self.handle_send_error(pipeline_id, e); self.handle_send_error(pipeline_id, e);
@ -2771,10 +2806,12 @@ where
Some(browser) => { Some(browser) => {
browser.focused_browsing_context_id = browsing_context_id; browser.focused_browsing_context_id = browsing_context_id;
}, },
None => return warn!( None => {
"Browser {} for focus msg does not exist", return warn!(
top_level_browsing_context_id "Browser {} for focus msg does not exist",
), top_level_browsing_context_id
)
},
}; };
// Focus parent iframes recursively // Focus parent iframes recursively
@ -2784,17 +2821,21 @@ where
fn focus_parent_pipeline(&mut self, browsing_context_id: BrowsingContextId) { fn focus_parent_pipeline(&mut self, browsing_context_id: BrowsingContextId) {
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) { let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx.parent_pipeline_id, Some(ctx) => ctx.parent_pipeline_id,
None => return warn!( None => {
"Browsing context {:?} focus parent after closure.", return warn!(
browsing_context_id "Browsing context {:?} focus parent after closure.",
), browsing_context_id
)
},
}; };
let parent_pipeline_id = match parent_pipeline_id { let parent_pipeline_id = match parent_pipeline_id {
Some(parent_id) => parent_id, Some(parent_id) => parent_id,
None => return debug!( None => {
"Browsing context {:?} focus has no parent.", return debug!(
browsing_context_id "Browsing context {:?} focus has no parent.",
), browsing_context_id
)
},
}; };
// Send a message to the parent of the provided browsing context (if it // Send a message to the parent of the provided browsing context (if it
@ -2864,7 +2905,12 @@ where
}; };
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) { let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx.parent_pipeline_id, Some(ctx) => ctx.parent_pipeline_id,
None => return warn!("Visibility change for closed browsing context {:?}.", pipeline_id), None => {
return warn!(
"Visibility change for closed browsing context {:?}.",
pipeline_id
)
},
}; };
if let Some(parent_pipeline_id) = parent_pipeline_id { if let Some(parent_pipeline_id) = parent_pipeline_id {
@ -3294,7 +3340,7 @@ where
fn focused_browsing_context_is_descendant_of( fn focused_browsing_context_is_descendant_of(
&self, &self,
browsing_context_id: BrowsingContextId browsing_context_id: BrowsingContextId,
) -> bool { ) -> bool {
let focused_browsing_context_id = self let focused_browsing_context_id = self
.active_browser_id .active_browser_id
@ -3389,11 +3435,12 @@ where
// This is an existing browsing context. // This is an existing browsing context.
None => match self.browsing_contexts.get(&change.browsing_context_id) { None => match self.browsing_contexts.get(&change.browsing_context_id) {
Some(ctx) => ctx.parent_pipeline_id, Some(ctx) => ctx.parent_pipeline_id,
None => return warn!( None => {
"Activated document {} after browsing context {} closure.", return warn!(
change.new_pipeline_id, "Activated document {} after browsing context {} closure.",
change.browsing_context_id, change.new_pipeline_id, change.browsing_context_id,
), )
},
}, },
}; };
if let Some(parent_pipeline_id) = parent_pipeline_id { if let Some(parent_pipeline_id) = parent_pipeline_id {
@ -3638,12 +3685,14 @@ where
new_size, new_size,
size_type, size_type,
)); ));
let pipeline_ids = browsing_context.pipelines let pipeline_ids = browsing_context
.pipelines
.iter() .iter()
.filter(|pipeline_id| **pipeline_id != pipeline.id); .filter(|pipeline_id| **pipeline_id != pipeline.id);
for id in pipeline_ids { for id in pipeline_ids {
if let Some(pipeline) = self.pipelines.get(&id) { if let Some(pipeline) = self.pipelines.get(&id) {
let _ = pipeline.event_loop let _ = pipeline
.event_loop
.send(ConstellationControlMsg::ResizeInactive( .send(ConstellationControlMsg::ResizeInactive(
pipeline.id, pipeline.id,
new_size, new_size,
@ -3757,11 +3806,12 @@ where
NeedsToReload::Yes(pipeline_id, load_data), NeedsToReload::Yes(pipeline_id, load_data),
); );
}, },
None => return warn!( None => {
"Discarding pipeline {} after browser {} closure", return warn!(
pipeline_id, "Discarding pipeline {} after browser {} closure",
top_level_browsing_context_id, pipeline_id, top_level_browsing_context_id,
), )
},
}; };
self.close_pipeline( self.close_pipeline(
pipeline_id, pipeline_id,
@ -3844,8 +3894,10 @@ where
// Randomly close a pipeline -if --random-pipeline-closure-probability is set // Randomly close a pipeline -if --random-pipeline-closure-probability is set
fn maybe_close_random_pipeline(&mut self) { fn maybe_close_random_pipeline(&mut self) {
match self.random_pipeline_closure { match self.random_pipeline_closure {
Some((ref mut rng, probability)) => if probability <= rng.gen::<f32>() { Some((ref mut rng, probability)) => {
return; if probability <= rng.gen::<f32>() {
return;
}
}, },
_ => return, _ => return,
}; };
@ -3881,7 +3933,8 @@ where
&mut self, &mut self,
top_level_id: TopLevelBrowsingContextId, top_level_id: TopLevelBrowsingContextId,
) -> &mut JointSessionHistory { ) -> &mut JointSessionHistory {
&mut self.browsers &mut self
.browsers
.entry(top_level_id) .entry(top_level_id)
// This shouldn't be necessary since `get_joint_session_history` is // This shouldn't be necessary since `get_joint_session_history` is
// invoked for existing browsers but we need this to satisfy the // invoked for existing browsers but we need this to satisfy the

4
components/constellation/network_listener.rs
View file

@ -113,7 +113,9 @@ impl NetworkListener {
location_url: metadata.location_url.clone(), location_url: metadata.location_url.clone(),
headers: headers.clone().into_inner(), headers: headers.clone().into_inner(),
referrer: metadata.referrer.clone(), referrer: metadata.referrer.clone(),
status_code: metadata.status.as_ref() status_code: metadata
.status
.as_ref()
.map(|&(code, _)| code) .map(|&(code, _)| code)
.unwrap_or(200), .unwrap_or(200),
}); });

13
components/constellation/pipeline.rs
View file

@ -240,10 +240,12 @@ impl Pipeline {
Err(e) => { Err(e) => {
error!("Cast to ScriptToDevtoolsControlMsg failed ({}).", e) error!("Cast to ScriptToDevtoolsControlMsg failed ({}).", e)
}, },
Ok(message) => if let Err(e) = Ok(message) => {
devtools_chan.send(DevtoolsControlMsg::FromScript(message)) if let Err(e) =
{ devtools_chan.send(DevtoolsControlMsg::FromScript(message))
warn!("Sending to devtools failed ({:?})", e) {
warn!("Sending to devtools failed ({:?})", e)
}
}, },
}, },
), ),
@ -430,8 +432,7 @@ impl Pipeline {
/// Notify the script thread that this pipeline is visible. /// Notify the script thread that this pipeline is visible.
pub fn notify_visibility(&self, is_visible: bool) { pub fn notify_visibility(&self, is_visible: bool) {
let script_msg = let script_msg = ConstellationControlMsg::ChangeFrameVisibilityStatus(self.id, is_visible);
ConstellationControlMsg::ChangeFrameVisibilityStatus(self.id, is_visible);
let compositor_msg = CompositorMsg::PipelineVisibilityChanged(self.id, is_visible); let compositor_msg = CompositorMsg::PipelineVisibilityChanged(self.id, is_visible);
let err = self.event_loop.send(script_msg); let err = self.event_loop.send(script_msg);
if let Err(e) = err { if let Err(e) = err {

6
components/debugger/lib.rs
View file

@ -49,7 +49,8 @@ pub fn start_server(port: u16) -> Sender {
.name("debugger-websocket".to_owned()) .name("debugger-websocket".to_owned())
.spawn(move || { .spawn(move || {
socket.listen(("127.0.0.1", port)).unwrap(); socket.listen(("127.0.0.1", port)).unwrap();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
while let Some(message) = receiver.recv() { while let Some(message) = receiver.recv() {
match message { match message {
Message::ShutdownServer => { Message::ShutdownServer => {
@ -58,7 +59,8 @@ pub fn start_server(port: u16) -> Sender {
} }
} }
sender.shutdown().unwrap(); sender.shutdown().unwrap();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
Sender(sender) Sender(sender)
} }

9
components/devtools/actors/console.rs
View file

@ -126,7 +126,8 @@ impl Actor for ConsoleActor {
self.pipeline, self.pipeline,
message_types, message_types,
chan, chan,
)).unwrap(); ))
.unwrap();
let messages = port let messages = port
.recv() .recv()
.map_err(|_| ())? .map_err(|_| ())?
@ -135,7 +136,8 @@ impl Actor for ConsoleActor {
let json_string = message.encode().unwrap(); let json_string = message.encode().unwrap();
let json = serde_json::from_str::<Value>(&json_string).unwrap(); let json = serde_json::from_str::<Value>(&json_string).unwrap();
json.as_object().unwrap().to_owned() json.as_object().unwrap().to_owned()
}).collect(); })
.collect();
let msg = GetCachedMessagesReply { let msg = GetCachedMessagesReply {
from: self.name(), from: self.name(),
@ -196,7 +198,8 @@ impl Actor for ConsoleActor {
self.pipeline, self.pipeline,
input.clone(), input.clone(),
chan, chan,
)).unwrap(); ))
.unwrap();
//TODO: extract conversion into protocol module or some other useful place //TODO: extract conversion into protocol module or some other useful place
let result = match port.recv().map_err(|_| ())? { let result = match port.recv().map_err(|_| ())? {

7
components/devtools/actors/device.rs
View file

@ -42,7 +42,7 @@ impl Actor for DeviceActor {
value: SystemInfo { value: SystemInfo {
apptype: "servo".to_string(), apptype: "servo".to_string(),
platformVersion: "63.0".to_string(), platformVersion: "63.0".to_string(),
} },
}; };
stream.write_json_packet(&msg); stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -73,12 +73,11 @@ impl DeviceActor {
.into_iter() .into_iter()
.collect(), .collect(),
), ),
)].into_iter() )]
.into_iter()
.collect(), .collect(),
), ),
}], }],
} }
} }
} }

18
components/devtools/actors/inspector.rs
View file

@ -111,14 +111,16 @@ impl Actor for NodeActor {
.iter() .iter()
.map(|json_mod| { .map(|json_mod| {
serde_json::from_str(&serde_json::to_string(json_mod).unwrap()).unwrap() serde_json::from_str(&serde_json::to_string(json_mod).unwrap()).unwrap()
}).collect(); })
.collect();
self.script_chan self.script_chan
.send(ModifyAttribute( .send(ModifyAttribute(
self.pipeline, self.pipeline,
registry.actor_to_script(target.to_owned()), registry.actor_to_script(target.to_owned()),
modifications, modifications,
)).unwrap(); ))
.unwrap();
let reply = ModifyAttributeReply { from: self.name() }; let reply = ModifyAttributeReply { from: self.name() };
stream.write_json_packet(&reply); stream.write_json_packet(&reply);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -228,7 +230,8 @@ impl NodeInfoToProtocol for NodeInfo {
namespace: attr.namespace, namespace: attr.namespace,
name: attr.name, name: attr.name,
value: attr.value, value: attr.value,
}).collect(), })
.collect(),
pseudoClassLocks: vec![], //TODO get this data from script pseudoClassLocks: vec![], //TODO get this data from script
@ -324,7 +327,8 @@ impl Actor for WalkerActor {
self.pipeline, self.pipeline,
registry.actor_to_script(target.to_owned()), registry.actor_to_script(target.to_owned()),
tx, tx,
)).unwrap(); ))
.unwrap();
let children = rx.recv().unwrap().ok_or(())?; let children = rx.recv().unwrap().ok_or(())?;
let msg = ChildrenReply { let msg = ChildrenReply {
@ -334,7 +338,8 @@ impl Actor for WalkerActor {
.into_iter() .into_iter()
.map(|child| { .map(|child| {
child.encode(registry, true, self.script_chan.clone(), self.pipeline) child.encode(registry, true, self.script_chan.clone(), self.pipeline)
}).collect(), })
.collect(),
from: self.name(), from: self.name(),
}; };
stream.write_json_packet(&msg); stream.write_json_packet(&msg);
@ -498,7 +503,8 @@ impl Actor for PageStyleActor {
self.pipeline, self.pipeline,
registry.actor_to_script(target.to_owned()), registry.actor_to_script(target.to_owned()),
tx, tx,
)).unwrap(); ))
.unwrap();
let ComputedNodeLayout { let ComputedNodeLayout {
display, display,
position, position,

27
components/devtools/actors/network_event.rs
View file

@ -33,7 +33,7 @@ struct HttpRequest {
struct HttpResponse { struct HttpResponse {
headers: Option<HeaderMap>, headers: Option<HeaderMap>,
status: Option<(StatusCode, String)>, status: Option<(StatusCode, String)>,
body: Option<Vec<u8>> body: Option<Vec<u8>>,
} }
pub struct NetworkEventActor { pub struct NetworkEventActor {
@ -192,7 +192,10 @@ impl Actor for NetworkEventActor {
let value = &value.to_str().unwrap().to_string(); let value = &value.to_str().unwrap().to_string();
rawHeadersString = rawHeadersString + name.as_str() + ":" + &value + "\r\n"; rawHeadersString = rawHeadersString + name.as_str() + ":" + &value + "\r\n";
headersSize += name.as_str().len() + value.len(); headersSize += name.as_str().len() + value.len();
headers.push(Header { name: name.as_str().to_owned(), value: value.to_owned() }); headers.push(Header {
name: name.as_str().to_owned(),
value: value.to_owned(),
});
} }
let msg = GetRequestHeadersReply { let msg = GetRequestHeadersReply {
from: self.name(), from: self.name(),
@ -376,8 +379,13 @@ impl NetworkEventActor {
// TODO: Send the correct values for all these fields. // TODO: Send the correct values for all these fields.
let hSizeOption = self.response.headers.as_ref().map(|headers| headers.len()); let hSizeOption = self.response.headers.as_ref().map(|headers| headers.len());
let hSize = hSizeOption.unwrap_or(0); let hSize = hSizeOption.unwrap_or(0);
let (status_code, status_message) = self.response.status.as_ref() let (status_code, status_message) = self
.map_or((0, "".to_owned()), |(code, text)| (code.as_u16(), text.clone())); .response
.status
.as_ref()
.map_or((0, "".to_owned()), |(code, text)| {
(code.as_u16(), text.clone())
});
// TODO: Send the correct values for remoteAddress and remotePort and http_version. // TODO: Send the correct values for remoteAddress and remotePort and http_version.
ResponseStartMsg { ResponseStartMsg {
httpVersion: "HTTP/1.1".to_owned(), httpVersion: "HTTP/1.1".to_owned(),
@ -395,7 +403,7 @@ impl NetworkEventActor {
if let Some(ref headers) = self.response.headers { if let Some(ref headers) = self.response.headers {
mString = match headers.typed_get::<ContentType>() { mString = match headers.typed_get::<ContentType>() {
Some(ct) => ct.to_string(), Some(ct) => ct.to_string(),
_ => "".to_owned() _ => "".to_owned(),
}; };
} }
// TODO: Set correct values when response's body is sent to the devtools in http_loader. // TODO: Set correct values when response's body is sent to the devtools in http_loader.
@ -436,10 +444,9 @@ impl NetworkEventActor {
} }
pub fn request_headers(&self) -> RequestHeadersMsg { pub fn request_headers(&self) -> RequestHeadersMsg {
let size = self.request let size = self.request.headers.iter().fold(0, |acc, (name, value)| {
.headers acc + name.as_str().len() + value.len()
.iter() });
.fold(0, |acc, (name, value)| acc + name.as_str().len() + value.len());
RequestHeadersMsg { RequestHeadersMsg {
headers: self.request.headers.len(), headers: self.request.headers.len(),
headersSize: size, headersSize: size,
@ -449,7 +456,7 @@ impl NetworkEventActor {
pub fn request_cookies(&self) -> RequestCookiesMsg { pub fn request_cookies(&self) -> RequestCookiesMsg {
let cookies_size = match self.request.headers.typed_get::<Cookie>() { let cookies_size = match self.request.headers.typed_get::<Cookie>() {
Some(ref cookie) => cookie.len(), Some(ref cookie) => cookie.len(),
_ => 0 _ => 0,
}; };
RequestCookiesMsg { RequestCookiesMsg {
cookies: cookies_size, cookies: cookies_size,

6
components/devtools/actors/performance.rs
View file

@ -106,7 +106,8 @@ impl PerformanceActor {
vec![( vec![(
"type".to_owned(), "type".to_owned(),
Value::String("canCurrentlyRecord".to_owned()), Value::String("canCurrentlyRecord".to_owned()),
)].into_iter() )]
.into_iter()
.collect(), .collect(),
), ),
response: Value::Object( response: Value::Object(
@ -117,7 +118,8 @@ impl PerformanceActor {
.into_iter() .into_iter()
.collect(), .collect(),
), ),
)].into_iter() )]
.into_iter()
.collect(), .collect(),
), ),
}], }],

1
components/devtools/actors/stylesheets.rs
View file

@ -30,4 +30,3 @@ impl StyleSheetsActor {
StyleSheetsActor { name: name } StyleSheetsActor { name: name }
} }
} }

9
components/devtools/actors/timeline.rs
View file

@ -169,7 +169,8 @@ impl TimelineActor {
emitter.send(markers); emitter.send(markers);
thread::sleep(Duration::from_millis(DEFAULT_TIMELINE_DATA_PULL_TIMEOUT)); thread::sleep(Duration::from_millis(DEFAULT_TIMELINE_DATA_PULL_TIMEOUT));
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
} }
@ -195,7 +196,8 @@ impl Actor for TimelineActor {
self.pipeline, self.pipeline,
self.marker_types.clone(), self.marker_types.clone(),
tx, tx,
)).unwrap(); ))
.unwrap();
*self.stream.borrow_mut() = stream.try_clone().ok(); *self.stream.borrow_mut() = stream.try_clone().ok();
@ -248,7 +250,8 @@ impl Actor for TimelineActor {
.send(DropTimelineMarkers( .send(DropTimelineMarkers(
self.pipeline, self.pipeline,
self.marker_types.clone(), self.marker_types.clone(),
)).unwrap(); ))
.unwrap();
if let Some(ref actor_name) = *self.framerate_actor.borrow() { if let Some(ref actor_name) = *self.framerate_actor.borrow() {
registry.drop_actor_later(actor_name.clone()); registry.drop_actor_later(actor_name.clone());

28
components/devtools/lib.rs
View file

@ -235,7 +235,17 @@ fn run_server(
let (pipeline, worker_id) = ids; let (pipeline, worker_id) = ids;
//TODO: move all this actor creation into a constructor method on BrowsingContextActor //TODO: move all this actor creation into a constructor method on BrowsingContextActor
let (target, console, emulation, inspector, timeline, profiler, performance, styleSheets, thread) = { let (
target,
console,
emulation,
inspector,
timeline,
profiler,
performance,
styleSheets,
thread,
) = {
let console = ConsoleActor { let console = ConsoleActor {
name: actors.new_name("console"), name: actors.new_name("console"),
script_chan: script_sender.clone(), script_chan: script_sender.clone(),
@ -347,7 +357,8 @@ fn run_server(
LogLevel::Warn => "warn", LogLevel::Warn => "warn",
LogLevel::Error => "error", LogLevel::Error => "error",
_ => "log", _ => "log",
}.to_owned(), }
.to_owned(),
timeStamp: precise_time_ns(), timeStamp: precise_time_ns(),
arguments: vec![console_message.message], arguments: vec![console_message.message],
filename: console_message.filename, filename: console_message.filename,
@ -373,7 +384,12 @@ fn run_server(
Some(actors.find::<WorkerActor>(actor_name).console.clone()) Some(actors.find::<WorkerActor>(actor_name).console.clone())
} else { } else {
let actor_name = (*actor_pipelines).get(&id)?; let actor_name = (*actor_pipelines).get(&id)?;
Some(actors.find::<BrowsingContextActor>(actor_name).console.clone()) Some(
actors
.find::<BrowsingContextActor>(actor_name)
.console
.clone(),
)
} }
} }
@ -537,9 +553,11 @@ fn run_server(
sender_clone sender_clone
.send(DevtoolsControlMsg::FromChrome( .send(DevtoolsControlMsg::FromChrome(
ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()), ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()),
)).unwrap(); ))
.unwrap();
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
while let Some(msg) = receiver.recv() { while let Some(msg) = receiver.recv() {
match msg { match msg {

3
components/dom_struct/lib.rs
View file

@ -55,7 +55,8 @@ pub fn dom_struct(args: TokenStream, input: TokenStream) -> TokenStream {
&self.#ident &self.#ident
} }
} }
).into() )
.into()
} else { } else {
panic!("#[dom_struct] only applies to structs with named fields"); panic!("#[dom_struct] only applies to structs with named fields");
} }

6
components/domobject_derive/lib.rs
View file

@ -76,9 +76,9 @@ fn expand_dom_object(input: syn::DeriveInput) -> quote::Tokens {
})); }));
let mut generics = input.generics.clone(); let mut generics = input.generics.clone();
generics generics.params.push(parse_quote!(
.params __T: crate::dom::bindings::reflector::DomObject
.push(parse_quote!(__T: crate::dom::bindings::reflector::DomObject)); ));
let (impl_generics, _, where_clause) = generics.split_for_impl(); let (impl_generics, _, where_clause) = generics.split_for_impl();

6
components/gfx/font.rs
View file

@ -254,7 +254,8 @@ impl Font {
TEXT_SHAPING_PERFORMANCE_COUNTER TEXT_SHAPING_PERFORMANCE_COUNTER
.fetch_add((end_time - start_time) as usize, Ordering::Relaxed); .fetch_add((end_time - start_time) as usize, Ordering::Relaxed);
Arc::new(glyphs) Arc::new(glyphs)
}).clone(); })
.clone();
self.shaper = shaper; self.shaper = shaper;
result result
} }
@ -450,7 +451,8 @@ impl FontGroup {
iter::once(FontFamilyDescriptor::default()) iter::once(FontFamilyDescriptor::default())
.chain(fallback_font_families(codepoint).into_iter().map(|family| { .chain(fallback_font_families(codepoint).into_iter().map(|family| {
FontFamilyDescriptor::new(FontFamilyName::from(family), FontSearchScope::Local) FontFamilyDescriptor::new(FontFamilyName::from(family), FontSearchScope::Local)
})).filter_map(|family| font_context.font(&self.descriptor, &family)) }))
.filter_map(|family| font_context.font(&self.descriptor, &family))
.find(predicate) .find(predicate)
} }
} }

12
components/gfx/font_cache_thread.rs
View file

@ -434,7 +434,8 @@ impl FontCache {
FontSearchScope::Local => { FontSearchScope::Local => {
self.find_font_in_local_family(&template_descriptor, &family_descriptor.name) self.find_font_in_local_family(&template_descriptor, &family_descriptor.name)
}, },
}.map(|t| self.get_font_template_info(t)) }
.map(|t| self.get_font_template_info(t))
} }
} }
@ -474,7 +475,8 @@ impl FontCacheThread {
cache.refresh_local_families(); cache.refresh_local_families();
cache.run(); cache.run();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
FontCacheThread { chan: chan } FontCacheThread { chan: chan }
} }
@ -490,7 +492,8 @@ impl FontCacheThread {
LowercaseString::new(&family.name), LowercaseString::new(&family.name),
sources, sources,
sender, sender,
)).unwrap(); ))
.unwrap();
} }
pub fn exit(&self) { pub fn exit(&self) {
@ -538,7 +541,8 @@ impl FontSource for FontCacheThread {
template_descriptor, template_descriptor,
family_descriptor, family_descriptor,
response_chan, response_chan,
)).expect("failed to send message to font cache thread"); ))
.expect("failed to send message to font cache thread");
let reply = response_port.recv(); let reply = response_port.recv();

3
components/gfx/font_context.rs
View file

@ -133,7 +133,8 @@ impl<S: FontSource> FontContext<S> {
.and_then(|template_info| { .and_then(|template_info| {
self.create_font(template_info, font_descriptor.to_owned()) self.create_font(template_info, font_descriptor.to_owned())
.ok() .ok()
}).map(|font| Rc::new(RefCell::new(font))); })
.map(|font| Rc::new(RefCell::new(font)));
self.font_cache.insert(cache_key, font.clone()); self.font_cache.insert(cache_key, font.clone());
font font

17
components/gfx/platform/freetype/android/font_list.rs
View file

@ -127,7 +127,11 @@ struct FontList {
impl FontList { impl FontList {
fn new() -> FontList { fn new() -> FontList {
// Possible paths containing the font mapping xml file. // Possible paths containing the font mapping xml file.
let paths = ["/etc/fonts.xml", "/system/etc/system_fonts.xml", "/package/etc/fonts.xml"]; let paths = [
"/etc/fonts.xml",
"/system/etc/system_fonts.xml",
"/package/etc/fonts.xml",
];
// Try to load and parse paths until one of them success. // Try to load and parse paths until one of them success.
let mut result = None; let mut result = None;
@ -213,7 +217,10 @@ impl FontList {
let alternatives = [ let alternatives = [
("sans-serif", "Roboto-Regular.ttf"), ("sans-serif", "Roboto-Regular.ttf"),
("Droid Sans", "DroidSans.ttf"), ("Droid Sans", "DroidSans.ttf"),
("Lomino", "/system/etc/ml/kali/Fonts/Lomino/Medium/LominoUI_Md.ttf"), (
"Lomino",
"/system/etc/ml/kali/Fonts/Lomino/Medium/LominoUI_Md.ttf",
),
]; ];
alternatives alternatives
@ -225,7 +232,8 @@ impl FontList {
filename: item.1.into(), filename: item.1.into(),
weight: None, weight: None,
}], }],
}).collect() })
.collect()
} }
// All Android fonts are located in /system/fonts // All Android fonts are located in /system/fonts
@ -348,7 +356,8 @@ impl FontList {
.map(|f| Font { .map(|f| Font {
filename: f.clone(), filename: f.clone(),
weight: None, weight: None,
}).collect(); })
.collect();
if !fonts.is_empty() { if !fonts.is_empty() {
out.push(FontFamily { out.push(FontFamily {

3
components/gfx/platform/freetype/font.rs
View file

@ -216,7 +216,8 @@ impl FontHandleMethods for FontHandle {
} }
} else { } else {
FontStretchKeyword::Normal FontStretchKeyword::Normal
}.compute(); }
.compute();
FontStretch(NonNegative(percentage)) FontStretch(NonNegative(percentage))
} }

3
components/gfx/platform/freetype/font_template.rs
View file

@ -25,7 +25,8 @@ impl fmt::Debug for FontTemplateData {
.field( .field(
"bytes", "bytes",
&self.bytes.as_ref().map(|b| format!("[{} bytes]", b.len())), &self.bytes.as_ref().map(|b| format!("[{} bytes]", b.len())),
).field("identifier", &self.identifier) )
.field("identifier", &self.identifier)
.finish() .finish()
} }
} }

3
components/gfx/platform/macos/font.rs
View file

@ -236,8 +236,7 @@ impl FontHandleMethods for FontHandle {
let count: CFIndex = 1; let count: CFIndex = 1;
let result = unsafe { let result = unsafe {
self self.ctfont
.ctfont
.get_glyphs_for_characters(&characters[0], &mut glyphs[0], count) .get_glyphs_for_characters(&characters[0], &mut glyphs[0], count)
}; };

6
components/gfx/platform/macos/font_template.rs
View file

@ -51,7 +51,8 @@ impl fmt::Debug for FontTemplateData {
.font_data .font_data
.as_ref() .as_ref()
.map(|bytes| format!("[{} bytes]", bytes.len())), .map(|bytes| format!("[{} bytes]", bytes.len())),
).finish() )
.finish()
} }
} }
@ -111,7 +112,8 @@ impl FontTemplateData {
.expect("No URL for Core Text font!") .expect("No URL for Core Text font!")
.get_string() .get_string()
.to_string(), .to_string(),
).expect("Couldn't parse Core Text font URL!") )
.expect("Couldn't parse Core Text font URL!")
.as_url() .as_url()
.to_file_path() .to_file_path()
.expect("Core Text font didn't name a path!"); .expect("Core Text font didn't name a path!");

6
components/gfx/platform/windows/font.rs
View file

@ -187,7 +187,8 @@ impl FontInfo {
8 => FontStretchKeyword::ExtraExpanded, 8 => FontStretchKeyword::ExtraExpanded,
9 => FontStretchKeyword::UltraExpanded, 9 => FontStretchKeyword::UltraExpanded,
_ => return Err(()), _ => return Err(()),
}.compute(), }
.compute(),
)); ));
let style = if italic_bool { let style = if italic_bool {
@ -224,7 +225,8 @@ impl FontInfo {
FontStretch::Expanded => FontStretchKeyword::Expanded, FontStretch::Expanded => FontStretchKeyword::Expanded,
FontStretch::ExtraExpanded => FontStretchKeyword::ExtraExpanded, FontStretch::ExtraExpanded => FontStretchKeyword::ExtraExpanded,
FontStretch::UltraExpanded => FontStretchKeyword::UltraExpanded, FontStretch::UltraExpanded => FontStretchKeyword::UltraExpanded,
}.compute(), }
.compute(),
)); ));
Ok(FontInfo { Ok(FontInfo {

3
components/gfx/platform/windows/font_template.rs
View file

@ -24,7 +24,8 @@ impl fmt::Debug for FontTemplateData {
.bytes .bytes
.as_ref() .as_ref()
.map(|bytes| format!("[{} bytes]", bytes.len())), .map(|bytes| format!("[{} bytes]", bytes.len())),
).field("identifier", &self.identifier) )
.field("identifier", &self.identifier)
.finish() .finish()
} }
} }

3
components/gfx/tests/font_context.rs
View file

@ -119,7 +119,8 @@ fn font_family(names: Vec<&str>) -> FontFamily {
name: Atom::from(name), name: Atom::from(name),
syntax: FamilyNameSyntax::Quoted, syntax: FamilyNameSyntax::Quoted,
}) })
}).collect(); })
.collect();
FontFamily(FontFamilyList::new(names.into_boxed_slice())) FontFamily(FontFamilyList::new(names.into_boxed_slice()))
} }

3
components/gfx/tests/font_template.rs
View file

@ -41,7 +41,8 @@ fn test_font_template_descriptor() {
let mut template = FontTemplate::new( let mut template = FontTemplate::new(
Atom::from(filename), Atom::from(filename),
Some(file.bytes().map(|b| b.unwrap()).collect()), Some(file.bytes().map(|b| b.unwrap()).collect()),
).unwrap(); )
.unwrap();
let context = FontContextHandle::new(); let context = FontContextHandle::new();

7
components/gfx/text/glyph.rs
View file

@ -226,9 +226,9 @@ impl<'a> DetailedGlyphStore {
/* TODO: don't actually assert this until asserts are compiled /* TODO: don't actually assert this until asserts are compiled
in/out based on severity, debug/release, etc. This assertion in/out based on severity, debug/release, etc. This assertion
would wreck the complexity of the lookup. would wreck the complexity of the lookup.
See Rust Issue #3647, #2228, #3627 for related information. See Rust Issue #3647, #2228, #3627 for related information.
do self.detail_lookup.borrow |arr| { do self.detail_lookup.borrow |arr| {
assert !arr.contains(entry) assert !arr.contains(entry)
} }
@ -541,7 +541,8 @@ impl<'a> GlyphStore {
data_for_glyphs[i].advance, data_for_glyphs[i].advance,
data_for_glyphs[i].offset, data_for_glyphs[i].offset,
) )
}).collect(); })
.collect();
self.has_detailed_glyphs = true; self.has_detailed_glyphs = true;
self.detail_store self.detail_store

3
components/gfx/text/text_run.rs
View file

@ -380,7 +380,8 @@ impl<'a> TextRun {
); );
remaining -= slice_advance; remaining -= slice_advance;
slice_index slice_index
}).sum() })
.sum()
} }
/// Returns an iterator that will iterate over all slices of glyphs that represent natural /// Returns an iterator that will iterate over all slices of glyphs that represent natural

20
components/layout/animation.rs
View file

@ -89,7 +89,10 @@ pub fn update_animation_state<E>(
}, },
}; };
debug!("update_animation_state({:?}): {:?}", still_running, running_animation); debug!(
"update_animation_state({:?}): {:?}",
still_running, running_animation
);
if still_running { if still_running {
animations_still_running.push(running_animation); animations_still_running.push(running_animation);
@ -97,11 +100,13 @@ pub fn update_animation_state<E>(
} }
if let Animation::Transition(node, _, ref frame) = running_animation { if let Animation::Transition(node, _, ref frame) = running_animation {
script_chan.send(ConstellationControlMsg::TransitionEnd( script_chan
node.to_untrusted_node_address(), .send(ConstellationControlMsg::TransitionEnd(
frame.property_animation.property_name().into(), node.to_untrusted_node_address(),
frame.duration, frame.property_animation.property_name().into(),
)).unwrap(); frame.duration,
))
.unwrap();
} }
expired_animations expired_animations
@ -150,7 +155,8 @@ pub fn update_animation_state<E>(
.send(ConstellationMsg::ChangeRunningAnimationsState( .send(ConstellationMsg::ChangeRunningAnimationsState(
pipeline_id, pipeline_id,
animation_state, animation_state,
)).unwrap(); ))
.unwrap();
} }
/// Recalculates style for a set of animations. This does *not* run with the DOM /// Recalculates style for a set of animations. This does *not* run with the DOM

9
components/layout/block.rs
View file

@ -1334,7 +1334,8 @@ impl BlockFlow {
self.fragment.style.writing_mode, self.fragment.style.writing_mode,
inline_size_for_float_placement, inline_size_for_float_placement,
block_size + self.fragment.margin.block_start_end(), block_size + self.fragment.margin.block_start_end(),
).convert( )
.convert(
self.fragment.style.writing_mode, self.fragment.style.writing_mode,
self.base.floats.writing_mode, self.base.floats.writing_mode,
), ),
@ -1361,7 +1362,8 @@ impl BlockFlow {
self.base.floats.writing_mode, self.base.floats.writing_mode,
self.base.writing_mode, self.base.writing_mode,
container_size, container_size,
).start; )
.start;
let margin_offset = LogicalPoint::new( let margin_offset = LogicalPoint::new(
self.base.writing_mode, self.base.writing_mode,
Au(0), Au(0),
@ -2626,7 +2628,8 @@ impl Flow for BlockFlow {
.early_absolute_position_info .early_absolute_position_info
.relative_containing_block_mode, .relative_containing_block_mode,
CoordinateSystem::Own, CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()), )
.translate(&stacking_context_position.to_vector()),
); );
} }

5
components/layout/construct.rs
View file

@ -185,7 +185,8 @@ impl InlineBlockSplit {
predecessors: mem::replace( predecessors: mem::replace(
fragment_accumulator, fragment_accumulator,
InlineFragmentsAccumulator::from_inline_node(node, style_context), InlineFragmentsAccumulator::from_inline_node(node, style_context),
).to_intermediate_inline_fragments::<ConcreteThreadSafeLayoutNode>(style_context), )
.to_intermediate_inline_fragments::<ConcreteThreadSafeLayoutNode>(style_context),
flow: flow, flow: flow,
}; };
@ -402,7 +403,7 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
&self.layout_context, &self.layout_context,
)); ));
SpecificFragmentInfo::Image(image_info) SpecificFragmentInfo::Image(image_info)
} },
Some(LayoutNodeType::Element(LayoutElementType::HTMLMediaElement)) => { Some(LayoutNodeType::Element(LayoutElementType::HTMLMediaElement)) => {
let data = node.media_data().unwrap(); let data = node.media_data().unwrap();
SpecificFragmentInfo::Media(Box::new(MediaFragmentInfo::new(data))) SpecificFragmentInfo::Media(Box::new(MediaFragmentInfo::new(data)))

3
components/layout/display_list/items.rs
View file

@ -590,7 +590,8 @@ impl ClippingRegion {
rect: complex.rect.translate(delta), rect: complex.rect.translate(delta),
radii: complex.radii, radii: complex.radii,
mode: complex.mode, mode: complex.mode,
}).collect(), })
.collect(),
} }
} }

3
components/layout/flex.rs
View file

@ -922,7 +922,8 @@ impl Flow for FlexFlow {
.base .base
.flags .flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) .contains(FlowFlags::IS_ABSOLUTELY_POSITIONED)
}).map(|(index, flow)| FlexItem::new(index, flow)) })
.map(|(index, flow)| FlexItem::new(index, flow))
.collect(); .collect();
items.sort_by_key(|item| item.order); items.sort_by_key(|item| item.order);

74
components/layout/fragment.rs
View file

@ -416,23 +416,28 @@ impl ImageFragmentInfo {
layout_context: &LayoutContext, layout_context: &LayoutContext,
) -> ImageFragmentInfo { ) -> ImageFragmentInfo {
// First use any image data present in the element... // First use any image data present in the element...
let image_or_metadata = node.image_data().and_then(|(image, metadata)| { let image_or_metadata = node
match (image, metadata) { .image_data()
.and_then(|(image, metadata)| match (image, metadata) {
(Some(image), _) => Some(ImageOrMetadata::Image(image)), (Some(image), _) => Some(ImageOrMetadata::Image(image)),
(None, Some(metadata)) => Some(ImageOrMetadata::Metadata(metadata)), (None, Some(metadata)) => Some(ImageOrMetadata::Metadata(metadata)),
_ => None, _ => None,
}
}).or_else(|| url.and_then(|url| {
// Otherwise query the image cache for anything known about the associated source URL.
layout_context.get_or_request_image_or_meta(
node.opaque(),
url,
UsePlaceholder::Yes
).map(|result| match result {
ImageOrMetadataAvailable::ImageAvailable(i, _) => ImageOrMetadata::Image(i),
ImageOrMetadataAvailable::MetadataAvailable(m) => ImageOrMetadata::Metadata(m),
}) })
})); .or_else(|| {
url.and_then(|url| {
// Otherwise query the image cache for anything known about the associated source URL.
layout_context
.get_or_request_image_or_meta(node.opaque(), url, UsePlaceholder::Yes)
.map(|result| match result {
ImageOrMetadataAvailable::ImageAvailable(i, _) => {
ImageOrMetadata::Image(i)
},
ImageOrMetadataAvailable::MetadataAvailable(m) => {
ImageOrMetadata::Metadata(m)
},
})
})
});
let current_pixel_density = density.unwrap_or(1f64); let current_pixel_density = density.unwrap_or(1f64);
@ -452,15 +457,13 @@ impl ImageFragmentInfo {
}), }),
) )
}, },
Some(ImageOrMetadata::Metadata(m)) => { Some(ImageOrMetadata::Metadata(m)) => (
( None,
None, Some(ImageMetadata {
Some(ImageMetadata { height: (m.height as f64 / current_pixel_density) as u32,
height: (m.height as f64 / current_pixel_density) as u32, width: (m.width as f64 / current_pixel_density) as u32,
width: (m.width as f64 / current_pixel_density) as u32, }),
}), ),
)
},
None => (None, None), None => (None, None),
}; };
@ -1012,7 +1015,7 @@ impl Fragment {
} else { } else {
Au(0) Au(0)
} }
} },
SpecificFragmentInfo::Media(ref info) => { SpecificFragmentInfo::Media(ref info) => {
if let Some((_, width, _)) = info.current_frame { if let Some((_, width, _)) = info.current_frame {
Au::from_px(width as i32) Au::from_px(width as i32)
@ -1042,7 +1045,7 @@ impl Fragment {
} else { } else {
Au(0) Au(0)
} }
} },
SpecificFragmentInfo::Media(ref info) => { SpecificFragmentInfo::Media(ref info) => {
if let Some((_, _, height)) = info.current_frame { if let Some((_, _, height)) = info.current_frame {
Au::from_px(height as i32) Au::from_px(height as i32)
@ -1174,17 +1177,21 @@ impl Fragment {
(_, Ordering::Equal) => (first_isize, first_bsize), (_, Ordering::Equal) => (first_isize, first_bsize),
// When both rectangles grow (smaller than min sizes), // When both rectangles grow (smaller than min sizes),
// Choose the larger one; // Choose the larger one;
(Ordering::Greater, Ordering::Greater) => if first_isize > second_isize { (Ordering::Greater, Ordering::Greater) => {
(first_isize, first_bsize) if first_isize > second_isize {
} else { (first_isize, first_bsize)
(second_isize, second_bsize) } else {
(second_isize, second_bsize)
}
}, },
// When both rectangles shrink (larger than max sizes), // When both rectangles shrink (larger than max sizes),
// Choose the smaller one; // Choose the smaller one;
(Ordering::Less, Ordering::Less) => if first_isize > second_isize { (Ordering::Less, Ordering::Less) => {
(second_isize, second_bsize) if first_isize > second_isize {
} else { (second_isize, second_bsize)
(first_isize, first_bsize) } else {
(first_isize, first_bsize)
}
}, },
// It does not matter which we choose here, because both sizes // It does not matter which we choose here, because both sizes
// will be clamped to constraint; // will be clamped to constraint;
@ -3173,7 +3180,8 @@ impl Fragment {
perspective_origin perspective_origin
.vertical .vertical
.to_used_value(stacking_relative_border_box.size.height), .to_used_value(stacking_relative_border_box.size.height),
).to_layout(); )
.to_layout();
let pre_transform = LayoutTransform::create_translation( let pre_transform = LayoutTransform::create_translation(
perspective_origin.x, perspective_origin.x,

15
components/layout/inline.rs
View file

@ -316,7 +316,8 @@ impl LineBreaker {
.map(|fragment| match fragment.specific { .map(|fragment| match fragment.specific {
SpecificFragmentInfo::ScannedText(ref info) => info.run.bidi_level, SpecificFragmentInfo::ScannedText(ref info) => info.run.bidi_level,
_ => para_level, _ => para_level,
}).collect(); })
.collect();
let mut lines = mem::replace(&mut self.lines, Vec::new()); let mut lines = mem::replace(&mut self.lines, Vec::new());
@ -336,7 +337,8 @@ impl LineBreaker {
let start = FragmentIndex(run.start as isize); let start = FragmentIndex(run.start as isize);
let len = FragmentIndex(run.len() as isize); let len = FragmentIndex(run.len() as isize);
(Range::new(start, len), levels[run.start]) (Range::new(start, len), levels[run.start])
}).collect(), })
.collect(),
); );
} }
} }
@ -1719,7 +1721,8 @@ impl Flow for InlineFlow {
debug_assert!(first_fragment_index < self.fragments.fragments.len()); debug_assert!(first_fragment_index < self.fragments.fragments.len());
let first_fragment = &self.fragments.fragments[first_fragment_index]; let first_fragment = &self.fragments.fragments[first_fragment_index];
let padding_box_origin = (first_fragment.border_box - let padding_box_origin = (first_fragment.border_box -
first_fragment.style.logical_border_width()).start; first_fragment.style.logical_border_width())
.start;
containing_block_positions.push( containing_block_positions.push(
padding_box_origin.to_physical(self.base.writing_mode, container_size), padding_box_origin.to_physical(self.base.writing_mode, container_size),
); );
@ -1733,7 +1736,8 @@ impl Flow for InlineFlow {
debug_assert!(first_fragment_index < self.fragments.fragments.len()); debug_assert!(first_fragment_index < self.fragments.fragments.len());
let first_fragment = &self.fragments.fragments[first_fragment_index]; let first_fragment = &self.fragments.fragments[first_fragment_index];
let padding_box_origin = (first_fragment.border_box - let padding_box_origin = (first_fragment.border_box -
first_fragment.style.logical_border_width()).start; first_fragment.style.logical_border_width())
.start;
containing_block_positions.push( containing_block_positions.push(
padding_box_origin.to_physical(self.base.writing_mode, container_size), padding_box_origin.to_physical(self.base.writing_mode, container_size),
); );
@ -1878,7 +1882,8 @@ impl Flow for InlineFlow {
relative_containing_block_size, relative_containing_block_size,
relative_containing_block_mode, relative_containing_block_mode,
CoordinateSystem::Own, CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()), )
.translate(&stacking_context_position.to_vector()),
) )
} }
} }

3
components/layout/list_item.rs
View file

@ -257,7 +257,8 @@ impl Flow for ListItemFlow {
.early_absolute_position_info .early_absolute_position_info
.relative_containing_block_mode, .relative_containing_block_mode,
CoordinateSystem::Own, CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()), )
.translate(&stacking_context_position.to_vector()),
); );
} }
} }

30
components/layout/model.rs
View file

@ -505,10 +505,12 @@ pub fn style_length(
) -> MaybeAuto { ) -> MaybeAuto {
match container_size { match container_size {
Some(length) => MaybeAuto::from_style(style_length, length), Some(length) => MaybeAuto::from_style(style_length, length),
None => if let LengthOrPercentageOrAuto::Length(length) = style_length { None => {
MaybeAuto::Specified(Au::from(length)) if let LengthOrPercentageOrAuto::Length(length) = style_length {
} else { MaybeAuto::Specified(Au::from(length))
MaybeAuto::Auto } else {
MaybeAuto::Auto
}
}, },
} }
} }
@ -580,19 +582,23 @@ impl SizeConstraint {
) -> SizeConstraint { ) -> SizeConstraint {
let mut min_size = match container_size { let mut min_size = match container_size {
Some(container_size) => min_size.to_used_value(container_size), Some(container_size) => min_size.to_used_value(container_size),
None => if let LengthOrPercentage::Length(length) = min_size { None => {
Au::from(length) if let LengthOrPercentage::Length(length) = min_size {
} else { Au::from(length)
Au(0) } else {
Au(0)
}
}, },
}; };
let mut max_size = match container_size { let mut max_size = match container_size {
Some(container_size) => max_size.to_used_value(container_size), Some(container_size) => max_size.to_used_value(container_size),
None => if let LengthOrPercentageOrNone::Length(length) = max_size { None => {
Some(Au::from(length)) if let LengthOrPercentageOrNone::Length(length) = max_size {
} else { Some(Au::from(length))
None } else {
None
}
}, },
}; };
// Make sure max size is not smaller than min size. // Make sure max size is not smaller than min size.

3
components/layout/multicol.rs
View file

@ -164,7 +164,8 @@ impl Flow for MulticolFlow {
LogicalSize::from_physical( LogicalSize::from_physical(
self.block_flow.base.writing_mode, self.block_flow.base.writing_mode,
ctx.shared_context().viewport_size(), ctx.shared_context().viewport_size(),
).block )
.block
} }
}, },
}); });

13
components/layout/query.rs
View file

@ -603,7 +603,7 @@ impl FragmentBorderBoxIterator for ParentOffsetBorderBoxIterator {
// cause this assertion to fail sometimes, so it's // cause this assertion to fail sometimes, so it's
// commented out for now. // commented out for now.
/*assert!(node.flags.contains(FIRST_FRAGMENT_OF_ELEMENT), /*assert!(node.flags.contains(FIRST_FRAGMENT_OF_ELEMENT),
"First fragment of inline node found wasn't its first fragment!");*/ "First fragment of inline node found wasn't its first fragment!");*/
self.node_offset_box = Some(NodeOffsetBoxInfo { self.node_offset_box = Some(NodeOffsetBoxInfo {
offset: border_box.origin, offset: border_box.origin,
@ -840,12 +840,11 @@ where
let applies = true; let applies = true;
fn used_value_for_position_property<N: LayoutNode>( fn used_value_for_position_property<N: LayoutNode>(
layout_el: <N::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteThreadSafeLayoutElement, layout_el: <N::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteThreadSafeLayoutElement,
layout_root: &mut Flow, layout_root: &mut Flow,
requested_node: N, requested_node: N,
longhand_id: LonghandId, longhand_id: LonghandId,
) -> String ) -> String {
{
let maybe_data = layout_el.borrow_layout_data(); let maybe_data = layout_el.borrow_layout_data();
let position = maybe_data.map_or(Point2D::zero(), |data| { let position = maybe_data.map_or(Point2D::zero(), |data| {
match (*data).flow_construction_result { match (*data).flow_construction_result {

3
components/layout/table_cell.rs
View file

@ -197,7 +197,8 @@ impl Flow for TableCellFlow {
let specified_inline_size = MaybeAuto::from_style( let specified_inline_size = MaybeAuto::from_style(
self.block_flow.fragment.style().content_inline_size(), self.block_flow.fragment.style().content_inline_size(),
Au(0), Au(0),
).specified_or_zero(); )
.specified_or_zero();
if self if self
.block_flow .block_flow
.base .base

18
components/layout/table_wrapper.rs
View file

@ -143,7 +143,8 @@ impl TableWrapperFlow {
); );
total_guess = &total_guess + &guess; total_guess = &total_guess + &guess;
guess guess
}).collect(); })
.collect();
// Assign inline sizes. // Assign inline sizes.
let selection = let selection =
@ -385,7 +386,8 @@ impl Flow for TableWrapperFlow {
size: column_intrinsic_inline_size.minimum_length, size: column_intrinsic_inline_size.minimum_length,
percentage: column_intrinsic_inline_size.percentage, percentage: column_intrinsic_inline_size.percentage,
}, },
).collect::<Vec<_>>(); )
.collect::<Vec<_>>();
// Our inline-size was set to the inline-size of the containing block by the flow's parent. // Our inline-size was set to the inline-size of the containing block by the flow's parent.
// Now compute the real value. // Now compute the real value.
@ -753,17 +755,17 @@ impl ExcessInlineSizeDistributionInfo {
if !column_intrinsic_inline_size.constrained && if !column_intrinsic_inline_size.constrained &&
column_intrinsic_inline_size.percentage == 0.0 column_intrinsic_inline_size.percentage == 0.0
{ {
self.preferred_inline_size_of_nonconstrained_columns_with_no_percentage = self.preferred_inline_size_of_nonconstrained_columns_with_no_percentage = self
self.preferred_inline_size_of_nonconstrained_columns_with_no_percentage + .preferred_inline_size_of_nonconstrained_columns_with_no_percentage +
column_intrinsic_inline_size.preferred; column_intrinsic_inline_size.preferred;
self.count_of_nonconstrained_columns_with_no_percentage += 1 self.count_of_nonconstrained_columns_with_no_percentage += 1
} }
if column_intrinsic_inline_size.constrained && if column_intrinsic_inline_size.constrained &&
column_intrinsic_inline_size.percentage == 0.0 column_intrinsic_inline_size.percentage == 0.0
{ {
self.preferred_inline_size_of_constrained_columns_with_no_percentage = self.preferred_inline_size_of_constrained_columns_with_no_percentage = self
self.preferred_inline_size_of_constrained_columns_with_no_percentage + .preferred_inline_size_of_constrained_columns_with_no_percentage +
column_intrinsic_inline_size.preferred column_intrinsic_inline_size.preferred
} }
self.total_percentage += column_intrinsic_inline_size.percentage; self.total_percentage += column_intrinsic_inline_size.percentage;
self.column_count += 1 self.column_count += 1

8
components/layout_thread/dom_wrapper.rs
View file

@ -687,9 +687,7 @@ impl<'le> ::selectors::Element for ServoLayoutElement<'le> {
type Impl = SelectorImpl; type Impl = SelectorImpl;
fn opaque(&self) -> ::selectors::OpaqueElement { fn opaque(&self) -> ::selectors::OpaqueElement {
::selectors::OpaqueElement::new(unsafe { ::selectors::OpaqueElement::new(unsafe { &*(self.as_node().opaque().0 as *const ()) })
&*(self.as_node().opaque().0 as *const ())
})
} }
fn parent_element(&self) -> Option<ServoLayoutElement<'le>> { fn parent_element(&self) -> Option<ServoLayoutElement<'le>> {
@ -1272,9 +1270,7 @@ impl<'le> ::selectors::Element for ServoThreadSafeLayoutElement<'le> {
type Impl = SelectorImpl; type Impl = SelectorImpl;
fn opaque(&self) -> ::selectors::OpaqueElement { fn opaque(&self) -> ::selectors::OpaqueElement {
::selectors::OpaqueElement::new(unsafe { ::selectors::OpaqueElement::new(unsafe { &*(self.as_node().opaque().0 as *const ()) })
&*(self.as_node().opaque().0 as *const ())
})
} }
fn parent_element(&self) -> Option<Self> { fn parent_element(&self) -> Option<Self> {

12
components/layout_thread/lib.rs
View file

@ -334,7 +334,8 @@ impl LayoutThreadFactory for LayoutThread {
if let Some(content_process_shutdown_chan) = content_process_shutdown_chan { if let Some(content_process_shutdown_chan) = content_process_shutdown_chan {
let _ = content_process_shutdown_chan.send(()); let _ = content_process_shutdown_chan.send(());
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
} }
@ -507,8 +508,7 @@ impl LayoutThread {
// Ask the router to proxy IPC messages from the font cache thread to the layout thread. // Ask the router to proxy IPC messages from the font cache thread to the layout thread.
let (ipc_font_cache_sender, ipc_font_cache_receiver) = ipc::channel().unwrap(); let (ipc_font_cache_sender, ipc_font_cache_receiver) = ipc::channel().unwrap();
let font_cache_receiver = let font_cache_receiver = route_ipc_receiver_to_new_servo_receiver(ipc_font_cache_receiver);
route_ipc_receiver_to_new_servo_receiver(ipc_font_cache_receiver);
LayoutThread { LayoutThread {
id: id, id: id,
@ -769,7 +769,8 @@ impl LayoutThread {
.filter_map(|name| { .filter_map(|name| {
let id = PropertyId::parse_enabled_for_all_content(&*name).ok()?; let id = PropertyId::parse_enabled_for_all_content(&*name).ok()?;
Some((name.clone(), id)) Some((name.clone(), id))
}).filter(|&(_, ref id)| !id.is_shorthand()) })
.filter(|&(_, ref id)| !id.is_shorthand())
.collect(); .collect();
let registered_painter = RegisteredPainterImpl { let registered_painter = RegisteredPainterImpl {
name: name.clone(), name: name.clone(),
@ -1249,7 +1250,8 @@ impl LayoutThread {
.send(ConstellationMsg::ViewportConstrained( .send(ConstellationMsg::ViewportConstrained(
self.id, self.id,
constraints.clone(), constraints.clone(),
)).unwrap(); ))
.unwrap();
} }
if had_used_viewport_units { if had_used_viewport_units {
if let Some(mut data) = element.mutate_data() { if let Some(mut data) = element.mutate_data() {

3
components/malloc_size_of_derive/lib.rs
View file

@ -88,7 +88,8 @@ fn malloc_size_of_derive(s: synstructure::Structure) -> quote::Tokens {
fn test_struct() { fn test_struct() {
let source = syn::parse_str( let source = syn::parse_str(
"struct Foo<T> { bar: Bar, baz: T, #[ignore_malloc_size_of = \"\"] z: Arc<T> }", "struct Foo<T> { bar: Bar, baz: T, #[ignore_malloc_size_of = \"\"] z: Arc<T> }",
).unwrap(); )
.unwrap();
let source = synstructure::Structure::new(&source); let source = synstructure::Structure::new(&source);
let expanded = malloc_size_of_derive(source).to_string(); let expanded = malloc_size_of_derive(source).to_string();

7
components/net/cookie_storage.rs
View file

@ -236,10 +236,9 @@ fn evict_one_cookie(is_secure_cookie: bool, cookies: &mut Vec<Cookie>) -> bool {
fn get_oldest_accessed(is_secure_cookie: bool, cookies: &mut Vec<Cookie>) -> Option<(usize, Tm)> { fn get_oldest_accessed(is_secure_cookie: bool, cookies: &mut Vec<Cookie>) -> Option<(usize, Tm)> {
let mut oldest_accessed: Option<(usize, Tm)> = None; let mut oldest_accessed: Option<(usize, Tm)> = None;
for (i, c) in cookies.iter().enumerate() { for (i, c) in cookies.iter().enumerate() {
if (c.cookie.secure().unwrap_or(false) == is_secure_cookie) && if (c.cookie.secure().unwrap_or(false) == is_secure_cookie) && oldest_accessed
oldest_accessed .as_ref()
.as_ref() .map_or(true, |a| c.last_access < a.1)
.map_or(true, |a| c.last_access < a.1)
{ {
oldest_accessed = Some((i, c.last_access)); oldest_accessed = Some((i, c.last_access));
} }

31
components/net/fetch/methods.rs
View file

@ -254,10 +254,11 @@ pub fn main_fetch(
Response::network_error(NetworkError::Internal("Non-http scheme".into())) Response::network_error(NetworkError::Internal("Non-http scheme".into()))
} else if request.use_cors_preflight || } else if request.use_cors_preflight ||
(request.unsafe_request && (request.unsafe_request &&
(!is_cors_safelisted_method(&request.method) || (!is_cors_safelisted_method(&request.method) || request
request.headers.iter().any(|(name, value)| { .headers
!is_cors_safelisted_request_header(&name, &value) .iter()
}))) { .any(|(name, value)| !is_cors_safelisted_request_header(&name, &value))))
{
// Substep 1. // Substep 1.
request.response_tainting = ResponseTainting::CorsTainting; request.response_tainting = ResponseTainting::CorsTainting;
// Substep 2. // Substep 2.
@ -372,11 +373,10 @@ pub fn main_fetch(
// in the previous step. // in the previous step.
let not_network_error = !response_is_network_error && !internal_response.is_network_error(); let not_network_error = !response_is_network_error && !internal_response.is_network_error();
if not_network_error && if not_network_error &&
(is_null_body_status(&internal_response.status) || (is_null_body_status(&internal_response.status) || match request.method {
match request.method { Method::HEAD | Method::CONNECT => true,
Method::HEAD | Method::CONNECT => true, _ => false,
_ => false, }) {
}) {
// when Fetch is used only asynchronously, we will need to make sure // when Fetch is used only asynchronously, we will need to make sure
// that nothing tries to write to the body at this point // that nothing tries to write to the body at this point
let mut body = internal_response.body.lock().unwrap(); let mut body = internal_response.body.lock().unwrap();
@ -791,13 +791,12 @@ fn should_be_blocked_due_to_mime_type(
}; };
// Step 2-3 // Step 2-3
destination.is_script_like() && destination.is_script_like() && match mime_type.type_() {
match mime_type.type_() { mime::AUDIO | mime::VIDEO | mime::IMAGE => true,
mime::AUDIO | mime::VIDEO | mime::IMAGE => true, mime::TEXT if mime_type.subtype() == mime::CSV => true,
mime::TEXT if mime_type.subtype() == mime::CSV => true, // Step 4
// Step 4 _ => false,
_ => false, }
}
} }
/// <https://fetch.spec.whatwg.org/#block-bad-port> /// <https://fetch.spec.whatwg.org/#block-bad-port>

28
components/net/http_loader.rs
View file

@ -506,12 +506,10 @@ pub fn http_fetch(
} }
// Substep 2 // Substep 2
if response.is_none() && if response.is_none() && request.is_subresource_request() && match request.origin {
request.is_subresource_request() && Origin::Origin(ref origin) => *origin == request.url().origin(),
match request.origin { _ => false,
Origin::Origin(ref origin) => *origin == request.url().origin(), } {
_ => false,
} {
// TODO (handle foreign fetch unimplemented) // TODO (handle foreign fetch unimplemented)
} }
@ -1044,11 +1042,10 @@ fn http_network_or_cache_fetch(
} }
} }
// Substep 4 // Substep 4
if revalidating_flag && if revalidating_flag && forward_response
forward_response .status
.status .as_ref()
.as_ref() .map_or(false, |s| s.0 == StatusCode::NOT_MODIFIED)
.map_or(false, |s| s.0 == StatusCode::NOT_MODIFIED)
{ {
if let Ok(mut http_cache) = context.state.http_cache.write() { if let Ok(mut http_cache) = context.state.http_cache.write() {
response = http_cache.refresh(&http_request, forward_response.clone(), done_chan); response = http_cache.refresh(&http_request, forward_response.clone(), done_chan);
@ -1384,11 +1381,10 @@ fn cors_preflight_fetch(
let response = http_network_or_cache_fetch(&mut preflight, false, false, &mut None, context); let response = http_network_or_cache_fetch(&mut preflight, false, false, &mut None, context);
// Step 6 // Step 6
if cors_check(&request, &response).is_ok() && if cors_check(&request, &response).is_ok() && response
response .status
.status .as_ref()
.as_ref() .map_or(false, |(status, _)| status.is_success())
.map_or(false, |(status, _)| status.is_success())
{ {
// Substep 1, 2 // Substep 1, 2
let mut methods = if response let mut methods = if response

7
components/net/mime_classifier.rs
View file

@ -404,10 +404,9 @@ impl Mp4Matcher {
} }
let mp4 = [0x6D, 0x70, 0x34]; let mp4 = [0x6D, 0x70, 0x34];
data[8..].starts_with(&mp4) || data[8..].starts_with(&mp4) || data[16..box_size]
data[16..box_size] .chunks(4)
.chunks(4) .any(|chunk| chunk.starts_with(&mp4))
.any(|chunk| chunk.starts_with(&mp4))
} }
} }
impl MIMEChecker for Mp4Matcher { impl MIMEChecker for Mp4Matcher {

80
components/net/tests/fetch.rs
View file

@ -221,19 +221,25 @@ fn test_cors_preflight_fetch() {
let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| {
if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0
{ {
assert!(request assert!(
.headers() request
.contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); .headers()
assert!(!request .contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)
.headers() );
.contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); assert!(
assert!(!request !request
.headers() .headers()
.get(header::REFERER) .contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)
.unwrap() );
.to_str() assert!(
.unwrap() !request
.contains("a.html")); .headers()
.get(header::REFERER)
.unwrap()
.to_str()
.unwrap()
.contains("a.html")
);
response response
.headers_mut() .headers_mut()
.typed_insert(AccessControlAllowOrigin::ANY); .typed_insert(AccessControlAllowOrigin::ANY);
@ -279,12 +285,16 @@ fn test_cors_preflight_cache_fetch() {
let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| {
if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0
{ {
assert!(request assert!(
.headers() request
.contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); .headers()
assert!(!request .contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)
.headers() );
.contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); assert!(
!request
.headers()
.contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)
);
response response
.headers_mut() .headers_mut()
.typed_insert(AccessControlAllowOrigin::ANY); .typed_insert(AccessControlAllowOrigin::ANY);
@ -344,12 +354,16 @@ fn test_cors_preflight_fetch_network_error() {
let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| { let handler = move |request: HyperRequest<Body>, response: &mut HyperResponse<Body>| {
if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0 if request.method() == Method::OPTIONS && state.clone().fetch_add(1, Ordering::SeqCst) == 0
{ {
assert!(request assert!(
.headers() request
.contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)); .headers()
assert!(!request .contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)
.headers() );
.contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)); assert!(
!request
.headers()
.contains_key(header::ACCESS_CONTROL_REQUEST_HEADERS)
);
response response
.headers_mut() .headers_mut()
.typed_insert(AccessControlAllowOrigin::ANY); .typed_insert(AccessControlAllowOrigin::ANY);
@ -408,9 +422,11 @@ fn test_fetch_response_is_basic_filtered() {
let headers = fetch_response.headers; let headers = fetch_response.headers;
assert!(!headers.contains_key(header::SET_COOKIE)); assert!(!headers.contains_key(header::SET_COOKIE));
assert!(headers assert!(
.get(HeaderName::from_static("set-cookie2")) headers
.is_none()); .get(HeaderName::from_static("set-cookie2"))
.is_none()
);
} }
#[test] #[test]
@ -480,9 +496,11 @@ fn test_fetch_response_is_cors_filtered() {
assert!(!headers.contains_key(header::ACCESS_CONTROL_ALLOW_ORIGIN)); assert!(!headers.contains_key(header::ACCESS_CONTROL_ALLOW_ORIGIN));
assert!(!headers.contains_key(header::SET_COOKIE)); assert!(!headers.contains_key(header::SET_COOKIE));
assert!(headers assert!(
.get(HeaderName::from_static("set-cookie2")) headers
.is_none()); .get(HeaderName::from_static("set-cookie2"))
.is_none()
);
} }
#[test] #[test]

56
components/net/tests/hsts.rs
View file

@ -103,12 +103,14 @@ fn test_push_entry_with_0_max_age_evicts_entry_from_list() {
let mut entries_map = HashMap::new(); let mut entries_map = HashMap::new();
entries_map.insert( entries_map.insert(
"mozilla.org".to_owned(), "mozilla.org".to_owned(),
vec![HstsEntry::new( vec![
"mozilla.org".to_owned(), HstsEntry::new(
IncludeSubdomains::NotIncluded, "mozilla.org".to_owned(),
Some(500000u64), IncludeSubdomains::NotIncluded,
) Some(500000u64),
.unwrap()], )
.unwrap(),
],
); );
let mut list = HstsList { let mut list = HstsList {
entries_map: entries_map, entries_map: entries_map,
@ -179,12 +181,14 @@ fn test_push_entry_to_hsts_list_should_not_create_duplicate_entry() {
let mut entries_map = HashMap::new(); let mut entries_map = HashMap::new();
entries_map.insert( entries_map.insert(
"mozilla.org".to_owned(), "mozilla.org".to_owned(),
vec![HstsEntry::new( vec![
"mozilla.org".to_owned(), HstsEntry::new(
IncludeSubdomains::NotIncluded, "mozilla.org".to_owned(),
None, IncludeSubdomains::NotIncluded,
) None,
.unwrap()], )
.unwrap(),
],
); );
let mut list = HstsList { let mut list = HstsList {
entries_map: entries_map, entries_map: entries_map,
@ -283,12 +287,14 @@ fn test_hsts_list_with_exact_domain_entry_is_is_host_secure() {
let mut entries_map = HashMap::new(); let mut entries_map = HashMap::new();
entries_map.insert( entries_map.insert(
"mozilla.org".to_owned(), "mozilla.org".to_owned(),
vec![HstsEntry::new( vec![
"mozilla.org".to_owned(), HstsEntry::new(
IncludeSubdomains::NotIncluded, "mozilla.org".to_owned(),
None, IncludeSubdomains::NotIncluded,
) None,
.unwrap()], )
.unwrap(),
],
); );
let hsts_list = HstsList { let hsts_list = HstsList {
@ -317,12 +323,14 @@ fn test_hsts_list_with_subdomain_when_include_subdomains_is_false_is_not_is_host
let mut entries_map = HashMap::new(); let mut entries_map = HashMap::new();
entries_map.insert( entries_map.insert(
"mozilla.org".to_owned(), "mozilla.org".to_owned(),
vec![HstsEntry::new( vec![
"mozilla.org".to_owned(), HstsEntry::new(
IncludeSubdomains::NotIncluded, "mozilla.org".to_owned(),
None, IncludeSubdomains::NotIncluded,
) None,
.unwrap()], )
.unwrap(),
],
); );
let hsts_list = HstsList { let hsts_list = HstsList {
entries_map: entries_map, entries_map: entries_map,

328
components/net/tests/http_loader.rs
View file

@ -142,13 +142,15 @@ fn test_check_default_headers_loaded_in_every_request() {
..RequestInit::default() ..RequestInit::default()
}); });
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
// Testing for method.POST // Testing for method.POST
let mut post_headers = headers.clone(); let mut post_headers = headers.clone();
@ -170,13 +172,15 @@ fn test_check_default_headers_loaded_in_every_request() {
..RequestInit::default() ..RequestInit::default()
}); });
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let _ = server.close(); let _ = server.close();
} }
@ -202,13 +206,15 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length
..RequestInit::default() ..RequestInit::default()
}); });
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let _ = server.close(); let _ = server.close();
} }
@ -237,13 +243,15 @@ fn test_request_and_response_data_with_network_messages() {
}); });
let (devtools_chan, devtools_port) = channel(); let (devtools_chan, devtools_port) = channel();
let response = fetch(&mut request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let _ = server.close(); let _ = server.close();
@ -336,13 +344,15 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
}); });
let (devtools_chan, devtools_port) = channel(); let (devtools_chan, devtools_port) = channel();
let response = fetch(&mut request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let _ = server.close(); let _ = server.close();
@ -580,13 +590,15 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
assert_eq!( assert_eq!(
context context
.state .state
@ -627,13 +639,15 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
assert_cookie_for_domain( assert_cookie_for_domain(
&context.state.cookie_jar, &context.state.cookie_jar,
@ -680,13 +694,15 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -727,13 +743,15 @@ fn test_load_sends_cookie_if_nonhttp() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -765,13 +783,15 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
assert_cookie_for_domain( assert_cookie_for_domain(
&context.state.cookie_jar, &context.state.cookie_jar,
@ -779,9 +799,11 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
Some("mozillaIs=theBest"), Some("mozillaIs=theBest"),
); );
let mut cookie_jar = context.state.cookie_jar.write().unwrap(); let mut cookie_jar = context.state.cookie_jar.write().unwrap();
assert!(cookie_jar assert!(
.cookies_for_url(&url, CookieSource::NonHTTP) cookie_jar
.is_none()); .cookies_for_url(&url, CookieSource::NonHTTP)
.is_none()
);
} }
#[test] #[test]
@ -813,13 +835,15 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
} }
@ -850,13 +874,15 @@ fn test_load_sets_content_length_to_length_of_request_body() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -890,13 +916,15 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -927,13 +955,15 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -967,13 +997,15 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -1004,13 +1036,15 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -1338,13 +1372,15 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
let _ = server.close(); let _ = server.close();
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
} }
#[test] #[test]
@ -1401,13 +1437,15 @@ fn test_origin_set() {
..RequestInit::default() ..RequestInit::default()
}); });
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let origin_url = ServoUrl::parse("http://example.com").unwrap(); let origin_url = ServoUrl::parse("http://example.com").unwrap();
// XXX: Not sure about the Some(80) here. origin_url.origin() returns 80 for the port but origin_url returns None. // XXX: Not sure about the Some(80) here. origin_url.origin() returns 80 for the port but origin_url returns None.
@ -1429,13 +1467,15 @@ fn test_origin_set() {
*origin_header_clone.lock().unwrap() = Some(origin.clone()); *origin_header_clone.lock().unwrap() = Some(origin.clone());
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
// Test Origin header is not set on method Head // Test Origin header is not set on method Head
let mut request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
@ -1448,13 +1488,15 @@ fn test_origin_set() {
*origin_header_clone.lock().unwrap() = None; *origin_header_clone.lock().unwrap() = None;
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(
.internal_response response
.unwrap() .internal_response
.status .unwrap()
.unwrap() .status
.0 .unwrap()
.is_success()); .0
.is_success()
);
let _ = server.close(); let _ = server.close();
} }

5
components/pixels/lib.rs
View file

@ -21,7 +21,10 @@ pub fn get_rect(pixels: &[u8], size: Size2D<u32>, rect: Rect<u32>) -> Cow<[u8]>
return Cow::Borrowed(&pixels[start..start + area * 4]); return Cow::Borrowed(&pixels[start..start + area * 4]);
} }
let mut data = Vec::with_capacity(area * 4); let mut data = Vec::with_capacity(area * 4);
for row in pixels[first_row_start..].chunks(row_length).take(rect.size.height as usize) { for row in pixels[first_row_start..]
.chunks(row_length)
.take(rect.size.height as usize)
{
data.extend_from_slice(&row[first_column_start..][..rect.size.width as usize * 4]); data.extend_from_slice(&row[first_column_start..][..rect.size.width as usize * 4]);
} }
data.into() data.into()

9
components/profile/mem.rs
View file

@ -43,7 +43,8 @@ impl Profiler {
if chan.send(ProfilerMsg::Print).is_err() { if chan.send(ProfilerMsg::Print).is_err() {
break; break;
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
// Always spawn the memory profiler. If there is no timer thread it won't receive regular // Always spawn the memory profiler. If there is no timer thread it won't receive regular
@ -53,7 +54,8 @@ impl Profiler {
.spawn(move || { .spawn(move || {
let mut mem_profiler = Profiler::new(port); let mut mem_profiler = Profiler::new(port);
mem_profiler.start(); mem_profiler.start();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
let mem_profiler_chan = ProfilerChan(chan); let mem_profiler_chan = ProfilerChan(chan);
@ -623,7 +625,8 @@ mod system_reporter {
let seg_re = Regex::new( let seg_re = Regex::new(
r"^[:xdigit:]+-[:xdigit:]+ (....) [:xdigit:]+ [:xdigit:]+:[:xdigit:]+ \d+ +(.*)", r"^[:xdigit:]+-[:xdigit:]+ (....) [:xdigit:]+ [:xdigit:]+:[:xdigit:]+ \d+ +(.*)",
).unwrap(); )
.unwrap();
let rss_re = Regex::new(r"^Rss: +(\d+) kB").unwrap(); let rss_re = Regex::new(r"^Rss: +(\d+) kB").unwrap();
// We record each segment's resident size. // We record each segment's resident size.

40
components/profile/time.rs
View file

@ -184,7 +184,8 @@ impl Profiler {
let trace = file_path.as_ref().and_then(|p| TraceDump::new(p).ok()); let trace = file_path.as_ref().and_then(|p| TraceDump::new(p).ok());
let mut profiler = Profiler::new(port, trace, Some(outputoption)); let mut profiler = Profiler::new(port, trace, Some(outputoption));
profiler.start(); profiler.start();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
// decide if we need to spawn the timer thread // decide if we need to spawn the timer thread
match option { match option {
&OutputOptions::FileName(_) | &OutputOptions::DB(_, _, _, _) => { &OutputOptions::FileName(_) | &OutputOptions::DB(_, _, _, _) => {
@ -200,7 +201,8 @@ impl Profiler {
if chan.send(ProfilerMsg::Print).is_err() { if chan.send(ProfilerMsg::Print).is_err() {
break; break;
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
}, },
} }
}, },
@ -214,7 +216,8 @@ impl Profiler {
let trace = file_path.as_ref().and_then(|p| TraceDump::new(p).ok()); let trace = file_path.as_ref().and_then(|p| TraceDump::new(p).ok());
let mut profiler = Profiler::new(port, trace, None); let mut profiler = Profiler::new(port, trace, None);
profiler.start(); profiler.start();
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} else { } else {
// No-op to handle messages when the time profiler is not printing: // No-op to handle messages when the time profiler is not printing:
thread::Builder::new() thread::Builder::new()
@ -228,7 +231,8 @@ impl Profiler {
}, },
_ => {}, _ => {},
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
}, },
} }
@ -281,7 +285,8 @@ impl Profiler {
start_time = end_time; start_time = end_time;
start_energy = end_energy; start_energy = end_energy;
} }
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
profiler_chan profiler_chan
@ -323,9 +328,11 @@ impl Profiler {
let ms = (t.1 - t.0) as f64 / 1000000f64; let ms = (t.1 - t.0) as f64 / 1000000f64;
self.find_or_insert(k, ms); self.find_or_insert(k, ms);
}, },
ProfilerMsg::Print => if let Some(ProfilerMsg::Time(..)) = self.last_msg { ProfilerMsg::Print => {
// only print if more data has arrived since the last printout if let Some(ProfilerMsg::Time(..)) = self.last_msg {
self.print_buckets(); // only print if more data has arrived since the last printout
self.print_buckets();
}
}, },
ProfilerMsg::Get(k, sender) => { ProfilerMsg::Get(k, sender) => {
let vec_option = self.buckets.get(&k); let vec_option = self.buckets.get(&k);
@ -381,7 +388,8 @@ impl Profiler {
file, file,
"_category_\t_incremental?_\t_iframe?_\t_url_\t_mean (ms)_\t\ "_category_\t_incremental?_\t_iframe?_\t_url_\t_mean (ms)_\t\
_median (ms)_\t_min (ms)_\t_max (ms)_\t_events_\n" _median (ms)_\t_min (ms)_\t_max (ms)_\t_events_\n"
).unwrap(); )
.unwrap();
for (&(ref category, ref meta), ref mut data) in &mut self.buckets { for (&(ref category, ref meta), ref mut data) in &mut self.buckets {
data.sort_by(|a, b| a.partial_cmp(b).expect("No NaN values in profiles")); data.sort_by(|a, b| a.partial_cmp(b).expect("No NaN values in profiles"));
let data_len = data.len(); let data_len = data.len();
@ -397,7 +405,8 @@ impl Profiler {
min, min,
max, max,
data_len data_len
).unwrap(); )
.unwrap();
} }
} }
}, },
@ -417,7 +426,8 @@ impl Profiler {
" _min (ms)_", " _min (ms)_",
" _max (ms)_", " _max (ms)_",
" _events_" " _events_"
).unwrap(); )
.unwrap();
for (&(ref category, ref meta), ref mut data) in &mut self.buckets { for (&(ref category, ref meta), ref mut data) in &mut self.buckets {
data.sort_by(|a, b| a.partial_cmp(b).expect("No NaN values in profiles")); data.sort_by(|a, b| a.partial_cmp(b).expect("No NaN values in profiles"));
let data_len = data.len(); let data_len = data.len();
@ -433,7 +443,8 @@ impl Profiler {
min, min,
max, max,
data_len data_len
).unwrap(); )
.unwrap();
} }
} }
writeln!(&mut lock, "").unwrap(); writeln!(&mut lock, "").unwrap();
@ -473,8 +484,9 @@ impl Profiler {
measurement.add_tag("host", meta.url.as_str()); measurement.add_tag("host", meta.url.as_str());
}; };
tokio::run(client.write_one(measurement, None) tokio::run(client.write_one(measurement, None).map_err(|e| {
.map_err(|e| warn!("Could not write measurement to profiler db: {:?}", e))); warn!("Could not write measurement to profiler db: {:?}", e)
}));
} }
} }
}, },

9
components/profile_traits/ipc.rs
View file

@ -54,14 +54,12 @@ where
Ok((ipc_sender, profiled_ipc_receiver)) Ok((ipc_sender, profiled_ipc_receiver))
} }
pub struct IpcBytesReceiver pub struct IpcBytesReceiver {
{
ipc_bytes_receiver: ipc::IpcBytesReceiver, ipc_bytes_receiver: ipc::IpcBytesReceiver,
time_profile_chan: ProfilerChan, time_profile_chan: ProfilerChan,
} }
impl IpcBytesReceiver impl IpcBytesReceiver {
{
pub fn recv(&self) -> Result<Vec<u8>, bincode::Error> { pub fn recv(&self) -> Result<Vec<u8>, bincode::Error> {
time::profile( time::profile(
ProfilerCategory::IpcBytesReceiver, ProfilerCategory::IpcBytesReceiver,
@ -74,8 +72,7 @@ impl IpcBytesReceiver
pub fn bytes_channel( pub fn bytes_channel(
time_profile_chan: ProfilerChan, time_profile_chan: ProfilerChan,
) -> Result<(ipc::IpcBytesSender, IpcBytesReceiver), Error> ) -> Result<(ipc::IpcBytesSender, IpcBytesReceiver), Error> {
{
let (ipc_bytes_sender, ipc_bytes_receiver) = ipc::bytes_channel()?; let (ipc_bytes_sender, ipc_bytes_receiver) = ipc::bytes_channel()?;
let profiled_ipc_bytes_receiver = IpcBytesReceiver { let profiled_ipc_bytes_receiver = IpcBytesReceiver {
ipc_bytes_receiver, ipc_bytes_receiver,

3
components/profile_traits/mem.rs
View file

@ -174,7 +174,8 @@ impl Reporter {
self.0 self.0
.send(ReporterRequest { .send(ReporterRequest {
reports_channel: reports_chan, reports_channel: reports_chan,
}).unwrap() })
.unwrap()
} }
} }

6
components/remutex/tests/smoke.rs
View file

@ -60,7 +60,8 @@ fn trylock_works() {
thread::spawn(move || { thread::spawn(move || {
let lock = m2.try_lock(); let lock = m2.try_lock();
assert!(lock.is_err()); assert!(lock.is_err());
}).join() })
.join()
.unwrap(); .unwrap();
let _lock3 = m.try_lock().unwrap(); let _lock3 = m.try_lock().unwrap();
} }
@ -84,7 +85,8 @@ fn poison_works() {
let _answer = Answer(lock2); let _answer = Answer(lock2);
println!("Intentionally panicking."); println!("Intentionally panicking.");
panic!("What the answer to my lifetimes dilemma is?"); panic!("What the answer to my lifetimes dilemma is?");
}).join(); })
.join();
assert!(result.is_err()); assert!(result.is_err());
let r = m.lock().err().unwrap().into_inner(); let r = m.lock().err().unwrap().into_inner();
assert_eq!(*r.borrow(), 42); assert_eq!(*r.borrow(), 42);

5
components/script/body.rs
View file

@ -175,8 +175,9 @@ fn run_form_data_algorithm(
} else { } else {
"" ""
}; };
let mime: Mime = mime_str.parse().map_err( let mime: Mime = mime_str
|_| Error::Type("Inappropriate MIME-type for Body".to_string()))?; .parse()
.map_err(|_| Error::Type("Inappropriate MIME-type for Body".to_string()))?;
// TODO // TODO
// ... Parser for Mime(TopLevel::Multipart, SubLevel::FormData, _) // ... Parser for Mime(TopLevel::Multipart, SubLevel::FormData, _)

3
components/script/build.rs
View file

@ -69,7 +69,8 @@ fn main() {
write!( write!(
&mut phf, &mut phf,
"pub static MAP: phf::Map<&'static [u8], unsafe fn(*mut JSContext, HandleObject)> = " "pub static MAP: phf::Map<&'static [u8], unsafe fn(*mut JSContext, HandleObject)> = "
).unwrap(); )
.unwrap();
map.build(&mut phf).unwrap(); map.build(&mut phf).unwrap();
write!(&mut phf, ";\n").unwrap(); write!(&mut phf, ";\n").unwrap();
} }

3
components/script/devtools.rs
View file

@ -172,7 +172,8 @@ pub fn handle_get_layout(
paddingLeft: String::from(computed_style.PaddingLeft()), paddingLeft: String::from(computed_style.PaddingLeft()),
width: width, width: width,
height: height, height: height,
})).unwrap(); }))
.unwrap();
} }
fn determine_auto_margins(window: &Window, node: &Node) -> AutoMargins { fn determine_auto_margins(window: &Window, node: &Node) -> AutoMargins {

3
components/script/document_loader.rs
View file

@ -153,7 +153,8 @@ impl DocumentLoader {
.send(CoreResourceMsg::Fetch( .send(CoreResourceMsg::Fetch(
request, request,
FetchChannels::ResponseMsg(fetch_target, Some(cancel_receiver)), FetchChannels::ResponseMsg(fetch_target, Some(cancel_receiver)),
)).unwrap(); ))
.unwrap();
} }
/// Mark an in-progress network request complete. /// Mark an in-progress network request complete.

69
components/script/dom/analysernode.rs
View file

@ -37,17 +37,20 @@ impl AnalyserNode {
context: &BaseAudioContext, context: &BaseAudioContext,
options: &AnalyserOptions, options: &AnalyserOptions,
) -> Fallible<(AnalyserNode, IpcReceiver<Block>)> { ) -> Fallible<(AnalyserNode, IpcReceiver<Block>)> {
let node_options = options.parent let node_options =
.unwrap_or(2, ChannelCountMode::Max, options
ChannelInterpretation::Speakers); .parent
.unwrap_or(2, ChannelCountMode::Max, ChannelInterpretation::Speakers);
if options.fftSize > 32768 || options.fftSize < 32 || if options.fftSize > 32768 ||
(options.fftSize & (options.fftSize - 1) != 0) { options.fftSize < 32 ||
return Err(Error::IndexSize) (options.fftSize & (options.fftSize - 1) != 0)
{
return Err(Error::IndexSize);
} }
if *options.maxDecibels <= *options.minDecibels { if *options.maxDecibels <= *options.minDecibels {
return Err(Error::IndexSize) return Err(Error::IndexSize);
} }
if *options.smoothingTimeConstant < 0. || *options.smoothingTimeConstant > 1. { if *options.smoothingTimeConstant < 0. || *options.smoothingTimeConstant > 1. {
@ -67,14 +70,19 @@ impl AnalyserNode {
1, // outputs 1, // outputs
)?; )?;
let engine = AnalysisEngine::new(
let engine = AnalysisEngine::new(options.fftSize as usize, options.fftSize as usize,
*options.smoothingTimeConstant, *options.smoothingTimeConstant,
*options.minDecibels, *options.maxDecibels); *options.minDecibels,
Ok((AnalyserNode { *options.maxDecibels,
node, );
engine: DomRefCell::new(engine) Ok((
}, rcv)) AnalyserNode {
node,
engine: DomRefCell::new(engine),
},
rcv,
))
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
@ -89,13 +97,19 @@ impl AnalyserNode {
let canceller = window.task_canceller(TaskSourceName::DOMManipulation); let canceller = window.task_canceller(TaskSourceName::DOMManipulation);
let this = Trusted::new(&*object); let this = Trusted::new(&*object);
ROUTER.add_route(recv.to_opaque(), Box::new(move |block| { ROUTER.add_route(
let this = this.clone(); recv.to_opaque(),
let _ = source.queue_with_canceller(task!(append_analysis_block: move || { Box::new(move |block| {
let this = this.clone();
let _ = source.queue_with_canceller(
task!(append_analysis_block: move || {
let this = this.root(); let this = this.root();
this.push_block(block.to().unwrap()) this.push_block(block.to().unwrap())
}), &canceller); }),
})); &canceller,
);
}),
);
Ok(object) Ok(object)
} }
@ -130,7 +144,6 @@ impl AnalyserNodeMethods for AnalyserNode {
// run whilst we're writing to it // run whilst we're writing to it
let dest = unsafe { array.as_mut_slice() }; let dest = unsafe { array.as_mut_slice() };
self.engine.borrow_mut().fill_byte_frequency_data(dest); self.engine.borrow_mut().fill_byte_frequency_data(dest);
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
@ -140,7 +153,6 @@ impl AnalyserNodeMethods for AnalyserNode {
// run whilst we're writing to it // run whilst we're writing to it
let dest = unsafe { array.as_mut_slice() }; let dest = unsafe { array.as_mut_slice() };
self.engine.borrow().fill_time_domain_data(dest); self.engine.borrow().fill_time_domain_data(dest);
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
@ -150,14 +162,12 @@ impl AnalyserNodeMethods for AnalyserNode {
// run whilst we're writing to it // run whilst we're writing to it
let dest = unsafe { array.as_mut_slice() }; let dest = unsafe { array.as_mut_slice() };
self.engine.borrow().fill_byte_time_domain_data(dest); self.engine.borrow().fill_byte_time_domain_data(dest);
} }
/// https://webaudio.github.io/web-audio-api/#dom-analysernode-fftsize /// https://webaudio.github.io/web-audio-api/#dom-analysernode-fftsize
fn SetFftSize(&self, value: u32) -> Fallible<()> { fn SetFftSize(&self, value: u32) -> Fallible<()> {
if value > 32768 || value < 32 || if value > 32768 || value < 32 || (value & (value - 1) != 0) {
(value & (value - 1) != 0) { return Err(Error::IndexSize);
return Err(Error::IndexSize)
} }
self.engine.borrow_mut().set_fft_size(value as usize); self.engine.borrow_mut().set_fft_size(value as usize);
Ok(()) Ok(())
@ -181,7 +191,7 @@ impl AnalyserNodeMethods for AnalyserNode {
/// https://webaudio.github.io/web-audio-api/#dom-analysernode-mindecibels /// https://webaudio.github.io/web-audio-api/#dom-analysernode-mindecibels
fn SetMinDecibels(&self, value: Finite<f64>) -> Fallible<()> { fn SetMinDecibels(&self, value: Finite<f64>) -> Fallible<()> {
if *value >= self.engine.borrow().get_max_decibels() { if *value >= self.engine.borrow().get_max_decibels() {
return Err(Error::IndexSize) return Err(Error::IndexSize);
} }
self.engine.borrow_mut().set_min_decibels(*value); self.engine.borrow_mut().set_min_decibels(*value);
Ok(()) Ok(())
@ -195,7 +205,7 @@ impl AnalyserNodeMethods for AnalyserNode {
/// https://webaudio.github.io/web-audio-api/#dom-analysernode-maxdecibels /// https://webaudio.github.io/web-audio-api/#dom-analysernode-maxdecibels
fn SetMaxDecibels(&self, value: Finite<f64>) -> Fallible<()> { fn SetMaxDecibels(&self, value: Finite<f64>) -> Fallible<()> {
if *value <= self.engine.borrow().get_min_decibels() { if *value <= self.engine.borrow().get_min_decibels() {
return Err(Error::IndexSize) return Err(Error::IndexSize);
} }
self.engine.borrow_mut().set_max_decibels(*value); self.engine.borrow_mut().set_max_decibels(*value);
Ok(()) Ok(())
@ -209,10 +219,9 @@ impl AnalyserNodeMethods for AnalyserNode {
/// https://webaudio.github.io/web-audio-api/#dom-analysernode-smoothingtimeconstant /// https://webaudio.github.io/web-audio-api/#dom-analysernode-smoothingtimeconstant
fn SetSmoothingTimeConstant(&self, value: Finite<f64>) -> Fallible<()> { fn SetSmoothingTimeConstant(&self, value: Finite<f64>) -> Fallible<()> {
if *value < 0. || *value > 1. { if *value < 0. || *value > 1. {
return Err(Error::IndexSize) return Err(Error::IndexSize);
} }
self.engine.borrow_mut().set_smoothing_constant(*value); self.engine.borrow_mut().set_smoothing_constant(*value);
Ok(()) Ok(())
} }
} }

20
components/script/dom/audiobuffer.rs
View file

@ -110,10 +110,8 @@ impl AudioBuffer {
// Initialize the underlying channels data with initial data provided by // Initialize the underlying channels data with initial data provided by
// the user or silence otherwise. // the user or silence otherwise.
fn set_initial_data(&self, initial_data: Option<&[Vec<f32>]>) { fn set_initial_data(&self, initial_data: Option<&[Vec<f32>]>) {
let mut channels = ServoMediaAudioBuffer::new( let mut channels =
self.number_of_channels as u8, ServoMediaAudioBuffer::new(self.number_of_channels as u8, self.length as usize);
self.length as usize,
);
for channel in 0..self.number_of_channels { for channel in 0..self.number_of_channels {
channels.buffers[channel as usize] = match initial_data { channels.buffers[channel as usize] = match initial_data {
Some(data) => data[channel as usize].clone(), Some(data) => data[channel as usize].clone(),
@ -143,7 +141,8 @@ impl AudioBuffer {
cx, cx,
CreateWith::Slice(&shared_channels.buffers[i]), CreateWith::Slice(&shared_channels.buffers[i]),
array.handle_mut(), array.handle_mut(),
).is_err() )
.is_err()
{ {
return false; return false;
} }
@ -159,10 +158,8 @@ impl AudioBuffer {
// https://webaudio.github.io/web-audio-api/#acquire-the-content // https://webaudio.github.io/web-audio-api/#acquire-the-content
#[allow(unsafe_code)] #[allow(unsafe_code)]
fn acquire_contents(&self) -> Option<ServoMediaAudioBuffer> { fn acquire_contents(&self) -> Option<ServoMediaAudioBuffer> {
let mut result = ServoMediaAudioBuffer::new( let mut result =
self.number_of_channels as u8, ServoMediaAudioBuffer::new(self.number_of_channels as u8, self.length as usize);
self.length as usize,
);
let cx = self.global().get_cx(); let cx = self.global().get_cx();
for (i, channel) in self.js_channels.borrow_mut().iter().enumerate() { for (i, channel) in self.js_channels.borrow_mut().iter().enumerate() {
// Step 1. // Step 1.
@ -203,7 +200,7 @@ impl AudioBuffer {
*self.shared_channels.borrow_mut() = channels; *self.shared_channels.borrow_mut() = channels;
} }
} }
return self.shared_channels.borrow() return self.shared_channels.borrow();
} }
} }
@ -324,7 +321,8 @@ impl AudioBufferMethods for AudioBuffer {
let js_channel_data = unsafe { js_channel.as_mut_slice() }; let js_channel_data = unsafe { js_channel.as_mut_slice() };
let (_, js_channel_data) = js_channel_data.split_at_mut(start_in_channel as usize); let (_, js_channel_data) = js_channel_data.split_at_mut(start_in_channel as usize);
unsafe { unsafe {
js_channel_data[0..bytes_to_copy].copy_from_slice(&source.as_slice()[0..bytes_to_copy]) js_channel_data[0..bytes_to_copy]
.copy_from_slice(&source.as_slice()[0..bytes_to_copy])
}; };
} else { } else {
return Err(Error::IndexSize); return Err(Error::IndexSize);

18
components/script/dom/baseaudiocontext.rs
View file

@ -348,7 +348,11 @@ impl BaseAudioContextMethods for BaseAudioContext {
/// https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createbiquadfilter /// https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createbiquadfilter
fn CreateBiquadFilter(&self) -> Fallible<DomRoot<BiquadFilterNode>> { fn CreateBiquadFilter(&self) -> Fallible<DomRoot<BiquadFilterNode>> {
BiquadFilterNode::new(&self.global().as_window(), &self, &BiquadFilterOptions::empty()) BiquadFilterNode::new(
&self.global().as_window(),
&self,
&BiquadFilterOptions::empty(),
)
} }
/// https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createchannelmerger /// https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createchannelmerger
@ -432,10 +436,12 @@ impl BaseAudioContextMethods for BaseAudioContext {
.lock() .lock()
.unwrap() .unwrap()
.resize(channel_count as usize, Vec::new()); .resize(channel_count as usize, Vec::new());
}).progress(move |buffer, channel| { })
.progress(move |buffer, channel| {
let mut decoded_audio = decoded_audio_.lock().unwrap(); let mut decoded_audio = decoded_audio_.lock().unwrap();
decoded_audio[(channel - 1) as usize].extend_from_slice((*buffer).as_ref()); decoded_audio[(channel - 1) as usize].extend_from_slice((*buffer).as_ref());
}).eos(move || { })
.eos(move || {
let _ = task_source.queue_with_canceller( let _ = task_source.queue_with_canceller(
task!(audio_decode_eos: move || { task!(audio_decode_eos: move || {
let this = this.root(); let this = this.root();
@ -461,7 +467,8 @@ impl BaseAudioContextMethods for BaseAudioContext {
}), }),
&canceller, &canceller,
); );
}).error(move |error| { })
.error(move |error| {
let _ = task_source_.queue_with_canceller( let _ = task_source_.queue_with_canceller(
task!(audio_decode_eos: move || { task!(audio_decode_eos: move || {
let this = this_.root(); let this = this_.root();
@ -478,7 +485,8 @@ impl BaseAudioContextMethods for BaseAudioContext {
}), }),
&canceller_, &canceller_,
); );
}).build(); })
.build();
self.audio_context_impl self.audio_context_impl
.decode_audio_data(audio_data, callbacks); .decode_audio_data(audio_data, callbacks);
} else { } else {

3
components/script/dom/bindings/settings_stack.rs
View file

@ -94,7 +94,8 @@ pub fn entry_global() -> DomRoot<GlobalScope> {
.rev() .rev()
.find(|entry| entry.kind == StackEntryKind::Entry) .find(|entry| entry.kind == StackEntryKind::Entry)
.map(|entry| DomRoot::from_ref(&*entry.global)) .map(|entry| DomRoot::from_ref(&*entry.global))
}).unwrap() })
.unwrap()
} }
/// RAII struct that pushes and pops entries from the script settings stack. /// RAII struct that pushes and pops entries from the script settings stack.

2
components/script/dom/bindings/trace.rs
View file

@ -457,7 +457,7 @@ unsafe_no_jsmanaged_fields!(AudioBuffer);
unsafe_no_jsmanaged_fields!(AudioContext<Backend>); unsafe_no_jsmanaged_fields!(AudioContext<Backend>);
unsafe_no_jsmanaged_fields!(NodeId); unsafe_no_jsmanaged_fields!(NodeId);
unsafe_no_jsmanaged_fields!(AnalysisEngine, DistanceModel, PanningModel, ParamType); unsafe_no_jsmanaged_fields!(AnalysisEngine, DistanceModel, PanningModel, ParamType);
unsafe_no_jsmanaged_fields!(Player<Error=ServoMediaError>); unsafe_no_jsmanaged_fields!(Player<Error = ServoMediaError>);
unsafe_no_jsmanaged_fields!(Mutex<MediaFrameRenderer>); unsafe_no_jsmanaged_fields!(Mutex<MediaFrameRenderer>);
unsafe_no_jsmanaged_fields!(RenderApiSender); unsafe_no_jsmanaged_fields!(RenderApiSender);

2
components/script/dom/bindings/utils.rs
View file

@ -178,7 +178,7 @@ pub fn get_array_index_from_id(_cx: *mut JSContext, id: HandleId) -> Option<u32>
if s > 'a' && s < 'z' { if s > 'a' && s < 'z' {
return -1; return -1;
} }
let i = 0; let i = 0;
let str = AtomToLinearString(JSID_TO_ATOM(id)); let str = AtomToLinearString(JSID_TO_ATOM(id));
return if StringIsArray(str, &mut i) != 0 { i } else { -1 } return if StringIsArray(str, &mut i) != 0 { i } else { -1 }

46
components/script/dom/biquadfilternode.rs
View file

@ -39,9 +39,10 @@ impl BiquadFilterNode {
context: &BaseAudioContext, context: &BaseAudioContext,
options: &BiquadFilterOptions, options: &BiquadFilterOptions,
) -> Fallible<BiquadFilterNode> { ) -> Fallible<BiquadFilterNode> {
let node_options = options.parent let node_options =
.unwrap_or(2, ChannelCountMode::Max, options
ChannelInterpretation::Speakers); .parent
.unwrap_or(2, ChannelCountMode::Max, ChannelInterpretation::Speakers);
let filter = Cell::new(options.type_); let filter = Cell::new(options.type_);
let options = options.into(); let options = options.into();
let node = AudioNode::new_inherited( let node = AudioNode::new_inherited(
@ -57,9 +58,9 @@ impl BiquadFilterNode {
node.node_id(), node.node_id(),
ParamType::Gain, ParamType::Gain,
AutomationRate::A_rate, AutomationRate::A_rate,
options.gain, // default value options.gain, // default value
f32::MIN, // min value f32::MIN, // min value
f32::MAX, // max value f32::MAX, // max value
); );
let q = AudioParam::new( let q = AudioParam::new(
window, window,
@ -67,9 +68,9 @@ impl BiquadFilterNode {
node.node_id(), node.node_id(),
ParamType::Q, ParamType::Q,
AutomationRate::A_rate, AutomationRate::A_rate,
options.q, // default value options.q, // default value
f32::MIN, // min value f32::MIN, // min value
f32::MAX, // max value f32::MAX, // max value
); );
let frequency = AudioParam::new( let frequency = AudioParam::new(
window, window,
@ -77,9 +78,9 @@ impl BiquadFilterNode {
node.node_id(), node.node_id(),
ParamType::Frequency, ParamType::Frequency,
AutomationRate::A_rate, AutomationRate::A_rate,
options.frequency, // default value options.frequency, // default value
f32::MIN, // min value f32::MIN, // min value
f32::MAX, // max value f32::MAX, // max value
); );
let detune = AudioParam::new( let detune = AudioParam::new(
window, window,
@ -87,9 +88,9 @@ impl BiquadFilterNode {
node.node_id(), node.node_id(),
ParamType::Detune, ParamType::Detune,
AutomationRate::A_rate, AutomationRate::A_rate,
options.detune, // default value options.detune, // default value
f32::MIN, // min value f32::MIN, // min value
f32::MAX, // max value f32::MAX, // max value
); );
Ok(BiquadFilterNode { Ok(BiquadFilterNode {
node, node,
@ -108,7 +109,11 @@ impl BiquadFilterNode {
options: &BiquadFilterOptions, options: &BiquadFilterOptions,
) -> Fallible<DomRoot<BiquadFilterNode>> { ) -> Fallible<DomRoot<BiquadFilterNode>> {
let node = BiquadFilterNode::new_inherited(window, context, options)?; let node = BiquadFilterNode::new_inherited(window, context, options)?;
Ok(reflect_dom_object(Box::new(node), window, BiquadFilterNodeBinding::Wrap)) Ok(reflect_dom_object(
Box::new(node),
window,
BiquadFilterNodeBinding::Wrap,
))
} }
pub fn Constructor( pub fn Constructor(
@ -149,10 +154,9 @@ impl BiquadFilterNodeMethods for BiquadFilterNode {
// https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-type // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-type
fn SetType(&self, filter: BiquadFilterType) { fn SetType(&self, filter: BiquadFilterType) {
self.filter.set(filter); self.filter.set(filter);
self.node self.node.message(AudioNodeMessage::BiquadFilterNode(
.message(AudioNodeMessage::BiquadFilterNode( BiquadFilterNodeMessage::SetFilterType(filter.into()),
BiquadFilterNodeMessage::SetFilterType(filter.into()), ));
));
} }
} }
@ -163,7 +167,7 @@ impl<'a> From<&'a BiquadFilterOptions> for BiquadFilterNodeOptions {
q: *options.Q, q: *options.Q,
frequency: *options.frequency, frequency: *options.frequency,
detune: *options.detune, detune: *options.detune,
filter: options.type_.into() filter: options.type_.into(),
} }
} }
} }

6
components/script/dom/bluetooth.rs
View file

@ -334,7 +334,8 @@ where
single, single,
child_type, child_type,
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }
@ -694,7 +695,8 @@ impl PermissionAlgorithm for Bluetooth {
device_id.clone(), device_id.clone(),
BluetoothScanfilterSequence::new(scan_filters), BluetoothScanfilterSequence::new(scan_filters),
sender, sender,
)).unwrap(); ))
.unwrap();
match receiver.recv().unwrap() { match receiver.recv().unwrap() {
Ok(true) => (), Ok(true) => (),

9
components/script/dom/bluetoothdevice.rs
View file

@ -152,7 +152,8 @@ impl BluetoothDevice {
.send(BluetoothRequest::IsRepresentedDeviceNull( .send(BluetoothRequest::IsRepresentedDeviceNull(
self.Id().to_string(), self.Id().to_string(),
sender, sender,
)).unwrap(); ))
.unwrap();
receiver.recv().unwrap() receiver.recv().unwrap()
} }
@ -242,7 +243,8 @@ impl BluetoothDevice {
.send(BluetoothRequest::GATTServerDisconnect( .send(BluetoothRequest::GATTServerDisconnect(
String::from(self.Id()), String::from(self.Id()),
sender, sender,
)).unwrap(); ))
.unwrap();
receiver.recv().unwrap().map_err(Error::from) receiver.recv().unwrap().map_err(Error::from)
} }
} }
@ -286,7 +288,8 @@ impl BluetoothDeviceMethods for BluetoothDevice {
.send(BluetoothRequest::WatchAdvertisements( .send(BluetoothRequest::WatchAdvertisements(
String::from(self.Id()), String::from(self.Id()),
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }

9
components/script/dom/bluetoothremotegattcharacteristic.rs
View file

@ -216,7 +216,8 @@ impl BluetoothRemoteGATTCharacteristicMethods for BluetoothRemoteGATTCharacteris
self.get_instance_id(), self.get_instance_id(),
vec, vec,
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }
@ -253,7 +254,8 @@ impl BluetoothRemoteGATTCharacteristicMethods for BluetoothRemoteGATTCharacteris
self.get_instance_id(), self.get_instance_id(),
true, true,
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }
@ -272,7 +274,8 @@ impl BluetoothRemoteGATTCharacteristicMethods for BluetoothRemoteGATTCharacteris
self.get_instance_id(), self.get_instance_id(),
false, false,
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }

3
components/script/dom/bluetoothremotegattdescriptor.rs
View file

@ -166,7 +166,8 @@ impl BluetoothRemoteGATTDescriptorMethods for BluetoothRemoteGATTDescriptor {
self.get_instance_id(), self.get_instance_id(),
vec, vec,
sender, sender,
)).unwrap(); ))
.unwrap();
return p; return p;
} }
} }

3
components/script/dom/bluetoothremotegattserver.rs
View file

@ -87,7 +87,8 @@ impl BluetoothRemoteGATTServerMethods for BluetoothRemoteGATTServer {
.send(BluetoothRequest::GATTServerConnect( .send(BluetoothRequest::GATTServerConnect(
String::from(self.Device().Id()), String::from(self.Device().Id()),
sender, sender,
)).unwrap(); ))
.unwrap();
// Step 5: return promise. // Step 5: return promise.
return p; return p;
} }

42
components/script/dom/canvasrenderingcontext2d.rs
View file

@ -266,7 +266,7 @@ impl CanvasRenderingContext2D {
CanvasImageSource::HTMLCanvasElement(canvas) => canvas.origin_is_clean(), CanvasImageSource::HTMLCanvasElement(canvas) => canvas.origin_is_clean(),
CanvasImageSource::HTMLImageElement(image) => { CanvasImageSource::HTMLImageElement(image) => {
image.same_origin(GlobalScope::entry().origin()) image.same_origin(GlobalScope::entry().origin())
} },
CanvasImageSource::CSSStyleValue(_) => true, CanvasImageSource::CSSStyleValue(_) => true,
} }
} }
@ -403,8 +403,7 @@ impl CanvasRenderingContext2D {
dh: Option<f64>, dh: Option<f64>,
) -> ErrorResult { ) -> ErrorResult {
debug!("Fetching image {}.", url); debug!("Fetching image {}.", url);
let (mut image_data, image_size) = let (mut image_data, image_size) = self.fetch_image_data(url).ok_or(Error::InvalidState)?;
self.fetch_image_data(url).ok_or(Error::InvalidState)?;
pixels::premultiply_inplace(&mut image_data); pixels::premultiply_inplace(&mut image_data);
let image_size = image_size.to_f64(); let image_size = image_size.to_f64();
@ -558,7 +557,10 @@ impl CanvasRenderingContext2D {
// FIXME(nox): This is probably wrong when this is a context for an // FIXME(nox): This is probably wrong when this is a context for an
// offscreen canvas. // offscreen canvas.
let canvas_size = self.canvas.as_ref().map_or(Size2D::zero(), |c| c.get_size()); let canvas_size = self
.canvas
.as_ref()
.map_or(Size2D::zero(), |c| c.get_size());
assert!(Rect::from_size(canvas_size).contains_rect(&rect)); assert!(Rect::from_size(canvas_size).contains_rect(&rect));
let (sender, receiver) = ipc::bytes_channel().unwrap(); let (sender, receiver) = ipc::bytes_channel().unwrap();
@ -1144,7 +1146,10 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
let (origin, size) = adjust_size_sign(Point2D::new(sx, sy), Size2D::new(sw, sh)); let (origin, size) = adjust_size_sign(Point2D::new(sx, sy), Size2D::new(sw, sh));
// FIXME(nox): This is probably wrong when this is a context for an // FIXME(nox): This is probably wrong when this is a context for an
// offscreen canvas. // offscreen canvas.
let canvas_size = self.canvas.as_ref().map_or(Size2D::zero(), |c| c.get_size()); let canvas_size = self
.canvas
.as_ref()
.map_or(Size2D::zero(), |c| c.get_size());
let read_rect = match pixels::clip(origin, size, canvas_size) { let read_rect = match pixels::clip(origin, size, canvas_size) {
Some(rect) => rect, Some(rect) => rect,
None => { None => {
@ -1153,12 +1158,25 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
}, },
}; };
ImageData::new(&self.global(), size.width, size.height, Some(self.get_rect(read_rect))) ImageData::new(
&self.global(),
size.width,
size.height,
Some(self.get_rect(read_rect)),
)
} }
// https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
fn PutImageData(&self, imagedata: &ImageData, dx: i32, dy: i32) { fn PutImageData(&self, imagedata: &ImageData, dx: i32, dy: i32) {
self.PutImageData_(imagedata, dx, dy, 0, 0, imagedata.Width() as i32, imagedata.Height() as i32) self.PutImageData_(
imagedata,
dx,
dy,
0,
0,
imagedata.Width() as i32,
imagedata.Height() as i32,
)
} }
// https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
@ -1176,7 +1194,6 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
// FIXME(nox): There are many arithmetic operations here that can // FIXME(nox): There are many arithmetic operations here that can
// overflow or underflow, this should probably be audited. // overflow or underflow, this should probably be audited.
let imagedata_size = Size2D::new(imagedata.Width(), imagedata.Height()); let imagedata_size = Size2D::new(imagedata.Width(), imagedata.Height());
if imagedata_size.area() == 0 { if imagedata_size.area() == 0 {
return; return;
@ -1190,7 +1207,10 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
// FIXME(nox): This is probably wrong when this is a context for an // FIXME(nox): This is probably wrong when this is a context for an
// offscreen canvas. // offscreen canvas.
let canvas_size = self.canvas.as_ref().map_or(Size2D::zero(), |c| c.get_size()); let canvas_size = self
.canvas
.as_ref()
.map_or(Size2D::zero(), |c| c.get_size());
// Steps 3-6. // Steps 3-6.
let (src_origin, src_size) = adjust_size_sign( let (src_origin, src_size) = adjust_size_sign(
@ -1214,9 +1234,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
// Step 7. // Step 7.
let (sender, receiver) = ipc::bytes_channel().unwrap(); let (sender, receiver) = ipc::bytes_channel().unwrap();
let pixels = unsafe { let pixels = unsafe { &imagedata.get_rect(Rect::new(src_rect.origin, dst_rect.size)) };
&imagedata.get_rect(Rect::new(src_rect.origin, dst_rect.size))
};
self.send_canvas_2d_msg(Canvas2dMsg::PutImageData(dst_rect, receiver)); self.send_canvas_2d_msg(Canvas2dMsg::PutImageData(dst_rect, receiver));
sender.send(pixels).unwrap(); sender.send(pixels).unwrap();
self.mark_as_dirty(); self.mark_as_dirty();

3
components/script/dom/cssstyledeclaration.rs
View file

@ -157,7 +157,8 @@ impl CSSStyleOwner {
.style_stylesheet() .style_stylesheet()
.contents .contents
.url_data .url_data
.read()).clone(), .read())
.clone(),
} }
} }
} }

15
components/script/dom/csssupportsrule.rs
View file

@ -82,14 +82,13 @@ impl CSSSupportsRule {
None, None,
); );
let enabled = { let enabled = {
let namespaces = let namespaces = self
self .cssconditionrule
.cssconditionrule .parent_stylesheet()
.parent_stylesheet() .style_stylesheet()
.style_stylesheet() .contents
.contents .namespaces
.namespaces .read();
.read();
cond.eval(&context, &namespaces) cond.eval(&context, &namespaces)
}; };
let mut guard = self.cssconditionrule.shared_lock().write(); let mut guard = self.cssconditionrule.shared_lock().write();

3
components/script/dom/customelementregistry.rs
View file

@ -97,7 +97,8 @@ impl CustomElementRegistry {
// Step 4-5 // Step 4-5
definition.local_name == *local_name && definition.local_name == *local_name &&
(definition.name == *local_name || Some(&definition.name) == is) (definition.name == *local_name || Some(&definition.name) == is)
}).cloned() })
.cloned()
} }
pub fn lookup_definition_by_constructor( pub fn lookup_definition_by_constructor(

12
components/script/dom/dedicatedworkerglobalscope.rs
View file

@ -318,7 +318,8 @@ impl DedicatedWorkerGlobalScope {
Box::new(SimpleWorkerErrorHandler::new(worker)), Box::new(SimpleWorkerErrorHandler::new(worker)),
pipeline_id, pipeline_id,
TaskSourceName::DOMManipulation, TaskSourceName::DOMManipulation,
)).unwrap(); ))
.unwrap();
return; return;
}, },
Ok((metadata, bytes)) => (metadata, bytes), Ok((metadata, bytes)) => (metadata, bytes),
@ -391,7 +392,8 @@ impl DedicatedWorkerGlobalScope {
parent_sender, parent_sender,
CommonScriptMsg::CollectReports, CommonScriptMsg::CollectReports,
); );
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
} }
pub fn script_chan(&self) -> Box<ScriptChan + Send> { pub fn script_chan(&self) -> Box<ScriptChan + Send> {
@ -495,7 +497,8 @@ impl DedicatedWorkerGlobalScope {
task, task,
Some(pipeline_id), Some(pipeline_id),
TaskSourceName::DOMManipulation, TaskSourceName::DOMManipulation,
)).unwrap(); ))
.unwrap();
} }
} }
@ -526,7 +529,8 @@ impl DedicatedWorkerGlobalScopeMethods for DedicatedWorkerGlobalScope {
task, task,
Some(pipeline_id), Some(pipeline_id),
TaskSourceName::DOMManipulation, TaskSourceName::DOMManipulation,
)).unwrap(); ))
.unwrap();
Ok(()) Ok(())
} }

65
components/script/dom/document.rs
View file

@ -539,7 +539,8 @@ impl Document {
); );
}), }),
self.window.upcast(), self.window.upcast(),
).unwrap(); )
.unwrap();
} }
} else { } else {
self.window().suspend(); self.window().suspend();
@ -1904,7 +1905,8 @@ impl Document {
} }
}), }),
self.window.upcast(), self.window.upcast(),
).unwrap(); )
.unwrap();
// Step 8. // Step 8.
let document = Trusted::new(self); let document = Trusted::new(self);
@ -1938,7 +1940,8 @@ impl Document {
); );
}), }),
self.window.upcast(), self.window.upcast(),
).unwrap(); )
.unwrap();
} }
// Step 9. // Step 9.
@ -2780,14 +2783,16 @@ impl Document {
owner owner
.upcast::<Node>() .upcast::<Node>()
.is_before(sheet_in_doc.owner.upcast()) .is_before(sheet_in_doc.owner.upcast())
}).cloned(); })
.cloned();
self.window() self.window()
.layout_chan() .layout_chan()
.send(Msg::AddStylesheet( .send(Msg::AddStylesheet(
sheet.clone(), sheet.clone(),
insertion_point.as_ref().map(|s| s.sheet.clone()), insertion_point.as_ref().map(|s| s.sheet.clone()),
)).unwrap(); ))
.unwrap();
let sheet = StyleSheetInDocument { let sheet = StyleSheetInDocument {
sheet, sheet,
@ -3621,7 +3626,8 @@ impl DocumentMethods for Document {
.child_elements() .child_elements()
.find(|node| { .find(|node| {
node.namespace() == &ns!(svg) && node.local_name() == &local_name!("title") node.namespace() == &ns!(svg) && node.local_name() == &local_name!("title")
}).map(DomRoot::upcast::<Node>) })
.map(DomRoot::upcast::<Node>)
} else { } else {
// Step 2. // Step 2.
root.upcast::<Node>() root.upcast::<Node>()
@ -3726,7 +3732,8 @@ impl DocumentMethods for Document {
HTMLElementTypeId::HTMLFrameSetElement, HTMLElementTypeId::HTMLFrameSetElement,
)) => true, )) => true,
_ => false, _ => false,
}).map(|node| DomRoot::downcast(node).unwrap()) })
.map(|node| DomRoot::downcast(node).unwrap())
}) })
} }
@ -3947,16 +3954,18 @@ impl DocumentMethods for Document {
return Err(Error::Security); return Err(Error::Security);
} }
let cookies = if let Some(cookie) = cookie_rs::Cookie::parse(cookie.to_string()).ok().map(Serde) { let cookies =
vec![cookie] if let Some(cookie) = cookie_rs::Cookie::parse(cookie.to_string()).ok().map(Serde) {
} else { vec![cookie]
vec![] } else {
}; vec![]
};
let _ = self.window let _ = self
.upcast::<GlobalScope>() .window
.resource_threads() .upcast::<GlobalScope>()
.send(SetCookiesForUrl(self.url(), cookies, NonHTTP)); .resource_threads()
.send(SetCookiesForUrl(self.url(), cookies, NonHTTP));
Ok(()) Ok(())
} }
@ -4158,7 +4167,8 @@ impl DocumentMethods for Document {
node::from_untrusted_node_address(js_runtime, untrusted_node_address) node::from_untrusted_node_address(js_runtime, untrusted_node_address)
}; };
DomRoot::downcast::<Element>(node) DomRoot::downcast::<Element>(node)
}).collect(); })
.collect();
// Step 4 // Step 4
if let Some(root_element) = self.GetDocumentElement() { if let Some(root_element) = self.GetDocumentElement() {
@ -4172,7 +4182,11 @@ impl DocumentMethods for Document {
} }
// https://html.spec.whatwg.org/multipage/#dom-document-open // https://html.spec.whatwg.org/multipage/#dom-document-open
fn Open(&self, _unused1: Option<DOMString>, _unused2: Option<DOMString>) -> Fallible<DomRoot<Document>> { fn Open(
&self,
_unused1: Option<DOMString>,
_unused2: Option<DOMString>,
) -> Fallible<DomRoot<Document>> {
// Step 1 // Step 1
if !self.is_html_document() { if !self.is_html_document() {
return Err(Error::InvalidState); return Err(Error::InvalidState);
@ -4266,12 +4280,19 @@ impl DocumentMethods for Document {
} }
// https://html.spec.whatwg.org/multipage/#dom-document-open-window // https://html.spec.whatwg.org/multipage/#dom-document-open-window
fn Open_(&self, url: DOMString, target: DOMString, features: DOMString) -> Fallible<DomRoot<WindowProxy>> { fn Open_(
&self,
url: DOMString,
target: DOMString,
features: DOMString,
) -> Fallible<DomRoot<WindowProxy>> {
// WhatWG spec states this should always return a WindowProxy, but the spec for WindowProxy.open states // WhatWG spec states this should always return a WindowProxy, but the spec for WindowProxy.open states
// it optionally returns a WindowProxy. Assume an error if window.open returns none. // it optionally returns a WindowProxy. Assume an error if window.open returns none.
// See https://github.com/whatwg/html/issues/4091 // See https://github.com/whatwg/html/issues/4091
let context = self.browsing_context().ok_or(Error::InvalidAccess)?; let context = self.browsing_context().ok_or(Error::InvalidAccess)?;
context.open(url, target, features).ok_or(Error::InvalidAccess) context
.open(url, target, features)
.ok_or(Error::InvalidAccess)
} }
// https://html.spec.whatwg.org/multipage/#dom-document-write // https://html.spec.whatwg.org/multipage/#dom-document-write
@ -4297,7 +4318,9 @@ impl DocumentMethods for Document {
// Either there is no parser, which means the parsing ended; // Either there is no parser, which means the parsing ended;
// or script nesting level is 0, which means the method was // or script nesting level is 0, which means the method was
// called from outside a parser-executed script. // called from outside a parser-executed script.
if self.is_prompting_or_unloading() || self.ignore_destructive_writes_counter.get() > 0 { if self.is_prompting_or_unloading() ||
self.ignore_destructive_writes_counter.get() > 0
{
// Step 4. // Step 4.
return Ok(()); return Ok(());
} }

6
components/script/dom/dommatrix.rs
View file

@ -295,7 +295,8 @@ impl DOMMatrixMethods for DOMMatrix {
// https://drafts.fxtf.org/geometry-1/#dom-dommatrix-multiplyself // https://drafts.fxtf.org/geometry-1/#dom-dommatrix-multiplyself
fn MultiplySelf(&self, other: &DOMMatrixInit) -> Fallible<DomRoot<DOMMatrix>> { fn MultiplySelf(&self, other: &DOMMatrixInit) -> Fallible<DomRoot<DOMMatrix>> {
// Steps 1-3. // Steps 1-3.
self.upcast::<DOMMatrixReadOnly>().multiply_self(other) self.upcast::<DOMMatrixReadOnly>()
.multiply_self(other)
// Step 4. // Step 4.
.and(Ok(DomRoot::from_ref(&self))) .and(Ok(DomRoot::from_ref(&self)))
} }
@ -303,7 +304,8 @@ impl DOMMatrixMethods for DOMMatrix {
// https://drafts.fxtf.org/geometry-1/#dom-dommatrix-premultiplyself // https://drafts.fxtf.org/geometry-1/#dom-dommatrix-premultiplyself
fn PreMultiplySelf(&self, other: &DOMMatrixInit) -> Fallible<DomRoot<DOMMatrix>> { fn PreMultiplySelf(&self, other: &DOMMatrixInit) -> Fallible<DomRoot<DOMMatrix>> {
// Steps 1-3. // Steps 1-3.
self.upcast::<DOMMatrixReadOnly>().pre_multiply_self(other) self.upcast::<DOMMatrixReadOnly>()
.pre_multiply_self(other)
// Step 4. // Step 4.
.and(Ok(DomRoot::from_ref(&self))) .and(Ok(DomRoot::from_ref(&self)))
} }

16
components/script/dom/element.rs
View file

@ -456,7 +456,8 @@ pub unsafe fn get_attr_for_layout<'a>(
.find(|attr| { .find(|attr| {
let attr = attr.to_layout(); let attr = attr.to_layout();
*name == attr.local_name_atom_forever() && (*attr.unsafe_get()).namespace() == namespace *name == attr.local_name_atom_forever() && (*attr.unsafe_get()).namespace() == namespace
}).map(|attr| attr.to_layout()) })
.map(|attr| attr.to_layout())
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
@ -491,7 +492,8 @@ impl RawLayoutElementHelpers for Element {
} else { } else {
None None
} }
}).collect() })
.collect()
} }
} }
@ -2014,7 +2016,8 @@ impl ElementMethods for Element {
rect.size.width.to_f64_px(), rect.size.width.to_f64_px(),
rect.size.height.to_f64_px(), rect.size.height.to_f64_px(),
) )
}).collect() })
.collect()
} }
// https://drafts.csswg.org/cssom-view/#dom-element-getboundingclientrect // https://drafts.csswg.org/cssom-view/#dom-element-getboundingclientrect
@ -2766,9 +2769,7 @@ impl<'a> SelectorsElement for DomRoot<Element> {
#[allow(unsafe_code)] #[allow(unsafe_code)]
fn opaque(&self) -> ::selectors::OpaqueElement { fn opaque(&self) -> ::selectors::OpaqueElement {
::selectors::OpaqueElement::new(unsafe { ::selectors::OpaqueElement::new(unsafe { &*self.reflector().get_jsobject().get() })
&*self.reflector().get_jsobject().get()
})
} }
fn parent_element(&self) -> Option<DomRoot<Element>> { fn parent_element(&self) -> Option<DomRoot<Element>> {
@ -3102,7 +3103,8 @@ impl Element {
}) })
// TODO: Check meta tags for a pragma-set default language // TODO: Check meta tags for a pragma-set default language
// TODO: Check HTTP Content-Language header // TODO: Check HTTP Content-Language header
}).next() })
.next()
.unwrap_or(String::new()) .unwrap_or(String::new())
} }

31
components/script/dom/eventsource.rs
View file

@ -40,7 +40,6 @@ use std::str::{Chars, FromStr};
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use utf8; use utf8;
const DEFAULT_RECONNECTION_TIME: u64 = 5000; const DEFAULT_RECONNECTION_TIME: u64 = 5000;
#[derive(Clone, Copy, Debug, JSTraceable, MallocSizeOf, PartialEq)] #[derive(Clone, Copy, Debug, JSTraceable, MallocSizeOf, PartialEq)]
@ -179,8 +178,10 @@ impl EventSourceContext {
self.data.push('\n'); self.data.push('\n');
}, },
"id" => mem::swap(&mut self.last_event_id, &mut self.value), "id" => mem::swap(&mut self.last_event_id, &mut self.value),
"retry" => if let Ok(time) = u64::from_str(&self.value) { "retry" => {
self.event_source.root().reconnection_time.set(time); if let Ok(time) = u64::from_str(&self.value) {
self.event_source.root().reconnection_time.set(time);
}
}, },
_ => (), _ => (),
} }
@ -339,13 +340,15 @@ impl FetchResponseListener for EventSourceContext {
match meta.content_type { match meta.content_type {
None => self.fail_the_connection(), None => self.fail_the_connection(),
Some(ct) => { Some(ct) => {
if <ContentType as Into<Mime>>::into(ct.into_inner()) == mime::TEXT_EVENT_STREAM { if <ContentType as Into<Mime>>::into(ct.into_inner()) ==
mime::TEXT_EVENT_STREAM
{
self.origin = meta.final_url.origin().ascii_serialization(); self.origin = meta.final_url.origin().ascii_serialization();
self.announce_the_connection(); self.announce_the_connection();
} else { } else {
self.fail_the_connection() self.fail_the_connection()
} }
} },
} }
}, },
Err(_) => { Err(_) => {
@ -503,7 +506,10 @@ impl EventSource {
}; };
// Step 10 // Step 10
// TODO(eijebong): Replace once typed headers allow it // TODO(eijebong): Replace once typed headers allow it
request.headers.insert(header::ACCEPT, HeaderValue::from_static("text/event-stream")); request.headers.insert(
header::ACCEPT,
HeaderValue::from_static("text/event-stream"),
);
// Step 11 // Step 11
request.cache_mode = CacheMode::NoStore; request.cache_mode = CacheMode::NoStore;
// Step 12 // Step 12
@ -543,7 +549,8 @@ impl EventSource {
.send(CoreResourceMsg::Fetch( .send(CoreResourceMsg::Fetch(
request, request,
FetchChannels::ResponseMsg(action_sender, Some(cancel_receiver)), FetchChannels::ResponseMsg(action_sender, Some(cancel_receiver)),
)).unwrap(); ))
.unwrap();
// Step 13 // Step 13
Ok(ev) Ok(ev)
} }
@ -614,8 +621,11 @@ impl EventSourceTimeoutCallback {
// Step 5.3 // Step 5.3
if !event_source.last_event_id.borrow().is_empty() { if !event_source.last_event_id.borrow().is_empty() {
//TODO(eijebong): Change this once typed header support custom values //TODO(eijebong): Change this once typed header support custom values
request.headers.insert(HeaderName::from_static("last-event-id"), request.headers.insert(
HeaderValue::from_str(&String::from(event_source.last_event_id.borrow().clone())).unwrap()); HeaderName::from_static("last-event-id"),
HeaderValue::from_str(&String::from(event_source.last_event_id.borrow().clone()))
.unwrap(),
);
} }
// Step 5.4 // Step 5.4
global global
@ -623,6 +633,7 @@ impl EventSourceTimeoutCallback {
.send(CoreResourceMsg::Fetch( .send(CoreResourceMsg::Fetch(
request, request,
FetchChannels::ResponseMsg(self.action_sender, None), FetchChannels::ResponseMsg(self.action_sender, None),
)).unwrap(); ))
.unwrap();
} }
} }

3
components/script/dom/eventtarget.rs
View file

@ -302,7 +302,8 @@ impl EventListeners {
} else { } else {
None None
} }
}).collect() })
.collect()
} }
fn has_listeners(&self) -> bool { fn has_listeners(&self) -> bool {

3
components/script/dom/filereader.rs
View file

@ -465,7 +465,8 @@ impl FileReader {
task_source, task_source,
canceller, canceller,
) )
}).expect("Thread spawning failed"); })
.expect("Thread spawning failed");
Ok(()) Ok(())
} }

Some files were not shown because too many files have changed in this diff Show more