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

Auto merge of #22126 - pyfisch:autoformat, r=jdm

Browse source 
Enforce rustfmt on CI

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/22126)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2018-11-07 08:47:57 -05:00 • committed by GitHub
commit da2d9b2228
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
609 changed files with 7934 additions and 5334 deletions
Download patch file Download diff file Expand all files Collapse all files

3
.travis.yml
View file

@ -4,6 +4,9 @@ matrix:
fast_finish: true
include:
- sudo: false
before_install:
- curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain none -y
- source ~/.profile
script:
- ./mach test-tidy --no-progress --all
- ./mach test-tidy --no-progress --self-test

44
components/allocator/lib.rs
View file

@ -23,38 +23,30 @@ mod platform {
/// Memory allocation APIs compatible with libc
pub mod libc_compat {
pub use super::ffi::{malloc, realloc, free};
pub use super::ffi::{free, malloc, realloc};
}
pub struct Allocator;
// The minimum alignment guaranteed by the architecture. This value is used to
// add fast paths for low alignment values.
#[cfg(
all(
any(
target_arch = "arm",
target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc"
)
)
)]
#[cfg(all(any(
target_arch = "arm",
target_arch = "mips",
target_arch = "mipsel",
target_arch = "powerpc"
)))]
const MIN_ALIGN: usize = 8;
#[cfg(
all(
any(
target_arch = "x86",
target_arch = "x86_64",
target_arch = "aarch64",
target_arch = "powerpc64",
target_arch = "powerpc64le",
target_arch = "mips64",
target_arch = "s390x",
target_arch = "sparc64"
)
)
)]
#[cfg(all(any(
target_arch = "x86",
target_arch = "x86_64",
target_arch = "aarch64",
target_arch = "powerpc64",
target_arch = "powerpc64le",
target_arch = "mips64",
target_arch = "s390x",
target_arch = "sparc64"
)))]
const MIN_ALIGN: usize = 16;
fn layout_to_flags(align: usize, size: usize) -> c_int {
@ -106,8 +98,8 @@ mod platform {
mod platform {
extern crate kernel32;
pub use std::alloc::System as Allocator;
use self::kernel32::{GetProcessHeap, HeapSize, HeapValidate};
pub use std::alloc::System as Allocator;
use std::os::raw::c_void;
/// Get the size of a heap block.

2
components/atoms/build.rs
View file

@ -6,7 +6,7 @@ extern crate string_cache_codegen;
use std::env;
use std::fs::File;
use std::io::{BufReader, BufRead};
use std::io::{BufRead, BufReader};
use std::path::Path;
fn main() {

21
components/bluetooth/lib.rs
View file

@ -16,11 +16,13 @@ extern crate uuid;
pub mod test;
use bluetooth_traits::blocklist::{uuid_is_blocklisted, Blocklist};
use bluetooth_traits::scanfilter::{
BluetoothScanfilter, BluetoothScanfilterSequence, RequestDeviceoptions,
};
use bluetooth_traits::{BluetoothCharacteristicMsg, BluetoothDescriptorMsg, BluetoothServiceMsg};
use bluetooth_traits::{BluetoothDeviceMsg, BluetoothRequest, BluetoothResponse, GATTType};
use bluetooth_traits::{BluetoothError, BluetoothResponseResult, BluetoothResult};
use bluetooth_traits::blocklist::{uuid_is_blocklisted, Blocklist};
use bluetooth_traits::scanfilter::{BluetoothScanfilter, BluetoothScanfilterSequence, RequestDeviceoptions};
use device::bluetooth::{BluetoothAdapter, BluetoothDevice, BluetoothGATTCharacteristic};
use device::bluetooth::{BluetoothGATTDescriptor, BluetoothGATTService};
use embedder_traits::{EmbedderMsg, EmbedderProxy};
@ -74,7 +76,8 @@ impl BluetoothThreadFactory for IpcSender<BluetoothRequest> {
BluetoothAdapter::init()
} else {
BluetoothAdapter::init_mock()
}.ok();
}
.ok();
thread::Builder::new()
.name("BluetoothThread".to_owned())
.spawn(move || {
@ -465,8 +468,10 @@ impl BluetoothManager {
};
services.retain(|s| {
!uuid_is_blocklisted(&s.get_uuid().unwrap_or(String::new()), Blocklist::All) &&
self.allowed_services.get(device_id).map_or(false, |uuids| {
!uuid_is_blocklisted(&s.get_uuid().unwrap_or(String::new()), Blocklist::All) && self
.allowed_services
.get(device_id)
.map_or(false, |uuids| {
uuids.contains(&s.get_uuid().unwrap_or(String::new()))
})
});
@ -556,9 +561,9 @@ impl BluetoothManager {
}
fn characteristic_is_cached(&self, characteristic_id: &str) -> bool {
self.cached_characteristics.contains_key(characteristic_id) &&
self.characteristic_to_service
.contains_key(characteristic_id)
self.cached_characteristics.contains_key(characteristic_id) && self
.characteristic_to_service
.contains_key(characteristic_id)
}
// Descriptor

12
components/bluetooth/test.rs
View file

@ -4,10 +4,12 @@
use crate::BluetoothManager;
use device::bluetooth::{BluetoothAdapter, BluetoothDevice};
use device::bluetooth::{BluetoothGATTCharacteristic, BluetoothGATTDescriptor, BluetoothGATTService};
use device::bluetooth::{
BluetoothGATTCharacteristic, BluetoothGATTDescriptor, BluetoothGATTService,
};
use std::borrow::ToOwned;
use std::cell::RefCell;
use std::collections::{HashSet, HashMap};
use std::collections::{HashMap, HashSet};
use std::error::Error;
use std::string::String;
use uuid::Uuid;
@ -294,14 +296,16 @@ fn create_generic_access_service(
NUMBER_OF_DIGITALS_UUID.to_owned(),
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(
&device_name_characteristic,
NUMBER_OF_DIGITALS_UUID.to_owned(),
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
let _characteristic_user_description = create_descriptor_with_value(

437
components/canvas/canvas_data.rs
View file

@ -3,14 +3,16 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use azure::azure::AzFloat;
use azure::azure_hl::SurfacePattern;
use azure::azure_hl::{AntialiasMode, CapStyle, CompositionOp, JoinStyle};
use azure::azure_hl::{BackendType, DrawOptions, DrawTarget, Pattern, StrokeOptions, SurfaceFormat};
use azure::azure_hl::{
BackendType, DrawOptions, DrawTarget, Pattern, StrokeOptions, SurfaceFormat,
};
use azure::azure_hl::{Color, ColorPattern, DrawSurfaceOptions, Filter, PathBuilder};
use azure::azure_hl::{ExtendMode, GradientStop, LinearGradientPattern, RadialGradientPattern};
use azure::azure_hl::SurfacePattern;
use canvas_traits::canvas::*;
use cssparser::RGBA;
use euclid::{Transform2D, Point2D, Vector2D, Rect, Size2D};
use euclid::{Point2D, Rect, Size2D, Transform2D, Vector2D};
use ipc_channel::ipc::IpcSender;
use num_traits::ToPrimitive;
use pixels;
@ -39,7 +41,7 @@ impl<'a> CanvasData<'a> {
size: Size2D<u32>,
webrender_api_sender: webrender_api::RenderApiSender,
antialias: AntialiasMode,
canvas_id: CanvasId
canvas_id: CanvasId,
) -> CanvasData<'a> {
let draw_target = CanvasData::create(size);
let path_builder = draw_target.create_path_builder();
@ -63,7 +65,7 @@ impl<'a> CanvasData<'a> {
image_size: Size2D<f64>,
dest_rect: Rect<f64>,
source_rect: Rect<f64>,
smoothing_enabled: bool
smoothing_enabled: bool,
) {
// We round up the floating pixel values to draw the pixels
let source_rect = source_rect.ceil();
@ -75,14 +77,22 @@ impl<'a> CanvasData<'a> {
};
let writer = |draw_target: &DrawTarget| {
write_image(&draw_target, image_data, source_rect.size, dest_rect,
smoothing_enabled, self.state.draw_options.composition,
self.state.draw_options.alpha);
write_image(
&draw_target,
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() {
let rect = Rect::new(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));
let rect = Rect::new(
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);
} else {
@ -103,7 +113,10 @@ impl<'a> CanvasData<'a> {
}
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>) {
@ -111,7 +124,8 @@ impl<'a> CanvasData<'a> {
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 {
Pattern::Surface(ref surface) => {
let surface_size = surface.size();
@ -119,21 +133,29 @@ impl<'a> CanvasData<'a> {
(true, true) => rect.size,
(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, 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,
}
},
);
if self.need_to_draw_shadow() {
self.draw_with_shadow(&draw_rect, |new_draw_target: &DrawTarget| {
new_draw_target.fill_rect(&draw_rect, self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options));
new_draw_target.fill_rect(
&draw_rect,
self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options),
);
});
} else {
self.drawtarget.fill_rect(&draw_rect, self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options));
self.drawtarget.fill_rect(
&draw_rect,
self.state.fill_style.to_pattern_ref(),
Some(&self.state.draw_options),
);
}
}
@ -148,27 +170,40 @@ impl<'a> CanvasData<'a> {
if self.need_to_draw_shadow() {
self.draw_with_shadow(&rect, |new_draw_target: &DrawTarget| {
new_draw_target.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts, &self.state.draw_options);
new_draw_target.stroke_rect(
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. {
let cap = match self.state.stroke_opts.line_join {
JoinStyle::Round => CapStyle::Round,
_ => CapStyle::Butt
_ => CapStyle::Butt,
};
let stroke_opts =
StrokeOptions::new(self.state.stroke_opts.line_width,
self.state.stroke_opts.line_join,
cap,
self.state.stroke_opts.miter_limit,
self.state.stroke_opts.mDashPattern);
self.drawtarget.stroke_line(rect.origin, rect.bottom_right(),
self.state.stroke_style.to_pattern_ref(),
&stroke_opts, &self.state.draw_options);
let stroke_opts = StrokeOptions::new(
self.state.stroke_opts.line_width,
self.state.stroke_opts.line_join,
cap,
self.state.stroke_opts.miter_limit,
self.state.stroke_opts.mDashPattern,
);
self.drawtarget.stroke_line(
rect.origin,
rect.bottom_right(),
self.state.stroke_style.to_pattern_ref(),
&stroke_opts,
&self.state.draw_options,
);
} else {
self.drawtarget.stroke_rect(rect, self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts, &self.state.draw_options);
self.drawtarget.stroke_rect(
rect,
self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts,
&self.state.draw_options,
);
}
}
@ -185,9 +220,11 @@ impl<'a> CanvasData<'a> {
return; // Paint nothing if gradient size is zero.
}
self.drawtarget.fill(&self.path_builder.finish(),
self.state.fill_style.to_pattern_ref(),
&self.state.draw_options);
self.drawtarget.fill(
&self.path_builder.finish(),
self.state.fill_style.to_pattern_ref(),
&self.state.draw_options,
);
}
pub fn stroke(&self) {
@ -195,10 +232,12 @@ impl<'a> CanvasData<'a> {
return; // Paint nothing if gradient size is zero.
}
self.drawtarget.stroke(&self.path_builder.finish(),
self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts,
&self.state.draw_options);
self.drawtarget.stroke(
&self.path_builder.finish(),
self.state.stroke_style.to_pattern_ref(),
&self.state.stroke_opts,
&self.state.draw_options,
);
}
pub fn clip(&self) {
@ -210,7 +249,7 @@ impl<'a> CanvasData<'a> {
x: f64,
y: f64,
_fill_rule: FillRule,
chan: IpcSender<bool>
chan: IpcSender<bool>,
) {
let path = self.path_builder.finish();
let result = path.contains_point(x, y, &self.state.transform);
@ -227,19 +266,22 @@ impl<'a> CanvasData<'a> {
}
pub fn rect(&self, rect: &Rect<f32>) {
self.path_builder.move_to(Point2D::new(rect.origin.x, rect.origin.y));
self.path_builder.line_to(Point2D::new(rect.origin.x + rect.size.width, rect.origin.y));
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
.move_to(Point2D::new(rect.origin.x, rect.origin.y));
self.path_builder
.line_to(Point2D::new(rect.origin.x + rect.size.width, rect.origin.y));
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();
}
pub fn quadratic_curve_to(
&self,
cp: &Point2D<AzFloat>,
endpoint: &Point2D<AzFloat>
) {
pub fn quadratic_curve_to(&self, cp: &Point2D<AzFloat>, endpoint: &Point2D<AzFloat>) {
self.path_builder.quadratic_curve_to(cp, endpoint)
}
@ -247,7 +289,7 @@ impl<'a> CanvasData<'a> {
&self,
cp1: &Point2D<AzFloat>,
cp2: &Point2D<AzFloat>,
endpoint: &Point2D<AzFloat>
endpoint: &Point2D<AzFloat>,
) {
self.path_builder.bezier_curve_to(cp1, cp2, endpoint)
}
@ -258,17 +300,13 @@ impl<'a> CanvasData<'a> {
radius: AzFloat,
start_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(
&self,
cp1: &Point2D<AzFloat>,
cp2: &Point2D<AzFloat>,
radius: AzFloat
) {
pub fn arc_to(&self, cp1: &Point2D<AzFloat>, cp2: &Point2D<AzFloat>, radius: AzFloat) {
let cp0 = self.path_builder.get_current_point();
let cp1 = *cp1;
let cp2 = *cp2;
@ -314,9 +352,17 @@ impl<'a> CanvasData<'a> {
let angle_end = (tp2.y - cy).atan2(tp2.x - cx);
self.line_to(&tp1);
if [cx, cy, angle_start, angle_end].iter().all(|x| x.is_finite()) {
self.arc(&Point2D::new(cx, cy), radius,
angle_start, angle_end, anticlockwise);
if [cx, cy, angle_start, angle_end]
.iter()
.all(|x| x.is_finite())
{
self.arc(
&Point2D::new(cx, cy),
radius,
angle_start,
angle_end,
anticlockwise,
);
}
}
@ -328,9 +374,17 @@ impl<'a> CanvasData<'a> {
rotation_angle: AzFloat,
start_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) {
@ -371,7 +425,9 @@ impl<'a> CanvasData<'a> {
}
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 {
@ -398,7 +454,13 @@ impl<'a> CanvasData<'a> {
#[allow(unsafe_code)]
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();
}
@ -414,9 +476,9 @@ impl<'a> CanvasData<'a> {
is_opaque: false,
allow_mipmaps: false,
};
let data = webrender_api::ImageData::Raw(Arc::new(
unsafe { self.drawtarget.snapshot().get_data_surface().data().into() },
));
let data = webrender_api::ImageData::Raw(Arc::new(unsafe {
self.drawtarget.snapshot().get_data_surface().data().into()
}));
let mut txn = webrender_api::Transaction::new();
@ -424,15 +486,17 @@ impl<'a> CanvasData<'a> {
Some(image_key) => {
debug!("Updating image {:?}.", image_key);
txn.update_image(image_key, descriptor, data, None);
}
},
None => {
self.image_key = Some(self.webrender_api.generate_image_key());
debug!("New image {:?}.", self.image_key);
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);
}
@ -449,12 +513,15 @@ impl<'a> CanvasData<'a> {
assert_eq!(imagedata.len() % 4, 0);
assert_eq!(rect.size.area() as usize, imagedata.len() / 4);
pixels::byte_swap_and_premultiply_inplace(&mut imagedata);
let source_surface = self.drawtarget.create_source_surface_from_data(
&imagedata,
rect.size.to_i32(),
rect.size.width as i32 * 4,
SurfaceFormat::B8G8R8A8,
).unwrap();
let source_surface = self
.drawtarget
.create_source_surface_from_data(
&imagedata,
rect.size.to_i32(),
rect.size.width as i32 * 4,
SurfaceFormat::B8G8R8A8,
)
.unwrap();
self.drawtarget.copy_surface(
source_surface,
Rect::from_size(rect.size.to_i32()),
@ -481,15 +548,19 @@ impl<'a> CanvasData<'a> {
// https://html.spec.whatwg.org/multipage/#when-shadows-are-drawn
fn need_to_draw_shadow(&self) -> bool {
self.state.shadow_color.a != 0.0f32 &&
(self.state.shadow_offset_x != 0.0f64 ||
self.state.shadow_offset_y != 0.0f64 ||
self.state.shadow_blur != 0.0f64)
(self.state.shadow_offset_x != 0.0f64 ||
self.state.shadow_offset_y != 0.0f64 ||
self.state.shadow_blur != 0.0f64)
}
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,
source_rect.size.height as i32),
self.drawtarget.get_format());
let draw_target = self.drawtarget.create_similar_draw_target(
&Size2D::new(
source_rect.size.width as i32,
source_rect.size.height as i32,
),
self.drawtarget.get_format(),
);
let matrix = Transform2D::identity()
.pre_translate(-source_rect.origin.to_vector().cast())
.pre_mul(&self.state.transform);
@ -498,19 +569,26 @@ impl<'a> CanvasData<'a> {
}
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 new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect);
draw_shadow_source(&new_draw_target);
self.drawtarget.draw_surface_with_shadow(new_draw_target.snapshot(),
&Point2D::new(shadow_src_rect.origin.x as AzFloat,
shadow_src_rect.origin.y as AzFloat),
&self.state.shadow_color,
&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);
self.drawtarget.draw_surface_with_shadow(
new_draw_target.snapshot(),
&Point2D::new(
shadow_src_rect.origin.x as AzFloat,
shadow_src_rect.origin.y as AzFloat,
),
&self.state.shadow_color,
&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
@ -519,11 +597,19 @@ impl<'a> CanvasData<'a> {
#[allow(unsafe_code)]
pub fn read_pixels(&self, read_rect: Rect<u32>, canvas_size: Size2D<u32>) -> Vec<u8> {
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![];
}
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 +648,13 @@ impl<'a> CanvasPaintState<'a> {
draw_options: DrawOptions::new(1.0, CompositionOp::Over, antialias),
fill_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(),
shadow_offset_x: 0.0,
shadow_offset_y: 0.0,
@ -594,10 +686,10 @@ fn write_image(
dest_rect: Rect<f64>,
smoothing_enabled: bool,
composition_op: CompositionOp,
global_alpha: f32
global_alpha: f32,
) {
if image_data.is_empty() {
return
return;
}
let image_rect = Rect::new(Point2D::zero(), image_size);
@ -612,12 +704,14 @@ fn write_image(
};
let image_size = image_size.to_i32();
let source_surface = draw_target.create_source_surface_from_data(
&image_data,
image_size,
image_size.width * 4,
SurfaceFormat::B8G8R8A8,
).unwrap();
let source_surface = draw_target
.create_source_surface_from_data(
&image_data,
image_size,
image_size.width * 4,
SurfaceFormat::B8G8R8A8,
)
.unwrap();
let draw_surface_options = DrawSurfaceOptions::new(filter, true);
let draw_options = DrawOptions::new(global_alpha, composition_op, AntialiasMode::None);
draw_target.draw_surface(
@ -635,8 +729,7 @@ pub trait PointToi32 {
impl PointToi32 for Point2D<f64> {
fn to_i32(&self) -> Point2D<i32> {
Point2D::new(self.x.to_i32().unwrap(),
self.y.to_i32().unwrap())
Point2D::new(self.x.to_i32().unwrap(), self.y.to_i32().unwrap())
}
}
@ -646,8 +739,7 @@ pub trait SizeToi32 {
impl SizeToi32 for Size2D<f64> {
fn to_i32(&self) -> Size2D<i32> {
Size2D::new(self.width.to_i32().unwrap(),
self.height.to_i32().unwrap())
Size2D::new(self.width.to_i32().unwrap(), self.height.to_i32().unwrap())
}
}
@ -658,19 +750,24 @@ pub trait RectToi32 {
impl RectToi32 for Rect<f64> {
fn to_i32(&self) -> Rect<i32> {
Rect::new(Point2D::new(self.origin.x.to_i32().unwrap(),
self.origin.y.to_i32().unwrap()),
Size2D::new(self.size.width.to_i32().unwrap(),
self.size.height.to_i32().unwrap()))
Rect::new(
Point2D::new(
self.origin.x.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> {
Rect::new(Point2D::new(self.origin.x.ceil(),
self.origin.y.ceil()),
Size2D::new(self.size.width.ceil(),
self.size.height.ceil()))
Rect::new(
Point2D::new(self.origin.x.ceil(), self.origin.y.ceil()),
Size2D::new(self.size.width.ceil(), self.size.height.ceil()),
)
}
}
pub trait ToAzureStyle {
@ -682,12 +779,13 @@ impl ToAzureStyle for Rect<f64> {
type Target = Rect<AzFloat>;
fn to_azure_style(self) -> Rect<AzFloat> {
Rect::new(Point2D::new(self.origin.x as AzFloat, self.origin.y as AzFloat),
Size2D::new(self.size.width as AzFloat, self.size.height as AzFloat))
Rect::new(
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 {
type Target = CapStyle;
@ -717,17 +815,17 @@ impl ToAzureStyle for CompositionStyle {
fn to_azure_style(self) -> CompositionOp {
match self {
CompositionStyle::SrcIn => CompositionOp::In,
CompositionStyle::SrcOut => CompositionOp::Out,
CompositionStyle::SrcOver => CompositionOp::Over,
CompositionStyle::SrcAtop => CompositionOp::Atop,
CompositionStyle::DestIn => CompositionOp::DestIn,
CompositionStyle::DestOut => CompositionOp::DestOut,
CompositionStyle::SrcIn => CompositionOp::In,
CompositionStyle::SrcOut => CompositionOp::Out,
CompositionStyle::SrcOver => CompositionOp::Over,
CompositionStyle::SrcAtop => CompositionOp::Atop,
CompositionStyle::DestIn => CompositionOp::DestIn,
CompositionStyle::DestOut => CompositionOp::DestOut,
CompositionStyle::DestOver => CompositionOp::DestOver,
CompositionStyle::DestAtop => CompositionOp::DestAtop,
CompositionStyle::Copy => CompositionOp::Source,
CompositionStyle::Lighter => CompositionOp::Add,
CompositionStyle::Xor => CompositionOp::Xor,
CompositionStyle::Copy => CompositionOp::Source,
CompositionStyle::Lighter => CompositionOp::Add,
CompositionStyle::Xor => CompositionOp::Xor,
}
}
}
@ -737,20 +835,20 @@ impl ToAzureStyle for BlendingStyle {
fn to_azure_style(self) -> CompositionOp {
match self {
BlendingStyle::Multiply => CompositionOp::Multiply,
BlendingStyle::Screen => CompositionOp::Screen,
BlendingStyle::Overlay => CompositionOp::Overlay,
BlendingStyle::Darken => CompositionOp::Darken,
BlendingStyle::Lighten => CompositionOp::Lighten,
BlendingStyle::Multiply => CompositionOp::Multiply,
BlendingStyle::Screen => CompositionOp::Screen,
BlendingStyle::Overlay => CompositionOp::Overlay,
BlendingStyle::Darken => CompositionOp::Darken,
BlendingStyle::Lighten => CompositionOp::Lighten,
BlendingStyle::ColorDodge => CompositionOp::ColorDodge,
BlendingStyle::ColorBurn => CompositionOp::ColorBurn,
BlendingStyle::HardLight => CompositionOp::HardLight,
BlendingStyle::SoftLight => CompositionOp::SoftLight,
BlendingStyle::ColorBurn => CompositionOp::ColorBurn,
BlendingStyle::HardLight => CompositionOp::HardLight,
BlendingStyle::SoftLight => CompositionOp::SoftLight,
BlendingStyle::Difference => CompositionOp::Difference,
BlendingStyle::Exclusion => CompositionOp::Exclusion,
BlendingStyle::Hue => CompositionOp::Hue,
BlendingStyle::Exclusion => CompositionOp::Exclusion,
BlendingStyle::Hue => CompositionOp::Hue,
BlendingStyle::Saturation => CompositionOp::Saturation,
BlendingStyle::Color => CompositionOp::Color,
BlendingStyle::Color => CompositionOp::Color,
BlendingStyle::Luminosity => CompositionOp::Luminosity,
}
}
@ -778,32 +876,49 @@ impl ToAzurePattern for FillOrStrokeStyle {
Pattern::Color(ColorPattern::new(color.to_azure_style()))
},
FillOrStrokeStyle::LinearGradient(ref linear_gradient_style) => {
let gradient_stops: Vec<GradientStop> = linear_gradient_style.stops.iter().map(|s| {
GradientStop {
let gradient_stops: Vec<GradientStop> = linear_gradient_style
.stops
.iter()
.map(|s| GradientStop {
offset: s.offset as AzFloat,
color: s.color.to_azure_style()
}
}).collect();
color: s.color.to_azure_style(),
})
.collect();
Pattern::LinearGradient(LinearGradientPattern::new(
&Point2D::new(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),
&Point2D::new(
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),
&Transform2D::identity(),
))
},
FillOrStrokeStyle::RadialGradient(ref radial_gradient_style) => {
let gradient_stops: Vec<GradientStop> = radial_gradient_style.stops.iter().map(|s| {
GradientStop {
let gradient_stops: Vec<GradientStop> = radial_gradient_style
.stops
.iter()
.map(|s| GradientStop {
offset: s.offset as AzFloat,
color: s.color.to_azure_style()
}
}).collect();
color: s.color.to_azure_style(),
})
.collect();
Pattern::RadialGradient(RadialGradientPattern::new(
&Point2D::new(radial_gradient_style.x0 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,
&Point2D::new(
radial_gradient_style.x0 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),
&Transform2D::identity(),
))
@ -822,7 +937,7 @@ impl ToAzurePattern for FillOrStrokeStyle {
surface_style.repeat_y,
&Transform2D::identity(),
))
}
},
})
}
}
@ -831,9 +946,11 @@ impl ToAzureStyle for RGBA {
type Target = Color;
fn to_azure_style(self) -> Color {
Color::rgba(self.red_f32() as AzFloat,
self.green_f32() as AzFloat,
self.blue_f32() as AzFloat,
self.alpha_f32() as AzFloat)
Color::rgba(
self.red_f32() as AzFloat,
self.green_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 webrender_api;
pub struct CanvasPaintThread <'a> {
pub struct CanvasPaintThread<'a> {
canvases: HashMap<CanvasId, CanvasData<'a>>,
next_canvas_id: CanvasId,
}
impl<'a> CanvasPaintThread <'a> {
fn new() -> CanvasPaintThread <'a> {
impl<'a> CanvasPaintThread<'a> {
fn new() -> CanvasPaintThread<'a> {
CanvasPaintThread {
canvases: HashMap::new(),
next_canvas_id: CanvasId(0),
@ -29,52 +29,49 @@ impl<'a> CanvasPaintThread <'a> {
/// communicate with it.
pub fn start() -> IpcSender<CanvasMsg> {
let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
thread::Builder::new().name("CanvasThread".to_owned()).spawn(move || {
let mut canvas_paint_thread = CanvasPaintThread::new();
loop {
match receiver.recv() {
Ok(msg) => {
match msg {
thread::Builder::new()
.name("CanvasThread".to_owned())
.spawn(move || {
let mut canvas_paint_thread = CanvasPaintThread::new();
loop {
match receiver.recv() {
Ok(msg) => match msg {
CanvasMsg::Canvas2d(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);
},
CanvasMsg::Create(creator, size, webrenderer_api_sender, antialias) => {
let canvas_id = canvas_paint_thread.create_canvas(
size,
webrenderer_api_sender,
antialias
antialias,
);
creator.send(canvas_id).unwrap();
},
CanvasMsg::Recreate(size, canvas_id) =>{
CanvasMsg::Recreate(size, canvas_id) => {
canvas_paint_thread.canvas(canvas_id).recreate(size);
},
CanvasMsg::FromScript(message, canvas_id) => {
match message {
FromScriptMsg::SendPixels(chan) => {
canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
}
}
CanvasMsg::FromScript(message, canvas_id) => match message {
FromScriptMsg::SendPixels(chan) => {
canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
},
},
CanvasMsg::FromLayout(message, canvas_id) => {
match message {
FromLayoutMsg::SendData(chan) => {
canvas_paint_thread.canvas(canvas_id).send_data(chan);
}
}
CanvasMsg::FromLayout(message, canvas_id) => match message {
FromLayoutMsg::SendData(chan) => {
canvas_paint_thread.canvas(canvas_id).send_data(chan);
},
},
CanvasMsg::Exit => break,
}
},
Err(e) => {
warn!("Error on CanvasPaintThread receive ({})", e);
},
Err(e) => {
warn!("Error on CanvasPaintThread receive ({})", e);
},
}
}
}
}).expect("Thread spawning failed");
})
.expect("Thread spawning failed");
sender
}
@ -83,7 +80,7 @@ impl<'a> CanvasPaintThread <'a> {
&mut self,
size: Size2D<u32>,
webrender_api_sender: webrender_api::RenderApiSender,
antialias: bool
antialias: bool,
) -> CanvasId {
let antialias = if antialias {
AntialiasMode::Default
@ -105,33 +102,17 @@ impl<'a> CanvasPaintThread <'a> {
Canvas2dMsg::FillText(text, x, y, max_width) => {
self.canvas(canvas_id).fill_text(text, x, y, max_width)
},
Canvas2dMsg::FillRect(ref 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::BeginPath => {
self.canvas(canvas_id).begin_path()
},
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::FillRect(ref 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::BeginPath => self.canvas(canvas_id).begin_path(),
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(
imagedata,
image_size,
@ -156,12 +137,11 @@ impl<'a> CanvasPaintThread <'a> {
image_size,
dest_rect,
source_rect,
smoothing
smoothing,
) => {
let image_data = self.canvas(canvas_id).read_pixels(
source_rect.to_u32(),
image_size.to_u32(),
);
let image_data = self
.canvas(canvas_id)
.read_pixels(source_rect.to_u32(), image_size.to_u32());
self.canvas(other_canvas_id).draw_image(
image_data.into(),
source_rect.size,
@ -170,68 +150,34 @@ impl<'a> CanvasPaintThread <'a> {
smoothing,
);
},
Canvas2dMsg::MoveTo(ref 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::MoveTo(ref 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::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) => {
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) => {
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) => {
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) => {
self.canvas(canvas_id).set_global_composition(op)
},
@ -240,7 +186,8 @@ impl<'a> CanvasPaintThread <'a> {
sender.send(&pixels).unwrap();
},
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) => {
self.canvas(canvas_id).set_shadow_offset_x(value)
@ -248,12 +195,10 @@ impl<'a> CanvasPaintThread <'a> {
Canvas2dMsg::SetShadowOffsetY(value) => {
self.canvas(canvas_id).set_shadow_offset_y(value)
},
Canvas2dMsg::SetShadowBlur(value) => {
self.canvas(canvas_id).set_shadow_blur(value)
},
Canvas2dMsg::SetShadowColor(ref color) => {
self.canvas(canvas_id).set_shadow_color(color.to_azure_style())
},
Canvas2dMsg::SetShadowBlur(value) => self.canvas(canvas_id).set_shadow_blur(value),
Canvas2dMsg::SetShadowColor(ref color) => self
.canvas(canvas_id)
.set_shadow_color(color.to_azure_style()),
}
}

70
components/canvas/gl_context.rs
View file

@ -2,16 +2,18 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use canvas_traits::webgl::{WebGLCommand, WebGLVersion, WebGLCommandBacktrace};
use compositing::compositor_thread::{CompositorProxy, self};
use super::webgl_thread::{GLState, WebGLImpl};
use canvas_traits::webgl::{WebGLCommand, WebGLCommandBacktrace, WebGLVersion};
use compositing::compositor_thread::{self, CompositorProxy};
use euclid::Size2D;
use gleam::gl;
use offscreen_gl_context::{ColorAttachmentType, GLContext, GLContextAttributes, GLContextDispatcher};
use offscreen_gl_context::{
ColorAttachmentType, GLContext, GLContextAttributes, GLContextDispatcher,
};
use offscreen_gl_context::{GLLimits, GLVersion};
use offscreen_gl_context::{NativeGLContext, NativeGLContextHandle, NativeGLContextMethods};
use offscreen_gl_context::{OSMesaContext, OSMesaContextHandle};
use std::sync::{Arc, Mutex};
use super::webgl_thread::{WebGLImpl, GLState};
/// The GLContextFactory is used to create shared GL contexts with the main thread GL context.
/// Currently, shared textures are used to render WebGL textures into the WR compositor.
@ -48,7 +50,7 @@ impl GLContextFactory {
&self,
webgl_version: WebGLVersion,
size: Size2D<u32>,
attributes: GLContextAttributes
attributes: GLContextAttributes,
) -> Result<GLContextWrapper, &'static str> {
Ok(match *self {
GLContextFactory::Native(ref handle, ref dispatcher) => {
@ -63,7 +65,7 @@ impl GLContextFactory {
Some(handle),
dispatcher,
)?)
}
},
GLContextFactory::OSMesa(ref handle) => {
GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
// FIXME(nox): Why are those i32 values?
@ -75,7 +77,7 @@ impl GLContextFactory {
Some(handle),
None,
)?)
}
},
})
}
@ -84,7 +86,7 @@ impl GLContextFactory {
&self,
webgl_version: WebGLVersion,
size: Size2D<u32>,
attributes: GLContextAttributes
attributes: GLContextAttributes,
) -> Result<GLContextWrapper, &'static str> {
Ok(match *self {
GLContextFactory::Native(..) => {
@ -98,7 +100,7 @@ impl GLContextFactory {
None,
None,
)?)
}
},
GLContextFactory::OSMesa(_) => {
GLContextWrapper::OSMesa(GLContext::new_shared_with_dispatcher(
// FIXME(nox): Why are those i32 values?
@ -110,7 +112,7 @@ impl GLContextFactory {
None,
None,
)?)
}
},
})
}
@ -122,7 +124,6 @@ impl GLContextFactory {
}
}
/// GLContextWrapper used to abstract NativeGLContext and OSMesaContext types
pub enum GLContextWrapper {
Native(GLContext<NativeGLContext>),
@ -134,10 +135,10 @@ impl GLContextWrapper {
match *self {
GLContextWrapper::Native(ref ctx) => {
ctx.make_current().unwrap();
}
},
GLContextWrapper::OSMesa(ref ctx) => {
ctx.make_current().unwrap();
}
},
}
}
@ -145,10 +146,10 @@ impl GLContextWrapper {
match *self {
GLContextWrapper::Native(ref ctx) => {
ctx.unbind().unwrap();
}
},
GLContextWrapper::OSMesa(ref ctx) => {
ctx.unbind().unwrap();
}
},
}
}
@ -156,26 +157,22 @@ impl GLContextWrapper {
&self,
cmd: WebGLCommand,
backtrace: WebGLCommandBacktrace,
state: &mut GLState
state: &mut GLState,
) {
match *self {
GLContextWrapper::Native(ref ctx) => {
WebGLImpl::apply(ctx, state, cmd, backtrace);
}
},
GLContextWrapper::OSMesa(ref ctx) => {
WebGLImpl::apply(ctx, state, cmd, backtrace);
}
},
}
}
pub fn gl(&self) -> &gl::Gl {
match *self {
GLContextWrapper::Native(ref ctx) => {
ctx.gl()
}
GLContextWrapper::OSMesa(ref ctx) => {
ctx.gl()
}
GLContextWrapper::Native(ref ctx) => ctx.gl(),
GLContextWrapper::OSMesa(ref ctx) => ctx.gl(),
}
}
@ -184,23 +181,29 @@ impl GLContextWrapper {
GLContextWrapper::Native(ref ctx) => {
let (real_size, texture_id) = {
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();
(real_size, texture_id, limits)
}
},
GLContextWrapper::OSMesa(ref ctx) => {
let (real_size, texture_id) = {
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();
(real_size, texture_id, limits)
}
},
}
}
@ -209,11 +212,11 @@ impl GLContextWrapper {
GLContextWrapper::Native(ref mut ctx) => {
// FIXME(nox): Why are those i32 values?
ctx.resize(size.to_i32())
}
},
GLContextWrapper::OSMesa(ref mut ctx) => {
// FIXME(nox): Why are those i32 values?
ctx.resize(size.to_i32())
}
},
}
}
}
@ -222,7 +225,7 @@ impl GLContextWrapper {
/// It's used in Windows to allow WGL GLContext sharing.
#[derive(Clone)]
pub struct MainThreadDispatcher {
compositor_proxy: Arc<Mutex<CompositorProxy>>
compositor_proxy: Arc<Mutex<CompositorProxy>>,
}
impl MainThreadDispatcher {
@ -234,6 +237,9 @@ impl MainThreadDispatcher {
}
impl GLContextDispatcher for MainThreadDispatcher {
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 gleam;
extern crate ipc_channel;
#[macro_use] extern crate log;
#[macro_use]
extern crate log;
extern crate num_traits;
extern crate offscreen_gl_context;
extern crate pixels;

4
components/canvas/webgl_mode/inprocess.rs
View file

@ -2,10 +2,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use canvas_traits::webgl::webgl_channel;
use canvas_traits::webgl::DOMToTextureCommand;
use canvas_traits::webgl::{WebGLChan, WebGLContextId, WebGLMsg, WebGLPipeline, WebGLReceiver};
use canvas_traits::webgl::{WebGLSender, WebVRCommand, WebVRRenderHandler};
use canvas_traits::webgl::DOMToTextureCommand;
use canvas_traits::webgl::webgl_channel;
use crate::gl_context::GLContextFactory;
use crate::webgl_thread::{WebGLExternalImageApi, WebGLExternalImageHandler, WebGLThread};
use euclid::Size2D;

1110
components/canvas/webgl_thread.rs
View file

File diff suppressed because it is too large Load diff

127
components/canvas_traits/canvas.rs
View file

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

10
components/canvas_traits/lib.rs
View file

@ -4,18 +4,20 @@
#![crate_name = "canvas_traits"]
#![crate_type = "rlib"]
#![deny(unsafe_code)]
extern crate cssparser;
extern crate euclid;
extern crate gleam;
extern crate ipc_channel;
#[macro_use] extern crate lazy_static;
#[macro_use]
extern crate lazy_static;
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;
#[macro_use] extern crate serde;
#[macro_use]
extern crate serde;
extern crate serde_bytes;
extern crate servo_config;
extern crate webrender_api;

105
components/canvas_traits/webgl.rs
View file

@ -11,18 +11,18 @@ use std::borrow::Cow;
use std::num::NonZeroU32;
use webrender_api::{DocumentId, ImageKey, PipelineId};
/// Sender type used in WebGLCommands.
pub use crate::webgl_channel::WebGLSender;
/// Helper function that creates a WebGL channel (WebGLSender, WebGLReceiver) to be used in WebGLCommands.
pub use crate::webgl_channel::webgl_channel;
/// Entry point channel type used for sending WebGLMsg messages to the WebGL renderer.
pub use crate::webgl_channel::WebGLChan;
/// Entry point type used in a Script Pipeline to get the WebGLChan to be used in that thread.
pub use crate::webgl_channel::WebGLPipeline;
/// Receiver type used in WebGLCommands.
pub use crate::webgl_channel::WebGLReceiver;
/// Result type for send()/recv() calls in in WebGLCommands.
pub use crate::webgl_channel::WebGLSendResult;
/// Helper function that creates a WebGL channel (WebGLSender, WebGLReceiver) to be used in WebGLCommands.
pub use crate::webgl_channel::webgl_channel;
/// Entry point type used in a Script Pipeline to get the WebGLChan to be used in that thread.
pub use crate::webgl_channel::WebGLPipeline;
/// Entry point channel type used for sending WebGLMsg messages to the WebGL renderer.
pub use crate::webgl_channel::WebGLChan;
/// Sender type used in WebGLCommands.
pub use crate::webgl_channel::WebGLSender;
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct WebGLCommandBacktrace {
@ -134,13 +134,15 @@ impl WebGLMsgSender {
/// Send a WebGLCommand message
#[inline]
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
#[inline]
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
@ -150,7 +152,8 @@ impl WebGLMsgSender {
size: Size2D<u32>,
sender: WebGLSender<Result<(), String>>,
) -> WebGLSendResult {
self.sender.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
self.sender
.send(WebGLMsg::ResizeContext(self.ctx_id, size, sender))
}
#[inline]
@ -160,7 +163,8 @@ impl WebGLMsgSender {
#[inline]
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 {
@ -290,11 +294,34 @@ pub enum WebGLCommand {
GetTexParameterInt(u32, TexParameterInt, WebGLSender<i32>),
TexParameteri(u32, u32, i32),
TexParameterf(u32, u32, f32),
DrawArrays { mode: u32, first: i32, count: i32 },
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 },
DrawArrays {
mode: u32,
first: i32,
count: i32,
},
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>),
GetUniformBool2(WebGLProgramId, i32, WebGLSender<[bool; 2]>),
GetUniformBool3(WebGLProgramId, i32, WebGLSender<[bool; 3]>),
@ -309,7 +336,11 @@ pub enum WebGLCommand {
GetUniformFloat4(WebGLProgramId, i32, WebGLSender<[f32; 4]>),
GetUniformFloat9(WebGLProgramId, i32, WebGLSender<[f32; 9]>),
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 {
@ -329,7 +360,6 @@ macro_rules! define_resource_id_struct {
self.0.get()
}
}
};
}
@ -340,7 +370,8 @@ macro_rules! define_resource_id {
#[allow(unsafe_code)]
impl<'de> ::serde::Deserialize<'de> for $name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: ::serde::Deserializer<'de>
where
D: ::serde::Deserializer<'de>,
{
let id = u32::deserialize(deserializer)?;
if id == 0 {
@ -353,32 +384,33 @@ macro_rules! define_resource_id {
impl ::serde::Serialize for $name {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ::serde::Serializer
where
S: ::serde::Serializer,
{
self.get().serialize(serializer)
}
}
impl ::std::fmt::Debug for $name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
-> Result<(), ::std::fmt::Error> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
fmt.debug_tuple(stringify!($name))
.field(&self.get())
.finish()
.field(&self.get())
.finish()
}
}
impl ::std::fmt::Display for $name {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
-> Result<(), ::std::fmt::Error> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
write!(fmt, "{}", self.get())
}
}
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);
@ -389,8 +421,9 @@ define_resource_id!(WebGLProgramId);
define_resource_id!(WebGLShaderId);
define_resource_id!(WebGLVertexArrayId);
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, Ord)]
#[derive(PartialEq, PartialOrd, Serialize)]
#[derive(
Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, Ord, PartialEq, PartialOrd, Serialize,
)]
pub struct WebGLContextId(pub usize);
#[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.
SubmitFrame(WebVRDeviceId, [f32; 4], [f32; 4]),
/// Stop presenting to a VR device
Release(WebVRDeviceId)
Release(WebVRDeviceId),
}
// Trait object that handles WebVR commands.
@ -436,7 +469,13 @@ pub trait WebVRRenderHandler: Send {
#[derive(Clone, Debug, Deserialize, Serialize)]
pub enum DOMToTextureCommand {
/// 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.
Detach(WebGLTextureId),
/// Lock message used for a correct synchronization with WebRender GL flow.

39
components/channel/lib.rs
View file

@ -15,46 +15,45 @@ pub use crossbeam_channel::*;
use ipc_channel::ipc::IpcReceiver;
use ipc_channel::router::ROUTER;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
pub fn route_ipc_receiver_to_new_servo_receiver<T>(ipc_receiver: IpcReceiver<T>) -> Receiver<T>
where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static
T: for<'de> Deserialize<'de> + Serialize + Send + 'static,
{
let (servo_sender, servo_receiver) = channel();
ROUTER.add_route(
ipc_receiver.to_opaque(),
Box::new(move |message| {
drop(servo_sender.send(message.to::<T>().unwrap()))
}),
Box::new(move |message| drop(servo_sender.send(message.to::<T>().unwrap()))),
);
servo_receiver
}
pub fn route_ipc_receiver_to_new_servo_sender<T>(ipc_receiver: IpcReceiver<T>, servo_sender: Sender<T>)
where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static
pub fn route_ipc_receiver_to_new_servo_sender<T>(
ipc_receiver: IpcReceiver<T>,
servo_sender: Sender<T>,
) where
T: for<'de> Deserialize<'de> + Serialize + Send + 'static,
{
ROUTER.add_route(
ipc_receiver.to_opaque(),
Box::new(move |message| {
drop(servo_sender.send(message.to::<T>().unwrap()))
}),
Box::new(move |message| drop(servo_sender.send(message.to::<T>().unwrap()))),
)
}
pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
let (base_sender, base_receiver) = crossbeam_channel::unbounded::<T>();
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)]
pub enum ChannelError {
ChannelClosedError
ChannelClosedError,
}
pub struct Receiver<T> {
@ -78,7 +77,10 @@ impl<T> Clone for 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,
is_disconnected,
@ -134,7 +136,10 @@ impl<T> Clone for 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,
is_disconnected,

3
components/compositing/build.rs
View file

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

58
components/compositing/compositor.rs
View file

@ -2,15 +2,17 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::CompositionPipeline;
use crate::SendableFrameTree;
use crate::compositor_thread::{CompositorProxy, CompositorReceiver};
use crate::compositor_thread::{InitialCompositorState, Msg};
#[cfg(feature = "gleam")]
use crate::gl;
use crate::touch::{TouchHandler, TouchAction};
use crate::windowing::{self, EmbedderCoordinates, MouseWindowEvent, WebRenderDebugOption, WindowMethods};
use euclid::{TypedPoint2D, TypedVector2D, TypedScale};
use crate::touch::{TouchAction, TouchHandler};
use crate::windowing::{
self, EmbedderCoordinates, MouseWindowEvent, WebRenderDebugOption, WindowMethods,
};
use crate::CompositionPipeline;
use crate::SendableFrameTree;
use euclid::{TypedPoint2D, TypedScale, TypedVector2D};
use gfx_traits::Epoch;
#[cfg(feature = "gleam")]
use image::{DynamicImage, ImageFormat};
@ -20,23 +22,23 @@ use msg::constellation_msg::{PipelineId, PipelineIndex, PipelineNamespaceId};
use net_traits::image::base::Image;
#[cfg(feature = "gleam")]
use net_traits::image::base::PixelFormat;
use profile_traits::time::{self as profile_time, ProfilerCategory, profile};
use profile_traits::time::{self as profile_time, profile, ProfilerCategory};
use script_traits::CompositorEvent::{MouseButtonEvent, MouseMoveEvent, TouchEvent};
use script_traits::{AnimationState, AnimationTickType, ConstellationMsg, LayoutControlMsg};
use script_traits::{MouseButton, MouseEventType, ScrollState, TouchEventType, TouchId};
use script_traits::{UntrustedNodeAddress, WindowSizeData, WindowSizeType};
use script_traits::CompositorEvent::{MouseMoveEvent, MouseButtonEvent, TouchEvent};
use servo_channel::Sender;
use servo_config::opts;
use servo_geometry::DeviceIndependentPixel;
use std::collections::HashMap;
use std::env;
use std::fs::{File, create_dir_all};
use std::fs::{create_dir_all, File};
use std::io::Write;
use std::num::NonZeroU32;
use std::rc::Rc;
use style_traits::{CSSPixel, DevicePixel, PinchZoomFactor};
use style_traits::cursor::CursorKind;
use style_traits::viewport::ViewportConstraints;
use style_traits::{CSSPixel, DevicePixel, PinchZoomFactor};
use time::{now, precise_time_ns, precise_time_s};
use webrender;
use webrender_api::{self, DeviceIntPoint, DevicePoint, HitTestFlags, HitTestResult};
@ -498,7 +500,10 @@ impl<Window: WindowMethods> IOCompositor<Window> {
(Msg::GetScreenAvailSize(req), ShutdownState::NotShuttingDown) => {
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 +844,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
&mut self,
delta: ScrollLocation,
cursor: DeviceIntPoint,
phase: TouchEventType
phase: TouchEventType,
) {
match phase {
TouchEventType::Move => self.on_scroll_window_event(delta, cursor),
@ -852,11 +857,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
}
}
fn on_scroll_window_event(
&mut self,
scroll_location: ScrollLocation,
cursor: DeviceIntPoint
) {
fn on_scroll_window_event(&mut self, scroll_location: ScrollLocation, cursor: DeviceIntPoint) {
self.pending_scroll_zoom_events.push(ScrollZoomEvent {
magnification: 1.0,
scroll_location: scroll_location,
@ -1155,15 +1156,19 @@ impl<Window: WindowMethods> IOCompositor<Window> {
pub fn composite(&mut self) {
let target = self.composite_target;
match self.composite_specific_target(target) {
Ok(_) => if opts::get().output_file.is_some() || opts::get().exit_after_load {
println!("Shutting down the Constellation after generating an output file or exit flag specified");
self.start_shutting_down();
Ok(_) => {
if opts::get().output_file.is_some() || opts::get().exit_after_load {
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 {
if e != UnableToComposite::NotReadyToPaintImage(
NotReadyToPaint::WaitingOnConstellation,
) {
println!("not ready to composite: {:?}", e);
Err(e) => {
if opts::get().is_running_problem_test {
if e != UnableToComposite::NotReadyToPaintImage(
NotReadyToPaint::WaitingOnConstellation,
) {
println!("not ready to composite: {:?}", e);
}
}
},
}
@ -1255,7 +1260,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
if let Some(pipeline) = self.pipeline(*id) {
// and inform the layout thread with the measured 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);
}
}
@ -1445,7 +1450,8 @@ impl<Window: WindowMethods> IOCompositor<Window> {
val.as_ref()
.map(|dir| dir.join("capture_webrender").join(&capture_id))
.ok()
}).find(|val| match create_dir_all(&val) {
})
.find(|val| match create_dir_all(&val) {
Ok(_) => true,
Err(err) => {
eprintln!("Unable to create path '{:?}' for capture: {:?}", &val, err);

2
components/compositing/compositor_thread.rs
View file

@ -4,8 +4,8 @@
//! Communication with the compositor thread.
use crate::SendableFrameTree;
use crate::compositor::CompositingReason;
use crate::SendableFrameTree;
use embedder_traits::EventLoopWaker;
use gfx_traits::Epoch;
use ipc_channel::ipc::IpcSender;

2
components/compositing/lib.rs
View file

@ -29,10 +29,10 @@ extern crate time;
extern crate webrender;
extern crate webrender_api;
pub use crate::compositor_thread::CompositorProxy;
pub use crate::compositor::IOCompositor;
pub use crate::compositor::RenderNotifier;
pub use crate::compositor::ShutdownState;
pub use crate::compositor_thread::CompositorProxy;
use euclid::TypedSize2D;
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;

6
components/compositing/touch.rs
View file

@ -2,10 +2,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use euclid::{TypedPoint2D, TypedVector2D};
use euclid::TypedScale;
use script_traits::{EventResult, TouchId};
use self::TouchState::*;
use euclid::TypedScale;
use euclid::{TypedPoint2D, TypedVector2D};
use script_traits::{EventResult, TouchId};
use style_traits::DevicePixel;
/// Minimum number of `DeviceIndependentPixel` to begin touch scrolling.

2
components/compositing/windowing.rs
View file

@ -17,7 +17,7 @@ use std::fmt::{Debug, Error, Formatter};
#[cfg(feature = "gleam")]
use std::rc::Rc;
use style_traits::DevicePixel;
use webrender_api::{DeviceIntPoint, DevicePoint, DeviceUintSize, DeviceUintRect, ScrollLocation};
use webrender_api::{DeviceIntPoint, DevicePoint, DeviceUintRect, DeviceUintSize, ScrollLocation};
#[derive(Clone)]
pub enum MouseWindowEvent {

11
components/config/opts.rs
View file

@ -19,7 +19,7 @@ use std::fs::{self, File};
use std::io::{self, Read, Write};
use std::path::{Path, PathBuf};
use std::process;
use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
use url::{self, Url};
/// Global flags for Servo, currently set on the command line.
@ -814,7 +814,8 @@ pub fn from_cmdline_args(args: &[String]) -> ArgumentParsingResult {
.or_else(|error| {
warn!("URL parsing failed ({:?}).", error);
Err(error)
}).ok()
})
.ok()
});
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| {
args_fail(&format!("Error parsing option: --resolution ({})", err))
})
}).collect();
})
.collect();
TypedSize2D::new(res[0], res[1])
},
None => TypedSize2D::new(1024, 740),
@ -970,7 +972,8 @@ pub fn from_cmdline_args(args: &[String]) -> ArgumentParsingResult {
.read_to_end(&mut contents)
.unwrap_or_else(|err| args_fail(&format!("Couldn't read {}: {}", filename, err)));
(contents, url)
}).collect();
})
.collect();
let do_not_use_native_titlebar = opt_match.opt_present("b") || !PREFS
.get("shell.native-titlebar.enabled")

5
components/config/prefs.rs
View file

@ -11,7 +11,7 @@ use std::borrow::ToOwned;
use std::cmp::max;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Write, stderr};
use std::io::{stderr, Read, Write};
use std::path::PathBuf;
use std::sync::{Arc, RwLock};
@ -192,7 +192,8 @@ fn init_user_prefs(path: &mut PathBuf) {
writeln!(
&mut stderr(),
"Error opening prefs.json from config directory"
).expect("failed printing to stderr");
)
.expect("failed printing to stderr");
}
}

2
components/config/tests/opts.rs
View file

@ -4,7 +4,7 @@
extern crate servo_config;
use servo_config::opts::{parse_url_or_filename, parse_pref_from_command_line};
use servo_config::opts::{parse_pref_from_command_line, parse_url_or_filename};
use servo_config::prefs::{PrefValue, PREFS};
use std::path::Path;

2
components/config/tests/prefs.rs
View file

@ -5,7 +5,7 @@
extern crate servo_config;
use servo_config::basedir;
use servo_config::prefs::{PREFS, PrefValue, read_prefs};
use servo_config::prefs::{read_prefs, PrefValue, PREFS};
use std::fs::{self, File};
use std::io::{Read, Write};

309
components/constellation/constellation.rs
View file

@ -96,49 +96,61 @@ use canvas::webgl_thread::WebGLThreads;
use canvas_traits::canvas::CanvasId;
use canvas_traits::canvas::CanvasMsg;
use clipboard::{ClipboardContext, ClipboardProvider};
use compositing::SendableFrameTree;
use compositing::compositor_thread::CompositorProxy;
use compositing::compositor_thread::Msg as ToCompositorMsg;
use crate::browsingcontext::{AllBrowsingContextsIterator, BrowsingContext, FullyActiveBrowsingContextsIterator};
use compositing::SendableFrameTree;
use crate::browsingcontext::NewBrowsingContextInfo;
use crate::browsingcontext::{
AllBrowsingContextsIterator, BrowsingContext, FullyActiveBrowsingContextsIterator,
};
use crate::event_loop::EventLoop;
use crate::network_listener::NetworkListener;
use crate::pipeline::{InitialPipelineState, Pipeline};
use crate::session_history::{JointSessionHistory, NeedsToReload, SessionHistoryChange, SessionHistoryDiff};
use crate::session_history::{
JointSessionHistory, NeedsToReload, SessionHistoryChange, SessionHistoryDiff,
};
use crate::timer_scheduler::TimerScheduler;
use debugger;
use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg};
use embedder_traits::{EmbedderMsg, EmbedderProxy};
use euclid::{Size2D, TypedSize2D, TypedScale};
use euclid::{Size2D, TypedScale, TypedSize2D};
use gfx::font_cache_thread::FontCacheThread;
use gfx_traits::Epoch;
use ipc_channel::{Error as IpcError};
use ipc_channel::ipc::{self, IpcSender, IpcReceiver};
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use ipc_channel::router::ROUTER;
use ipc_channel::Error as IpcError;
use keyboard_types::KeyboardEvent;
use layout_traits::LayoutThreadFactory;
use log::{Log, Level, LevelFilter, Metadata, Record};
use msg::constellation_msg::{BrowsingContextId, PipelineId, HistoryStateId, TopLevelBrowsingContextId};
use log::{Level, LevelFilter, Log, Metadata, Record};
use msg::constellation_msg::{
BrowsingContextId, HistoryStateId, PipelineId, TopLevelBrowsingContextId,
};
use msg::constellation_msg::{PipelineNamespace, PipelineNamespaceId, TraversalDirection};
use net_traits::{self, IpcSend, FetchResponseMsg, ResourceThreads};
use net_traits::pub_domains::reg_host;
use net_traits::request::RequestInit;
use net_traits::storage_thread::{StorageThreadMsg, StorageType};
use net_traits::{self, FetchResponseMsg, IpcSend, ResourceThreads};
use profile_traits::mem;
use profile_traits::time;
use script_traits::{AnimationState, AuxiliaryBrowsingContextLoadInfo, AnimationTickType, CompositorEvent};
use script_traits::{ConstellationControlMsg, ConstellationMsg as FromCompositorMsg, DiscardBrowsingContext};
use script_traits::{webdriver_msg, LogEntry, ScriptToConstellationChan, ServiceWorkerMsg};
use script_traits::{
AnimationState, AnimationTickType, AuxiliaryBrowsingContextLoadInfo, CompositorEvent,
};
use script_traits::{
ConstellationControlMsg, ConstellationMsg as FromCompositorMsg, DiscardBrowsingContext,
};
use script_traits::{DocumentActivity, DocumentState, LayoutControlMsg, LoadData};
use script_traits::{IFrameLoadInfo, IFrameLoadInfoWithData, IFrameSandboxState, TimerSchedulerMsg};
use script_traits::{
IFrameLoadInfo, IFrameLoadInfoWithData, IFrameSandboxState, TimerSchedulerMsg,
};
use script_traits::{LayoutMsg as FromLayoutMsg, ScriptMsg as FromScriptMsg, ScriptThreadFactory};
use script_traits::{LogEntry, ScriptToConstellationChan, ServiceWorkerMsg, webdriver_msg};
use script_traits::{SWManagerMsg, ScopeThings, UpdatePipelineIdReason, WebDriverCommandMsg};
use script_traits::{WindowSizeData, WindowSizeType};
use serde::{Deserialize, Serialize};
use servo_channel::{Receiver, Sender, channel};
use servo_channel::{channel, Receiver, Sender};
use servo_config::opts;
use servo_config::prefs::PREFS;
use servo_rand::{Rng, SeedableRng, ServoRng, random};
use servo_rand::{random, Rng, SeedableRng, ServoRng};
use servo_remutex::ReentrantMutex;
use servo_url::{Host, ImmutableOrigin, ServoUrl};
use std::borrow::ToOwned;
@ -149,9 +161,9 @@ use std::process;
use std::rc::{Rc, Weak};
use std::sync::Arc;
use std::thread;
use style_traits::CSSPixel;
use style_traits::cursor::CursorKind;
use style_traits::viewport::ViewportConstraints;
use style_traits::CSSPixel;
use webrender_api;
use webvr_traits::{WebVREvent, WebVRMsg};
@ -718,9 +730,8 @@ where
match reg_host(&load_data.url) {
None => (None, None),
Some(host) => {
let event_loop = self
.event_loops.get(&host)
.and_then(|weak| weak.upgrade());
let event_loop =
self.event_loops.get(&host).and_then(|weak| weak.upgrade());
match event_loop {
None => (None, Some(host)),
Some(event_loop) => (Some(event_loop.clone()), None),
@ -855,7 +866,8 @@ where
is_private,
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 let Some(parent_pipeline_id) = parent_pipeline_id {
@ -866,7 +878,10 @@ where
}
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);
}
@ -1229,14 +1244,22 @@ where
.and_then(|pipeline| self.browsing_contexts.get(&pipeline.browsing_context_id))
.map(|ctx| (ctx.id, ctx.parent_pipeline_id));
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) => {
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));
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) => {
@ -1641,11 +1664,14 @@ where
fn handle_new_top_level_browsing_context(
&mut self,
url: ServoUrl,
top_level_browsing_context_id: TopLevelBrowsingContextId
top_level_browsing_context_id: TopLevelBrowsingContextId,
) {
let window_size = self.window_size.initial_viewport;
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);
let browsing_context_id = BrowsingContextId::from(top_level_browsing_context_id);
let load_data = LoadData::new(url.clone(), None, None, None);
@ -1655,10 +1681,13 @@ where
// Register this new top-level browsing context id as a browser and set
// its focused browsing context to be itself.
self.browsers.insert(top_level_browsing_context_id, Browser {
focused_browsing_context_id: browsing_context_id,
session_history: JointSessionHistory::new(),
});
self.browsers.insert(
top_level_browsing_context_id,
Browser {
focused_browsing_context_id: browsing_context_id,
session_history: JointSessionHistory::new(),
},
);
self.new_pipeline(
pipeline_id,
@ -1718,11 +1747,12 @@ where
};
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(browsing_context) => browsing_context.parent_pipeline_id,
None => return warn!(
"Subframe {} loaded in closed browsing context {}.",
pipeline_id,
browsing_context_id,
),
None => {
return warn!(
"Subframe {} loaded in closed browsing context {}.",
pipeline_id, browsing_context_id,
)
},
};
let parent_pipeline_id = match parent_pipeline_id {
Some(parent_pipeline_id) => parent_pipeline_id,
@ -1779,7 +1809,8 @@ where
let (load_data, is_private) = {
// 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));
let load_data = load_info.load_data.unwrap_or_else(|| {
let url = match old_pipeline {
@ -1792,23 +1823,25 @@ where
});
let is_parent_private = {
let parent_browsing_context_id =
match self.pipelines.get(&parent_pipeline_id) {
Some(pipeline) => pipeline.browsing_context_id,
None => return warn!(
let parent_browsing_context_id = match self.pipelines.get(&parent_pipeline_id) {
Some(pipeline) => pipeline.browsing_context_id,
None => {
return warn!(
"Script loaded url in iframe {} in closed parent pipeline {}.",
browsing_context_id,
parent_pipeline_id,
),
};
browsing_context_id, parent_pipeline_id,
)
},
};
let is_parent_private =
match self.browsing_contexts.get(&parent_browsing_context_id) {
Some(ctx) => ctx.is_private,
None => return warn!(
None => {
return warn!(
"Script loaded url in iframe {} in closed parent browsing context {}.",
browsing_context_id,
parent_browsing_context_id,
),
)
},
};
is_parent_private
};
@ -1820,10 +1853,12 @@ where
let (replace, window_size, is_visible) = {
let browsing_context = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx,
None => return warn!(
"Script loaded url in iframe with closed browsing context {}.",
browsing_context_id,
),
None => {
return warn!(
"Script loaded url in iframe with closed browsing context {}.",
browsing_context_id,
)
},
};
let replace = if replace {
Some(NeedsToReload::No(browsing_context.pipeline_id))
@ -1876,19 +1911,22 @@ where
let load_data = LoadData::new(url.clone(), Some(parent_pipeline_id), None, None);
let (pipeline, is_private, is_visible) = {
let (script_sender, parent_browsing_context_id) =
match self.pipelines.get(&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 (script_sender, parent_browsing_context_id) = match self
.pipelines
.get(&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) =
match self.browsing_contexts.get(&parent_browsing_context_id) {
Some(ctx) => (ctx.is_private, ctx.is_visible),
None => return warn!(
"New iframe {} loaded in closed parent browsing context {}.",
browsing_context_id,
parent_browsing_context_id,
),
None => {
return warn!(
"New iframe {} loaded in closed parent browsing context {}.",
browsing_context_id, parent_browsing_context_id,
)
},
};
let is_private = is_private || is_parent_private;
let pipeline = Pipeline::new(
@ -1923,9 +1961,11 @@ where
});
}
fn handle_script_new_auxiliary(&mut self,
load_info: AuxiliaryBrowsingContextLoadInfo,
layout_sender: IpcSender<LayoutControlMsg>) {
fn handle_script_new_auxiliary(
&mut self,
load_info: AuxiliaryBrowsingContextLoadInfo,
layout_sender: IpcSender<LayoutControlMsg>,
) {
let AuxiliaryBrowsingContextLoadInfo {
opener_pipeline_id,
new_top_level_browsing_context_id,
@ -1942,19 +1982,22 @@ where
let (script_sender, opener_browsing_context_id) =
match self.pipelines.get(&opener_pipeline_id) {
Some(pipeline) => (pipeline.event_loop.clone(), pipeline.browsing_context_id),
None => return warn!(
"Auxiliary loaded url in closed iframe {}.",
opener_pipeline_id
),
None => {
return warn!(
"Auxiliary loaded url in closed iframe {}.",
opener_pipeline_id
)
},
};
let (is_opener_private, is_opener_visible) =
match self.browsing_contexts.get(&opener_browsing_context_id) {
Some(ctx) => (ctx.is_private, ctx.is_visible),
None => return warn!(
"New auxiliary {} loaded in closed opener browsing context {}.",
new_browsing_context_id,
opener_browsing_context_id,
),
None => {
return warn!(
"New auxiliary {} loaded in closed opener browsing context {}.",
new_browsing_context_id, opener_browsing_context_id,
)
},
};
let pipeline = Pipeline::new(
new_pipeline_id,
@ -1966,7 +2009,7 @@ where
self.compositor_proxy.clone(),
url,
is_opener_visible,
load_data
load_data,
);
(pipeline, is_opener_private, is_opener_visible)
@ -1974,10 +2017,13 @@ where
assert!(!self.pipelines.contains_key(&new_pipeline_id));
self.pipelines.insert(new_pipeline_id, pipeline);
self.browsers.insert(new_top_level_browsing_context_id, Browser {
focused_browsing_context_id: new_browsing_context_id,
session_history: JointSessionHistory::new(),
});
self.browsers.insert(
new_top_level_browsing_context_id,
Browser {
focused_browsing_context_id: new_browsing_context_id,
session_history: JointSessionHistory::new(),
},
);
self.add_pending_change(SessionHistoryChange {
top_level_browsing_context_id: new_top_level_browsing_context_id,
browsing_context_id: new_browsing_context_id,
@ -2098,8 +2144,7 @@ where
// against future changes that might break things.
warn!(
"Pipeline {} loaded url in closed browsing context {}.",
source_id,
browsing_context_id,
source_id, browsing_context_id,
);
return None;
},
@ -2448,12 +2493,13 @@ where
// TODO: Save the sandbox state so it can be restored here.
let sandbox = IFrameSandboxState::IFrameUnsandboxed;
let (top_level_id,
old_pipeline_id,
parent_pipeline_id,
window_size,
is_private,
is_visible
let (
top_level_id,
old_pipeline_id,
parent_pipeline_id,
window_size,
is_private,
is_visible,
) = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => (
ctx.top_level_id,
@ -2651,18 +2697,19 @@ where
let event = CompositorEvent::KeyboardEvent(event);
let pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx.pipeline_id,
None => return warn!(
"Got key event for nonexistent browsing context {}.",
browsing_context_id,
),
None => {
return warn!(
"Got key event for nonexistent browsing context {}.",
browsing_context_id,
)
},
};
let msg = ConstellationControlMsg::SendEvent(pipeline_id, event);
let result = match self.pipelines.get(&pipeline_id) {
Some(pipeline) => pipeline.event_loop.send(msg),
None => return debug!(
"Pipeline {:?} got key event after closure.",
pipeline_id
),
None => {
return debug!("Pipeline {:?} got key event after closure.", pipeline_id)
},
};
if let Err(e) = result {
self.handle_send_error(pipeline_id, e);
@ -2771,10 +2818,12 @@ where
Some(browser) => {
browser.focused_browsing_context_id = browsing_context_id;
},
None => return warn!(
"Browser {} for focus msg does not exist",
top_level_browsing_context_id
),
None => {
return warn!(
"Browser {} for focus msg does not exist",
top_level_browsing_context_id
)
},
};
// Focus parent iframes recursively
@ -2784,17 +2833,21 @@ where
fn focus_parent_pipeline(&mut self, browsing_context_id: BrowsingContextId) {
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_id) {
Some(ctx) => ctx.parent_pipeline_id,
None => return warn!(
"Browsing context {:?} focus parent after closure.",
browsing_context_id
),
None => {
return warn!(
"Browsing context {:?} focus parent after closure.",
browsing_context_id
)
},
};
let parent_pipeline_id = match parent_pipeline_id {
Some(parent_id) => parent_id,
None => return debug!(
"Browsing context {:?} focus has no parent.",
browsing_context_id
),
None => {
return debug!(
"Browsing context {:?} focus has no parent.",
browsing_context_id
)
},
};
// Send a message to the parent of the provided browsing context (if it
@ -2864,7 +2917,12 @@ where
};
let parent_pipeline_id = match self.browsing_contexts.get(&browsing_context_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 {
@ -3294,7 +3352,7 @@ where
fn focused_browsing_context_is_descendant_of(
&self,
browsing_context_id: BrowsingContextId
browsing_context_id: BrowsingContextId,
) -> bool {
let focused_browsing_context_id = self
.active_browser_id
@ -3389,11 +3447,12 @@ where
// This is an existing browsing context.
None => match self.browsing_contexts.get(&change.browsing_context_id) {
Some(ctx) => ctx.parent_pipeline_id,
None => return warn!(
"Activated document {} after browsing context {} closure.",
change.new_pipeline_id,
change.browsing_context_id,
),
None => {
return warn!(
"Activated document {} after browsing context {} closure.",
change.new_pipeline_id, change.browsing_context_id,
)
},
},
};
if let Some(parent_pipeline_id) = parent_pipeline_id {
@ -3638,12 +3697,14 @@ where
new_size,
size_type,
));
let pipeline_ids = browsing_context.pipelines
let pipeline_ids = browsing_context
.pipelines
.iter()
.filter(|pipeline_id| **pipeline_id != pipeline.id);
for id in pipeline_ids {
if let Some(pipeline) = self.pipelines.get(&id) {
let _ = pipeline.event_loop
let _ = pipeline
.event_loop
.send(ConstellationControlMsg::ResizeInactive(
pipeline.id,
new_size,
@ -3757,11 +3818,12 @@ where
NeedsToReload::Yes(pipeline_id, load_data),
);
},
None => return warn!(
"Discarding pipeline {} after browser {} closure",
pipeline_id,
top_level_browsing_context_id,
),
None => {
return warn!(
"Discarding pipeline {} after browser {} closure",
pipeline_id, top_level_browsing_context_id,
)
},
};
self.close_pipeline(
pipeline_id,
@ -3844,8 +3906,10 @@ where
// Randomly close a pipeline -if --random-pipeline-closure-probability is set
fn maybe_close_random_pipeline(&mut self) {
match self.random_pipeline_closure {
Some((ref mut rng, probability)) => if probability <= rng.gen::<f32>() {
return;
Some((ref mut rng, probability)) => {
if probability <= rng.gen::<f32>() {
return;
}
},
_ => return,
};
@ -3881,7 +3945,8 @@ where
&mut self,
top_level_id: TopLevelBrowsingContextId,
) -> &mut JointSessionHistory {
&mut self.browsers
&mut self
.browsers
.entry(top_level_id)
// This shouldn't be necessary since `get_joint_session_history` is
// invoked for existing browsers but we need this to satisfy the

2
components/constellation/event_loop.rs
View file

@ -6,8 +6,8 @@
//! view of a script thread. When an `EventLoop` is dropped, an `ExitScriptThread`
//! message is sent to the script thread, asking it to shut down.
use ipc_channel::Error;
use ipc_channel::ipc::IpcSender;
use ipc_channel::Error;
use script_traits::ConstellationControlMsg;
use std::marker::PhantomData;
use std::rc::Rc;

4
components/constellation/lib.rs
View file

@ -53,7 +53,9 @@ mod sandboxing;
mod session_history;
mod timer_scheduler;
pub use crate::constellation::{Constellation, FromCompositorLogger, FromScriptLogger, InitialConstellationState};
pub use crate::constellation::{
Constellation, FromCompositorLogger, FromScriptLogger, InitialConstellationState,
};
pub use crate::pipeline::UnprivilegedPipelineContent;
#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
pub use crate::sandboxing::content_process_sandbox_profile;

8
components/constellation/network_listener.rs
View file

@ -11,10 +11,10 @@ use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use msg::constellation_msg::PipelineId;
use net::http_loader::{set_default_accept, set_default_accept_language};
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseMsg};
use net_traits::{IpcSend, NetworkError, ResourceThreads};
use net_traits::request::{Destination, RequestInit};
use net_traits::response::ResponseInit;
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseMsg};
use net_traits::{IpcSend, NetworkError, ResourceThreads};
use servo_channel::Sender;
pub struct NetworkListener {
@ -113,7 +113,9 @@ impl NetworkListener {
location_url: metadata.location_url.clone(),
headers: headers.clone().into_inner(),
referrer: metadata.referrer.clone(),
status_code: metadata.status.as_ref()
status_code: metadata
.status
.as_ref()
.map(|&(code, _)| code)
.unwrap_or(200),
});

25
components/constellation/pipeline.rs
View file

@ -4,23 +4,23 @@
use bluetooth_traits::BluetoothRequest;
use canvas_traits::webgl::WebGLPipeline;
use compositing::compositor_thread::Msg as CompositorMsg;
use compositing::CompositionPipeline;
use compositing::CompositorProxy;
use compositing::compositor_thread::Msg as CompositorMsg;
use crate::event_loop::EventLoop;
use devtools_traits::{DevtoolsControlMsg, ScriptToDevtoolsControlMsg};
use euclid::{TypedSize2D, TypedScale};
use euclid::{TypedScale, TypedSize2D};
use gfx::font_cache_thread::FontCacheThread;
use ipc_channel::Error;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use ipc_channel::router::ROUTER;
use ipc_channel::Error;
use layout_traits::LayoutThreadFactory;
use metrics::PaintTimeMetrics;
use msg::constellation_msg::{BrowsingContextId, HistoryStateId, PipelineId, PipelineNamespaceId};
use msg::constellation_msg::TopLevelBrowsingContextId;
use msg::constellation_msg::{BrowsingContextId, HistoryStateId, PipelineId, PipelineNamespaceId};
use net::image_cache::ImageCacheImpl;
use net_traits::{IpcSend, ResourceThreads};
use net_traits::image_cache::ImageCache;
use net_traits::{IpcSend, ResourceThreads};
use profile_traits::mem as profile_mem;
use profile_traits::time;
use script_traits::{ConstellationControlMsg, DiscardBrowsingContext, ScriptToConstellationChan};
@ -30,7 +30,7 @@ use script_traits::{NewLayoutInfo, SWManagerMsg, SWManagerSenders};
use script_traits::{ScriptThreadFactory, TimerSchedulerMsg, WindowSizeData};
use servo_channel::Sender;
use servo_config::opts::{self, Opts};
use servo_config::prefs::{PREFS, Pref};
use servo_config::prefs::{Pref, PREFS};
use servo_url::ServoUrl;
use std::collections::{HashMap, HashSet};
#[cfg(not(windows))]
@ -240,10 +240,12 @@ impl Pipeline {
Err(e) => {
error!("Cast to ScriptToDevtoolsControlMsg failed ({}).", e)
},
Ok(message) => if let Err(e) =
devtools_chan.send(DevtoolsControlMsg::FromScript(message))
{
warn!("Sending to devtools failed ({:?})", e)
Ok(message) => {
if let Err(e) =
devtools_chan.send(DevtoolsControlMsg::FromScript(message))
{
warn!("Sending to devtools failed ({:?})", e)
}
},
},
),
@ -430,8 +432,7 @@ impl Pipeline {
/// Notify the script thread that this pipeline is visible.
pub fn notify_visibility(&self, is_visible: bool) {
let script_msg =
ConstellationControlMsg::ChangeFrameVisibilityStatus(self.id, is_visible);
let script_msg = ConstellationControlMsg::ChangeFrameVisibilityStatus(self.id, is_visible);
let compositor_msg = CompositorMsg::PipelineVisibilityChanged(self.id, is_visible);
let err = self.event_loop.send(script_msg);
if let Err(e) = err {

6
components/constellation/session_history.rs
View file

@ -3,11 +3,13 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::browsingcontext::NewBrowsingContextInfo;
use msg::constellation_msg::{BrowsingContextId, HistoryStateId, PipelineId, TopLevelBrowsingContextId};
use msg::constellation_msg::{
BrowsingContextId, HistoryStateId, PipelineId, TopLevelBrowsingContextId,
};
use script_traits::LoadData;
use servo_url::ServoUrl;
use std::{fmt, mem};
use std::cmp::PartialEq;
use std::{fmt, mem};
/// Represents the joint session history
/// https://html.spec.whatwg.org/multipage/#joint-session-history

6
components/debugger/lib.rs
View file

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

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

@ -10,10 +10,10 @@
use crate::actor::{Actor, ActorMessageStatus, ActorRegistry};
use crate::actors::object::ObjectActor;
use crate::protocol::JsonPacketStream;
use devtools_traits::{CachedConsoleMessageTypes, DevtoolScriptControlMsg};
use devtools_traits::CachedConsoleMessage;
use devtools_traits::EvaluateJSReply::{ActorValue, BooleanValue, StringValue};
use devtools_traits::EvaluateJSReply::{NullValue, NumberValue, VoidValue};
use devtools_traits::{CachedConsoleMessageTypes, DevtoolScriptControlMsg};
use ipc_channel::ipc::{self, IpcSender};
use msg::constellation_msg::PipelineId;
use serde_json::{self, Map, Number, Value};
@ -126,7 +126,8 @@ impl Actor for ConsoleActor {
self.pipeline,
message_types,
chan,
)).unwrap();
))
.unwrap();
let messages = port
.recv()
.map_err(|_| ())?
@ -135,7 +136,8 @@ impl Actor for ConsoleActor {
let json_string = message.encode().unwrap();
let json = serde_json::from_str::<Value>(&json_string).unwrap();
json.as_object().unwrap().to_owned()
}).collect();
})
.collect();
let msg = GetCachedMessagesReply {
from: self.name(),
@ -196,7 +198,8 @@ impl Actor for ConsoleActor {
self.pipeline,
input.clone(),
chan,
)).unwrap();
))
.unwrap();
//TODO: extract conversion into protocol module or some other useful place
let result = match port.recv().map_err(|_| ())? {

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

@ -3,8 +3,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::actor::{Actor, ActorMessageStatus, ActorRegistry};
use crate::protocol::{ActorDescription, Method};
use crate::protocol::JsonPacketStream;
use crate::protocol::{ActorDescription, Method};
use serde_json::{Map, Value};
use std::net::TcpStream;
@ -42,7 +42,7 @@ impl Actor for DeviceActor {
value: SystemInfo {
apptype: "servo".to_string(),
platformVersion: "63.0".to_string(),
}
},
};
stream.write_json_packet(&msg);
ActorMessageStatus::Processed
@ -73,12 +73,11 @@ impl DeviceActor {
.into_iter()
.collect(),
),
)].into_iter()
)]
.into_iter()
.collect(),
),
}],
}
}
}

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

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

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

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

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

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

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

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

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

@ -6,9 +6,9 @@ use crate::actor::{Actor, ActorMessageStatus, ActorRegistry};
use crate::actors::framerate::FramerateActor;
use crate::actors::memory::{MemoryActor, TimelineMemoryReply};
use crate::protocol::JsonPacketStream;
use devtools_traits::{PreciseTime, TimelineMarker, TimelineMarkerType};
use devtools_traits::DevtoolScriptControlMsg;
use devtools_traits::DevtoolScriptControlMsg::{DropTimelineMarkers, SetTimelineMarkers};
use devtools_traits::{PreciseTime, TimelineMarker, TimelineMarkerType};
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use msg::constellation_msg::PipelineId;
use serde::{Serialize, Serializer};
@ -169,7 +169,8 @@ impl TimelineActor {
emitter.send(markers);
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.marker_types.clone(),
tx,
)).unwrap();
))
.unwrap();
*self.stream.borrow_mut() = stream.try_clone().ok();
@ -248,7 +250,8 @@ impl Actor for TimelineActor {
.send(DropTimelineMarkers(
self.pipeline,
self.marker_types.clone(),
)).unwrap();
))
.unwrap();
if let Some(ref actor_name) = *self.framerate_actor.borrow() {
registry.drop_actor_later(actor_name.clone());

32
components/devtools/lib.rs
View file

@ -48,11 +48,11 @@ use devtools_traits::{DevtoolScriptControlMsg, DevtoolsPageInfo, LogLevel, Netwo
use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId};
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;
use servo_channel::{Receiver, Sender, channel};
use servo_channel::{channel, Receiver, Sender};
use std::borrow::ToOwned;
use std::cell::RefCell;
use std::collections::HashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::collections::HashMap;
use std::net::{Shutdown, TcpListener, TcpStream};
use std::sync::{Arc, Mutex};
use std::thread;
@ -235,7 +235,17 @@ fn run_server(
let (pipeline, worker_id) = ids;
//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 {
name: actors.new_name("console"),
script_chan: script_sender.clone(),
@ -347,7 +357,8 @@ fn run_server(
LogLevel::Warn => "warn",
LogLevel::Error => "error",
_ => "log",
}.to_owned(),
}
.to_owned(),
timeStamp: precise_time_ns(),
arguments: vec![console_message.message],
filename: console_message.filename,
@ -373,7 +384,12 @@ fn run_server(
Some(actors.find::<WorkerActor>(actor_name).console.clone())
} else {
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
.send(DevtoolsControlMsg::FromChrome(
ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()),
)).unwrap();
))
.unwrap();
}
}).expect("Thread spawning failed");
})
.expect("Thread spawning failed");
while let Some(msg) = receiver.recv() {
match msg {

2
components/devtools_traits/lib.rs
View file

@ -24,8 +24,8 @@ extern crate serde;
extern crate servo_url;
extern crate time;
use http::HeaderMap;
use http::method::Method;
use http::HeaderMap;
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;
use servo_url::ServoUrl;

3
components/dom_struct/lib.rs
View file

@ -55,7 +55,8 @@ pub fn dom_struct(args: TokenStream, input: TokenStream) -> TokenStream {
&self.#ident
}
}
).into()
)
.into()
} else {
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();
generics
.params
.push(parse_quote!(__T: crate::dom::bindings::reflector::DomObject));
generics.params.push(parse_quote!(
__T: crate::dom::bindings::reflector::DomObject
));
let (impl_generics, _, where_clause) = generics.split_for_impl();

2
components/fallible/lib.rs
View file

@ -5,9 +5,9 @@
extern crate hashglobe;
extern crate smallvec;
use hashglobe::FailedAllocationError;
#[cfg(feature = "known_system_malloc")]
use hashglobe::alloc;
use hashglobe::FailedAllocationError;
use smallvec::Array;
use smallvec::SmallVec;
use std::vec::Vec;

10
components/gfx/font.rs
View file

@ -9,9 +9,9 @@ use crate::platform::font::{FontHandle, FontTable};
use crate::platform::font_context::FontContextHandle;
pub use crate::platform::font_list::fallback_font_families;
use crate::platform::font_template::FontTemplateData;
use crate::text::Shaper;
use crate::text::glyph::{ByteIndex, GlyphData, GlyphId, GlyphStore};
use crate::text::shaping::ShaperMethods;
use crate::text::Shaper;
use euclid::{Point2D, Rect, Size2D};
use ordered_float::NotNan;
use servo_atoms::Atom;
@ -22,8 +22,8 @@ use std::collections::HashMap;
use std::iter;
use std::rc::Rc;
use std::str;
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use std::sync::Arc;
use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering};
use style::computed_values::{font_stretch, font_style, font_variant_caps, font_weight};
use style::properties::style_structs::Font as FontStyleStruct;
use style::values::computed::font::SingleFontFamily;
@ -254,7 +254,8 @@ impl Font {
TEXT_SHAPING_PERFORMANCE_COUNTER
.fetch_add((end_time - start_time) as usize, Ordering::Relaxed);
Arc::new(glyphs)
}).clone();
})
.clone();
self.shaper = shaper;
result
}
@ -450,7 +451,8 @@ impl FontGroup {
iter::once(FontFamilyDescriptor::default())
.chain(fallback_font_families(codepoint).into_iter().map(|family| {
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)
}
}

18
components/gfx/font_cache_thread.rs
View file

@ -7,22 +7,22 @@ use crate::font::{FontFamilyDescriptor, FontFamilyName, FontSearchScope};
use crate::font_context::FontSource;
use crate::font_template::{FontTemplate, FontTemplateDescriptor};
use crate::platform::font_context::FontContextHandle;
use crate::platform::font_list::SANS_SERIF_FONT_FAMILY;
use crate::platform::font_list::for_each_available_family;
use crate::platform::font_list::for_each_variation;
use crate::platform::font_list::system_default_family;
use crate::platform::font_list::SANS_SERIF_FONT_FAMILY;
use crate::platform::font_template::FontTemplateData;
use fontsan;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use net_traits::{CoreResourceThread, FetchResponseMsg, fetch_async};
use net_traits::request::{Destination, RequestInit};
use net_traits::{fetch_async, CoreResourceThread, FetchResponseMsg};
use servo_atoms::Atom;
use servo_url::ServoUrl;
use std::{fmt, f32, mem, thread};
use std::borrow::ToOwned;
use std::collections::HashMap;
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use std::{f32, fmt, mem, thread};
use style::font_face::{EffectiveSources, Source};
use style::values::computed::font::FamilyName;
use webrender_api;
@ -434,7 +434,8 @@ impl FontCache {
FontSearchScope::Local => {
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.run();
}).expect("Thread spawning failed");
})
.expect("Thread spawning failed");
FontCacheThread { chan: chan }
}
@ -490,7 +492,8 @@ impl FontCacheThread {
LowercaseString::new(&family.name),
sources,
sender,
)).unwrap();
))
.unwrap();
}
pub fn exit(&self) {
@ -538,7 +541,8 @@ impl FontSource for FontCacheThread {
template_descriptor,
family_descriptor,
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();

7
components/gfx/font_context.rs
View file

@ -3,7 +3,9 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use app_units::Au;
use crate::font::{Font, FontDescriptor, FontFamilyDescriptor, FontGroup, FontHandleMethods, FontRef};
use crate::font::{
Font, FontDescriptor, FontFamilyDescriptor, FontGroup, FontHandleMethods, FontRef,
};
use crate::font_cache_thread::FontTemplateInfo;
use crate::font_template::FontTemplateDescriptor;
use crate::platform::font::FontHandle;
@ -133,7 +135,8 @@ impl<S: FontSource> FontContext<S> {
.and_then(|template_info| {
self.create_font(template_info, font_descriptor.to_owned())
.ok()
}).map(|font| Rc::new(RefCell::new(font)));
})
.map(|font| Rc::new(RefCell::new(font)));
self.font_cache.insert(cache_key, font.clone());
font

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

@ -8,11 +8,11 @@ use std::fs::File;
use std::io::{self, Read};
use std::path::Path;
use ucd::{Codepoint, UnicodeBlock};
use xml5ever::Attribute;
use xml5ever::driver::parse_document;
use xml5ever::rcdom::*;
use xml5ever::rcdom::{Node, RcDom};
use xml5ever::tendril::TendrilSink;
use xml5ever::Attribute;
lazy_static! {
static ref FONT_LIST: FontList = FontList::new();
@ -127,7 +127,11 @@ struct FontList {
impl FontList {
fn new() -> FontList {
// 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.
let mut result = None;
@ -213,7 +217,10 @@ impl FontList {
let alternatives = [
("sans-serif", "Roboto-Regular.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
@ -225,7 +232,8 @@ impl FontList {
filename: item.1.into(),
weight: None,
}],
}).collect()
})
.collect()
}
// All Android fonts are located in /system/fonts
@ -348,7 +356,8 @@ impl FontList {
.map(|f| Font {
filename: f.clone(),
weight: None,
}).collect();
})
.collect();
if !fonts.is_empty() {
out.push(FontFamily {

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

@ -2,6 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use super::c_str_to_string;
use app_units::Au;
use crate::font::{FontHandleMethods, FontMetrics, FontTableMethods};
use crate::font::{FontTableTag, FractionalPixel, GPOS, GSUB, KERN};
@ -9,6 +10,7 @@ use crate::platform::font_context::FontContextHandle;
use crate::platform::font_template::FontTemplateData;
use crate::text::glyph::GlyphId;
use crate::text::util::fixed_to_float;
use freetype::freetype::FT_Sfnt_Tag;
use freetype::freetype::{FT_Done_Face, FT_New_Face, FT_New_Memory_Face};
use freetype::freetype::{FT_F26Dot6, FT_Face, FT_FaceRec};
use freetype::freetype::{FT_Get_Char_Index, FT_Get_Postscript_Name};
@ -17,18 +19,16 @@ use freetype::freetype::{FT_GlyphSlot, FT_Library, FT_Long, FT_ULong};
use freetype::freetype::{FT_Int32, FT_Kerning_Mode, FT_STYLE_FLAG_ITALIC};
use freetype::freetype::{FT_Load_Glyph, FT_Set_Char_Size};
use freetype::freetype::{FT_SizeRec, FT_Size_Metrics, FT_UInt, FT_Vector};
use freetype::freetype::FT_Sfnt_Tag;
use freetype::succeeded;
use freetype::tt_os2::TT_OS2;
use servo_atoms::Atom;
use std::{mem, ptr};
use std::ffi::CString;
use std::os::raw::{c_char, c_long};
use std::sync::Arc;
use std::{mem, ptr};
use style::computed_values::font_stretch::T as FontStretch;
use style::computed_values::font_weight::T as FontWeight;
use style::values::computed::font::FontStyle;
use super::c_str_to_string;
// This constant is not present in the freetype
// bindings due to bindgen not handling the way
@ -216,7 +216,8 @@ impl FontHandleMethods for FontHandle {
}
} else {
FontStretchKeyword::Normal
}.compute();
}
.compute();
FontStretch(NonNegative(percentage))
}

2
components/gfx/platform/freetype/font_context.rs
View file

@ -10,7 +10,7 @@ use freetype::freetype::FT_MemoryRec_;
use freetype::freetype::FT_New_Library;
use freetype::succeeded;
use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
use servo_allocator::libc_compat::{malloc, realloc, free};
use servo_allocator::libc_compat::{free, malloc, realloc};
use servo_allocator::usable_size;
use std::os::raw::{c_long, c_void};
use std::ptr;

6
components/gfx/platform/freetype/font_list.rs
View file

@ -2,18 +2,20 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use super::c_str_to_string;
use crate::text::util::is_cjk;
use fontconfig::fontconfig::{FcChar8, FcResultMatch, FcSetSystem};
use fontconfig::fontconfig::{FcConfigGetCurrent, FcConfigGetFonts, FcConfigSubstitute};
use fontconfig::fontconfig::{FcDefaultSubstitute, FcFontMatch, FcNameParse, FcPatternGetString};
use fontconfig::fontconfig::{FcFontSetDestroy, FcMatchPattern, FcPatternCreate, FcPatternDestroy};
use fontconfig::fontconfig::{FcFontSetList, FcObjectSetCreate, FcObjectSetDestroy, FcPatternAddString};
use fontconfig::fontconfig::{
FcFontSetList, FcObjectSetCreate, FcObjectSetDestroy, FcPatternAddString,
};
use fontconfig::fontconfig::{FcObjectSetAdd, FcPatternGetInteger};
use libc;
use libc::{c_char, c_int};
use std::ffi::CString;
use std::ptr;
use super::c_str_to_string;
static FC_FAMILY: &'static [u8] = b"family\0";
static FC_FILE: &'static [u8] = b"file\0";

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

@ -5,7 +5,7 @@
use servo_atoms::Atom;
use std::fmt;
use std::fs::File;
use std::io::{Read, Error};
use std::io::{Error, Read};
use webrender_api::NativeFontHandle;
/// Platform specific font representation for Linux.
@ -25,7 +25,8 @@ impl fmt::Debug for FontTemplateData {
.field(
"bytes",
&self.bytes.as_ref().map(|b| format!("[{} bytes]", b.len())),
).field("identifier", &self.identifier)
)
.field("identifier", &self.identifier)
.finish()
}
}

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

@ -11,17 +11,19 @@ use core_foundation::string::UniChar;
use core_graphics::font::CGGlyph;
use core_graphics::geometry::CGRect;
use core_text::font::CTFont;
use core_text::font_descriptor::{SymbolicTraitAccessors, TraitAccessors};
use core_text::font_descriptor::kCTFontDefaultOrientation;
use crate::font::{FontHandleMethods, FontMetrics, FontTableMethods, FontTableTag, FractionalPixel};
use core_text::font_descriptor::{SymbolicTraitAccessors, TraitAccessors};
use crate::font::{
FontHandleMethods, FontMetrics, FontTableMethods, FontTableTag, FractionalPixel,
};
use crate::font::{GPOS, GSUB, KERN};
use crate::platform::font_template::FontTemplateData;
use crate::platform::macos::font_context::FontContextHandle;
use crate::text::glyph::GlyphId;
use servo_atoms::Atom;
use std::{fmt, ptr};
use std::ops::Range;
use std::sync::Arc;
use std::{fmt, ptr};
use style::values::computed::font::{FontStretch, FontStyle, FontWeight};
const KERN_PAIR_LEN: usize = 6;
@ -236,8 +238,7 @@ impl FontHandleMethods for FontHandle {
let count: CFIndex = 1;
let result = unsafe {
self
.ctfont
self.ctfont
.get_glyphs_for_characters(&characters[0], &mut glyphs[0], count)
};

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

@ -7,15 +7,15 @@ use core_graphics::data_provider::CGDataProvider;
use core_graphics::font::CGFont;
use core_text;
use core_text::font::CTFont;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::{Error, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use servo_atoms::Atom;
use servo_url::ServoUrl;
use std::borrow::ToOwned;
use std::collections::HashMap;
use std::fmt;
use std::fs::File;
use std::io::{Read, Error as IoError};
use std::io::{Error as IoError, Read};
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use webrender_api::NativeFontHandle;
@ -51,7 +51,8 @@ impl fmt::Debug for FontTemplateData {
.font_data
.as_ref()
.map(|bytes| format!("[{} bytes]", bytes.len())),
).finish()
)
.finish()
}
}
@ -111,7 +112,8 @@ impl FontTemplateData {
.expect("No URL for Core Text font!")
.get_string()
.to_string(),
).expect("Couldn't parse Core Text font URL!")
)
.expect("Couldn't parse Core Text font URL!")
.as_url()
.to_file_path()
.expect("Core Text font didn't name a path!");

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

@ -23,8 +23,8 @@ use std::sync::Arc;
use style::computed_values::font_stretch::T as StyleFontStretch;
use style::computed_values::font_weight::T as StyleFontWeight;
use style::values::computed::font::FontStyle as StyleFontStyle;
use style::values::generics::NonNegative;
use style::values::generics::font::FontStyle as GenericFontStyle;
use style::values::generics::NonNegative;
use style::values::specified::font::FontStretchKeyword;
use truetype;
@ -119,7 +119,7 @@ struct FontInfo {
impl FontInfo {
fn new_from_face(face: &FontFace) -> Result<FontInfo, ()> {
use std::cmp::{min, max};
use std::cmp::{max, min};
use std::io::Cursor;
use truetype::{NamingTable, Value, WindowsMetrics};
@ -187,7 +187,8 @@ impl FontInfo {
8 => FontStretchKeyword::ExtraExpanded,
9 => FontStretchKeyword::UltraExpanded,
_ => return Err(()),
}.compute(),
}
.compute(),
));
let style = if italic_bool {
@ -224,7 +225,8 @@ impl FontInfo {
FontStretch::Expanded => FontStretchKeyword::Expanded,
FontStretch::ExtraExpanded => FontStretchKeyword::ExtraExpanded,
FontStretch::UltraExpanded => FontStretchKeyword::UltraExpanded,
}.compute(),
}
.compute(),
));
Ok(FontInfo {

4
components/gfx/platform/windows/font_list.rs
View file

@ -3,11 +3,11 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::text::util::unicode_plane;
use dwrote::{Font, FontDescriptor, FontCollection};
use dwrote::{Font, FontCollection, FontDescriptor};
use servo_atoms::Atom;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Mutex;
use std::sync::atomic::{Ordering, AtomicUsize};
use ucd::{Codepoint, UnicodeBlock};
lazy_static! {

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

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

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

@ -10,8 +10,10 @@ extern crate style;
extern crate webrender_api;
use app_units::Au;
use gfx::font::{fallback_font_families, FontDescriptor, FontFamilyDescriptor, FontFamilyName, FontSearchScope};
use gfx::font_cache_thread::{FontTemplates, FontTemplateInfo};
use gfx::font::{
fallback_font_families, FontDescriptor, FontFamilyDescriptor, FontFamilyName, FontSearchScope,
};
use gfx::font_cache_thread::{FontTemplateInfo, FontTemplates};
use gfx::font_context::{FontContext, FontContextHandle, FontSource};
use gfx::font_template::FontTemplateDescriptor;
use servo_arc::Arc;
@ -24,7 +26,9 @@ use std::path::PathBuf;
use std::rc::Rc;
use style::properties::longhands::font_variant_caps::computed_value::T as FontVariantCaps;
use style::properties::style_structs::Font as FontStyleStruct;
use style::values::computed::font::{FamilyName, FamilyNameSyntax, FontFamily, FontFamilyList, FontSize};
use style::values::computed::font::{
FamilyName, FamilyNameSyntax, FontFamily, FontFamilyList, FontSize,
};
use style::values::computed::font::{FontStretch, FontWeight, SingleFontFamily};
use style::values::generics::font::FontStyle;
@ -119,7 +123,8 @@ fn font_family(names: Vec<&str>) -> FontFamily {
name: Atom::from(name),
syntax: FamilyNameSyntax::Quoted,
})
}).collect();
})
.collect();
FontFamily(FontFamilyList::new(names.into_boxed_slice()))
}

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

@ -19,10 +19,10 @@ fn test_font_template_descriptor() {
use std::fs::File;
use std::io::prelude::*;
use std::path::PathBuf;
use style::values::computed::Percentage;
use style::values::computed::font::{FontStretch, FontWeight};
use style::values::generics::NonNegative;
use style::values::computed::Percentage;
use style::values::generics::font::FontStyle;
use style::values::generics::NonNegative;
fn descriptor(filename: &str) -> FontTemplateDescriptor {
let mut path: PathBuf = [
@ -41,7 +41,8 @@ fn test_font_template_descriptor() {
let mut template = FontTemplate::new(
Atom::from(filename),
Some(file.bytes().map(|b| b.unwrap()).collect()),
).unwrap();
)
.unwrap();
let context = FontContextHandle::new();

2
components/gfx/tests/text_util.rs
View file

@ -4,7 +4,7 @@
extern crate gfx;
use gfx::text::util::{CompressionMode, transform_text};
use gfx::text::util::{transform_text, CompressionMode};
#[test]
fn test_transform_compress_none() {

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

@ -10,9 +10,9 @@ use euclid::Point2D;
))]
use packed_simd::u32x4;
use range::{self, EachIndex, Range, RangeIndex};
use std::{fmt, mem, u16};
use std::cmp::{Ordering, PartialOrd};
use std::vec::Vec;
use std::{fmt, mem, u16};
pub use gfx_traits::ByteIndex;
@ -223,16 +223,15 @@ impl<'a> DetailedGlyphStore {
entry_offset, glyphs
);
/* TODO: don't actually assert this until asserts are compiled
in/out based on severity, debug/release, etc. This assertion
would wreck the complexity of the lookup.
See Rust Issue #3647, #2228, #3627 for related information.
do self.detail_lookup.borrow |arr| {
assert !arr.contains(entry)
}
*/
// TODO: don't actually assert this until asserts are compiled
// in/out based on severity, debug/release, etc. This assertion
// would wreck the complexity of the lookup.
//
// See Rust Issue #3647, #2228, #3627 for related information.
//
// do self.detail_lookup.borrow |arr| {
// assert !arr.contains(entry)
// }
self.detail_lookup.push(entry);
self.detail_buffer.extend_from_slice(glyphs);
@ -541,7 +540,8 @@ impl<'a> GlyphStore {
data_for_glyphs[i].advance,
data_for_glyphs[i].offset,
)
}).collect();
})
.collect();
self.has_detailed_glyphs = true;
self.detail_store

20
components/gfx/text/shaping/harfbuzz.rs
View file

@ -5,15 +5,7 @@
#![allow(unsafe_code)]
use app_units::Au;
use crate::font::{ShapingFlags, Font, FontTableMethods, FontTableTag, ShapingOptions, KERN};
use crate::harfbuzz::{HB_DIRECTION_LTR, HB_DIRECTION_RTL, HB_MEMORY_MODE_READONLY};
use crate::harfbuzz::{hb_blob_create, hb_face_create_for_tables};
use crate::harfbuzz::{hb_buffer_create, hb_font_destroy};
use crate::harfbuzz::{hb_buffer_get_glyph_infos, hb_shape};
use crate::harfbuzz::{hb_buffer_set_direction, hb_buffer_set_script};
use crate::harfbuzz::{hb_buffer_t, hb_codepoint_t, hb_font_funcs_t};
use crate::harfbuzz::{hb_face_t, hb_font_t};
use crate::harfbuzz::{hb_position_t, hb_tag_t};
use crate::font::{Font, FontTableMethods, FontTableTag, ShapingFlags, ShapingOptions, KERN};
use crate::harfbuzz::hb_blob_t;
use crate::harfbuzz::hb_bool_t;
use crate::harfbuzz::hb_buffer_add_utf8;
@ -32,13 +24,21 @@ use crate::harfbuzz::hb_font_set_ppem;
use crate::harfbuzz::hb_font_set_scale;
use crate::harfbuzz::hb_glyph_info_t;
use crate::harfbuzz::hb_glyph_position_t;
use crate::harfbuzz::{hb_blob_create, hb_face_create_for_tables};
use crate::harfbuzz::{hb_buffer_create, hb_font_destroy};
use crate::harfbuzz::{hb_buffer_get_glyph_infos, hb_shape};
use crate::harfbuzz::{hb_buffer_set_direction, hb_buffer_set_script};
use crate::harfbuzz::{hb_buffer_t, hb_codepoint_t, hb_font_funcs_t};
use crate::harfbuzz::{hb_face_t, hb_font_t};
use crate::harfbuzz::{hb_position_t, hb_tag_t};
use crate::harfbuzz::{HB_DIRECTION_LTR, HB_DIRECTION_RTL, HB_MEMORY_MODE_READONLY};
use crate::platform::font::FontTable;
use crate::text::glyph::{ByteIndex, GlyphData, GlyphId, GlyphStore};
use crate::text::shaping::ShaperMethods;
use crate::text::util::{fixed_to_float, float_to_fixed, is_bidi_control};
use euclid::Point2D;
use std::{char, cmp, ptr};
use std::os::raw::{c_char, c_int, c_uint, c_void};
use std::{char, cmp, ptr};
const NO_GLYPH: i32 = -1;
const LIGA: u32 = ot_tag!('l', 'i', 'g', 'a');

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

@ -9,7 +9,7 @@ use crate::platform::font_template::FontTemplateData;
use crate::text::glyph::{ByteIndex, GlyphStore};
use range::Range;
use std::cell::Cell;
use std::cmp::{Ordering, max};
use std::cmp::{max, Ordering};
use std::slice::Iter;
use std::sync::Arc;
use style::str::char_is_whitespace;
@ -380,7 +380,8 @@ impl<'a> TextRun {
);
remaining -= slice_advance;
slice_index
}).sum()
})
.sum()
}
/// Returns an iterator that will iterate over all slices of glyphs that represent natural

2
components/gfx_traits/lib.rs
View file

@ -17,7 +17,7 @@ extern crate serde;
pub mod print_tree;
use range::RangeIndex;
use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering};
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
/// A newtype struct for denoting the age of messages; prevents race conditions.
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]

4
components/hashglobe/src/fake.rs
View file

@ -20,8 +20,8 @@ use std::fmt;
use std::hash::{BuildHasher, Hash};
use std::ops::{Deref, DerefMut};
pub use std::collections::hash_map::{Entry, RandomState, Iter as MapIter, IterMut as MapIterMut};
pub use std::collections::hash_set::{Iter as SetIter, IntoIter as SetIntoIter};
pub use std::collections::hash_map::{Entry, Iter as MapIter, IterMut as MapIterMut, RandomState};
pub use std::collections::hash_set::{IntoIter as SetIntoIter, Iter as SetIter};
#[derive(Clone)]
pub struct HashMap<K, V, S = RandomState>(StdMap<K, V, S>);

8
components/hashglobe/src/hash_map.rs
View file

@ -15,13 +15,13 @@ use std::borrow::Borrow;
use std::cmp::max;
use std::fmt::{self, Debug};
#[allow(deprecated)]
use std::hash::{Hash, BuildHasher};
use std::hash::{BuildHasher, Hash};
use std::iter::FromIterator;
use std::mem::{self, replace};
use std::ops::{Deref, Index};
use super::table::{self, Bucket, EmptyBucket, FullBucket, FullBucketMut, RawTable, SafeHash};
use super::table::BucketState::{Empty, Full};
use super::table::{self, Bucket, EmptyBucket, FullBucket, FullBucketMut, RawTable, SafeHash};
use FailedAllocationError;
@ -2214,11 +2214,11 @@ fn assert_covariance() {
#[cfg(test)]
mod test_map {
extern crate rand;
use super::HashMap;
use self::rand::{thread_rng, Rng};
use super::Entry::{Occupied, Vacant};
use super::HashMap;
use super::RandomState;
use cell::RefCell;
use self::rand::{thread_rng, Rng};
#[test]
fn test_zero_capacities() {

8
components/hashglobe/src/hash_set.rs
View file

@ -10,12 +10,12 @@
use std::borrow::Borrow;
use std::fmt;
use std::hash::{Hash, BuildHasher};
use std::hash::{BuildHasher, Hash};
use std::iter::{Chain, FromIterator};
use std::ops::{BitOr, BitAnd, BitXor, Sub};
use std::ops::{BitAnd, BitOr, BitXor, Sub};
use super::Recover;
use super::hash_map::{self, HashMap, Keys, RandomState};
use super::Recover;
// Future Optimization (FIXME!)
// =============================
@ -1258,8 +1258,8 @@ fn assert_covariance() {
#[cfg(test)]
mod test_set {
use super::HashSet;
use super::hash_map::RandomState;
use super::HashSet;
#[test]
fn test_zero_capacities() {

2
components/hashglobe/src/table.rs
View file

@ -9,13 +9,13 @@
// except according to those terms.
use alloc::{alloc, dealloc};
use shim::{Shared, Unique};
use std::cmp;
use std::hash::{BuildHasher, Hash, Hasher};
use std::marker;
use std::mem::{self, align_of, size_of};
use std::ops::{Deref, DerefMut};
use std::ptr;
use shim::{Unique, Shared};
use self::BucketState::*;
use FailedAllocationError;

24
components/layout/animation.rs
View file

@ -11,10 +11,10 @@ use crate::opaque_node::OpaqueNodeMethods;
use fxhash::FxHashMap;
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;
use script_traits::{AnimationState, ConstellationControlMsg, LayoutMsg as ConstellationMsg};
use script_traits::UntrustedNodeAddress;
use script_traits::{AnimationState, ConstellationControlMsg, LayoutMsg as ConstellationMsg};
use servo_channel::Receiver;
use style::animation::{Animation, update_style_for_animation};
use style::animation::{update_style_for_animation, Animation};
use style::dom::TElement;
use style::font_metrics::ServoMetricsProvider;
use style::selector_parser::RestyleDamage;
@ -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 {
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 {
script_chan.send(ConstellationControlMsg::TransitionEnd(
node.to_untrusted_node_address(),
frame.property_animation.property_name().into(),
frame.duration,
)).unwrap();
script_chan
.send(ConstellationControlMsg::TransitionEnd(
node.to_untrusted_node_address(),
frame.property_animation.property_name().into(),
frame.duration,
))
.unwrap();
}
expired_animations
@ -150,7 +155,8 @@ pub fn update_animation_state<E>(
.send(ConstellationMsg::ChangeRunningAnimationsState(
pipeline_id,
animation_state,
)).unwrap();
))
.unwrap();
}
/// Recalculates style for a set of animations. This does *not* run with the DOM

31
components/layout/block.rs
View file

@ -27,18 +27,26 @@
use app_units::{Au, MAX_AU};
use crate::context::LayoutContext;
use crate::display_list::items::DisplayListSection;
use crate::display_list::StackingContextCollectionState;
use crate::display_list::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use crate::display_list::{DisplayListBuildState, StackingContextCollectionFlags};
use crate::display_list::StackingContextCollectionState;
use crate::display_list::items::DisplayListSection;
use crate::floats::{ClearType, FloatKind, Floats, PlacementInfo};
use crate::flow::{BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ForceNonfloatedFlag, GetBaseFlow};
use crate::flow::{ImmutableFlowUtils, LateAbsolutePositionInfo, OpaqueFlow, FragmentationContext, FlowFlags};
use crate::flow::{
BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ForceNonfloatedFlag, GetBaseFlow,
};
use crate::flow::{
FlowFlags, FragmentationContext, ImmutableFlowUtils, LateAbsolutePositionInfo, OpaqueFlow,
};
use crate::flow_list::FlowList;
use crate::fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, Overflow, FragmentFlags};
use crate::fragment::{
CoordinateSystem, Fragment, FragmentBorderBoxIterator, FragmentFlags, Overflow,
};
use crate::incremental::RelayoutMode;
use crate::layout_debug;
use crate::model::{AdjoiningMargins, CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo, MaybeAuto};
use crate::model::{
AdjoiningMargins, CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo, MaybeAuto,
};
use crate::sequential;
use crate::traversal::PreorderFlowTraversal;
use euclid::{Point2D, Rect, SideOffsets2D, Size2D};
@ -58,8 +66,8 @@ use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalMargin, LogicalPoint, LogicalRect, LogicalSize, WritingMode};
use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::{LengthOrPercentageOrNone, LengthOrPercentage};
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrNone};
/// Information specific to floated blocks.
#[derive(Clone, Serialize)]
@ -1334,7 +1342,8 @@ impl BlockFlow {
self.fragment.style.writing_mode,
inline_size_for_float_placement,
block_size + self.fragment.margin.block_start_end(),
).convert(
)
.convert(
self.fragment.style.writing_mode,
self.base.floats.writing_mode,
),
@ -1361,7 +1370,8 @@ impl BlockFlow {
self.base.floats.writing_mode,
self.base.writing_mode,
container_size,
).start;
)
.start;
let margin_offset = LogicalPoint::new(
self.base.writing_mode,
Au(0),
@ -2626,7 +2636,8 @@ impl Flow for BlockFlow {
.early_absolute_position_info
.relative_containing_block_mode,
CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()),
)
.translate(&stacking_context_position.to_vector()),
);
}

37
components/layout/construct.rs
View file

@ -11,21 +11,28 @@
//! maybe it's an absolute or fixed position thing that hasn't found its containing block yet.
//! Construction items bubble up the tree from children to parents until they find their homes.
use crate::ServoArc;
use crate::block::BlockFlow;
use crate::context::{LayoutContext, with_thread_local_font_context};
use crate::data::{LayoutDataFlags, LayoutData};
use crate::context::{with_thread_local_font_context, LayoutContext};
use crate::data::{LayoutData, LayoutDataFlags};
use crate::display_list::items::OpaqueNode;
use crate::flex::FlexFlow;
use crate::floats::FloatKind;
use crate::flow::{AbsoluteDescendants, Flow, FlowClass, GetBaseFlow, ImmutableFlowUtils};
use crate::flow::{FlowFlags, MutableFlowUtils, MutableOwnedFlowUtils};
use crate::flow_ref::FlowRef;
use crate::fragment::{CanvasFragmentInfo, Fragment, FragmentFlags, GeneratedContentInfo, IframeFragmentInfo};
use crate::fragment::{ImageFragmentInfo, InlineAbsoluteFragmentInfo, InlineAbsoluteHypotheticalFragmentInfo};
use crate::fragment::{InlineBlockFragmentInfo, MediaFragmentInfo, SpecificFragmentInfo, SvgFragmentInfo};
use crate::fragment::{TableColumnFragmentInfo, UnscannedTextFragmentInfo, WhitespaceStrippingResult};
use crate::inline::{InlineFlow, InlineFragmentNodeInfo, InlineFragmentNodeFlags};
use crate::fragment::{
CanvasFragmentInfo, Fragment, FragmentFlags, GeneratedContentInfo, IframeFragmentInfo,
};
use crate::fragment::{
ImageFragmentInfo, InlineAbsoluteFragmentInfo, InlineAbsoluteHypotheticalFragmentInfo,
};
use crate::fragment::{
InlineBlockFragmentInfo, MediaFragmentInfo, SpecificFragmentInfo, SvgFragmentInfo,
};
use crate::fragment::{
TableColumnFragmentInfo, UnscannedTextFragmentInfo, WhitespaceStrippingResult,
};
use crate::inline::{InlineFlow, InlineFragmentNodeFlags, InlineFragmentNodeInfo};
use crate::linked_list::prepend_from;
use crate::list_item::{ListItemFlow, ListStyleTypeContent};
use crate::multicol::{MulticolColumnFlow, MulticolFlow};
@ -40,15 +47,18 @@ use crate::table_wrapper::TableWrapperFlow;
use crate::text::TextRunScanner;
use crate::traversal::PostorderNodeMutTraversal;
use crate::wrapper::{LayoutNodeLayoutData, TextContent, ThreadSafeLayoutNodeHelpers};
use script_layout_interface::{LayoutElementType, LayoutNodeType, is_image_data};
use script_layout_interface::wrapper_traits::{PseudoElementType, ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use crate::ServoArc;
use script_layout_interface::wrapper_traits::{
PseudoElementType, ThreadSafeLayoutElement, ThreadSafeLayoutNode,
};
use script_layout_interface::{is_image_data, LayoutElementType, LayoutNodeType};
use servo_config::opts;
use servo_url::ServoUrl;
use std::collections::LinkedList;
use std::marker::PhantomData;
use std::mem;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use style::computed_values::caption_side::T as CaptionSide;
use style::computed_values::display::T as Display;
use style::computed_values::empty_cells::T as EmptyCells;
@ -185,7 +195,8 @@ impl InlineBlockSplit {
predecessors: mem::replace(
fragment_accumulator,
InlineFragmentsAccumulator::from_inline_node(node, style_context),
).to_intermediate_inline_fragments::<ConcreteThreadSafeLayoutNode>(style_context),
)
.to_intermediate_inline_fragments::<ConcreteThreadSafeLayoutNode>(style_context),
flow: flow,
};
@ -402,7 +413,7 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
&self.layout_context,
));
SpecificFragmentInfo::Image(image_info)
}
},
Some(LayoutNodeType::Element(LayoutElementType::HTMLMediaElement)) => {
let data = node.media_data().unwrap();
SpecificFragmentInfo::Media(Box::new(MediaFragmentInfo::new(data)))

2
components/layout/context.rs
View file

@ -4,7 +4,7 @@
//! Data needed by the layout thread.
use crate::display_list::items::{WebRenderImageInfo, OpaqueNode};
use crate::display_list::items::{OpaqueNode, WebRenderImageInfo};
use crate::opaque_node::OpaqueNodeMethods;
use fnv::FnvHasher;
use gfx::font_cache_thread::FontCacheThread;

2
components/layout/display_list/background.rs
View file

@ -13,8 +13,8 @@ use style::computed_values::background_clip::single_value::T as BackgroundClip;
use style::computed_values::background_origin::single_value::T as BackgroundOrigin;
use style::properties::style_structs::Background;
use style::values::computed::{BackgroundSize, LengthOrPercentageOrAuto};
use style::values::generics::NonNegative;
use style::values::generics::background::BackgroundSize as GenericBackgroundSize;
use style::values::generics::NonNegative;
use style::values::specified::background::BackgroundRepeatKeyword;
use webrender_api::BorderRadius;

8
components/layout/display_list/border.rs
View file

@ -9,14 +9,14 @@ use crate::display_list::ToLayout;
use euclid::{Rect, SideOffsets2D, Size2D};
use style::computed_values::border_image_outset::T as BorderImageOutset;
use style::properties::style_structs::Border;
use style::values::Either;
use style::values::computed::NumberOrPercentage;
use style::values::computed::{BorderCornerRadius, BorderImageWidth};
use style::values::computed::{BorderImageSideWidth, LengthOrNumber};
use style::values::computed::NumberOrPercentage;
use style::values::generics::border::{BorderImageSideWidth as GenericBorderImageSideWidth};
use style::values::generics::border::BorderImageSideWidth as GenericBorderImageSideWidth;
use style::values::generics::rect::Rect as StyleRect;
use style::values::Either;
use webrender_api::{BorderRadius, BorderSide, BorderStyle, ColorF};
use webrender_api::{LayoutSize, LayoutSideOffsets, NormalBorder};
use webrender_api::{LayoutSideOffsets, LayoutSize, NormalBorder};
/// Computes a border radius size against the containing size.
///

18
components/layout/display_list/builder.rs
View file

@ -12,31 +12,31 @@ use app_units::{Au, AU_PER_PX};
use canvas_traits::canvas::{CanvasMsg, FromLayoutMsg};
use crate::block::BlockFlow;
use crate::context::LayoutContext;
use crate::display_list::ToLayout;
use crate::display_list::background::{self, get_cyclic};
use crate::display_list::border;
use crate::display_list::gradient;
use crate::display_list::items::{BaseDisplayItem, BLUR_INFLATION_FACTOR, ClipScrollNode};
use crate::display_list::items::{BaseDisplayItem, ClipScrollNode, BLUR_INFLATION_FACTOR};
use crate::display_list::items::{ClipScrollNodeIndex, ClipScrollNodeType, ClippingAndScrolling};
use crate::display_list::items::{ClippingRegion, DisplayItem, DisplayItemMetadata, DisplayList};
use crate::display_list::items::{DisplayListSection, CommonDisplayItem};
use crate::display_list::items::{CommonDisplayItem, DisplayListSection};
use crate::display_list::items::{IframeDisplayItem, OpaqueNode};
use crate::display_list::items::{PopAllTextShadowsDisplayItem, PushTextShadowDisplayItem};
use crate::display_list::items::{StackingContext, StackingContextType, StickyFrameData};
use crate::display_list::items::{TextOrientation, WebRenderImageInfo};
use crate::display_list::ToLayout;
use crate::flex::FlexFlow;
use crate::flow::{BaseFlow, Flow, FlowFlags};
use crate::flow_ref::FlowRef;
use crate::fragment::{CanvasFragmentSource, CoordinateSystem, Fragment, ScannedTextFragmentInfo};
use crate::fragment::SpecificFragmentInfo;
use crate::fragment::{CanvasFragmentSource, CoordinateSystem, Fragment, ScannedTextFragmentInfo};
use crate::inline::{InlineFlow, InlineFragmentNodeFlags};
use crate::list_item::ListItemFlow;
use crate::model::MaybeAuto;
use crate::table_cell::CollapsedBordersForCell;
use euclid::{rect, Point2D, Rect, SideOffsets2D, Size2D, TypedSize2D, Vector2D};
use fnv::FnvHashMap;
use gfx::text::TextRun;
use gfx::text::glyph::ByteIndex;
use gfx::text::TextRun;
use gfx_traits::{combine_id_with_fragment_type, FragmentType, StackingContextId};
use ipc_channel::ipc;
use msg::constellation_msg::{BrowsingContextId, PipelineId};
@ -56,20 +56,20 @@ use style::computed_values::visibility::T as Visibility;
use style::logical_geometry::{LogicalMargin, LogicalPoint, LogicalRect};
use style::properties::{style_structs, ComputedValues};
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::{Either, RGBA};
use style::values::computed::Gradient;
use style::values::computed::effects::SimpleShadow;
use style::values::computed::image::Image as ComputedImage;
use style::values::computed::Gradient;
use style::values::generics::background::BackgroundSize;
use style::values::generics::image::{GradientKind, Image, PaintWorklet};
use style::values::generics::ui::Cursor;
use style::values::{Either, RGBA};
use style_traits::cursor::CursorKind;
use style_traits::CSSPixel;
use style_traits::ToCss;
use style_traits::cursor::CursorKind;
use webrender_api::{self, BorderDetails, BorderRadius, BorderSide, BoxShadowClipMode, ColorF};
use webrender_api::{ExternalScrollId, FilterOp, GlyphInstance, ImageRendering, LayoutRect};
use webrender_api::{LayoutSize, LayoutTransform, LayoutVector2D, LineStyle, NinePatchBorder};
use webrender_api::{NinePatchBorderSource, NormalBorder, StickyOffsetBounds, ScrollSensitivity};
use webrender_api::{NinePatchBorderSource, NormalBorder, ScrollSensitivity, StickyOffsetBounds};
fn establishes_containing_block_for_absolute(
flags: StackingContextCollectionFlags,

2
components/layout/display_list/conversions.rs
View file

@ -7,10 +7,10 @@ use euclid::{Point2D, Rect, SideOffsets2D, Size2D, Vector2D};
use style::computed_values::image_rendering::T as ImageRendering;
use style::computed_values::mix_blend_mode::T as MixBlendMode;
use style::computed_values::transform_style::T as TransformStyle;
use style::values::RGBA;
use style::values::computed::{BorderStyle, Filter};
use style::values::generics::effects::Filter as GenericFilter;
use style::values::specified::border::BorderImageRepeatKeyword;
use style::values::RGBA;
use webrender_api as wr;
pub trait ToLayout {

4
components/layout/display_list/gradient.rs
View file

@ -8,11 +8,11 @@ use app_units::Au;
use crate::display_list::ToLayout;
use euclid::{Point2D, Size2D, Vector2D};
use style::properties::ComputedValues;
use style::values::computed::{Angle, GradientItem, LengthOrPercentage, Percentage, Position};
use style::values::computed::image::{EndingShape, LineDirection};
use style::values::generics::image::{Circle, Ellipse, ShapeExtent};
use style::values::computed::{Angle, GradientItem, LengthOrPercentage, Percentage, Position};
use style::values::generics::image::EndingShape as GenericEndingShape;
use style::values::generics::image::GradientItem as GenericGradientItem;
use style::values::generics::image::{Circle, Ellipse, ShapeExtent};
use style::values::specified::position::{X, Y};
use webrender_api::{ExtendMode, Gradient, GradientBuilder, GradientStop, RadialGradient};

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

@ -13,8 +13,8 @@
//! low-level drawing primitives.
use euclid::{SideOffsets2D, TypedRect, Vector2D};
use gfx_traits::{self, StackingContextId};
use gfx_traits::print_tree::PrintTree;
use gfx_traits::{self, StackingContextId};
use msg::constellation_msg::PipelineId;
use net_traits::image::base::Image;
use servo_geometry::MaxRect;
@ -590,7 +590,8 @@ impl ClippingRegion {
rect: complex.rect.translate(delta),
radii: complex.radii,
mode: complex.mode,
}).collect(),
})
.collect(),
}
}

11
components/layout/flex.rs
View file

@ -7,10 +7,10 @@
use app_units::{Au, MAX_AU};
use crate::block::{AbsoluteAssignBSizesTraversal, BlockFlow, MarginsMayCollapseFlag};
use crate::context::LayoutContext;
use crate::display_list::{DisplayListBuildState, FlexFlowDisplayListBuilding};
use crate::display_list::StackingContextCollectionState;
use crate::display_list::{DisplayListBuildState, FlexFlowDisplayListBuilding};
use crate::floats::FloatKind;
use crate::flow::{Flow, FlowClass, GetBaseFlow, ImmutableFlowUtils, OpaqueFlow, FlowFlags};
use crate::flow::{Flow, FlowClass, FlowFlags, GetBaseFlow, ImmutableFlowUtils, OpaqueFlow};
use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use crate::layout_debug;
use crate::model::{AdjoiningMargins, CollapsibleMargins};
@ -27,8 +27,10 @@ use style::computed_values::justify_content::T as JustifyContent;
use style::logical_geometry::{Direction, LogicalSize};
use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
use style::values::computed::flex::FlexBasis;
use style::values::computed::{
LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone,
};
use style::values::generics::flex::FlexBasis as GenericFlexBasis;
/// The size of an axis. May be a specified size, a min/max
@ -922,7 +924,8 @@ impl Flow for FlexFlow {
.base
.flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED)
}).map(|(index, flow)| FlexItem::new(index, flow))
})
.map(|(index, flow)| FlexItem::new(index, flow))
.collect();
items.sort_by_key(|item| item.order);

8
components/layout/flow.rs
View file

@ -28,8 +28,8 @@
use app_units::Au;
use crate::block::{BlockFlow, FormattingContextType};
use crate::context::LayoutContext;
use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
use crate::display_list::items::ClippingAndScrolling;
use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
use crate::flex::FlexFlow;
use crate::floats::{Floats, SpeculatedFloatPlacement};
use crate::flow_list::{FlowList, FlowListIterator, MutFlowListIterator};
@ -46,16 +46,16 @@ use crate::table_colgroup::TableColGroupFlow;
use crate::table_row::TableRowFlow;
use crate::table_rowgroup::TableRowGroupFlow;
use crate::table_wrapper::TableWrapperFlow;
use euclid::{Point2D, Vector2D, Rect, Size2D};
use gfx_traits::StackingContextId;
use euclid::{Point2D, Rect, Size2D, Vector2D};
use gfx_traits::print_tree::PrintTree;
use gfx_traits::StackingContextId;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use servo_geometry::{au_rect_to_f32_rect, f32_rect_to_au_rect, MaxRect};
use std::fmt;
use std::iter::Zip;
use std::slice::IterMut;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use style::computed_values::clear::T as Clear;
use style::computed_values::float::T as Float;
use style::computed_values::overflow_x::T as StyleOverflow;

4
components/layout/flow_list.rs
View file

@ -5,8 +5,8 @@
use crate::flow::{Flow, FlowClass};
use crate::flow_ref::FlowRef;
use serde::ser::{Serialize, SerializeSeq, Serializer};
use serde_json::{Map, Value, to_value};
use std::collections::{LinkedList, linked_list};
use serde_json::{to_value, Map, Value};
use std::collections::{linked_list, LinkedList};
use std::ops::Deref;
use std::sync::Arc;

98
components/layout/fragment.rs
View file

@ -5,24 +5,24 @@
//! The `Fragment` type, which represents the leaves of the layout tree.
use app_units::Au;
use canvas_traits::canvas::{CanvasMsg, CanvasId};
use crate::ServoArc;
use crate::context::{LayoutContext, with_thread_local_font_context};
use canvas_traits::canvas::{CanvasId, CanvasMsg};
use crate::context::{with_thread_local_font_context, LayoutContext};
use crate::display_list::items::{ClipScrollNodeIndex, OpaqueNode, BLUR_INFLATION_FACTOR};
use crate::display_list::ToLayout;
use crate::display_list::items::{BLUR_INFLATION_FACTOR, ClipScrollNodeIndex, OpaqueNode};
use crate::floats::ClearType;
use crate::flow::{GetBaseFlow, ImmutableFlowUtils};
use crate::flow_ref::FlowRef;
use crate::inline::{InlineFragmentNodeFlags, InlineFragmentContext, InlineFragmentNodeInfo};
use crate::inline::{InlineFragmentContext, InlineFragmentNodeFlags, InlineFragmentNodeInfo};
use crate::inline::{InlineMetrics, LineMetrics};
#[cfg(debug_assertions)]
use crate::layout_debug;
use crate::model::{self, IntrinsicISizes, IntrinsicISizesContribution, MaybeAuto, SizeConstraint};
use crate::model::style_length;
use crate::model::{self, IntrinsicISizes, IntrinsicISizesContribution, MaybeAuto, SizeConstraint};
use crate::text;
use crate::text::TextRunScanner;
use crate::wrapper::ThreadSafeLayoutNodeHelpers;
use euclid::{Point2D, Vector2D, Rect, Size2D};
use crate::ServoArc;
use euclid::{Point2D, Rect, Size2D, Vector2D};
use gfx;
use gfx::text::glyph::ByteIndex;
use gfx::text::text_run::{TextRun, TextRunSlice};
@ -32,15 +32,17 @@ use msg::constellation_msg::{BrowsingContextId, PipelineId};
use net_traits::image::base::{Image, ImageMetadata};
use net_traits::image_cache::{ImageOrMetadataAvailable, UsePlaceholder};
use range::*;
use script_layout_interface::wrapper_traits::{
PseudoElementType, ThreadSafeLayoutElement, ThreadSafeLayoutNode,
};
use script_layout_interface::{HTMLCanvasData, HTMLCanvasDataSource, HTMLMediaData, SVGSVGData};
use script_layout_interface::wrapper_traits::{PseudoElementType, ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use serde::ser::{Serialize, SerializeStruct, Serializer};
use servo_url::ServoUrl;
use std::{f32, fmt};
use std::borrow::ToOwned;
use std::cmp::{Ordering, max, min};
use std::cmp::{max, min, Ordering};
use std::collections::LinkedList;
use std::sync::{Arc, Mutex};
use std::{f32, fmt};
use style::computed_values::border_collapse::T as BorderCollapse;
use style::computed_values::box_sizing::T as BoxSizing;
use style::computed_values::clear::T as Clear;
@ -59,8 +61,8 @@ use style::properties::ComputedValues;
use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::str::char_is_whitespace;
use style::values::computed::{Length, LengthOrPercentage, LengthOrPercentageOrAuto};
use style::values::computed::counters::ContentItem;
use style::values::computed::{Length, LengthOrPercentage, LengthOrPercentageOrAuto};
use style::values::generics::box_::{Perspective, VerticalAlign};
use style::values::generics::transform;
use webrender_api::{self, LayoutTransform};
@ -416,23 +418,28 @@ impl ImageFragmentInfo {
layout_context: &LayoutContext,
) -> ImageFragmentInfo {
// First use any image data present in the element...
let image_or_metadata = node.image_data().and_then(|(image, metadata)| {
match (image, metadata) {
let image_or_metadata = node
.image_data()
.and_then(|(image, metadata)| match (image, metadata) {
(Some(image), _) => Some(ImageOrMetadata::Image(image)),
(None, Some(metadata)) => Some(ImageOrMetadata::Metadata(metadata)),
_ => 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);
@ -452,15 +459,13 @@ impl ImageFragmentInfo {
}),
)
},
Some(ImageOrMetadata::Metadata(m)) => {
(
None,
Some(ImageMetadata {
height: (m.height as f64 / current_pixel_density) as u32,
width: (m.width as f64 / current_pixel_density) as u32,
}),
)
},
Some(ImageOrMetadata::Metadata(m)) => (
None,
Some(ImageMetadata {
height: (m.height as f64 / current_pixel_density) as u32,
width: (m.width as f64 / current_pixel_density) as u32,
}),
),
None => (None, None),
};
@ -1012,7 +1017,7 @@ impl Fragment {
} else {
Au(0)
}
}
},
SpecificFragmentInfo::Media(ref info) => {
if let Some((_, width, _)) = info.current_frame {
Au::from_px(width as i32)
@ -1042,7 +1047,7 @@ impl Fragment {
} else {
Au(0)
}
}
},
SpecificFragmentInfo::Media(ref info) => {
if let Some((_, _, height)) = info.current_frame {
Au::from_px(height as i32)
@ -1174,17 +1179,21 @@ impl Fragment {
(_, Ordering::Equal) => (first_isize, first_bsize),
// When both rectangles grow (smaller than min sizes),
// Choose the larger one;
(Ordering::Greater, Ordering::Greater) => if first_isize > second_isize {
(first_isize, first_bsize)
} else {
(second_isize, second_bsize)
(Ordering::Greater, Ordering::Greater) => {
if first_isize > second_isize {
(first_isize, first_bsize)
} else {
(second_isize, second_bsize)
}
},
// When both rectangles shrink (larger than max sizes),
// Choose the smaller one;
(Ordering::Less, Ordering::Less) => if first_isize > second_isize {
(second_isize, second_bsize)
} else {
(first_isize, first_bsize)
(Ordering::Less, Ordering::Less) => {
if first_isize > second_isize {
(second_isize, second_bsize)
} else {
(first_isize, first_bsize)
}
},
// It does not matter which we choose here, because both sizes
// will be clamped to constraint;
@ -3173,7 +3182,8 @@ impl Fragment {
perspective_origin
.vertical
.to_used_value(stacking_relative_border_box.size.height),
).to_layout();
)
.to_layout();
let pre_transform = LayoutTransform::create_translation(
perspective_origin.x,

6
components/layout/generated_content.rs
View file

@ -8,10 +8,12 @@
//! done in parallel and is therefore a sequential pass that runs on as little of the flow tree
//! as possible.
use crate::context::{LayoutContext, with_thread_local_font_context};
use crate::context::{with_thread_local_font_context, LayoutContext};
use crate::display_list::items::OpaqueNode;
use crate::flow::{Flow, FlowFlags, GetBaseFlow, ImmutableFlowUtils};
use crate::fragment::{Fragment, GeneratedContentInfo, SpecificFragmentInfo, UnscannedTextFragmentInfo};
use crate::fragment::{
Fragment, GeneratedContentInfo, SpecificFragmentInfo, UnscannedTextFragmentInfo,
};
use crate::text::TextRunScanner;
use crate::traversal::InorderFlowTraversal;
use script_layout_interface::wrapper_traits::PseudoElementType;

2
components/layout/incremental.rs
View file

@ -2,7 +2,7 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::flow::{FlowFlags, Flow, GetBaseFlow};
use crate::flow::{Flow, FlowFlags, GetBaseFlow};
use style::computed_values::float::T as Float;
use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::ServoRestyleDamage;

27
components/layout/inline.rs
View file

@ -3,32 +3,32 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use app_units::{Au, MIN_AU};
use crate::ServoArc;
use crate::block::AbsoluteAssignBSizesTraversal;
use crate::context::{LayoutContext, LayoutFontContext};
use crate::display_list::{DisplayListBuildState, InlineFlowDisplayListBuilding};
use crate::display_list::StackingContextCollectionState;
use crate::display_list::items::OpaqueNode;
use crate::display_list::StackingContextCollectionState;
use crate::display_list::{DisplayListBuildState, InlineFlowDisplayListBuilding};
use crate::floats::{FloatKind, Floats, PlacementInfo};
use crate::flow::{BaseFlow, Flow, FlowClass, ForceNonfloatedFlag};
use crate::flow::{FlowFlags, EarlyAbsolutePositionInfo, GetBaseFlow, OpaqueFlow};
use crate::flow::{EarlyAbsolutePositionInfo, FlowFlags, GetBaseFlow, OpaqueFlow};
use crate::flow_ref::FlowRef;
use crate::fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, Overflow};
use crate::fragment::FragmentFlags;
use crate::fragment::SpecificFragmentInfo;
use crate::fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, Overflow};
use crate::layout_debug;
use crate::model::IntrinsicISizesContribution;
use crate::text;
use crate::traversal::PreorderFlowTraversal;
use crate::ServoArc;
use euclid::{Point2D, Size2D};
use gfx::font::FontMetrics;
use gfx_traits::print_tree::PrintTree;
use range::{Range, RangeIndex};
use script_layout_interface::wrapper_traits::PseudoElementType;
use std::{fmt, i32, isize, mem};
use std::cmp::max;
use std::collections::VecDeque;
use std::sync::Arc;
use std::{fmt, i32, isize, mem};
use style::computed_values::display::T as Display;
use style::computed_values::overflow_x::T as StyleOverflow;
use style::computed_values::position::T as Position;
@ -316,7 +316,8 @@ impl LineBreaker {
.map(|fragment| match fragment.specific {
SpecificFragmentInfo::ScannedText(ref info) => info.run.bidi_level,
_ => para_level,
}).collect();
})
.collect();
let mut lines = mem::replace(&mut self.lines, Vec::new());
@ -336,7 +337,8 @@ impl LineBreaker {
let start = FragmentIndex(run.start as isize);
let len = FragmentIndex(run.len() as isize);
(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());
let first_fragment = &self.fragments.fragments[first_fragment_index];
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(
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());
let first_fragment = &self.fragments.fragments[first_fragment_index];
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(
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_mode,
CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()),
)
.translate(&stacking_context_position.to_vector()),
)
}
}

2
components/layout/layout_debug.rs
View file

@ -13,7 +13,7 @@ use std::cell::RefCell;
use std::fs::File;
use std::io::Write;
#[cfg(debug_assertions)]
use std::sync::atomic::{ATOMIC_USIZE_INIT, AtomicUsize, Ordering};
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
thread_local!(static STATE_KEY: RefCell<Option<State>> = RefCell::new(None));

2
components/layout/lib.rs
View file

@ -87,9 +87,9 @@ pub mod traversal;
pub mod wrapper;
// For unit tests:
pub use self::data::LayoutData;
pub use crate::fragment::Fragment;
pub use crate::fragment::SpecificFragmentInfo;
pub use self::data::LayoutData;
// We can't use servo_arc for everything in layout, because the Flow stuff uses
// weak references.

11
components/layout/list_item.rs
View file

@ -7,13 +7,15 @@
use app_units::Au;
use crate::block::BlockFlow;
use crate::context::{LayoutContext, with_thread_local_font_context};
use crate::display_list::{DisplayListBuildState, ListItemFlowDisplayListBuilding};
use crate::context::{with_thread_local_font_context, LayoutContext};
use crate::display_list::StackingContextCollectionState;
use crate::display_list::{DisplayListBuildState, ListItemFlowDisplayListBuilding};
use crate::floats::FloatKind;
use crate::flow::{Flow, FlowClass, OpaqueFlow};
use crate::fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, GeneratedContentInfo};
use crate::fragment::Overflow;
use crate::fragment::{
CoordinateSystem, Fragment, FragmentBorderBoxIterator, GeneratedContentInfo,
};
use crate::generated_content;
use crate::inline::InlineFlow;
use euclid::Point2D;
@ -257,7 +259,8 @@ impl Flow for ListItemFlow {
.early_absolute_position_info
.relative_containing_block_mode,
CoordinateSystem::Own,
).translate(&stacking_context_position.to_vector()),
)
.translate(&stacking_context_position.to_vector()),
);
}
}

32
components/layout/model.rs
View file

@ -11,8 +11,8 @@ use std::cmp::{max, min};
use std::fmt;
use style::logical_geometry::{LogicalMargin, WritingMode};
use style::properties::ComputedValues;
use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentage};
use style::values::computed::LengthOrPercentageOrNone;
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
/// A collapsible margin. See CSS 2.1 § 8.3.1.
#[derive(Clone, Copy, Debug)]
@ -505,10 +505,12 @@ pub fn style_length(
) -> MaybeAuto {
match container_size {
Some(length) => MaybeAuto::from_style(style_length, length),
None => if let LengthOrPercentageOrAuto::Length(length) = style_length {
MaybeAuto::Specified(Au::from(length))
} else {
MaybeAuto::Auto
None => {
if let LengthOrPercentageOrAuto::Length(length) = style_length {
MaybeAuto::Specified(Au::from(length))
} else {
MaybeAuto::Auto
}
},
}
}
@ -580,19 +582,23 @@ impl SizeConstraint {
) -> SizeConstraint {
let mut min_size = match container_size {
Some(container_size) => min_size.to_used_value(container_size),
None => if let LengthOrPercentage::Length(length) = min_size {
Au::from(length)
} else {
Au(0)
None => {
if let LengthOrPercentage::Length(length) = min_size {
Au::from(length)
} else {
Au(0)
}
},
};
let mut max_size = match container_size {
Some(container_size) => max_size.to_used_value(container_size),
None => if let LengthOrPercentageOrNone::Length(length) = max_size {
Some(Au::from(length))
} else {
None
None => {
if let LengthOrPercentageOrNone::Length(length) = max_size {
Some(Au::from(length))
} else {
None
}
},
};
// Make sure max size is not smaller than min size.

11
components/layout/multicol.rs
View file

@ -5,23 +5,23 @@
//! CSS Multi-column layout http://dev.w3.org/csswg/css-multicol/
use app_units::Au;
use crate::ServoArc;
use crate::block::BlockFlow;
use crate::context::LayoutContext;
use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
use crate::floats::FloatKind;
use crate::flow::{Flow, FlowClass, OpaqueFlow, FragmentationContext, GetBaseFlow};
use crate::flow::{Flow, FlowClass, FragmentationContext, GetBaseFlow, OpaqueFlow};
use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use crate::ServoArc;
use euclid::{Point2D, Vector2D};
use gfx_traits::print_tree::PrintTree;
use std::cmp::{min, max};
use std::cmp::{max, min};
use std::fmt;
use std::sync::Arc;
use style::logical_geometry::LogicalSize;
use style::properties::ComputedValues;
use style::values::Either;
use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
use style::values::generics::column::ColumnCount;
use style::values::Either;
#[allow(unsafe_code)]
unsafe impl crate::flow::HasBaseFlow for MulticolFlow {}
@ -164,7 +164,8 @@ impl Flow for MulticolFlow {
LogicalSize::from_physical(
self.block_flow.base.writing_mode,
ctx.shared_context().viewport_size(),
).block
)
.block
}
},
});

2
components/layout/parallel.rs
View file

@ -14,7 +14,7 @@ use crate::flow::{Flow, GetBaseFlow};
use crate::flow_ref::FlowRef;
use crate::traversal::{AssignBSizes, AssignISizes, BubbleISizes};
use crate::traversal::{PostorderFlowTraversal, PreorderFlowTraversal};
use profile_traits::time::{self, TimerMetadata, profile};
use profile_traits::time::{self, profile, TimerMetadata};
use rayon;
use servo_config::opts;
use smallvec::SmallVec;

33
components/layout/query.rs
View file

@ -7,27 +7,29 @@
use app_units::Au;
use crate::construct::ConstructionResult;
use crate::context::LayoutContext;
use crate::display_list::IndexableText;
use crate::display_list::items::{DisplayList, OpaqueNode, ScrollOffsetMap};
use crate::display_list::IndexableText;
use crate::flow::{Flow, GetBaseFlow};
use crate::fragment::{Fragment, FragmentBorderBoxIterator, SpecificFragmentInfo};
use crate::inline::InlineFragmentNodeFlags;
use crate::opaque_node::OpaqueNodeMethods;
use crate::sequential;
use crate::wrapper::LayoutNodeLayoutData;
use euclid::{Point2D, Vector2D, Rect, Size2D};
use euclid::{Point2D, Rect, Size2D, Vector2D};
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::PipelineId;
use script_layout_interface::{LayoutElementType, LayoutNodeType};
use script_layout_interface::StyleData;
use script_layout_interface::rpc::TextIndexResponse;
use script_layout_interface::rpc::{ContentBoxResponse, ContentBoxesResponse, LayoutRPC};
use script_layout_interface::rpc::{NodeGeometryResponse, NodeScrollIdResponse};
use script_layout_interface::rpc::{OffsetParentResponse, ResolvedStyleResponse, StyleResponse};
use script_layout_interface::rpc::TextIndexResponse;
use script_layout_interface::wrapper_traits::{LayoutNode, ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use script_layout_interface::wrapper_traits::{
LayoutNode, ThreadSafeLayoutElement, ThreadSafeLayoutNode,
};
use script_layout_interface::StyleData;
use script_layout_interface::{LayoutElementType, LayoutNodeType};
use script_traits::LayoutMsg as ConstellationMsg;
use script_traits::UntrustedNodeAddress;
use std::cmp::{min, max};
use std::cmp::{max, min};
use std::ops::Deref;
use std::sync::{Arc, Mutex};
use style::computed_values::display::T as Display;
@ -35,8 +37,8 @@ use style::computed_values::position::T as Position;
use style::computed_values::visibility::T as Visibility;
use style::context::{StyleContext, ThreadLocalStyleContext};
use style::dom::TElement;
use style::logical_geometry::{WritingMode, BlockFlowDirection, InlineBaseDirection};
use style::properties::{style_structs, PropertyId, PropertyDeclarationId, LonghandId};
use style::logical_geometry::{BlockFlowDirection, InlineBaseDirection, WritingMode};
use style::properties::{style_structs, LonghandId, PropertyDeclarationId, PropertyId};
use style::selector_parser::PseudoElement;
use style_traits::ToCss;
use webrender_api::ExternalScrollId;
@ -603,7 +605,7 @@ impl FragmentBorderBoxIterator for ParentOffsetBorderBoxIterator {
// cause this assertion to fail sometimes, so it's
// commented out for now.
/*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 {
offset: border_box.origin,
@ -840,12 +842,11 @@ where
let applies = true;
fn used_value_for_position_property<N: LayoutNode>(
layout_el: <N::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteThreadSafeLayoutElement,
layout_root: &mut Flow,
requested_node: N,
longhand_id: LonghandId,
) -> String
{
layout_el: <N::ConcreteThreadSafeLayoutNode as ThreadSafeLayoutNode>::ConcreteThreadSafeLayoutElement,
layout_root: &mut Flow,
requested_node: N,
longhand_id: LonghandId,
) -> String {
let maybe_data = layout_el.borrow_layout_data();
let position = maybe_data.map_or(Point2D::zero(), |data| {
match (*data).flow_construction_result {

4
components/layout/sequential.rs
View file

@ -8,8 +8,8 @@ use app_units::Au;
use crate::context::LayoutContext;
use crate::display_list::{DisplayListBuildState, StackingContextCollectionState};
use crate::floats::SpeculatedFloatPlacement;
use crate::flow::{Flow, ImmutableFlowUtils, FlowFlags, GetBaseFlow};
use crate::fragment::{FragmentBorderBoxIterator, CoordinateSystem};
use crate::flow::{Flow, FlowFlags, GetBaseFlow, ImmutableFlowUtils};
use crate::fragment::{CoordinateSystem, FragmentBorderBoxIterator};
use crate::generated_content::ResolveGeneratedContent;
use crate::incremental::RelayoutMode;
use crate::traversal::{AssignBSizes, AssignISizes, BubbleISizes, BuildDisplayList};

13
components/layout/table.rs
View file

@ -9,8 +9,13 @@ use crate::block::{BlockFlow, CandidateBSizeIterator, ISizeAndMarginsComputer};
use crate::block::{ISizeConstraintInput, ISizeConstraintSolution};
use crate::context::LayoutContext;
use crate::display_list::{BlockFlowDisplayListBuilding, BorderPaintingMode};
use crate::display_list::{DisplayListBuildState, StackingContextCollectionFlags, StackingContextCollectionState};
use crate::flow::{BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, ImmutableFlowUtils, GetBaseFlow, OpaqueFlow};
use crate::display_list::{
DisplayListBuildState, StackingContextCollectionFlags, StackingContextCollectionState,
};
use crate::flow::{
BaseFlow, EarlyAbsolutePositionInfo, Flow, FlowClass, GetBaseFlow, ImmutableFlowUtils,
OpaqueFlow,
};
use crate::flow_list::{FlowListIterator, MutFlowListIterator};
use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use crate::layout_debug;
@ -25,11 +30,11 @@ use std::{cmp, fmt};
use style::computed_values::{border_collapse, border_spacing, table_layout};
use style::context::SharedStyleContext;
use style::logical_geometry::LogicalSize;
use style::properties::ComputedValues;
use style::properties::style_structs::Background;
use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::CSSFloat;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::CSSFloat;
#[allow(unsafe_code)]
unsafe impl crate::flow::HasBaseFlow for TableFlow {}

3
components/layout/table_cell.rs
View file

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

4
components/layout/table_row.rs
View file

@ -9,7 +9,9 @@ use crate::block::{BlockFlow, ISizeAndMarginsComputer};
use crate::context::LayoutContext;
use crate::display_list::{BlockFlowDisplayListBuilding, DisplayListBuildState};
use crate::display_list::{StackingContextCollectionFlags, StackingContextCollectionState};
use crate::flow::{EarlyAbsolutePositionInfo, Flow, FlowClass, ImmutableFlowUtils, GetBaseFlow, OpaqueFlow};
use crate::flow::{
EarlyAbsolutePositionInfo, Flow, FlowClass, GetBaseFlow, ImmutableFlowUtils, OpaqueFlow,
};
use crate::flow_list::MutFlowListIterator;
use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use crate::layout_debug;

30
components/layout/table_wrapper.rs
View file

@ -12,13 +12,17 @@
//! Hereafter this document is referred to as INTRINSIC.
use app_units::Au;
use crate::block::{AbsoluteNonReplaced, BlockFlow, FloatNonReplaced, ISizeAndMarginsComputer, ISizeConstraintInput};
use crate::block::{
AbsoluteNonReplaced, BlockFlow, FloatNonReplaced, ISizeAndMarginsComputer, ISizeConstraintInput,
};
use crate::block::{ISizeConstraintSolution, MarginsMayCollapseFlag};
use crate::context::LayoutContext;
use crate::display_list::{BlockFlowDisplayListBuilding, DisplayListBuildState, StackingContextCollectionFlags};
use crate::display_list::StackingContextCollectionState;
use crate::display_list::{
BlockFlowDisplayListBuilding, DisplayListBuildState, StackingContextCollectionFlags,
};
use crate::floats::FloatKind;
use crate::flow::{Flow, FlowClass, ImmutableFlowUtils, FlowFlags, OpaqueFlow};
use crate::flow::{Flow, FlowClass, FlowFlags, ImmutableFlowUtils, OpaqueFlow};
use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use crate::model::MaybeAuto;
use crate::table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize};
@ -31,8 +35,8 @@ use style::computed_values::{position, table_layout};
use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalRect, LogicalSize};
use style::properties::ComputedValues;
use style::values::CSSFloat;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::CSSFloat;
#[derive(Clone, Copy, Debug, Serialize)]
pub enum TableLayout {
@ -143,7 +147,8 @@ impl TableWrapperFlow {
);
total_guess = &total_guess + &guess;
guess
}).collect();
})
.collect();
// Assign inline sizes.
let selection =
@ -385,7 +390,8 @@ impl Flow for TableWrapperFlow {
size: column_intrinsic_inline_size.minimum_length,
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.
// Now compute the real value.
@ -753,17 +759,17 @@ impl ExcessInlineSizeDistributionInfo {
if !column_intrinsic_inline_size.constrained &&
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 +
column_intrinsic_inline_size.preferred;
self.preferred_inline_size_of_nonconstrained_columns_with_no_percentage = self
.preferred_inline_size_of_nonconstrained_columns_with_no_percentage +
column_intrinsic_inline_size.preferred;
self.count_of_nonconstrained_columns_with_no_percentage += 1
}
if column_intrinsic_inline_size.constrained &&
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 +
column_intrinsic_inline_size.preferred
self.preferred_inline_size_of_constrained_columns_with_no_percentage = self
.preferred_inline_size_of_constrained_columns_with_no_percentage +
column_intrinsic_inline_size.preferred
}
self.total_percentage += column_intrinsic_inline_size.percentage;
self.column_count += 1

6
components/layout/text.rs
View file

@ -10,7 +10,7 @@ use crate::fragment::{Fragment, ScannedTextFlags};
use crate::fragment::{ScannedTextFragmentInfo, SpecificFragmentInfo, UnscannedTextFragmentInfo};
use crate::inline::{InlineFragmentNodeFlags, InlineFragments};
use crate::linked_list::split_off_head;
use gfx::font::{FontRef, FontMetrics, RunMetrics, ShapingFlags, ShapingOptions};
use gfx::font::{FontMetrics, FontRef, RunMetrics, ShapingFlags, ShapingOptions};
use gfx::text::glyph::ByteIndex;
use gfx::text::text_run::TextRun;
use gfx::text::util::{self, CompressionMode};
@ -26,11 +26,11 @@ use style::computed_values::text_transform::T as TextTransform;
use style::computed_values::white_space::T as WhiteSpace;
use style::computed_values::word_break::T as WordBreak;
use style::logical_geometry::{LogicalSize, WritingMode};
use style::properties::ComputedValues;
use style::properties::style_structs::Font as FontStyleStruct;
use style::properties::ComputedValues;
use style::values::generics::text::LineHeight;
use unicode_bidi as bidi;
use unicode_script::{Script, get_script};
use unicode_script::{get_script, Script};
use xi_unicode::LineBreakLeafIter;
/// Returns the concatenated text of a list of unscanned text fragments.

6
components/layout/traversal.rs
View file

@ -7,9 +7,9 @@
use crate::construct::FlowConstructor;
use crate::context::LayoutContext;
use crate::display_list::DisplayListBuildState;
use crate::flow::{FlowFlags, Flow, GetBaseFlow, ImmutableFlowUtils};
use crate::wrapper::{GetRawData, LayoutNodeLayoutData};
use crate::flow::{Flow, FlowFlags, GetBaseFlow, ImmutableFlowUtils};
use crate::wrapper::ThreadSafeLayoutNodeHelpers;
use crate::wrapper::{GetRawData, LayoutNodeLayoutData};
use script_layout_interface::wrapper_traits::{LayoutNode, ThreadSafeLayoutNode};
use servo_config::opts;
use style::context::{SharedStyleContext, StyleContext};
@ -17,8 +17,8 @@ use style::data::ElementData;
use style::dom::{NodeInfo, TElement, TNode};
use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::traversal::{DomTraversal, recalc_style_at};
use style::traversal::PerLevelTraversalData;
use style::traversal::{recalc_style_at, DomTraversal};
pub struct RecalcStyleAndConstructFlows<'a> {
context: LayoutContext<'a>,

2
components/layout/wrapper.rs
View file

@ -32,8 +32,8 @@
use atomic_refcell::{AtomicRef, AtomicRefMut};
use crate::data::{LayoutData, LayoutDataFlags, StyleAndLayoutData};
use script_layout_interface::wrapper_traits::{ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use script_layout_interface::wrapper_traits::GetLayoutData;
use script_layout_interface::wrapper_traits::{ThreadSafeLayoutElement, ThreadSafeLayoutNode};
use style::dom::{NodeInfo, TNode};
use style::selector_parser::RestyleDamage;
use style::values::computed::counters::ContentItem;

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