mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

servo: Merge #735 - Upgrade to latest Rust (from kmcallister:rust-upgrade); r=kmcallister,metajack 

Was #734.

Source-Repo: https://github.com/servo/servo
Source-Revision: 2359587cbbc77a86d92c9628f19bc883818c563f
This commit is contained in:
Keegan McAllister 2013-08-16 15:46:03 -07:00
Родитель 8e37355941
Коммит f8dd4f7823
76 изменённых файлов: 1174 добавлений и 1119 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

12
servo/Makefile.in
Просмотреть файл

@ -29,7 +29,7 @@ B := $(CFG_BUILD_DIR)
MKFILE_DEPS := config.stamp $(call rwildcard,$(S)mk/,*)
CFG_RUSTC_FLAGS := $(RUSTFLAGS) -A default_methods
CFG_RUSTC_FLAGS := $(RUSTFLAGS)
ifdef CFG_DISABLE_OPTIMIZE
$(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
@ -235,23 +235,23 @@ all: src/compiler/rust/rust-auto-clean-stamp servo package
$(DONE_util): $(DEPS_util)
@$(call E, compile: $@)
$(Q)$(RUSTC) $(RFLAGS_util) -o $@ $< && touch $@
$(Q)$(RUSTC) $(RFLAGS_util) --out-dir src/components/util $< && touch $@
$(DONE_net): $(DEPS_net)
@$(call E, compile: $@)
$(Q)$(RUSTC) $(RFLAGS_net) -o $@ $< && touch $@
$(Q)$(RUSTC) $(RFLAGS_net) --out-dir src/components/net $< && touch $@
$(DONE_msg): $(DEPS_msg)
@$(call E, compile: $@)
$(Q)$(RUSTC) $(RFLAGS_msg) -o $@ $< && touch $@
$(Q)$(RUSTC) $(RFLAGS_msg) --out-dir src/components/msg $< && touch $@
$(DONE_gfx): $(DEPS_gfx)
@$(call E, compile: $@)
$(Q)$(RUSTC) $(RFLAGS_gfx) -o $@ $< && touch $@
$(Q)$(RUSTC) $(RFLAGS_gfx) --out-dir src/components/gfx $< && touch $@
$(DONE_script): $(DEPS_script)
@$(call E, compile: $@)
$(Q)$(RUSTC) $(RFLAGS_script) -o $@ $< && touch $@
$(Q)$(RUSTC) $(RFLAGS_script) --out-dir src/components/script $< && touch $@
BINDINGS_SRC = $(S)/src/components/script/dom/bindings/codegen

2
servo/configure поставляемый
Просмотреть файл

@ -403,11 +403,9 @@ CFG_SUBMODULES="\
support/css/rust-css \
support/css/rust-cssparser \
support/geom/rust-geom \
support/glut/rust-glut \
support/glfw/glfw \
support/glfw/glfw-rs \
support/harfbuzz/rust-harfbuzz \
support/http-client/rust-http-client \
support/hubbub/libhubbub \
support/hubbub/rust-hubbub \
support/layers/rust-layers \

8
servo/mk/sub.mk
Просмотреть файл

@ -51,10 +51,6 @@ DEPS_glfw-rs += \
glfw \
$(NULL)
DEPS_rust-glut += \
rust-opengles \
$(NULL)
DEPS_rust-layers += \
rust-geom \
rust-opengles \
@ -143,10 +139,6 @@ DEPS_rust-layers += \
rust-cocoa \
$(NULL)
DEPS_rust-glut += \
rust-cocoa \
$(NULL)
endif
ifeq ($(CFG_OSTYPE),unknown-linux-gnu)

2
servo/src/compiler/rust-auto-clean-trigger
Просмотреть файл

@ -1,4 +1,4 @@
# If this file is modified, then rust will be forcibly cleaned and then rebuilt.
# The actual contents of this file do not matter, but to trigger a change on the
# build bots then the contents should be changed so git updates the mtime.
2013-07-09
2013-08-15

10
servo/src/components/gfx/display_list.rs
Просмотреть файл

@ -23,7 +23,7 @@ use std::cast::transmute_region;
use geom::{Point2D, Rect, Size2D, SideOffsets2D};
use servo_net::image::base::Image;
use servo_util::range::Range;
use extra::arc::ARC;
use extra::arc::Arc;
/// A list of rendering operations to be performed.
pub struct DisplayList<E> {
@ -48,7 +48,7 @@ impl<E> DisplayList<E> {
/// Draws the display list into the given render context.
pub fn draw_into_context(&self, render_context: &RenderContext) {
debug!("Beginning display list.");
for self.list.iter().advance |item| {
for item in self.list.iter() {
// FIXME(Issue #150): crashes
//debug!("drawing %?", *item);
item.draw_into_context(render_context)
@ -93,7 +93,7 @@ pub struct TextDisplayItem<E> {
/// Renders an image.
pub struct ImageDisplayItem<E> {
base: BaseDisplayItem<E>,
image: ARC<~Image>,
image: Arc<~Image>,
}
/// Renders a border.
@ -156,7 +156,7 @@ impl<E> DisplayItem<E> {
}
}
fn base<'a>(&'a self) -> &'a BaseDisplayItem<E> {
pub fn base<'a>(&'a self) -> &'a BaseDisplayItem<E> {
// FIXME(tkuehn): Workaround for Rust region bug.
unsafe {
match *self {
@ -168,7 +168,7 @@ impl<E> DisplayItem<E> {
}
}
fn bounds(&self) -> Rect<Au> {
pub fn bounds(&self) -> Rect<Au> {
self.base().bounds
}
}

55
servo/src/components/gfx/font.rs
Просмотреть файл

@ -10,7 +10,6 @@ use platform::font::{FontHandle, FontTable};
use render_context::RenderContext;
use servo_util::range::Range;
use std::cast;
use std::result;
use std::ptr;
use std::str;
use std::vec;
@ -18,7 +17,7 @@ use servo_util::cache::{Cache, HashCache};
use text::glyph::{GlyphStore, GlyphIndex};
use text::shaping::ShaperMethods;
use text::{Shaper, TextRun};
use extra::arc::ARC;
use extra::arc::Arc;
use azure::{AzFloat, AzScaledFontRef};
use azure::scaled_font::ScaledFont;
@ -58,12 +57,12 @@ pub type FractionalPixel = float;
pub type FontTableTag = u32;
trait FontTableTagConversions {
pub fn tag_to_str(&self) -> ~str;
pub trait FontTableTagConversions {
fn tag_to_str(&self) -> ~str;
}
impl FontTableTagConversions for FontTableTag {
pub fn tag_to_str(&self) -> ~str {
fn tag_to_str(&self) -> ~str {
unsafe {
let reversed = str::raw::from_buf_len(cast::transmute(self), 4);
return str::from_chars([reversed.char_at(3),
@ -183,7 +182,7 @@ impl FontGroup {
pub fn new(families: @str, style: &UsedFontStyle, fonts: ~[@mut Font]) -> FontGroup {
FontGroup {
families: families,
style: copy *style,
style: (*style).clone(),
fonts: fonts,
}
}
@ -240,7 +239,7 @@ pub struct Font {
metrics: FontMetrics,
backend: BackendType,
profiler_chan: ProfilerChan,
shape_cache: HashCache<~str, ARC<GlyphStore>>,
shape_cache: HashCache<~str, Arc<GlyphStore>>,
}
impl Font {
@ -252,9 +251,9 @@ impl Font {
-> Result<@mut Font, ()> {
let handle = FontHandleMethods::new_from_buffer(&ctx.handle, buffer, style);
let handle: FontHandle = if handle.is_ok() {
result::unwrap(handle)
handle.unwrap()
} else {
return Err(handle.get_err());
return Err(handle.unwrap_err());
};
let metrics = handle.get_metrics();
@ -264,7 +263,7 @@ impl Font {
handle: handle,
azure_font: None,
shaper: None,
style: copy *style,
style: (*style).clone(),
metrics: metrics,
backend: backend,
profiler_chan: profiler_chan,
@ -281,7 +280,7 @@ impl Font {
handle: handle,
azure_font: None,
shaper: None,
style: copy *style,
style: (*style).clone(),
metrics: metrics,
backend: backend,
profiler_chan: profiler_chan,
@ -302,7 +301,7 @@ impl Font {
return Ok(Font::new_from_adopted_handle(fctx, styled_handle, style, backend, profiler_chan));
}
priv fn get_shaper(@mut self) -> @Shaper {
fn get_shaper(@mut self) -> @Shaper {
// fast path: already created a shaper
match self.shaper {
Some(shaper) => { return shaper; },
@ -333,7 +332,7 @@ impl Font {
// TODO: this should return a borrowed pointer, but I can't figure
// out why borrowck doesn't like my implementation.
priv fn get_azure_font(&mut self) -> AzScaledFontRef {
fn get_azure_font(&mut self) -> AzScaledFontRef {
// fast path: we've already created the azure font resource
match self.azure_font {
Some(ref azfont) => return azfont.get_ref(),
@ -347,14 +346,14 @@ impl Font {
}
#[cfg(target_os="macos")]
priv fn create_azure_font(&mut self) -> ScaledFont {
fn create_azure_font(&mut self) -> ScaledFont {
let cg_font = self.handle.get_CGFont();
let size = self.style.pt_size as AzFloat;
ScaledFont::new(self.backend, &cg_font, size)
}
#[cfg(target_os="linux")]
priv fn create_azure_font(&self) -> ScaledFont {
fn create_azure_font(&self) -> ScaledFont {
let freetype_font = self.handle.face;
let size = self.style.pt_size as AzFloat;
ScaledFont::new(self.backend, freetype_font, size)
@ -387,14 +386,14 @@ impl Font {
fields: 0x0200 as uint16_t
};
let mut origin = copy baseline_origin;
let mut origin = baseline_origin.clone();
let mut azglyphs = ~[];
azglyphs.reserve(range.length());
for run.iter_slices_for_range(range) |glyphs, _offset, slice_range| {
for glyphs.iter_glyphs_for_char_range(slice_range) |_i, glyph| {
let glyph_advance = glyph.advance_();
let glyph_offset = glyph.offset().get_or_default(Au::zero_point());
for (glyphs, _offset, slice_range) in run.iter_slices_for_range(range) {
for (_i, glyph) in glyphs.iter_glyphs_for_char_range(&slice_range) {
let glyph_advance = glyph.advance();
let glyph_offset = glyph.offset().unwrap_or_default(Au::zero_point());
let azglyph = struct__AzGlyph {
mIndex: glyph.index() as uint32_t,
@ -431,9 +430,9 @@ impl Font {
// TODO(Issue #199): alter advance direction for RTL
// TODO(Issue #98): using inter-char and inter-word spacing settings when measuring text
let mut advance = Au(0);
for run.iter_slices_for_range(range) |glyphs, _offset, slice_range| {
for glyphs.iter_glyphs_for_char_range(slice_range) |_i, glyph| {
advance = advance + glyph.advance_();
for (glyphs, _offset, slice_range) in run.iter_slices_for_range(range) {
for (_i, glyph) in glyphs.iter_glyphs_for_char_range(&slice_range) {
advance = advance + glyph.advance();
}
}
RunMetrics::new(advance, self.metrics.ascent, self.metrics.descent)
@ -444,25 +443,25 @@ impl Font {
slice_range: &Range)
-> RunMetrics {
let mut advance = Au(0);
for glyphs.iter_glyphs_for_char_range(slice_range) |_i, glyph| {
advance = advance + glyph.advance_();
for (_i, glyph) in glyphs.iter_glyphs_for_char_range(slice_range) {
advance = advance + glyph.advance();
}
RunMetrics::new(advance, self.metrics.ascent, self.metrics.descent)
}
pub fn shape_text(@mut self, text: ~str, is_whitespace: bool) -> ARC<GlyphStore> {
pub fn shape_text(@mut self, text: ~str, is_whitespace: bool) -> Arc<GlyphStore> {
do profile(time::LayoutShapingCategory, self.profiler_chan.clone()) {
let shaper = self.get_shaper();
do self.shape_cache.find_or_create(&text) |txt| {
let mut glyphs = GlyphStore::new(text.char_len(), is_whitespace);
shaper.shape_text(*txt, &mut glyphs);
ARC(glyphs)
Arc::new(glyphs)
}
}
}
pub fn get_descriptor(&self) -> FontDescriptor {
FontDescriptor::new(copy self.style, SelectorPlatformIdentifier(self.handle.face_identifier()))
FontDescriptor::new(self.style.clone(), SelectorPlatformIdentifier(self.handle.face_identifier()))
}
pub fn glyph_index(&self, codepoint: char) -> Option<GlyphIndex> {

39
servo/src/components/gfx/font_context.rs
Просмотреть файл

@ -14,7 +14,6 @@ use platform::font_context::FontContextHandle;
use azure::azure_hl::BackendType;
use std::hashmap::HashMap;
use std::result;
// TODO(Rust #3934): creating lots of new dummy styles is a workaround
// for not being able to store symbolic enums in top-level constants.
@ -34,7 +33,6 @@ pub trait FontContextHandleMethods {
fn create_font_from_identifier(&self, ~str, UsedFontStyle) -> Result<FontHandle, ()>;
}
#[allow(non_implicitly_copyable_typarams)]
pub struct FontContext {
instance_cache: LRUCache<FontDescriptor, @mut Font>,
font_list: Option<FontList>, // only needed by layout
@ -45,7 +43,6 @@ pub struct FontContext {
profiler_chan: ProfilerChan,
}
#[allow(non_implicitly_copyable_typarams)]
impl<'self> FontContext {
pub fn new(backend: BackendType,
needs_font_list: bool,
@ -75,7 +72,7 @@ impl<'self> FontContext {
}
}
priv fn get_font_list(&'self self) -> &'self FontList {
fn get_font_list(&'self self) -> &'self FontList {
self.font_list.get_ref()
}
@ -113,23 +110,23 @@ impl<'self> FontContext {
}
}
priv fn transform_family(&self, family: &str) -> ~str {
fn transform_family(&self, family: &str) -> ~str {
// FIXME: Need a find_like() in HashMap.
let family = family.to_str();
debug!("(transform family) searching for `%s`", family);
match self.generic_fonts.find(&family) {
None => family,
Some(mapped_family) => copy *mapped_family
Some(mapped_family) => (*mapped_family).clone()
}
}
priv fn create_font_group(&mut self, style: &SpecifiedFontStyle) -> @FontGroup {
fn create_font_group(&mut self, style: &SpecifiedFontStyle) -> @FontGroup {
let mut fonts = ~[];
debug!("(create font group) --- starting ---");
// TODO(Issue #193): make iteration over 'font-family' more robust.
for style.families.split_iter(',').advance |family| {
for family in style.families.split_iter(',') {
let family_name = family.trim();
let transformed_family_name = self.transform_family(family_name);
debug!("(create font group) transformed family is `%s`", transformed_family_name);
@ -139,16 +136,16 @@ impl<'self> FontContext {
};
let mut found = false;
for result.iter().advance |font_entry| {
for font_entry in result.iter() {
found = true;
let font_id =
SelectorPlatformIdentifier(font_entry.handle.face_identifier());
let font_desc = FontDescriptor::new(copy *style, font_id);
let font_desc = FontDescriptor::new((*style).clone(), font_id);
let instance = self.get_font_by_descriptor(&font_desc);
do result::iter(&instance) |font: &@mut Font| { fonts.push(*font); }
for font in instance.iter() { fonts.push(*font); }
};
if !found {
@ -158,19 +155,19 @@ impl<'self> FontContext {
let last_resort = FontList::get_last_resort_font_families();
for last_resort.iter().advance |family| {
for family in last_resort.iter() {
let result = do self.font_list.chain_ref |fl| {
fl.find_font_in_family(*family, style)
};
for result.iter().advance |font_entry| {
for font_entry in result.iter() {
let font_id =
SelectorPlatformIdentifier(font_entry.handle.face_identifier());
let font_desc = FontDescriptor::new(copy *style, font_id);
let font_desc = FontDescriptor::new((*style).clone(), font_id);
let instance = self.get_font_by_descriptor(&font_desc);
do result::iter(&instance) |font: &@mut Font| {
for font in instance.iter() {
fonts.push(*font);
}
}
@ -178,26 +175,26 @@ impl<'self> FontContext {
assert!(fonts.len() > 0);
// TODO(Issue #179): Split FontStyle into specified and used styles
let used_style = copy *style;
let used_style = (*style).clone();
debug!("(create font group) --- finished ---");
@FontGroup::new(style.families.to_managed(), &used_style, fonts)
}
priv fn create_font_instance(&self, desc: &FontDescriptor) -> Result<@mut Font, ()> {
fn create_font_instance(&self, desc: &FontDescriptor) -> Result<@mut Font, ()> {
return match &desc.selector {
// TODO(Issue #174): implement by-platform-name font selectors.
&SelectorPlatformIdentifier(ref identifier) => {
let result_handle = self.handle.create_font_from_identifier(copy *identifier,
copy desc.style);
result::chain(result_handle, |handle| {
let result_handle = self.handle.create_font_from_identifier((*identifier).clone(),
desc.style.clone());
do result_handle.chain |handle| {
Ok(Font::new_from_adopted_handle(self,
handle,
&desc.style,
self.backend,
self.profiler_chan.clone()))
})
}
}
};
}

9
servo/src/components/gfx/font_list.rs
Просмотреть файл

@ -42,7 +42,7 @@ impl FontList {
list
}
priv fn refresh(&mut self, _: &FontContextHandle) {
fn refresh(&mut self, _: &FontContextHandle) {
// TODO(Issue #186): don't refresh unless something actually
// changed. Does OSX have a notification for this event?
//
@ -61,7 +61,7 @@ impl FontList {
// if such family exists, try to match style to a font
let mut result: Option<@FontEntry> = None;
for family.iter().advance |fam| {
for fam in family.iter() {
result = fam.find_font_for_style(&self.handle, style);
}
@ -76,7 +76,7 @@ impl FontList {
result
}
priv fn find_family(&self, family_name: &str) -> Option<@mut FontFamily> {
fn find_family(&self, family_name: &str) -> Option<@mut FontFamily> {
// look up canonical name
let family = self.family_map.find_equiv(&family_name);
@ -125,8 +125,7 @@ impl FontFamily {
// TODO(Issue #190): if not in the fast path above, do
// expensive matching of weights, etc.
let this: &mut FontFamily = self; // FIXME: borrow checker workaround
for this.entries.iter().advance |entry| {
for entry in self.entries.iter() {
if (style.weight.is_bold() == entry.is_bold()) &&
(style.italic == entry.is_italic()) {

3
servo/src/components/gfx/gfx.rc
Просмотреть файл

@ -10,7 +10,6 @@
extern mod azure;
extern mod geom;
extern mod http_client;
extern mod stb_image;
extern mod extra;
extern mod servo_net (name = "net");
@ -36,7 +35,7 @@ pub use gfx_font_list = font_list;
pub use servo_gfx_font = font;
pub use servo_gfx_font_list = font_list;
priv mod render_context;
mod render_context;
// Rendering
pub mod color;

11
servo/src/components/gfx/opts.rs
Просмотреть файл

@ -23,7 +23,6 @@ pub struct Opts {
output_file: Option<~str>,
}
#[allow(non_implicitly_copyable_typarams)]
pub fn from_cmdline_args(args: &[~str]) -> Opts {
use extra::getopts;
@ -40,13 +39,13 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
let opt_match = match getopts::getopts(args, opts) {
result::Ok(m) => m,
result::Err(f) => fail!(getopts::fail_str(copy f)),
result::Err(f) => fail!(getopts::fail_str(f.clone())),
};
let urls = if opt_match.free.is_empty() {
fail!(~"servo asks that you provide 1 or more URLs")
} else {
copy opt_match.free
opt_match.free.clone()
};
let render_backend = match getopts::opt_maybe_str(&opt_match, "r") {
@ -69,18 +68,18 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
};
let tile_size: uint = match getopts::opt_maybe_str(&opt_match, "s") {
Some(tile_size_str) => uint::from_str(tile_size_str).get(),
Some(tile_size_str) => uint::from_str(tile_size_str).unwrap(),
None => 512,
};
let n_render_threads: uint = match getopts::opt_maybe_str(&opt_match, "t") {
Some(n_render_threads_str) => uint::from_str(n_render_threads_str).get(),
Some(n_render_threads_str) => uint::from_str(n_render_threads_str).unwrap(),
None => 1, // FIXME: Number of cores.
};
// if only flag is present, default to 5 second period
let profiler_period = do getopts::opt_default(&opt_match, "p", "5").map |period| {
float::from_str(*period).get()
float::from_str(*period).unwrap()
};
let exit_after_load = getopts::opt_present(&opt_match, "x");

20
servo/src/components/gfx/platform/linux/font.rs
Просмотреть файл

@ -73,7 +73,7 @@ impl Drop for FontHandle {
}
impl FontHandleMethods for FontHandle {
pub fn new_from_buffer(fctx: &FontContextHandle,
fn new_from_buffer(fctx: &FontContextHandle,
buf: ~[u8],
style: &SpecifiedFontStyle)
-> Result<FontHandle, ()> {
@ -173,12 +173,12 @@ impl FontHandleMethods for FontHandle {
FontHandleMethods::new_from_buffer(fctx, buf.clone(), style)
}
FontSourceFile(ref file) => {
FontHandle::new_from_file(fctx, copy *file, style)
FontHandle::new_from_file(fctx, (*file).clone(), style)
}
}
}
pub fn glyph_index(&self,
fn glyph_index(&self,
codepoint: char) -> Option<GlyphIndex> {
assert!(self.face.is_not_null());
unsafe {
@ -192,7 +192,7 @@ impl FontHandleMethods for FontHandle {
}
}
pub fn glyph_h_advance(&self,
fn glyph_h_advance(&self,
glyph: GlyphIndex) -> Option<FractionalPixel> {
assert!(self.face.is_not_null());
unsafe {
@ -213,7 +213,7 @@ impl FontHandleMethods for FontHandle {
}
}
pub fn get_metrics(&self) -> FontMetrics {
fn get_metrics(&self) -> FontMetrics {
/* TODO(Issue #76): complete me */
let face = self.get_face_rec();
@ -242,7 +242,7 @@ impl FontHandleMethods for FontHandle {
}
impl<'self> FontHandle {
priv fn set_char_size(face: FT_Face, pt_size: float) -> Result<(), ()>{
fn set_char_size(face: FT_Face, pt_size: float) -> Result<(), ()>{
let char_width = float_to_fixed_ft(pt_size) as FT_F26Dot6;
let char_height = float_to_fixed_ft(pt_size) as FT_F26Dot6;
let h_dpi = 72;
@ -262,7 +262,7 @@ impl<'self> FontHandle {
let mut face: FT_Face = ptr::null();
let face_index = 0 as FT_Long;
do str::as_c_str(file) |file_str| {
do file.to_c_str().with_ref |file_str| {
FT_New_Face(ft_ctx, file_str,
face_index, ptr::to_mut_unsafe_ptr(&mut face));
}
@ -289,7 +289,7 @@ impl<'self> FontHandle {
let mut face: FT_Face = ptr::null();
let face_index = 0 as FT_Long;
do str::as_c_str(file) |file_str| {
do file.to_c_str().with_ref |file_str| {
FT_New_Face(ft_ctx, file_str,
face_index, ptr::to_mut_unsafe_ptr(&mut face));
}
@ -305,13 +305,13 @@ impl<'self> FontHandle {
}
}
priv fn get_face_rec(&'self self) -> &'self FT_FaceRec {
fn get_face_rec(&'self self) -> &'self FT_FaceRec {
unsafe {
&(*self.face)
}
}
priv fn font_units_to_au(&self, value: float) -> Au {
fn font_units_to_au(&self, value: float) -> Au {
let face = self.get_face_rec();
// face.size is a *c_void in the bindings, presumably to avoid

35
servo/src/components/gfx/platform/linux/font_list.rs
Просмотреть файл

@ -26,10 +26,9 @@ use platform::font_context::FontContextHandle;
use std::hashmap::HashMap;
use std::libc;
use std::libc::c_int;
use std::libc::{c_int, c_char};
use std::ptr;
use std::str;
use std::uint;
pub struct FontListHandle {
fctx: FontContextHandle,
@ -45,13 +44,13 @@ impl FontListHandle {
unsafe {
let config = FcConfigGetCurrent();
let fontSet = FcConfigGetFonts(config, FcSetSystem);
for uint::range(0, (*fontSet).nfont as uint) |i| {
for i in range(0, (*fontSet).nfont as int) {
let font = (*fontSet).fonts.offset(i);
let family: *FcChar8 = ptr::null();
let mut v: c_int = 0;
do str::as_c_str("family") |FC_FAMILY| {
do "family".to_c_str().with_ref |FC_FAMILY| {
while FcPatternGetString(*font, FC_FAMILY, v, &family) == FcResultMatch {
let family_name = str::raw::from_buf(family as *u8);
let family_name = str::raw::from_c_str(family as *c_char);
debug!("Creating new FontFamily for family: %s", family_name);
let new_family = @mut FontFamily::new(family_name);
family_map.insert(family_name, new_family);
@ -71,8 +70,8 @@ impl FontListHandle {
let font_set_array_ptr = ptr::to_unsafe_ptr(&font_set);
let pattern = FcPatternCreate();
assert!(pattern.is_not_null());
do str::as_c_str("family") |FC_FAMILY| {
do str::as_c_str(family.family_name) |family_name| {
do "family".to_c_str().with_ref |FC_FAMILY| {
do family.family_name.to_c_str().with_ref |family_name| {
let ok = FcPatternAddString(pattern, FC_FAMILY, family_name as *FcChar8);
assert!(ok != 0);
}
@ -81,10 +80,10 @@ impl FontListHandle {
let object_set = FcObjectSetCreate();
assert!(object_set.is_not_null());
do str::as_c_str("file") |FC_FILE| {
do "file".to_c_str().with_ref |FC_FILE| {
FcObjectSetAdd(object_set, FC_FILE);
}
do str::as_c_str("index") |FC_INDEX| {
do "index".to_c_str().with_ref |FC_INDEX| {
FcObjectSetAdd(object_set, FC_INDEX);
}
@ -92,9 +91,9 @@ impl FontListHandle {
debug!("found %? variations", (*matches).nfont);
for uint::range(0, (*matches).nfont as uint) |i| {
for i in range(0, (*matches).nfont as int) {
let font = (*matches).fonts.offset(i);
let file = do str::as_c_str("file") |FC_FILE| {
let file = do "file".to_c_str().with_ref |FC_FILE| {
let file: *FcChar8 = ptr::null();
if FcPatternGetString(*font, FC_FILE, 0, &file) == FcResultMatch {
str::raw::from_c_str(file as *libc::c_char)
@ -102,7 +101,7 @@ impl FontListHandle {
fail!();
}
};
let index = do str::as_c_str("index") |FC_INDEX| {
let index = do "index".to_c_str().with_ref |FC_INDEX| {
let index: libc::c_int = 0;
if FcPatternGetInteger(*font, FC_INDEX, 0, &index) == FcResultMatch {
index
@ -151,8 +150,8 @@ pub fn path_from_identifier(name: ~str, style: &UsedFontStyle) -> Result<~str, (
let config = FcConfigGetCurrent();
let wrapper = AutoPattern { pattern: FcPatternCreate() };
let pattern = wrapper.pattern;
let res = do str::as_c_str("family") |FC_FAMILY| {
do str::as_c_str(name) |family| {
let res = do "family".to_c_str().with_ref |FC_FAMILY| {
do name.to_c_str().with_ref |family| {
FcPatternAddString(pattern, FC_FAMILY, family as *FcChar8)
}
};
@ -162,7 +161,7 @@ pub fn path_from_identifier(name: ~str, style: &UsedFontStyle) -> Result<~str, (
}
if style.italic {
let res = do str::as_c_str("slant") |FC_SLANT| {
let res = do "slant".to_c_str().with_ref |FC_SLANT| {
FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC)
};
if res != 1 {
@ -171,7 +170,7 @@ pub fn path_from_identifier(name: ~str, style: &UsedFontStyle) -> Result<~str, (
}
}
if style.weight.is_bold() {
let res = do str::as_c_str("weight") |FC_WEIGHT| {
let res = do "weight".to_c_str().with_ref |FC_WEIGHT| {
FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD)
};
if res != 1 {
@ -194,13 +193,13 @@ pub fn path_from_identifier(name: ~str, style: &UsedFontStyle) -> Result<~str, (
}
let file: *FcChar8 = ptr::null();
let res = do str::as_c_str("file") |FC_FILE| {
let res = do "file".to_c_str().with_ref |FC_FILE| {
FcPatternGetString(result_pattern, FC_FILE, 0, &file)
};
if res != FcResultMatch {
debug!("getting filename for font failed");
return Err(());
}
Ok(str::raw::from_buf(file as *u8))
Ok(str::raw::from_c_str(file as *c_char))
}
}

4
servo/src/components/gfx/platform/macos/font_context.rs
Просмотреть файл

@ -8,8 +8,6 @@ use platform::macos::font::FontHandle;
use core_text;
use std::result;
pub struct FontContextHandle {
ctx: ()
}
@ -33,7 +31,7 @@ impl FontContextHandleMethods for FontContextHandle {
style: UsedFontStyle)
-> Result<FontHandle, ()> {
let ctfont_result = core_text::font::new_from_name(name, style.pt_size);
do result::chain(ctfont_result) |ctfont| {
do ctfont_result.chain |ctfont| {
FontHandle::new_from_CTFont(self, ctfont)
}
}

13
servo/src/components/gfx/platform/macos/font_list.rs
Просмотреть файл

@ -12,11 +12,9 @@ use core_foundation::array::CFArray;
use core_foundation::base::CFWrapper;
use core_foundation::string::{CFString, CFStringRef};
use core_text::font_collection::CTFontCollectionMethods;
use core_text::font_descriptor::CTFontDescriptorRef;
use core_text;
use std::hashmap::HashMap;
use std::result;
pub struct FontListHandle {
fctx: FontContextHandle,
@ -32,24 +30,25 @@ impl FontListHandle {
pub fn get_available_families(&self) -> FontFamilyMap {
let family_names: CFArray<CFStringRef> = core_text::font_collection::get_family_names();
let mut family_map: FontFamilyMap = HashMap::new();
for family_names.each |&strref: &CFStringRef| {
for strref in family_names.iter() {
let family_name = CFString::wrap_shared(strref).to_str();
debug!("Creating new FontFamily for family: %s", family_name);
let new_family = @mut FontFamily::new(family_name);
family_map.insert(family_name, new_family);
}
return family_map;
family_map
}
pub fn load_variations_for_family(&self, family: @mut FontFamily) {
debug!("Looking for faces of family: %s", family.family_name);
let family_collection = core_text::font_collection::create_for_family(family.family_name);
for family_collection.get_descriptors().each |descref: &CTFontDescriptorRef| {
let desc = CFWrapper::wrap_shared(*descref);
let family_descriptors = family_collection.get_descriptors();
for descref in family_descriptors.iter() {
let desc = CFWrapper::wrap_shared(descref);
let font = core_text::font::new_from_descriptor(&desc, 0.0);
let handle = result::unwrap(FontHandle::new_from_CTFont(&self.fctx, font));
let handle = FontHandle::new_from_CTFont(&self.fctx, font).unwrap();
debug!("Creating new FontEntry for face: %s", handle.face_name());
let entry = @FontEntry::new(handle);

4
servo/src/components/gfx/render_context.rs
Просмотреть файл

@ -16,7 +16,7 @@ use geom::rect::Rect;
use geom::size::Size2D;
use geom::side_offsets::SideOffsets2D;
use servo_net::image::base::Image;
use extra::arc::ARC;
use extra::arc::Arc;
pub struct RenderContext<'self> {
canvas: &'self LayerBuffer,
@ -77,7 +77,7 @@ impl<'self> RenderContext<'self> {
self.canvas.draw_target.stroke_line(start, end, &pattern, &stroke_opts, &draw_opts);
}
pub fn draw_image(&self, bounds: Rect<Au>, image: ARC<~Image>) {
pub fn draw_image(&self, bounds: Rect<Au>, image: Arc<~Image>) {
let image = image.get();
let size = Size2D(image.width as i32, image.height as i32);
let stride = image.width * 4;

11
servo/src/components/gfx/render_task.rs
Просмотреть файл

@ -39,6 +39,7 @@ pub enum Msg {
}
/// A request from the compositor to the renderer for tiles that need to be (re)displayed.
#[deriving(Clone)]
pub struct BufferRequest {
// The rect in pixels that will be drawn to the screen
screen_rect: Rect<uint>,
@ -70,7 +71,7 @@ impl RenderChan {
}
}
priv struct RenderTask<C> {
struct RenderTask<C> {
id: PipelineId,
port: Port<Msg>,
compositor: C,
@ -87,7 +88,7 @@ priv struct RenderTask<C> {
/// Permission to send paint messages to the compositor
paint_permission: bool,
/// Cached copy of last layers rendered
last_paint_msg: Option<(arc::ARC<LayerBufferSet>, Size2D<uint>)>,
last_paint_msg: Option<(arc::Arc<LayerBufferSet>, Size2D<uint>)>,
}
impl<C: RenderListener + Send> RenderTask<C> {
@ -112,7 +113,7 @@ impl<C: RenderListener + Send> RenderTask<C> {
id: id,
port: port.take(),
compositor: compositor,
font_ctx: @mut FontContext::new(copy opts.render_backend,
font_ctx: @mut FontContext::new(opts.render_backend.clone(),
false,
profiler_chan.clone()),
opts: opts,
@ -179,7 +180,7 @@ impl<C: RenderListener + Send> RenderTask<C> {
// Divide up the layer into tiles.
do time::profile(time::RenderingPrepBuffCategory, self.profiler_chan.clone()) {
for tiles.iter().advance |tile| {
for tile in tiles.iter() {
let width = tile.screen_rect.size.width;
let height = tile.screen_rect.size.height;
@ -230,7 +231,7 @@ impl<C: RenderListener + Send> RenderTask<C> {
let layer_buffer_set = LayerBufferSet {
buffers: new_buffers,
};
let layer_buffer_set = arc::ARC(layer_buffer_set);
let layer_buffer_set = arc::Arc::new(layer_buffer_set);
debug!("render_task: returning surface");
if self.paint_permission {

2
servo/src/components/gfx/surface.rs
Просмотреть файл

@ -28,7 +28,7 @@ pub struct ImageSurface {
impl ImageSurface {
pub fn new(size: Size2D<int>, format: format) -> ImageSurface {
ImageSurface {
size: copy size,
size: size.clone(),
format: format,
buffer: vec::from_elem((size.area() as uint) * format.bpp(), 0u8)
}

124
servo/src/components/gfx/text/glyph.rs
Просмотреть файл

@ -12,8 +12,8 @@ use std::cmp::{Ord, Eq};
use std::num::NumCast;
use std::u16;
use std::vec;
use std::uint;
use std::util;
use std::iterator;
use geom::point::Point2D;
use extra::sort;
@ -25,6 +25,7 @@ use extra::sort;
/// In the uncommon case (multiple glyphs per unicode character, large glyph index/advance, or
/// glyph offsets), we pack the glyph count into GlyphEntry, and store the other glyph information
/// in DetailedGlyphStore.
#[deriving(Clone)]
struct GlyphEntry {
value: u32
}
@ -256,6 +257,7 @@ impl GlyphEntry {
// Stores data for a detailed glyph, in the case that several glyphs
// correspond to one character, or the glyph's data couldn't be packed.
#[deriving(Clone)]
struct DetailedGlyph {
index: GlyphIndex,
// glyph's advance, in the text's direction (RTL or RTL)
@ -274,7 +276,7 @@ impl DetailedGlyph {
}
}
#[deriving(Eq)]
#[deriving(Eq, Clone)]
struct DetailedGlyphRecord {
// source string offset/GlyphEntry offset in the TextRun
entry_offset: uint,
@ -459,7 +461,7 @@ enum GlyphInfo<'self> {
}
impl<'self> GlyphInfo<'self> {
fn index(self) -> GlyphIndex {
pub fn index(self) -> GlyphIndex {
match self {
SimpleGlyphInfo(store, entry_i) => store.entry_buffer[entry_i].index(),
DetailGlyphInfo(store, entry_i, detail_j) => {
@ -470,7 +472,7 @@ impl<'self> GlyphInfo<'self> {
#[inline(always)]
// FIXME: Resolution conflicts with IteratorUtil trait so adding trailing _
fn advance_(self) -> Au {
pub fn advance(self) -> Au {
match self {
SimpleGlyphInfo(store, entry_i) => store.entry_buffer[entry_i].advance(),
DetailGlyphInfo(store, entry_i, detail_j) => {
@ -479,7 +481,7 @@ impl<'self> GlyphInfo<'self> {
}
}
fn offset(self) -> Option<Point2D<Au>> {
pub fn offset(self) -> Option<Point2D<Au>> {
match self {
SimpleGlyphInfo(_, _) => None,
DetailGlyphInfo(store, entry_i, detail_j) => {
@ -488,14 +490,14 @@ impl<'self> GlyphInfo<'self> {
}
}
fn is_ligature_start(self) -> bool {
pub fn is_ligature_start(self) -> bool {
match self {
SimpleGlyphInfo(store, entry_i) => store.entry_buffer[entry_i].is_ligature_start(),
DetailGlyphInfo(store, entry_i, _) => store.entry_buffer[entry_i].is_ligature_start()
}
}
fn is_cluster_start(self) -> bool {
pub fn is_cluster_start(self) -> bool {
match self {
SimpleGlyphInfo(store, entry_i) => store.entry_buffer[entry_i].is_cluster_start(),
DetailGlyphInfo(store, entry_i, _) => store.entry_buffer[entry_i].is_cluster_start()
@ -597,62 +599,24 @@ impl<'self> GlyphStore {
self.entry_buffer[i] = entry;
}
pub fn iter_glyphs_for_char_index(&'self self,
i: uint,
cb: &fn(uint, &GlyphInfo<'self>) -> bool)
-> bool {
assert!(i < self.entry_buffer.len());
let entry = &self.entry_buffer[i];
match entry.is_simple() {
true => {
let proxy = &SimpleGlyphInfo(self, i);
cb(i, proxy);
},
false => {
let glyphs = self.detail_store.get_detailed_glyphs_for_entry(i,
entry.glyph_count());
for uint::range(0, glyphs.len()) |j| {
let proxy = &DetailGlyphInfo(self, i, j as u16);
cb(i, proxy);
}
}
}
true
pub fn iter_glyphs_for_char_index(&'self self, i: uint) -> GlyphIterator<'self> {
self.iter_glyphs_for_char_range(&Range::new(i, 1))
}
pub fn iter_glyphs_for_char_range(&'self self,
range: &Range,
callback: &fn(uint, &GlyphInfo<'self>) -> bool)
-> bool {
if range.begin() >= self.entry_buffer.len() {
error!("iter_glyphs_for_range: range.begin beyond length!");
return false
pub fn iter_glyphs_for_char_range(&'self self, rang: &Range) -> GlyphIterator<'self> {
if rang.begin() >= self.entry_buffer.len() {
fail!("iter_glyphs_for_range: range.begin beyond length!");
}
if range.end() > self.entry_buffer.len() {
error!("iter_glyphs_for_range: range.end beyond length!");
return false
if rang.end() > self.entry_buffer.len() {
fail!("iter_glyphs_for_range: range.end beyond length!");
}
for range.eachi |i| {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
if !self.iter_glyphs_for_char_index(i, |a, b| callback(a, b)) {
break
}
GlyphIterator {
store: self,
char_index: rang.begin(),
char_range: rang.eachi(),
glyph_range: None
}
true
}
pub fn iter_all_glyphs(&'self self, callback: &fn(uint, &GlyphInfo<'self>) -> bool) -> bool {
for uint::range(0, self.entry_buffer.len()) |i| {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
if !self.iter_glyphs_for_char_index(i, |a, b| callback(a, b)) {
break;
}
}
true
}
// getter methods
@ -711,3 +675,49 @@ impl<'self> GlyphStore {
self.entry_buffer[i] = entry.set_can_break_before(t);
}
}
pub struct GlyphIterator<'self> {
priv store: &'self GlyphStore,
priv char_index: uint,
priv char_range: iterator::Range<uint>,
priv glyph_range: Option<iterator::Range<uint>>,
}
impl<'self> Iterator<(uint, GlyphInfo<'self>)> for GlyphIterator<'self> {
// I tried to start with something simpler and apply FlatMap, but the
// inability to store free variables in the FlatMap struct was problematic.
fn next(&mut self) -> Option<(uint, GlyphInfo<'self>)> {
// Would use 'match' here but it borrows contents in a way that
// interferes with mutation.
if self.glyph_range.is_some() {
match self.glyph_range.unwrap().next() {
Some(j) => Some((self.char_index,
DetailGlyphInfo(self.store, self.char_index, j as u16))),
None => {
// No more glyphs for current character. Try to get another.
self.glyph_range = None;
self.next()
}
}
} else {
// No glyph range. Look at next character.
match self.char_range.next() {
Some(i) => {
self.char_index = i;
assert!(i < self.store.entry_buffer.len());
let entry = &self.store.entry_buffer[i];
if entry.is_simple() {
Some((self.char_index, SimpleGlyphInfo(self.store, i)))
} else {
let glyphs = self.store.detail_store
.get_detailed_glyphs_for_entry(i, entry.glyph_count());
self.glyph_range = Some(range(0, glyphs.len()));
self.next()
}
},
None => None
}
}
}
}

21
servo/src/components/gfx/text/shaping/harfbuzz.rs
Просмотреть файл

@ -16,7 +16,6 @@ use std::cast::transmute;
use std::libc::{c_uint, c_int, c_void, c_char};
use std::ptr;
use std::ptr::null;
use std::str;
use std::uint;
use std::util::ignore;
use std::vec;
@ -86,7 +85,7 @@ impl ShapedGlyphData {
fn byte_offset_of_glyph(&self, i: uint) -> uint {
assert!(i < self.count);
let glyph_info_i = ptr::offset(self.glyph_infos, i);
let glyph_info_i = ptr::offset(self.glyph_infos, i as int);
unsafe {
(*glyph_info_i).cluster as uint
}
@ -101,8 +100,8 @@ impl ShapedGlyphData {
assert!(i < self.count);
unsafe {
let glyph_info_i = ptr::offset(self.glyph_infos, i);
let pos_info_i = ptr::offset(self.pos_infos, i);
let glyph_info_i = ptr::offset(self.glyph_infos, i as int);
let pos_info_i = ptr::offset(self.pos_infos, i as int);
let x_offset = Shaper::fixed_to_float((*pos_info_i).x_offset);
let y_offset = Shaper::fixed_to_float((*pos_info_i).y_offset);
let x_advance = Shaper::fixed_to_float((*pos_info_i).x_advance);
@ -216,8 +215,8 @@ impl ShaperMethods for Shaper {
let hb_buffer: *hb_buffer_t = hb_buffer_create();
hb_buffer_set_direction(hb_buffer, HB_DIRECTION_LTR);
// Using as_buf because it never does a copy - we don't need the trailing null
do str::as_buf(text) |ctext: *u8, _: uint| {
// Using as_imm_buf because it never does a copy - we don't need the trailing null
do text.as_imm_buf |ctext: *u8, _: uint| {
hb_buffer_add_utf8(hb_buffer,
ctext as *c_char,
text.len() as c_int,
@ -272,7 +271,7 @@ impl Shaper {
}
debug!("(glyph idx) -> (text byte offset)");
for uint::range(0, glyph_data.len()) |i| {
for i in range(0, glyph_data.len()) {
// loc refers to a *byte* offset within the utf8 string.
let loc = glyph_data.byte_offset_of_glyph(i);
if loc < byte_max {
@ -335,7 +334,7 @@ impl Shaper {
// extend glyph range to max glyph index covered by char_span,
// in cases where one char made several glyphs and left some unassociated chars.
let mut max_glyph_idx = glyph_span.end();
for char_byte_span.eachi |i| {
for i in char_byte_span.eachi() {
if byteToGlyph[i] > NO_GLYPH {
max_glyph_idx = uint::max(byteToGlyph[i] as uint, max_glyph_idx);
}
@ -359,7 +358,7 @@ impl Shaper {
probably doesn't work.");
let mut all_glyphs_are_within_cluster: bool = true;
for glyph_span.eachi |j| {
for j in glyph_span.eachi() {
let loc = glyph_data.byte_offset_of_glyph(j);
if !char_byte_span.contains(loc) {
all_glyphs_are_within_cluster = false;
@ -398,7 +397,7 @@ impl Shaper {
// cspan: [-]
// covsp: [---------------]
let mut covered_byte_span = copy char_byte_span;
let mut covered_byte_span = char_byte_span.clone();
// extend, clipping at end of text range.
while covered_byte_span.end() < byte_max
&& byteToGlyph[covered_byte_span.end()] == NO_GLYPH {
@ -438,7 +437,7 @@ impl Shaper {
// collect all glyphs to be assigned to the first character.
let mut datas = ~[];
for glyph_span.eachi |glyph_i| {
for glyph_i in glyph_span.eachi() {
let shape = glyph_data.get_entry_for_glyph(glyph_i, &mut y_pos);
datas.push(GlyphData::new(shape.codepoint,
shape.advance,

150
servo/src/components/gfx/text/text_run.rs
Просмотреть файл

@ -2,27 +2,29 @@
* 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 std::vec::VecIterator;
use font_context::FontContext;
use geometry::Au;
use text::glyph::GlyphStore;
use font::{Font, FontDescriptor, RunMetrics};
use servo_util::range::Range;
use extra::arc::ARC;
use extra::arc::Arc;
/// A text run.
pub struct TextRun {
text: ~str,
font: @mut Font,
underline: bool,
glyphs: ~[ARC<GlyphStore>],
glyphs: ~[Arc<GlyphStore>],
}
/// This is a hack until TextRuns are normally sendable, or we instead use ARC<TextRun> everywhere.
/// This is a hack until TextRuns are normally sendable, or we instead use Arc<TextRun> everywhere.
pub struct SendableTextRun {
text: ~str,
font: FontDescriptor,
underline: bool,
priv glyphs: ~[ARC<GlyphStore>],
priv glyphs: ~[Arc<GlyphStore>],
}
impl SendableTextRun {
@ -33,7 +35,7 @@ impl SendableTextRun {
};
TextRun {
text: copy self.text,
text: self.text.clone(),
font: font,
underline: self.underline,
glyphs: self.glyphs.clone(),
@ -41,6 +43,78 @@ impl SendableTextRun {
}
}
pub struct SliceIterator<'self> {
priv glyph_iter: VecIterator<'self, Arc<GlyphStore>>,
priv range: Range,
priv offset: uint,
}
impl<'self> Iterator<(&'self GlyphStore, uint, Range)> for SliceIterator<'self> {
fn next(&mut self) -> Option<(&'self GlyphStore, uint, Range)> {
loop {
let slice_glyphs = self.glyph_iter.next();
if slice_glyphs.is_none() {
return None;
}
let slice_glyphs = slice_glyphs.unwrap().get();
let slice_range = Range::new(self.offset, slice_glyphs.char_len());
let mut char_range = self.range.intersect(&slice_range);
char_range.shift_by(-(self.offset.to_int()));
let old_offset = self.offset;
self.offset += slice_glyphs.char_len();
if !char_range.is_empty() {
return Some((slice_glyphs, old_offset, char_range))
}
}
}
}
pub struct LineIterator<'self> {
priv range: Range,
priv clump: Option<Range>,
priv slices: SliceIterator<'self>,
}
impl<'self> Iterator<Range> for LineIterator<'self> {
fn next(&mut self) -> Option<Range> {
// Loop until we hit whitespace and are in a clump.
loop {
match self.slices.next() {
Some((glyphs, offset, slice_range)) => {
match (glyphs.is_whitespace(), self.clump) {
(false, Some(ref mut c)) => {
c.extend_by(slice_range.length().to_int());
}
(false, None) => {
let mut c = slice_range;
c.shift_by(offset.to_int());
self.clump = Some(c);
}
(true, None) => { /* chomp whitespace */ }
(true, Some(c)) => {
self.clump = None;
// The final whitespace clump is not included.
return Some(c);
}
}
},
None => {
// flush any remaining chars as a line
if self.clump.is_some() {
let mut c = self.clump.take_unwrap();
c.extend_to(self.range.end());
return Some(c);
} else {
return None;
}
}
}
}
}
}
impl<'self> TextRun {
pub fn new(font: @mut Font, text: ~str, underline: bool) -> TextRun {
let glyphs = TextRun::break_and_shape(font, text);
@ -58,7 +132,7 @@ impl<'self> TextRun {
self.font.teardown();
}
pub fn break_and_shape(font: @mut Font, text: &str) -> ~[ARC<GlyphStore>] {
pub fn break_and_shape(font: @mut Font, text: &str) -> ~[Arc<GlyphStore>] {
// TODO(Issue #230): do a better job. See Gecko's LineBreaker.
let mut glyphs = ~[];
@ -115,7 +189,7 @@ impl<'self> TextRun {
pub fn serialize(&self) -> SendableTextRun {
SendableTextRun {
text: copy self.text,
text: self.text.clone(),
font: self.font.get_descriptor(),
underline: self.underline,
glyphs: self.glyphs.clone(),
@ -128,10 +202,10 @@ impl<'self> TextRun {
}
}
pub fn glyphs(&'self self) -> &'self ~[ARC<GlyphStore>] { &self.glyphs }
pub fn glyphs(&'self self) -> &'self ~[Arc<GlyphStore>] { &self.glyphs }
pub fn range_is_trimmable_whitespace(&self, range: &Range) -> bool {
for self.iter_slices_for_range(range) |slice_glyphs, _, _| {
for (slice_glyphs, _, _) in self.iter_slices_for_range(range) {
if !slice_glyphs.is_whitespace() { return false; }
}
true
@ -148,61 +222,27 @@ impl<'self> TextRun {
pub fn min_width_for_range(&self, range: &Range) -> Au {
let mut max_piece_width = Au(0);
debug!("iterating outer range %?", range);
for self.iter_slices_for_range(range) |glyphs, offset, slice_range| {
for (glyphs, offset, slice_range) in self.iter_slices_for_range(range) {
debug!("iterated on %?[%?]", offset, slice_range);
let metrics = self.font.measure_text_for_slice(glyphs, slice_range);
let metrics = self.font.measure_text_for_slice(glyphs, &slice_range);
max_piece_width = Au::max(max_piece_width, metrics.advance_width);
}
max_piece_width
}
pub fn iter_slices_for_range(&self,
range: &Range,
f: &fn(&GlyphStore, uint, &Range) -> bool)
-> bool {
let mut offset = 0;
for self.glyphs.iter().advance |slice_glyphs| {
// Determine the range of this slice that we need.
let slice_range = Range::new(offset, slice_glyphs.get().char_len());
let mut char_range = range.intersect(&slice_range);
char_range.shift_by(-(offset.to_int()));
let unwrapped_glyphs = slice_glyphs.get();
if !char_range.is_empty() {
if !f(unwrapped_glyphs, offset, &char_range) { break }
}
offset += unwrapped_glyphs.char_len();
pub fn iter_slices_for_range(&'self self, range: &Range) -> SliceIterator<'self> {
SliceIterator {
glyph_iter: self.glyphs.iter(),
range: *range,
offset: 0,
}
true
}
pub fn iter_natural_lines_for_range(&self, range: &Range, f: &fn(&Range) -> bool) -> bool {
let mut clump = Range::new(range.begin(), 0);
let mut in_clump = false;
for self.iter_slices_for_range(range) |glyphs, offset, slice_range| {
match (glyphs.is_whitespace(), in_clump) {
(false, true) => { clump.extend_by(slice_range.length().to_int()); }
(false, false) => {
in_clump = true;
clump = *slice_range;
clump.shift_by(offset.to_int());
}
(true, false) => { /* chomp whitespace */ }
(true, true) => {
in_clump = false;
// The final whitespace clump is not included.
if !f(&clump) { break }
}
}
pub fn iter_natural_lines_for_range(&'self self, range: &Range) -> LineIterator<'self> {
LineIterator {
range: *range,
clump: None,
slices: self.iter_slices_for_range(range),
}
// flush any remaining chars as a line
if in_clump {
clump.extend_to(range.end());
f(&clump);
}
true
}
}

14
servo/src/components/gfx/text/util.rs
Просмотреть файл

@ -24,7 +24,7 @@ pub fn transform_text(text: &str, mode: CompressionMode, incoming_whitespace: bo
let mut out_str: ~str = ~"";
let out_whitespace = match mode {
CompressNone | DiscardNewline => {
for text.iter().advance |ch: char| {
for ch in text.iter() {
if is_discardable_char(ch, mode) {
// TODO: record skipped char
} else {
@ -40,7 +40,7 @@ pub fn transform_text(text: &str, mode: CompressionMode, incoming_whitespace: bo
CompressWhitespace | CompressWhitespaceNewline => {
let mut in_whitespace: bool = incoming_whitespace;
for text.iter().advance |ch: char| {
for ch in text.iter() {
// TODO: discard newlines between CJK chars
let mut next_in_whitespace: bool = is_in_whitespace(ch, mode);
@ -134,7 +134,7 @@ fn test_transform_compress_none() {
~"foobarbaz\n\n"];
let mode = CompressNone;
for uint::range(0, test_strs.len()) |i| {
for i in range(0, test_strs.len()) {
(trimmed_str, _out) = transform_text(test_strs[i], mode, true);
assert!(trimmed_str == test_strs[i])
}
@ -162,7 +162,7 @@ fn test_transform_discard_newline() {
assert!(test_strs.len() == oracle_strs.len());
let mode = DiscardNewline;
for uint::range(0, test_strs.len()) |i| {
for i in range(0, test_strs.len()) {
(trimmed_str, _out) = transform_text(test_strs[i], mode, true);
assert!(trimmed_str == oracle_strs[i])
}
@ -189,7 +189,7 @@ fn test_transform_compress_whitespace() {
assert!(test_strs.len() == oracle_strs.len());
let mode = CompressWhitespace;
for uint::range(0, test_strs.len()) |i| {
for i in range(0, test_strs.len()) {
(trimmed_str, _out) = transform_text(test_strs[i], mode, true);
assert!(trimmed_str == oracle_strs[i])
}
@ -216,7 +216,7 @@ fn test_transform_compress_whitespace_newline() {
assert!(test_strs.len() == oracle_strs.len());
let mode = CompressWhitespaceNewline;
for uint::range(0, test_strs.len()) |i| {
for i in range(0, test_strs.len()) {
(trimmed_str, _out) = transform_text(test_strs[i], mode, true);
assert!(trimmed_str == oracle_strs[i])
}
@ -245,7 +245,7 @@ fn test_transform_compress_whitespace_newline() {
assert!(test_strs.len() == oracle_strs.len());
let mode = CompressWhitespaceNewline;
for uint::range(0, test_strs.len()) |i| {
for i in range(0, test_strs.len()) {
(trimmed_str, _out) = transform_text(test_strs[i], mode, false);
assert!(trimmed_str == oracle_strs[i])
}

26
servo/src/components/main/compositing/compositor_layer.rs
Просмотреть файл

@ -87,7 +87,7 @@ impl CompositorLayer {
// true; otherwise returns false, so a parent layer can scroll instead.
pub fn scroll(&mut self, delta: Point2D<f32>, cursor: Point2D<f32>, window_size: Size2D<f32>) -> bool {
let cursor = cursor - self.scroll_offset;
for self.children.mut_iter().filter(|x| !x.child.hidden).advance |child| {
for child in self.children.mut_iter().filter(|x| !x.child.hidden) {
match child.container.scissor {
None => {
error!("CompositorLayer: unable to perform cursor hit test for layer");
@ -131,7 +131,7 @@ impl CompositorLayer {
// page coordinates.
pub fn send_mouse_event(&self, event: MouseWindowEvent, cursor: Point2D<f32>) {
let cursor = cursor - self.scroll_offset;
for self.children.iter().filter(|&x| !x.child.hidden).advance |child| {
for child in self.children.iter().filter(|&x| !x.child.hidden) {
match child.container.scissor {
None => {
error!("CompositorLayer: unable to perform cursor hit test for layer");
@ -197,7 +197,7 @@ impl CompositorLayer {
}
};
self.children.mut_iter().filter(|x| !x.child.hidden)
.transform(transform)
.map(transform)
.fold(false, |a, b| a || b) || redisplay
}
@ -206,7 +206,7 @@ impl CompositorLayer {
// and clip the layer to the specified size in page coordinates.
// This method returns false if the specified layer is not found.
pub fn set_clipping_rect(&mut self, pipeline_id: PipelineId, new_rect: Rect<f32>) -> bool {
for self.children.iter().advance |child_node| {
for child_node in self.children.iter() {
if pipeline_id != child_node.child.pipeline.id {
loop;
}
@ -219,7 +219,7 @@ impl CompositorLayer {
}
// ID does not match any of our immediate children, so recurse on descendents (including hidden children)
self.children.mut_iter().transform(|x| &mut x.child).any(|x| x.set_clipping_rect(pipeline_id, new_rect))
self.children.mut_iter().map(|x| &mut x.child).any(|x| x.set_clipping_rect(pipeline_id, new_rect))
}
@ -265,15 +265,15 @@ impl CompositorLayer {
// Delete old layer.
while current_layer_child.is_some() {
let trash = current_layer_child.get();
do current_layer_child.get().with_common |common| {
let trash = current_layer_child.unwrap();
do current_layer_child.unwrap().with_common |common| {
current_layer_child = common.next_sibling;
}
self.root_layer.remove_child(trash);
}
// Add child layers.
for self.children.mut_iter().filter(|x| !x.child.hidden).advance |child| {
for child in self.children.mut_iter().filter(|x| !x.child.hidden) {
current_layer_child = match current_layer_child {
None => {
child.container.common.parent = None;
@ -295,7 +295,7 @@ impl CompositorLayer {
};
let all_tiles = quadtree.get_all_tiles();
for all_tiles.iter().advance |buffer| {
for buffer in all_tiles.iter() {
debug!("osmain: compositing buffer rect %?", &buffer.rect);
// Find or create a texture layer.
@ -313,7 +313,7 @@ impl CompositorLayer {
texture_layer.manager = @buffer.draw_target.clone() as @TextureManager;
// Move on to the next sibling.
do current_layer_child.get().with_common |common| {
do current_layer_child.unwrap().with_common |common| {
common.next_sibling
}
}
@ -339,7 +339,7 @@ impl CompositorLayer {
Tree(ref mut quadtree) => quadtree,
};
for new_buffers.buffers.iter().advance |buffer| {
for buffer in new_buffers.buffers.iter() {
// TODO: This may return old buffers, which should be sent back to the renderer.
quadtree.add_tile_pixel(buffer.screen_pos.origin.x, buffer.screen_pos.origin.y,
buffer.resolution, ~buffer.clone());
@ -349,7 +349,7 @@ impl CompositorLayer {
return true;
}
// ID does not match ours, so recurse on descendents (including hidden children).
self.children.mut_iter().transform(|x| &mut x.child).any(|x| x.add_buffers(pipeline_id, new_buffers))
self.children.mut_iter().map(|x| &mut x.child).any(|x| x.add_buffers(pipeline_id, new_buffers))
}
// Deletes a specified sublayer, including hidden children. Returns false if the layer is not found.
@ -362,7 +362,7 @@ impl CompositorLayer {
true
}
None => {
self.children.mut_iter().transform(|x| &mut x.child).any(|x| x.delete(pipeline_id))
self.children.mut_iter().map(|x| &mut x.child).any(|x| x.delete(pipeline_id))
}
}
}

54
servo/src/components/main/compositing/mod.rs
Просмотреть файл

@ -20,15 +20,12 @@ use gfx::opts::Opts;
use azure::azure_hl::{DataSourceSurface, DrawTarget, SourceSurfaceMethods, current_gl_context};
use azure::azure::AzGLContext;
use std::cell::Cell;
use std::comm;
use std::comm::{Chan, SharedChan, Port};
use std::num::Orderable;
use std::task;
use std::uint;
use std::vec;
use extra::uv_global_loop;
use extra::timer;
use std::rt::rtio::RtioTimer;
use std::rt::io::timer::Timer;
use geom::matrix::identity;
use geom::point::Point2D;
use geom::size::Size2D;
@ -80,7 +77,7 @@ impl RenderListener for CompositorChan {
port.recv()
}
fn paint(&self, id: PipelineId, layer_buffer_set: arc::ARC<LayerBufferSet>) {
fn paint(&self, id: PipelineId, layer_buffer_set: arc::Arc<LayerBufferSet>) {
self.chan.send(Paint(id, layer_buffer_set))
}
@ -136,7 +133,7 @@ pub enum Msg {
DeleteLayer(PipelineId),
/// Requests that the compositor paint the given layer buffer set for the given page size.
Paint(PipelineId, arc::ARC<LayerBufferSet>),
Paint(PipelineId, arc::Arc<LayerBufferSet>),
/// Alerts the compositor to the current status of page loading.
ChangeReadyState(ReadyState),
/// Alerts the compositor to the current status of rendering.
@ -192,24 +189,7 @@ impl CompositorTask {
}
/// Starts the compositor, which listens for messages on the specified port.
pub fn create(opts: Opts,
port: Port<Msg>,
profiler_chan: ProfilerChan,
shutdown_chan: Chan<()>) {
let port = Cell::new(port);
let shutdown_chan = Cell::new(shutdown_chan);
let opts = Cell::new(opts);
do on_osmain {
let compositor_task = CompositorTask::new(opts.take(),
port.take(),
profiler_chan.clone(),
shutdown_chan.take());
debug!("preparing to enter main loop");
compositor_task.run_main_loop();
};
}
fn run_main_loop(&self) {
pub fn run(&self) {
let app: Application = ApplicationMethods::new();
let window: @mut Window = WindowMethods::new(&app);
@ -242,7 +222,7 @@ impl CompositorTask {
let ask_for_tiles = || {
let window_size_page = Size2D(window_size.width as f32 / world_zoom,
window_size.height as f32 / world_zoom);
for compositor_layer.mut_iter().advance |layer| {
for layer in compositor_layer.mut_iter() {
recomposite = layer.get_buffer_request(Rect(Point2D(0f32, 0f32), window_size_page),
world_zoom) || recomposite;
}
@ -368,7 +348,7 @@ impl CompositorTask {
MouseWindowMouseDownEvent(_, p) => Point2D(p.x / world_zoom, p.y / world_zoom),
MouseWindowMouseUpEvent(_, p) => Point2D(p.x / world_zoom, p.y / world_zoom),
};
for compositor_layer.iter().advance |layer| {
for layer in compositor_layer.iter() {
layer.send_mouse_event(mouse_window_event, point);
}
}
@ -380,7 +360,7 @@ impl CompositorTask {
cursor.y as f32 / world_zoom);
let page_window = Size2D(window_size.width as f32 / world_zoom,
window_size.height as f32 / world_zoom);
for compositor_layer.mut_iter().advance |layer| {
for layer in compositor_layer.mut_iter() {
recomposite = layer.scroll(page_delta, page_cursor, page_window) || recomposite;
}
ask_for_tiles();
@ -402,7 +382,7 @@ impl CompositorTask {
let page_cursor = Point2D(-1f32, -1f32); // Make sure this hits the base layer
let page_window = Size2D(window_size.width as f32 / world_zoom,
window_size.height as f32 / world_zoom);
for compositor_layer.mut_iter().advance |layer| {
for layer in compositor_layer.mut_iter() {
layer.scroll(page_delta, page_cursor, page_window);
}
@ -458,7 +438,7 @@ impl CompositorTask {
// flip image vertically (texture is upside down)
let orig_pixels = pixels.clone();
let stride = width * 3;
for uint::range(0, height) |y| {
for y in range(0, height) {
let dst_start = y * stride;
let src_start = (height - y - 1) * stride;
vec::bytes::copy_memory(pixels.mut_slice(dst_start, dst_start + stride),
@ -483,6 +463,7 @@ impl CompositorTask {
};
// Enter the main event loop.
let tm = Timer::new().unwrap();
while !done {
// Check for new messages coming from the rendering task.
check_for_messages(&self.port);
@ -495,7 +476,7 @@ impl CompositorTask {
composite();
}
timer::sleep(&uv_global_loop::get(), 10);
tm.sleep(10);
// If a pinch-zoom happened recently, ask for tiles at the new resolution
if zoom_action && precise_time_s() - zoom_time > 0.3 {
@ -508,14 +489,3 @@ impl CompositorTask {
self.shutdown_chan.send(())
}
}
/// A function for spawning into the platform's main thread.
fn on_osmain(f: ~fn()) {
// FIXME: rust#6399
let mut main_task = task::task();
main_task.sched_mode(task::PlatformThread);
do main_task.spawn {
f();
}
}

18
servo/src/components/main/compositing/quadtree.rs
Просмотреть файл

@ -47,7 +47,7 @@ struct QuadtreeNode<T> {
tile_mem: uint,
}
priv enum Quadrant {
enum Quadrant {
TL = 0,
TR = 1,
BL = 2,
@ -212,7 +212,7 @@ impl<T: Tile> Quadtree<T> {
let difference = (new_size as f32 / self.root.size as f32).log2() as int;
if difference > 0 { // doubling
let difference = difference as uint;
for range(0, difference) |i| {
for i in range(0, difference) {
let new_root = ~QuadtreeNode {
tile: None,
origin: Point2D(0f32, 0f32),
@ -225,7 +225,7 @@ impl<T: Tile> Quadtree<T> {
}
} else if difference < 0 { // halving
let difference = difference.abs() as uint;
for difference.times {
for _ in range(0, difference) {
let remove = replace(&mut self.root.quadrants[TL as int], None);
match remove {
Some(child) => self.root = child,
@ -299,7 +299,7 @@ impl<T: Tile> QuadtreeNode<T> {
fn get_all_tiles<'r>(&'r self) -> ~[&'r T] {
let mut ret = ~[];
for self.quadrants.iter().advance |quad| {
for quad in self.quadrants.iter() {
match *quad {
Some(ref child) => ret = ret + child.get_all_tiles(),
None => {}
@ -332,7 +332,7 @@ impl<T: Tile> QuadtreeNode<T> {
self.tile = Some(tile);
// FIXME: This should be inline, but currently won't compile
let quads = [TL, TR, BL, BR];
for quads.iter().advance |quad| {
for quad in quads.iter() {
self.quadrants[*quad as int] = None;
}
self.render_flag = false;
@ -439,7 +439,7 @@ impl<T: Tile> QuadtreeNode<T> {
let mut del_quad: Option<Quadrant> = None;
let mut ret = (None, false, 0);
for queue.iter().advance |quad| {
for quad in queue.iter() {
match self.quadrants[*quad as int] {
Some(ref mut child) => {
let (tile, flag, delta) = child.remove_tile(x, y);
@ -514,7 +514,7 @@ impl<T: Tile> QuadtreeNode<T> {
let old_mem = self.tile_mem;
// FIXME: This should be inline, but currently won't compile
let quads = [TL, TR, BL, BR];
for quads.iter().advance |quad| {
for quad in quads.iter() {
self.quadrants[*quad as int] = None;
}
self.tile_mem = tile.get_mem();
@ -561,7 +561,7 @@ impl<T: Tile> QuadtreeNode<T> {
let mut redisplay = false;
let mut delta = 0;
for quads_to_check.iter().advance |quad| {
for quad in quads_to_check.iter() {
// Recurse into child
let new_window = match *quad {
TL => Rect(window.origin,
@ -628,7 +628,7 @@ impl<T: Tile> QuadtreeNode<T> {
ret = fmt!("%s<table border=1><tr>", ret);
// FIXME: This should be inline, but currently won't compile
let quads = [TL, TR, BL, BR];
for quads.iter().advance |quad| {
for quad in quads.iter() {
match self.quadrants[*quad as int] {
Some(ref child) => {
ret = fmt!("%s<td>%s</td>", ret, child.get_html());

84
servo/src/components/main/constellation.rs
Просмотреть файл

@ -4,8 +4,6 @@
use compositing::{CompositorChan, SetIds};
use extra::net::url;
use std::cell::Cell;
use std::comm;
use std::comm::Port;
@ -51,7 +49,7 @@ struct FrameTree {
// Need to clone the FrameTrees, but _not_ the Pipelines
impl Clone for FrameTree {
fn clone(&self) -> FrameTree {
let mut children = do self.children.iter().transform |&frame_tree| {
let mut children = do self.children.iter().map |&frame_tree| {
@mut (*frame_tree).clone()
};
FrameTree {
@ -95,27 +93,27 @@ impl FrameTree {
/// Replaces a node of the frame tree in place. Returns the node that was removed or the original node
/// if the node to replace could not be found.
fn replace_child(&mut self, id: PipelineId, new_child: @mut FrameTree) -> Result<@mut FrameTree, @mut FrameTree> {
fn replace_child(&mut self, id: PipelineId, new_child: @mut FrameTree) -> Either<@mut FrameTree, @mut FrameTree> {
let new_child_cell = Cell::new(new_child);
for self.children.mut_iter().advance |child| {
for child in self.children.mut_iter() {
let new_child = new_child_cell.take();
if child.pipeline.id == id {
new_child.parent = child.parent;
return Ok(replace(child, new_child));
return Left(replace(child, new_child));
}
let replaced = child.replace_child(id, new_child);
if replaced.is_ok() {
if replaced.is_left() {
return replaced;
}
new_child_cell.put_back(replaced.get_err());
new_child_cell.put_back(replaced.unwrap_right());
}
Err(new_child_cell.take())
Right(new_child_cell.take())
}
fn to_sendable(&self) -> SendableFrameTree {
let sendable_frame_tree = SendableFrameTree {
pipeline: (*self.pipeline).clone(),
children: self.children.iter().transform(|frame_tree| frame_tree.to_sendable()).collect(),
children: self.children.iter().map(|frame_tree| frame_tree.to_sendable()).collect(),
};
sendable_frame_tree
}
@ -169,17 +167,17 @@ impl NavigationContext {
* when it is known that there exists either a previous page or a next page. */
pub fn back(&mut self) -> @mut FrameTree {
self.next.push(self.current.swap_unwrap());
self.next.push(self.current.take_unwrap());
self.current = Some(self.previous.pop());
debug!("previous: %? next: %? current: %?", self.previous, self.next, *self.current.get_ref());
self.current.get()
self.current.unwrap()
}
pub fn forward(&mut self) -> @mut FrameTree {
self.previous.push(self.current.swap_unwrap());
self.previous.push(self.current.take_unwrap());
self.current = Some(self.next.pop());
debug!("previous: %? next: %? current: %?", self.previous, self.next, *self.current.get_ref());
self.current.get()
self.current.unwrap()
}
/// Loads a new set of page frames, returning all evicted frame trees
@ -187,7 +185,7 @@ impl NavigationContext {
debug!("navigating to %?", frame_tree);
let evicted = replace(&mut self.next, ~[]);
if self.current.is_some() {
self.previous.push(self.current.swap_unwrap());
self.previous.push(self.current.take_unwrap());
}
self.current = Some(frame_tree);
evicted
@ -204,7 +202,7 @@ impl NavigationContext {
let from_prev = do self.previous.iter().filter_map |frame_tree| {
frame_tree.find_mut(pipeline_id)
};
from_prev.chain_(from_current).chain_(from_next).collect()
from_prev.chain(from_current).chain(from_next).collect()
}
pub fn contains(&mut self, pipeline_id: PipelineId) -> bool {
@ -212,7 +210,7 @@ impl NavigationContext {
let from_next = self.next.iter();
let from_prev = self.previous.iter();
let mut all_contained = from_prev.chain_(from_current).chain_(from_next);
let mut all_contained = from_prev.chain(from_current).chain(from_next);
do all_contained.any |frame_tree| {
frame_tree.contains(pipeline_id)
}
@ -227,7 +225,7 @@ impl Constellation {
profiler_chan: ProfilerChan)
-> ConstellationChan {
let opts = Cell::new(copy *opts);
let opts = Cell::new((*opts).clone());
let (constellation_port, constellation_chan) = special_stream!(ConstellationChan);
let constellation_port = Cell::new(constellation_port);
@ -285,7 +283,7 @@ impl Constellation {
match request {
ExitMsg(sender) => {
for self.pipelines.iter().advance |(_id, ref pipeline)| {
for (_id, ref pipeline) in self.pipelines.iter() {
pipeline.exit();
}
self.image_cache_task.exit();
@ -304,7 +302,7 @@ impl Constellation {
self.image_cache_task.clone(),
self.resource_task.clone(),
self.profiler_chan.clone(),
copy self.opts,
self.opts.clone(),
{
let size = self.compositor_chan.get_size();
from_value(Size2D(size.width as uint, size.height as uint))
@ -339,7 +337,7 @@ impl Constellation {
let matching_pending_frames = do self.pending_frames.iter().filter_map |frame_change| {
frame_change.after.find_mut(source_pipeline_id)
};
matching_navi_frames.consume_iter().chain_(matching_pending_frames).collect()
matching_navi_frames.move_iter().chain(matching_pending_frames).collect()
};
if frame_trees.is_empty() {
@ -370,7 +368,7 @@ impl Constellation {
self.compositor_chan.clone(),
self.image_cache_task.clone(),
self.profiler_chan.clone(),
copy self.opts,
self.opts.clone(),
source_pipeline,
size_future)
} else {
@ -382,7 +380,7 @@ impl Constellation {
self.image_cache_task.clone(),
self.resource_task.clone(),
self.profiler_chan.clone(),
copy self.opts,
self.opts.clone(),
size_future)
};
@ -391,7 +389,7 @@ impl Constellation {
} else {
pipeline.load(url, None);
}
for frame_trees.iter().advance |frame_tree| {
for frame_tree in frame_trees.iter() {
frame_tree.children.push(@mut FrameTree {
pipeline: pipeline,
parent: Some(source_pipeline),
@ -405,14 +403,14 @@ impl Constellation {
// If there is already a pending page (self.pending_frames), it will not be overridden;
// However, if the id is not encompassed by another change, it will be.
LoadUrlMsg(source_id, url, size_future) => {
debug!("received message to load %s", url::to_str(&url));
debug!("received message to load %s", url.to_str());
// Make sure no pending page would be overridden.
let source_frame = self.current_frame().get_ref().find_mut(source_id).expect(
"Constellation: received a LoadUrlMsg from a pipeline_id associated
with a pipeline not in the active frame tree. This should be
impossible.");
for self.pending_frames.iter().advance |frame_change| {
for frame_change in self.pending_frames.iter() {
let old_id = frame_change.before.expect("Constellation: Received load msg
from pipeline, but there is no currently active page. This should
be impossible.");
@ -438,7 +436,7 @@ impl Constellation {
self.image_cache_task.clone(),
self.resource_task.clone(),
self.profiler_chan.clone(),
copy self.opts,
self.opts.clone(),
size_future);
if url.path.ends_with(".js") {
@ -473,7 +471,7 @@ impl Constellation {
return true
} else {
let old = self.current_frame().get_ref();
for old.iter().advance |frame| {
for frame in old.iter() {
frame.pipeline.revoke_paint_permission();
}
}
@ -485,7 +483,7 @@ impl Constellation {
return true
} else {
let old = self.current_frame().get_ref();
for old.iter().advance |frame| {
for frame in old.iter() {
frame.pipeline.revoke_paint_permission();
}
}
@ -493,7 +491,7 @@ impl Constellation {
}
};
for destination_frame.iter().advance |frame| {
for frame in destination_frame.iter() {
let pipeline = &frame.pipeline;
pipeline.reload(Some(constellation_msg::Navigate));
}
@ -507,7 +505,7 @@ impl Constellation {
// from a pending frame. The only time that we will grant paint permission is
// when the message originates from a pending frame or the current frame.
for self.current_frame().iter().advance |&current_frame| {
for &current_frame in self.current_frame().iter() {
// Messages originating in the current frame are not navigations;
// TODO(tkuehn): In fact, this kind of message might be provably
// impossible to occur.
@ -523,26 +521,26 @@ impl Constellation {
let pending_index = do self.pending_frames.rposition |frame_change| {
frame_change.after.pipeline.id == pipeline_id
};
for pending_index.iter().advance |&pending_index| {
for &pending_index in pending_index.iter() {
let frame_change = self.pending_frames.swap_remove(pending_index);
let to_add = frame_change.after;
// Create the next frame tree that will be given to the compositor
let next_frame_tree = match to_add.parent {
None => to_add, // to_add is the root
Some(_parent) => @mut (*self.current_frame().get()).clone(),
Some(_parent) => @mut (*self.current_frame().unwrap()).clone(),
};
// If there are frames to revoke permission from, do so now.
match frame_change.before {
Some(revoke_id) => {
let current_frame = self.current_frame().get();
let current_frame = self.current_frame().unwrap();
let to_revoke = current_frame.find_mut(revoke_id).expect(
"Constellation: pending frame change refers to an old
frame not contained in the current frame. This is a bug");
for to_revoke.iter().advance |frame| {
for frame in to_revoke.iter() {
frame.pipeline.revoke_paint_permission();
}
@ -556,7 +554,7 @@ impl Constellation {
// Add to_add to parent's children, if it is not the root
let parent = &to_add.parent;
let to_add = Cell::new(to_add);
for parent.iter().advance |parent| {
for parent in parent.iter() {
let parent = next_frame_tree.find_mut(parent.id).expect(
"Constellation: pending frame has a parent frame that is not
active. This is a bug.");
@ -571,13 +569,13 @@ impl Constellation {
ResizedWindowBroadcast(new_size) => match *self.current_frame() {
Some(ref current_frame) => {
let current_frame_id = current_frame.pipeline.id.clone();
for self.navigation_context.previous.iter().advance |frame_tree| {
for frame_tree in self.navigation_context.previous.iter() {
let pipeline = &frame_tree.pipeline;
if current_frame_id != pipeline.id {
pipeline.script_chan.send(ResizeInactiveMsg(new_size));
}
}
for self.navigation_context.next.iter().advance |frame_tree| {
for frame_tree in self.navigation_context.next.iter() {
let pipeline = &frame_tree.pipeline;
if current_frame_id != pipeline.id {
pipeline.script_chan.send(ResizeInactiveMsg(new_size));
@ -585,10 +583,10 @@ impl Constellation {
}
}
None => {
for self.navigation_context.previous.iter().advance |frame_tree| {
for frame_tree in self.navigation_context.previous.iter() {
frame_tree.pipeline.script_chan.send(ResizeInactiveMsg(new_size));
}
for self.navigation_context.next.iter().advance |frame_tree| {
for frame_tree in self.navigation_context.next.iter() {
frame_tree.pipeline.script_chan.send(ResizeInactiveMsg(new_size));
}
}
@ -608,9 +606,9 @@ impl Constellation {
match frame_tree.pipeline.navigation_type {
Some(constellation_msg::Load) => {
let evicted = self.navigation_context.load(frame_tree);
for evicted.iter().advance |frame_tree| {
for frame_tree in evicted.iter() {
// exit any pipelines that don't exist outside the evicted frame trees
for frame_tree.iter().advance |frame| {
for frame in frame_tree.iter() {
if !self.navigation_context.contains(frame.pipeline.id) {
frame_tree.pipeline.exit();
self.pipelines.remove(&frame_tree.pipeline.id);
@ -626,7 +624,7 @@ impl Constellation {
let (port, chan) = comm::stream();
self.compositor_chan.send(SetIds(frame_tree.to_sendable(), chan));
port.recv();
for frame_tree.iter().advance |frame| {
for frame in frame_tree.iter() {
frame.pipeline.grant_paint_permission();
}
}

4
servo/src/components/main/css/matching.rs
Просмотреть файл

@ -11,7 +11,7 @@ use layout::incremental;
use script::dom::node::{AbstractNode, LayoutView};
use newcss::complete::CompleteSelectResults;
use newcss::select::{SelectCtx, SelectResults};
use servo_util::tree::TreeUtils;
use servo_util::tree::TreeNodeRef;
pub trait MatchMethods {
fn restyle_subtree(&self, select_ctx: &SelectCtx);
@ -48,7 +48,7 @@ impl MatchMethods for AbstractNode<LayoutView> {
};
}
for self.each_child |kid| {
for kid in self.children() {
kid.restyle_subtree(select_ctx);
}
}

2
servo/src/components/main/css/node_util.rs
Просмотреть файл

@ -65,7 +65,7 @@ impl<'self> NodeUtil<'self> for AbstractNode<LayoutView> {
if !self.has_layout_data() {
return default;
}
self.layout_data().restyle_damage.get_or_default(default)
self.layout_data().restyle_damage.unwrap_or_default(default)
}
/// Set the restyle damage field.

7
servo/src/components/main/css/select.rs
Просмотреть файл

@ -2,10 +2,9 @@
* 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 extra::net::url::Url;
use url_from_str = extra::net::url::from_str;
use extra::url::Url;
use std::cell::Cell;
use std::result;
use std::FromStr;
use newcss::stylesheet::Stylesheet;
use newcss::select::SelectCtx;
use newcss::types::OriginUA;
@ -29,7 +28,7 @@ fn servo_default_style() -> Stylesheet {
}
fn default_url(name: &str) -> Url {
result::unwrap(url_from_str(fmt!("http://%s", name)))
FromStr::from_str(fmt!("http://%s", name)).unwrap()
}
fn style_stream(style: &str) -> DataStream {

2
servo/src/components/main/css/select_handler.rs
Просмотреть файл

@ -101,7 +101,7 @@ impl SelectHandler<AbstractNode<LayoutView>> for NodeSelectHandler {
None => false,
Some(existing_classes) => {
let mut ret = false;
for existing_classes.split_iter(' ').advance |s| {
for s in existing_classes.split_iter(' ') {
if s == class {
ret = true;
break;

12
servo/src/components/main/layout/aux.rs
Просмотреть файл

@ -9,7 +9,7 @@ use layout::incremental::RestyleDamage;
use newcss::complete::CompleteSelectResults;
use script::dom::node::{AbstractNode, LayoutView};
use servo_util::tree::TreeUtils;
use servo_util::tree::TreeNodeRef;
/// Data that layout associates with a node.
pub struct LayoutData {
@ -37,7 +37,7 @@ impl LayoutData {
/// Functionality useful for querying the layout-specific data on DOM nodes.
pub trait LayoutAuxMethods {
fn layout_data(self) -> @mut LayoutData;
pub fn has_layout_data(self) -> bool;
fn has_layout_data(self) -> bool;
fn set_layout_data(self, data: @mut LayoutData);
fn initialize_layout_data(self) -> Option<@mut LayoutData>;
@ -45,17 +45,17 @@ pub trait LayoutAuxMethods {
}
impl LayoutAuxMethods for AbstractNode<LayoutView> {
pub fn layout_data(self) -> @mut LayoutData {
fn layout_data(self) -> @mut LayoutData {
unsafe {
self.unsafe_layout_data()
}
}
pub fn has_layout_data(self) -> bool {
fn has_layout_data(self) -> bool {
unsafe {
self.unsafe_has_layout_data()
}
}
pub fn set_layout_data(self, data: @mut LayoutData) {
fn set_layout_data(self, data: @mut LayoutData) {
unsafe {
self.unsafe_set_layout_data(data)
}
@ -84,7 +84,7 @@ impl LayoutAuxMethods for AbstractNode<LayoutView> {
/// Initializes layout data and styles for a Node tree, if any nodes do not have
/// this data already. Append created layout data to the task's GC roots.
fn initialize_style_for_subtree(self, refs: &mut ~[@mut LayoutData]) {
let _ = for self.traverse_preorder |n| {
let _ = for n in self.traverse_preorder() {
match n.initialize_layout_data() {
Some(r) => refs.push(r),
None => {}

23
servo/src/components/main/layout/block.rs
Просмотреть файл

@ -18,7 +18,7 @@ use geom::rect::Rect;
use gfx::display_list::DisplayList;
use gfx::geometry::Au;
use gfx::geometry;
use servo_util::tree::{TreeNodeRef, TreeUtils};
use servo_util::tree::TreeNodeRef;
pub struct BlockFlowData {
/// Data common to all flows.
@ -50,7 +50,7 @@ impl BlockFlowData {
pub fn teardown(&mut self) {
self.common.teardown();
for self.box.iter().advance |box| {
for box in self.box.iter() {
box.teardown();
}
self.box = None;
@ -94,7 +94,7 @@ impl BlockFlowData {
let mut num_floats = 0;
/* find max width from child block contexts */
for BlockFlow(self).each_child |child_ctx| {
for child_ctx in BlockFlow(self).children() {
assert!(child_ctx.starts_block_flow() || child_ctx.starts_inline_flow());
do child_ctx.with_mut_base |child_node| {
@ -124,7 +124,7 @@ impl BlockFlowData {
/// Computes left and right margins and width based on CSS 2.1 secion 10.3.3.
/// Requires borders and padding to already be computed
priv fn compute_horiz( &self,
fn compute_horiz( &self,
width: MaybeAuto,
left_margin: MaybeAuto,
right_margin: MaybeAuto,
@ -192,7 +192,7 @@ impl BlockFlowData {
let mut remaining_width = self.common.position.size.width;
let mut x_offset = Au(0);
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
let style = box.style();
do box.with_model |model| {
// Can compute padding here since we know containing block width.
@ -239,7 +239,7 @@ impl BlockFlowData {
}
let has_inorder_children = self.common.is_inorder || self.common.num_floats > 0;
for BlockFlow(self).each_child |kid| {
for kid in BlockFlow(self).children() {
assert!(kid.starts_block_flow() || kid.starts_inline_flow());
do kid.with_mut_base |child_node| {
@ -278,7 +278,7 @@ impl BlockFlowData {
let mut left_offset = Au(0);
let mut float_ctx = Invalid;
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
clearance = match box.clear() {
None => Au(0),
Some(clear) => {
@ -303,7 +303,7 @@ impl BlockFlowData {
// repeat until all children are visited.
// last_child.floats_out -> self.floats_out (done at the end of this method)
float_ctx = self.common.floats_in.translate(Point2D(-left_offset, -top_offset));
for BlockFlow(self).each_child |kid| {
for kid in BlockFlow(self).children() {
do kid.with_mut_base |child_node| {
child_node.floats_in = float_ctx.clone();
}
@ -311,10 +311,9 @@ impl BlockFlowData {
do kid.with_mut_base |child_node| {
float_ctx = child_node.floats_out.clone();
}
}
}
for BlockFlow(self).each_child |kid| {
for kid in BlockFlow(self).children() {
do kid.with_mut_base |child_node| {
child_node.position.origin.y = cur_y;
cur_y = cur_y + child_node.position.size.height;
@ -327,7 +326,7 @@ impl BlockFlowData {
cur_y - top_offset
};
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
let style = box.style();
let maybe_height = MaybeAuto::from_height(style.height(), Au(0), style.font_size());
let maybe_height = maybe_height.specified_or_zero();
@ -380,7 +379,7 @@ impl BlockFlowData {
// go deeper into the flow tree
let flow = BlockFlow(self);
for flow.each_child |child| {
for child in flow.children() {
do child.with_mut_base |base| {
base.abs_position = self.common.abs_position + base.position.origin;
}

25
servo/src/components/main/layout/box.rs
Просмотреть файл

@ -16,7 +16,6 @@ use std::cell::Cell;
use std::cmp::ApproxEq;
use std::managed;
use std::num::Zero;
use std::uint;
use geom::{Point2D, Rect, Size2D, SideOffsets2D};
use gfx::display_list::{BaseDisplayItem, BorderDisplayItem, BorderDisplayItemClass};
use gfx::display_list::{DisplayList, ImageDisplayItem, ImageDisplayItemClass};
@ -38,7 +37,7 @@ use script::dom::node::{AbstractNode, LayoutView};
use servo_net::image::holder::ImageHolder;
use servo_net::local_image_cache::LocalImageCache;
use servo_util::range::*;
use extra::net::url::Url;
use extra::url::Url;
/// Render boxes (`struct RenderBox`) are the leaves of the layout tree. They cannot position
/// themselves. In general, render boxes do not have a simple correspondence with CSS boxes as in
@ -292,14 +291,13 @@ impl RenderBox {
text_box.range,
max_width);
for text_box.run.iter_slices_for_range(&text_box.range)
|glyphs, offset, slice_range| {
for (glyphs, offset, slice_range) in text_box.run.iter_slices_for_range(&text_box.range) {
debug!("split_to_width: considering slice (offset=%?, range=%?, remain_width=%?)",
offset,
slice_range,
remaining_width);
let metrics = text_box.run.metrics_for_slice(glyphs, slice_range);
let metrics = text_box.run.metrics_for_slice(glyphs, &slice_range);
let advance = metrics.advance_width;
let should_continue: bool;
@ -385,7 +383,7 @@ impl RenderBox {
//
// TODO(eatkinson): integrate with
// get_min_width and get_pref_width?
priv fn guess_width (&self) -> Au {
fn guess_width (&self) -> Au {
do self.with_base |base| {
if(!base.node.is_element()) {
Au(0)
@ -433,7 +431,7 @@ impl RenderBox {
ImageRenderBoxClass(image_box) => {
// TODO: Consult the CSS `width` property as well as margins and borders.
// TODO: If the image isn't available, consult `width`.
Au::from_px(image_box.image.get_size().get_or_default(Size2D(0, 0)).width)
Au::from_px(image_box.image.get_size().unwrap_or_default(Size2D(0, 0)).width)
}
TextRenderBoxClass(text_box) => {
@ -454,7 +452,7 @@ impl RenderBox {
GenericRenderBoxClass(*) => Au(0),
ImageRenderBoxClass(image_box) => {
Au::from_px(image_box.image.get_size().get_or_default(Size2D(0, 0)).width)
Au::from_px(image_box.image.get_size().unwrap_or_default(Size2D(0, 0)).width)
}
TextRenderBoxClass(text_box) => {
@ -465,9 +463,8 @@ impl RenderBox {
// report nothing and the parent flow can factor in minimum/preferred widths of any
// text runs that it owns.
let mut max_line_width = Au(0);
for text_box.run.iter_natural_lines_for_range(&text_box.range)
|line_range| {
let line_metrics = text_box.run.metrics_for_range(line_range);
for line_range in text_box.run.iter_natural_lines_for_range(&text_box.range) {
let line_metrics = text_box.run.metrics_for_range(&line_range);
max_line_width = Au::max(max_line_width, line_metrics.advance_width);
}
@ -782,7 +779,7 @@ impl RenderBox {
// FIXME: Too much allocation here.
let font_families = do my_style.font_family().map |family| {
match *family {
CSSFontFamilyFamilyName(ref family_str) => copy *family_str,
CSSFontFamilyFamilyName(ref family_str) => (*family_str).clone(),
CSSFontFamilyGenericFamily(Serif) => ~"serif",
CSSFontFamilyGenericFamily(SansSerif) => ~"sans-serif",
CSSFontFamilyGenericFamily(Cursive) => ~"cursive",
@ -823,7 +820,7 @@ impl RenderBox {
self.nearest_ancestor_element().style().text_align()
}
fn line_height(&self) -> CSSLineHeight {
pub fn line_height(&self) -> CSSLineHeight {
self.nearest_ancestor_element().style().line_height()
}
@ -875,7 +872,7 @@ impl RenderBox {
/// Dumps a render box for debugging, with indentation.
pub fn dump_indent(&self, indent: uint) {
let mut string = ~"";
for uint::range(0u, indent) |_i| {
for _ in range(0u, indent) {
string.push_str(" ");
}

33
servo/src/components/main/layout/box_builder.rs
Просмотреть файл

@ -30,7 +30,7 @@ use script::dom::element::*;
use script::dom::node::{AbstractNode, CommentNodeTypeId, DoctypeNodeTypeId};
use script::dom::node::{ElementNodeTypeId, LayoutView, TextNodeTypeId};
use servo_util::range::Range;
use servo_util::tree::{TreeNodeRef, TreeNode, TreeUtils};
use servo_util::tree::{TreeNodeRef, TreeNode};
pub struct LayoutTreeBuilder {
root_flow: Option<FlowContext>,
@ -60,7 +60,7 @@ enum InlineSpacerSide {
LogicalAfter,
}
priv fn simulate_UA_display_rules(node: AbstractNode<LayoutView>) -> CSSDisplay {
fn simulate_UA_display_rules(node: AbstractNode<LayoutView>) -> CSSDisplay {
// FIXME
/*let resolved = do node.aux |nd| {
match nd.style.display_type {
@ -145,8 +145,7 @@ impl BoxGenerator {
} else if self.inline_spacers_needed_for_node(node) {
// else, maybe make a spacer for "left" margin, border, padding
let inline_spacer = self.make_inline_spacer_for_node_side(ctx, node, LogicalBefore);
for inline_spacer.iter().advance
|spacer: &RenderBox| {
for spacer in inline_spacer.iter() {
inline.boxes.push(*spacer);
}
}
@ -220,7 +219,7 @@ impl BoxGenerator {
// If this non-leaf box generates extra horizontal spacing, add a SpacerBox for
// it.
let result = self.make_inline_spacer_for_node_side(ctx, node, LogicalAfter);
for result.iter().advance |spacer| {
for spacer in result.iter() {
let boxes = &mut self.flow.inline().boxes;
boxes.push(*spacer);
}
@ -269,7 +268,7 @@ impl BoxGenerator {
do node.with_imm_image_element |image_element| {
if image_element.image.is_some() {
// FIXME(pcwalton): Don't copy URLs.
let url = copy *image_element.image.get_ref();
let url = (*image_element.image.get_ref()).clone();
ImageRenderBoxClass(@mut ImageRenderBox::new(base, url, layout_ctx.image_cache))
} else {
info!("Tried to make image box, but couldn't find image. Made generic box \
@ -328,7 +327,7 @@ impl LayoutTreeBuilder {
// recurse on child nodes.
let mut prev_generator: Option<@mut BoxGenerator> = None;
for cur_node.each_child |child_node| {
for child_node in cur_node.children() {
prev_generator = self.construct_recursively(layout_ctx, child_node, this_generator, prev_generator);
}
@ -340,7 +339,7 @@ impl LayoutTreeBuilder {
// eventually be elided or split, but the mapping between
// nodes and FlowContexts should not change during layout.
let flow: &FlowContext = &this_generator.flow;
for flow.each_child |child_flow| {
for child_flow in flow.children() {
do child_flow.with_base |child_node| {
let dom_node = child_node.node;
assert!(dom_node.has_layout_data());
@ -403,22 +402,22 @@ impl LayoutTreeBuilder {
// Floats
(CSSDisplayBlock, BlockFlow(_), _) |
(CSSDisplayBlock, FloatFlow(_), _) if !is_float.is_none() => {
self.create_child_generator(node, parent_generator, Flow_Float(is_float.get()))
self.create_child_generator(node, parent_generator, Flow_Float(is_float.unwrap()))
}
// If we're placing a float after an inline, append the float to the inline flow,
// then continue building from the inline flow in case there are more inlines
// afterward.
(CSSDisplayBlock, _, Some(InlineFlow(_))) if !is_float.is_none() => {
let float_generator = self.create_child_generator(node,
sibling_generator.get(),
Flow_Float(is_float.get()));
return Some((float_generator, sibling_generator.get()));
sibling_generator.unwrap(),
Flow_Float(is_float.unwrap()));
return Some((float_generator, sibling_generator.unwrap()));
}
// This is a catch-all case for when:
// a) sibling_flow is None
// b) sibling_flow is a BlockFlow
(CSSDisplayBlock, InlineFlow(_), _) if !is_float.is_none() => {
self.create_child_generator(node, parent_generator, Flow_Float(is_float.get()))
self.create_child_generator(node, parent_generator, Flow_Float(is_float.unwrap()))
}
(CSSDisplayBlock, BlockFlow(info), _) => match (info.is_root, node.parent_node()) {
@ -515,7 +514,7 @@ impl LayoutTreeBuilder {
let mut found_child_block = false;
let flow = *parent_flow;
for flow.each_child |child_ctx: FlowContext| {
for child_ctx in flow.children() {
match child_ctx {
InlineFlow(*) | InlineBlockFlow(*) => found_child_inline = true,
BlockFlow(*) => found_child_block = true,
@ -535,7 +534,7 @@ impl LayoutTreeBuilder {
let first_child = do parent_flow.with_base |parent_node| {
parent_node.first_child
};
for first_child.iter().advance |&first_flow| {
for &first_flow in first_child.iter() {
if first_flow.starts_inline_flow() {
// FIXME: workaround for rust#6393
let mut do_remove = false;
@ -558,7 +557,7 @@ impl LayoutTreeBuilder {
let last_child = do parent_flow.with_base |parent_node| {
parent_node.last_child
};
for last_child.iter().advance |&last_flow| {
for &last_flow in last_child.iter() {
if last_flow.starts_inline_flow() {
// FIXME: workaround for rust#6393
let mut do_remove = false;
@ -580,7 +579,7 @@ impl LayoutTreeBuilder {
// Issue 543: We only need to do this if there are inline child
// flows, but there's not a quick way to check at the moment.
for (*parent_flow).each_child |child_flow: FlowContext| {
for child_flow in (*parent_flow).children() {
match child_flow {
InlineFlow(*) | InlineBlockFlow(*) => {
let mut scanner = TextRunScanner::new();

34
servo/src/components/main/layout/float.rs
Просмотреть файл

@ -15,7 +15,7 @@ use geom::rect::Rect;
use gfx::display_list::DisplayList;
use gfx::geometry::Au;
use gfx::geometry;
use servo_util::tree::{TreeNodeRef, TreeUtils};
use servo_util::tree::TreeNodeRef;
pub struct FloatFlowData {
/// Data common to all flows.
@ -55,7 +55,7 @@ impl FloatFlowData {
pub fn teardown(&mut self) {
self.common.teardown();
for self.box.iter().advance |box| {
for box in self.box.iter() {
box.teardown();
}
self.box = None;
@ -69,7 +69,7 @@ impl FloatFlowData {
let mut pref_width = Au(0);
let mut num_floats = 0;
for FloatFlow(self).each_child |child_ctx| {
for child_ctx in FloatFlow(self).children() {
//assert!(child_ctx.starts_block_flow() || child_ctx.starts_inline_flow());
do child_ctx.with_mut_base |child_node| {
@ -108,7 +108,7 @@ impl FloatFlowData {
// Parent usually sets this, but floats are never inorder
self.common.is_inorder = false;
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
let style = box.style();
do box.with_model |model| {
// Can compute padding here since we know containing block width.
@ -162,7 +162,7 @@ impl FloatFlowData {
self.common.position.size.width = remaining_width;
let has_inorder_children = self.common.num_floats > 0;
for FloatFlow(self).each_child |kid| {
for kid in FloatFlow(self).children() {
//assert!(kid.starts_block_flow() || kid.starts_inline_flow());
do kid.with_mut_base |child_node| {
@ -199,15 +199,13 @@ impl FloatFlowData {
};
do box.with_base |base| {
let noncontent_width = base.model.padding.left + base.model.padding.right +
base.model.border.left + base.model.border.right;
let noncontent_height = base.model.padding.top + base.model.padding.bottom +
base.model.border.top + base.model.border.bottom;
let noncontent_width = base.model.padding.left + base.model.padding.right +
base.model.border.left + base.model.border.right;
let noncontent_height = base.model.padding.top + base.model.padding.bottom +
base.model.border.top + base.model.border.bottom;
full_noncontent_width = noncontent_width + base.model.margin.left + base.model.margin.right;
full_noncontent_height = noncontent_height + base.model.margin.top + base.model.margin.bottom;
full_noncontent_width = noncontent_width + base.model.margin.left + base.model.margin.right;
full_noncontent_height = noncontent_height + base.model.margin.top + base.model.margin.bottom;
}
});
@ -231,7 +229,7 @@ impl FloatFlowData {
let has_inorder_children = self.common.num_floats > 0;
if has_inorder_children {
let mut float_ctx = FloatContext::new(self.floated_children);
for FloatFlow(self).each_child |kid| {
for kid in FloatFlow(self).children() {
do kid.with_mut_base |child_node| {
child_node.floats_in = float_ctx.clone();
}
@ -245,14 +243,14 @@ impl FloatFlowData {
let mut cur_y = Au(0);
let mut top_offset = Au(0);
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
do box.with_model |model| {
top_offset = model.margin.top + model.border.top + model.padding.top;
cur_y = cur_y + top_offset;
}
}
for FloatFlow(self).each_child |kid| {
for kid in FloatFlow(self).children() {
do kid.with_mut_base |child_node| {
child_node.position.origin.y = cur_y;
cur_y = cur_y + child_node.position.size.height;
@ -279,7 +277,7 @@ impl FloatFlowData {
//TODO(eatkinson): compute heights properly using the 'height' property.
for self.box.iter().advance |&box| {
for &box in self.box.iter() {
let height_prop =
MaybeAuto::from_height(box.style().height(),
Au(0),
@ -316,7 +314,7 @@ impl FloatFlowData {
// go deeper into the flow tree
let flow = FloatFlow(self);
for flow.each_child |child| {
for child in flow.children() {
do child.with_mut_base |base| {
base.abs_position = offset + base.position.origin;
}

14
servo/src/components/main/layout/float_context.rs
Просмотреть файл

@ -10,6 +10,7 @@ use std::util::replace;
use std::vec;
use std::i32::max_value;
#[deriving(Clone)]
pub enum FloatType{
FloatLeft,
FloatRight
@ -28,6 +29,7 @@ struct FloatContextBase{
offset: Point2D<Au>
}
#[deriving(Clone)]
struct FloatData{
bounds: Rect<Au>,
f_type: FloatType
@ -174,7 +176,7 @@ impl FloatContextBase{
let mut r_bottom = None;
// Find the float collisions for the given vertical range.
for self.float_data.iter().advance |float| {
for float in self.float_data.iter() {
debug!("available_rect: Checking for collision against float");
match *float{
None => (),
@ -268,7 +270,7 @@ impl FloatContextBase{
/// Returns true if the given rect overlaps with any floats.
fn collides_with_float(&self, bounds: &Rect<Au>) -> bool {
for self.float_data.iter().advance |float| {
for float in self.float_data.iter() {
match *float{
None => (),
Some(data) => {
@ -290,7 +292,7 @@ impl FloatContextBase{
let left = left - self.offset.x;
let mut max_height = None;
for self.float_data.iter().advance |float| {
for float in self.float_data.iter() {
match *float {
None => (),
Some(f_data) => {
@ -298,7 +300,7 @@ impl FloatContextBase{
f_data.bounds.origin.x + f_data.bounds.size.width > left &&
f_data.bounds.origin.x < left + width {
let new_y = f_data.bounds.origin.y;
max_height = Some(min(max_height.get_or_default(new_y), new_y));
max_height = Some(min(max_height.unwrap_or_default(new_y), new_y));
}
}
}
@ -338,7 +340,7 @@ impl FloatContextBase{
let height = self.max_height_for_bounds(rect.origin.x,
rect.origin.y,
rect.size.width);
let height = height.get_or_default(Au(max_value));
let height = height.unwrap_or_default(Au(max_value));
return match info.f_type {
FloatLeft => Rect(Point2D(rect.origin.x, float_y),
Size2D(rect.size.width, height)),
@ -359,7 +361,7 @@ impl FloatContextBase{
fn clearance(&self, clear: ClearType) -> Au {
let mut clearance = Au(0);
for self.float_data.iter().advance |float| {
for float in self.float_data.iter() {
match *float {
None => (),
Some(f_data) => {

162
servo/src/components/main/layout/flow.rs
Просмотреть файл

@ -36,14 +36,13 @@ use layout::incremental::RestyleDamage;
use css::node_style::StyledNode;
use std::cell::Cell;
use std::uint;
use std::io::stderr;
use geom::point::Point2D;
use geom::rect::Rect;
use gfx::display_list::DisplayList;
use gfx::geometry::Au;
use script::dom::node::{AbstractNode, LayoutView};
use servo_util::tree::{TreeNode, TreeNodeRef, TreeUtils};
use servo_util::tree::{TreeNode, TreeNodeRef};
/// The type of the formatting context and data specific to each context, such as line box
/// structures or float lists.
@ -84,29 +83,25 @@ impl FlowContext {
//
// FIXME: Unify this with traverse_preorder_prune, which takes a separate
// 'prune' function.
fn partially_traverse_preorder(&self, callback: &fn(FlowContext) -> bool) {
pub fn partially_traverse_preorder(&self, callback: &fn(FlowContext) -> bool) {
if !callback((*self).clone()) {
return;
}
for self.each_child |kid| {
for kid in self.children() {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
kid.partially_traverse_preorder(|a| callback(a));
}
}
fn traverse_bu_sub_inorder (&self, callback: &fn(FlowContext) -> bool) -> bool {
for self.each_child |kid| {
pub fn traverse_bu_sub_inorder (&self, callback: &fn(FlowContext)) {
for kid in self.children() {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
if !kid.traverse_bu_sub_inorder(|a| callback(a)) {
return false;
}
kid.traverse_bu_sub_inorder(|a| callback(a));
}
if !self.is_inorder() {
callback((*self).clone())
} else {
true
}
}
}
@ -119,14 +114,14 @@ impl FlowData {
// or we risk dynamic borrow failures.
self.parent = None;
for self.first_child.iter().advance |flow| {
for flow in self.first_child.iter() {
flow.teardown();
}
self.first_child = None;
self.last_child = None;
for self.next_sibling.iter().advance |flow| {
for flow in self.next_sibling.iter() {
flow.teardown();
}
self.next_sibling = None;
@ -164,8 +159,50 @@ impl TreeNodeRef<FlowData> for FlowContext {
TableFlow(info) => callback(info),
}
}
fn parent_node(node: &FlowData) -> Option<FlowContext> {
node.parent
}
fn first_child(node: &FlowData) -> Option<FlowContext> {
node.first_child
}
fn last_child(node: &FlowData) -> Option<FlowContext> {
node.last_child
}
fn prev_sibling(node: &FlowData) -> Option<FlowContext> {
node.prev_sibling
}
fn next_sibling(node: &FlowData) -> Option<FlowContext> {
node.next_sibling
}
fn set_parent_node(node: &mut FlowData, new_parent_node: Option<FlowContext>) {
node.parent = new_parent_node
}
fn set_first_child(node: &mut FlowData, new_first_child: Option<FlowContext>) {
node.first_child = new_first_child
}
fn set_last_child(node: &mut FlowData, new_last_child: Option<FlowContext>) {
node.last_child = new_last_child
}
fn set_prev_sibling(node: &mut FlowData, new_prev_sibling: Option<FlowContext>) {
node.prev_sibling = new_prev_sibling
}
fn set_next_sibling(node: &mut FlowData, new_next_sibling: Option<FlowContext>) {
node.next_sibling = new_next_sibling
}
}
impl TreeNode<FlowContext> for FlowData { }
/// Data common to all flows.
///
/// FIXME: We need a naming convention for pseudo-inheritance like this. How about
@ -196,45 +233,20 @@ pub struct FlowData {
is_inorder: bool,
}
impl TreeNode<FlowContext> for FlowData {
fn parent_node(&self) -> Option<FlowContext> {
self.parent
}
pub struct BoxIterator {
priv boxes: ~[RenderBox],
priv index: uint,
}
fn first_child(&self) -> Option<FlowContext> {
self.first_child
}
fn last_child(&self) -> Option<FlowContext> {
self.last_child
}
fn prev_sibling(&self) -> Option<FlowContext> {
self.prev_sibling
}
fn next_sibling(&self) -> Option<FlowContext> {
self.next_sibling
}
fn set_parent_node(&mut self, new_parent_node: Option<FlowContext>) {
self.parent = new_parent_node
}
fn set_first_child(&mut self, new_first_child: Option<FlowContext>) {
self.first_child = new_first_child
}
fn set_last_child(&mut self, new_last_child: Option<FlowContext>) {
self.last_child = new_last_child
}
fn set_prev_sibling(&mut self, new_prev_sibling: Option<FlowContext>) {
self.prev_sibling = new_prev_sibling
}
fn set_next_sibling(&mut self, new_next_sibling: Option<FlowContext>) {
self.next_sibling = new_next_sibling
impl Iterator<RenderBox> for BoxIterator {
fn next(&mut self) -> Option<RenderBox> {
if self.index >= self.boxes.len() {
None
} else {
let v = self.boxes[self.index].clone();
self.index += 1;
Some(v)
}
}
}
@ -408,43 +420,15 @@ impl<'self> FlowContext {
}
}
pub fn iter_all_boxes(&self, cb: &fn(RenderBox) -> bool) -> bool {
match *self {
BlockFlow(block) => {
let block = &mut *block;
for block.box.iter().advance |box| {
if !cb(*box) {
break;
}
}
}
InlineFlow(inline) => {
let inline = &mut *inline;
for inline.boxes.iter().advance |box| {
if !cb(*box) {
break;
}
}
}
_ => fail!(fmt!("Don't know how to iterate node's RenderBoxes for %?", self))
pub fn iter_all_boxes(&self) -> BoxIterator {
BoxIterator {
boxes: match *self {
BlockFlow (block) => block.box.map_default(~[], |&x| ~[x]),
InlineFlow(inline) => inline.boxes.clone(),
_ => fail!(fmt!("Don't know how to iterate node's RenderBoxes for %?", self))
},
index: 0,
}
true
}
pub fn iter_boxes_for_node(&self,
node: AbstractNode<LayoutView>,
callback: &fn(RenderBox) -> bool)
-> bool {
for self.iter_all_boxes |box| {
if box.node() == node {
if !callback(box) {
break;
}
}
}
true
}
/// Dumps the flow tree for debugging.
@ -455,7 +439,7 @@ impl<'self> FlowContext {
/// Dumps the flow tree, for debugging, with indentation.
pub fn dump_indent(&self, indent: uint) {
let mut s = ~"|";
for uint::range(0, indent) |_i| {
for _ in range(0, indent) {
s.push_str("---- ");
}
@ -463,7 +447,7 @@ impl<'self> FlowContext {
stderr().write_line(s);
// FIXME: this should have a pure/const version?
for self.each_child |child| {
for child in self.children() {
child.dump_indent(indent + 1)
}
}

53
servo/src/components/main/layout/inline.rs
Просмотреть файл

@ -21,8 +21,9 @@ use newcss::values::{CSSTextAlignLeft, CSSTextAlignCenter, CSSTextAlignRight, CS
use newcss::units::{Em, Px, Pt};
use newcss::values::{CSSLineHeightNormal, CSSLineHeightNumber, CSSLineHeightLength, CSSLineHeightPercentage};
use servo_util::range::Range;
use servo_util::tree::{TreeNodeRef, TreeUtils};
use extra::deque::Deque;
use servo_util::tree::TreeNodeRef;
use extra::container::Deque;
use extra::ringbuf::RingBuf;
/*
Lineboxes are represented as offsets into the child list, rather than
@ -62,7 +63,7 @@ struct LineboxScanner {
flow: FlowContext,
floats: FloatContext,
new_boxes: ~[RenderBox],
work_list: @mut Deque<RenderBox>,
work_list: @mut RingBuf<RenderBox>,
pending_line: LineBox,
lines: ~[LineBox],
cur_y: Au,
@ -76,7 +77,7 @@ impl LineboxScanner {
flow: inline,
floats: float_ctx,
new_boxes: ~[],
work_list: @mut Deque::new(),
work_list: @mut RingBuf::new(),
pending_line: LineBox {
range: Range::empty(),
bounds: Rect(Point2D(Au(0), Au(0)), Size2D(Au(0), Au(0))),
@ -122,7 +123,7 @@ impl LineboxScanner {
debug!("LineboxScanner: Working with box from box list: b%d", box.id());
box
} else {
let box = self.work_list.pop_front();
let box = self.work_list.pop_front().unwrap();
debug!("LineboxScanner: Working with box from work list: b%d", box.id());
box
};
@ -176,7 +177,7 @@ impl LineboxScanner {
match box {
ImageRenderBoxClass(image_box) => {
let size = image_box.image.get_size();
let height = Au::from_px(size.get_or_default(Size2D(0, 0)).height);
let height = Au::from_px(size.unwrap_or_default(Size2D(0, 0)).height);
image_box.base.position.size.height = height;
debug!("box_height: found image height: %?", height);
height
@ -360,11 +361,11 @@ impl LineboxScanner {
self.pending_line.green_zone = next_green_zone;
assert!(!line_is_empty, "Non-terminating line breaking");
self.work_list.add_front(in_box);
self.work_list.push_front(in_box);
return true;
} else {
debug!("LineboxScanner: case=adding box collides vertically with floats: breaking line");
self.work_list.add_front(in_box);
self.work_list.push_front(in_box);
return false;
}
}
@ -407,7 +408,7 @@ impl LineboxScanner {
match (left, right) {
(Some(left_box), Some(right_box)) => {
self.push_box_to_line(left_box);
self.work_list.add_front(right_box);
self.work_list.push_front(right_box);
}
(Some(left_box), None) => self.push_box_to_line(left_box),
(None, Some(right_box)) => self.push_box_to_line(right_box),
@ -423,7 +424,7 @@ impl LineboxScanner {
match (left, right) {
(Some(left_box), Some(right_box)) => {
self.push_box_to_line(left_box);
self.work_list.add_front(right_box);
self.work_list.push_front(right_box);
}
(Some(left_box), None) => {
self.push_box_to_line(left_box);
@ -438,7 +439,7 @@ impl LineboxScanner {
return true;
} else {
debug!("LineboxScanner: case=split box didn't fit, not appending and deferring original box.");
self.work_list.add_front(in_box);
self.work_list.push_front(in_box);
return false;
}
}
@ -491,7 +492,7 @@ impl InlineFlowData {
pub fn teardown(&mut self) {
self.common.teardown();
for self.boxes.iter().advance |box| {
for box in self.boxes.iter() {
box.teardown();
}
self.boxes = ~[];
@ -515,7 +516,7 @@ impl InlineFlowData {
pub fn bubble_widths_inline(@mut self, ctx: &mut LayoutContext) {
let mut num_floats = 0;
for InlineFlow(self).each_child |kid| {
for kid in InlineFlow(self).children() {
do kid.with_mut_base |base| {
num_floats += base.num_floats;
base.floats_in = FloatContext::new(base.num_floats);
@ -528,7 +529,7 @@ impl InlineFlowData {
let mut min_width = Au(0);
let mut pref_width = Au(0);
for this.boxes.iter().advance |box| {
for box in this.boxes.iter() {
debug!("FlowContext[%d]: measuring %s", self.common.id, box.debug_str());
min_width = Au::max(min_width, box.get_min_width(ctx));
pref_width = Au::max(pref_width, box.get_pref_width(ctx));
@ -549,11 +550,11 @@ impl InlineFlowData {
// `RenderBox`.
{
let this = &mut *self;
for this.boxes.iter().advance |&box| {
for &box in this.boxes.iter() {
match box {
ImageRenderBoxClass(image_box) => {
let size = image_box.image.get_size();
let width = Au::from_px(size.get_or_default(Size2D(0, 0)).width);
let width = Au::from_px(size.unwrap_or_default(Size2D(0, 0)).width);
image_box.base.position.size.width = width;
}
TextRenderBoxClass(_) => {
@ -571,7 +572,7 @@ impl InlineFlowData {
} // End of for loop.
}
for InlineFlow(self).each_child |kid| {
for kid in InlineFlow(self).children() {
do kid.with_mut_base |base| {
base.position.size.width = self.common.position.size.width;
base.is_inorder = self.common.is_inorder;
@ -587,7 +588,7 @@ impl InlineFlowData {
}
pub fn assign_height_inorder_inline(@mut self, ctx: &mut LayoutContext) {
for InlineFlow(self).each_child |kid| {
for kid in InlineFlow(self).children() {
kid.assign_height_inorder(ctx);
}
self.assign_height_inline(ctx);
@ -607,7 +608,7 @@ impl InlineFlowData {
scanner.scan_for_lines();
// Now, go through each line and lay out the boxes inside
for self.lines.iter().advance |line| {
for line in self.lines.iter() {
// We need to distribute extra width based on text-align.
let mut slack_width = line.green_zone.width - line.bounds.size.width;
if slack_width < Au(0) {
@ -633,7 +634,7 @@ impl InlineFlowData {
// So sorry, but justified text is more complicated than shuffling linebox coordinates.
// TODO(Issue #213): implement `text-align: justify`
CSSTextAlignLeft | CSSTextAlignJustify => {
for line.range.eachi |i| {
for i in line.range.eachi() {
do self.boxes[i].with_mut_base |base| {
base.position.origin.x = offset_x;
offset_x = offset_x + base.position.size.width;
@ -642,7 +643,7 @@ impl InlineFlowData {
}
CSSTextAlignCenter => {
offset_x = offset_x + slack_width.scale_by(0.5f);
for line.range.eachi |i| {
for i in line.range.eachi() {
do self.boxes[i].with_mut_base |base| {
base.position.origin.x = offset_x;
offset_x = offset_x + base.position.size.width;
@ -651,7 +652,7 @@ impl InlineFlowData {
}
CSSTextAlignRight => {
offset_x = offset_x + slack_width;
for line.range.eachi |i| {
for i in line.range.eachi() {
do self.boxes[i].with_mut_base |base| {
base.position.origin.x = offset_x;
offset_x = offset_x + base.position.size.width;
@ -665,13 +666,13 @@ impl InlineFlowData {
// the baseline.
let mut baseline_offset = Au(0);
let mut max_height = Au(0);
for line.range.eachi |box_i| {
for box_i in line.range.eachi() {
let cur_box = self.boxes[box_i];
match cur_box {
ImageRenderBoxClass(image_box) => {
let size = image_box.image.get_size();
let height = Au::from_px(size.get_or_default(Size2D(0, 0)).height);
let height = Au::from_px(size.unwrap_or_default(Size2D(0, 0)).height);
image_box.base.position.size.height = height;
image_box.base.position.translate(&Point2D(Au(0), -height))
@ -718,7 +719,7 @@ impl InlineFlowData {
}
// Now go back and adjust the Y coordinates to match the baseline we determined.
for line.range.eachi |box_i| {
for box_i in line.range.eachi() {
let cur_box = self.boxes[box_i];
// TODO(#226): This is completely wrong. We need to use the element's `line-height`
@ -765,7 +766,7 @@ impl InlineFlowData {
self.common.id,
self.boxes.len());
for self.boxes.iter().advance |box| {
for box in self.boxes.iter() {
box.build_display_list(builder, dirty, &self.common.abs_position, list)
}

32
servo/src/components/main/layout/layout_task.rs
Просмотреть файл

@ -41,10 +41,10 @@ use script::script_task::{ReflowCompleteMsg, ScriptChan, SendEventMsg};
use servo_msg::constellation_msg::{ConstellationChan, PipelineId};
use servo_net::image_cache_task::{ImageCacheTask, ImageResponseMsg};
use servo_net::local_image_cache::LocalImageCache;
use servo_util::tree::{TreeNodeRef, TreeUtils};
use servo_util::tree::TreeNodeRef;
use servo_util::time::{ProfilerChan, profile};
use servo_util::time;
use extra::net::url::Url;
use extra::url::Url;
struct LayoutTask {
id: PipelineId,
@ -181,7 +181,7 @@ impl LayoutTask {
};
// FIXME: Bad copy!
let doc_url = copy data.url;
let doc_url = data.url.clone();
let script_chan = data.script_chan.clone();
debug!("layout: received layout request for: %s", doc_url.to_str());
@ -232,7 +232,7 @@ impl LayoutTask {
// Propagate restyle damage up and down the tree, as appropriate.
// FIXME: Merge this with flow tree building and/or the other traversals.
for layout_root.traverse_preorder |flow| {
for flow in layout_root.traverse_preorder() {
// Also set any damage implied by resize.
if resized {
do flow.with_mut_base |base| {
@ -242,7 +242,7 @@ impl LayoutTask {
let prop = flow.with_base(|base| base.restyle_damage.propagate_down());
if prop.is_nonempty() {
for flow.each_child |kid_ctx| {
for kid_ctx in flow.children() {
do kid_ctx.with_mut_base |kid| {
kid.restyle_damage.union_in_place(prop);
}
@ -250,8 +250,8 @@ impl LayoutTask {
}
}
for layout_root.traverse_postorder |flow| {
for flow.each_child |child| {
for flow in layout_root.traverse_postorder() {
for child in flow.children() {
do child.with_base |child_base| {
do flow.with_mut_base |base| {
base.restyle_damage.union_in_place(child_base.restyle_damage);
@ -266,20 +266,20 @@ impl LayoutTask {
// Perform the primary layout passes over the flow tree to compute the locations of all
// the boxes.
do profile(time::LayoutMainCategory, self.profiler_chan.clone()) {
for layout_root.traverse_postorder_prune(|f| f.restyle_damage().lacks(BubbleWidths)) |flow| {
for flow in layout_root.traverse_postorder_prune(|f| f.restyle_damage().lacks(BubbleWidths)) {
flow.bubble_widths(&mut layout_ctx);
};
// FIXME: We want to do
// for layout_root.traverse_preorder_prune(|f| f.restyle_damage().lacks(Reflow)) |flow| {
// for flow in layout_root.traverse_preorder_prune(|f| f.restyle_damage().lacks(Reflow)) {
// but FloatContext values can't be reused, so we need to recompute them every time.
for layout_root.traverse_preorder |flow| {
for flow in layout_root.traverse_preorder() {
flow.assign_widths(&mut layout_ctx);
};
// For now, this is an inorder traversal
// FIXME: prune this traversal as well
for layout_root.traverse_bu_sub_inorder |flow| {
do layout_root.traverse_bu_sub_inorder |flow| {
flow.assign_height(&mut layout_ctx);
}
}
@ -366,8 +366,10 @@ impl LayoutTask {
None => Err(()),
Some(flow) => {
let mut boxes = ~[];
for flow.iter_boxes_for_node(node) |box| {
boxes.push(box.content_box());
for box in flow.iter_all_boxes() {
if box.node() == node {
boxes.push(box.content_box());
}
}
Ok(ContentBoxesResponse(boxes))
@ -382,7 +384,7 @@ impl LayoutTask {
transmute(node)
};
let mut flow_node: AbstractNode<LayoutView> = node;
for node.traverse_preorder |node| {
for node in node.traverse_preorder() {
if node.layout_data().flow.is_some() {
flow_node = node;
break;
@ -413,7 +415,7 @@ impl LayoutTask {
let mut resp = Err(());
let display_list = &display_list.take().list;
// iterate in reverse to ensure we have the most recently painted render box
for display_list.rev_iter().advance |display_item| {
for display_item in display_list.rev_iter() {
let bounds = display_item.bounds();
// TODO this check should really be performed by a method of DisplayItem
if x <= bounds.origin.x + bounds.size.width &&

18
servo/src/components/main/layout/text.rs
Просмотреть файл

@ -4,7 +4,6 @@
//! Text layout.
use std::uint;
use std::vec;
use gfx::text::text_run::TextRun;
@ -13,7 +12,6 @@ use layout::box::{RenderBox, RenderBoxBase, TextRenderBox};
use layout::box::{TextRenderBoxClass, UnscannedTextRenderBoxClass};
use layout::context::LayoutContext;
use layout::flow::FlowContext;
use layout::util::{NodeRange};
use newcss::values::{CSSTextDecoration, CSSTextDecorationUnderline};
use servo_util::range::Range;
@ -50,7 +48,7 @@ pub trait UnscannedMethods {
impl UnscannedMethods for RenderBox {
fn raw_text(&self) -> ~str {
match *self {
UnscannedTextRenderBoxClass(text_box) => copy text_box.text,
UnscannedTextRenderBoxClass(text_box) => text_box.text.clone(),
_ => fail!(~"unsupported operation: box.raw_text() on non-unscanned text box."),
}
}
@ -75,7 +73,7 @@ impl TextRunScanner {
let mut last_whitespace = true;
let mut out_boxes = ~[];
for uint::range(0, flow.inline().boxes.len()) |box_i| {
for box_i in range(0, flow.inline().boxes.len()) {
debug!("TextRunScanner: considering box: %?", flow.inline().boxes[box_i].debug_str());
if box_i > 0 && !can_coalesce_text_nodes(flow.inline().boxes, box_i-1, box_i) {
last_whitespace = self.flush_clump_to_list(ctx, flow, last_whitespace, &mut out_boxes);
@ -204,7 +202,7 @@ impl TextRunScanner {
let mut run_str: ~str = ~"";
let mut new_ranges: ~[Range] = ~[];
let mut char_total = 0;
for uint::range(0, transformed_strs.len()) |i| {
for i in range(0, transformed_strs.len()) {
let added_chars = transformed_strs[i].char_len();
new_ranges.push(Range::new(char_total, added_chars));
run_str.push_str(transformed_strs[i]);
@ -231,7 +229,7 @@ impl TextRunScanner {
// Make new boxes with the run and adjusted text indices.
debug!("TextRunScanner: pushing box(es) in range: %?", self.clump);
for clump.eachi |i| {
for i in clump.eachi() {
let range = new_ranges[i - self.clump.begin()];
if range.length() == 0 {
debug!("Elided an `UnscannedTextbox` because it was zero-length after \
@ -241,7 +239,7 @@ impl TextRunScanner {
}
do in_boxes[i].with_base |base| {
let new_box = @mut adapt_textbox_with_range(*base, run.get(), range);
let new_box = @mut adapt_textbox_with_range(*base, run.unwrap(), range);
out_boxes.push(TextRenderBoxClass(new_box));
}
}
@ -249,19 +247,19 @@ impl TextRunScanner {
} // End of match.
debug!("--- In boxes: ---");
for in_boxes.iter().enumerate().advance |(i, box)| {
for (i, box) in in_boxes.iter().enumerate() {
debug!("%u --> %s", i, box.debug_str());
}
debug!("------------------");
debug!("--- Out boxes: ---");
for out_boxes.iter().enumerate().advance |(i, box)| {
for (i, box) in out_boxes.iter().enumerate() {
debug!("%u --> %s", i, box.debug_str());
}
debug!("------------------");
debug!("--- Elem ranges: ---");
for inline.elems.eachi_mut |i: uint, nr: &NodeRange| {
for (i, nr) in inline.elems.eachi() {
debug!("%u: %? --> %s", i, nr.range, nr.node.debug_str()); ()
}
debug!("--------------------");

33
servo/src/components/main/layout/util.rs
Просмотреть файл

@ -6,6 +6,9 @@ use layout::box::{RenderBox};
use script::dom::node::{AbstractNode, LayoutView};
use servo_util::range::Range;
use std::iterator::Enumerate;
use std::vec::VecIterator;
pub struct NodeRange {
node: AbstractNode<LayoutView>,
range: Range,
@ -13,7 +16,7 @@ pub struct NodeRange {
impl NodeRange {
pub fn new(node: AbstractNode<LayoutView>, range: &Range) -> NodeRange {
NodeRange { node: node, range: copy *range }
NodeRange { node: node, range: (*range).clone() }
}
}
@ -31,7 +34,7 @@ impl ElementMapping {
}
pub fn each(&self, callback: &fn(nr: &NodeRange) -> bool) -> bool {
for self.entries.iter().advance |nr| {
for nr in self.entries.iter() {
if !callback(nr) {
break
}
@ -39,41 +42,27 @@ impl ElementMapping {
true
}
pub fn eachi(&self, callback: &fn(i: uint, nr: &NodeRange) -> bool) -> bool {
for self.entries.iter().enumerate().advance |(i, nr)| {
if !callback(i, nr) {
break
}
}
true
}
pub fn eachi_mut(&self, callback: &fn(i: uint, nr: &NodeRange) -> bool) -> bool {
for self.entries.iter().enumerate().advance |(i, nr)| {
if !callback(i, nr) {
break
}
}
true
pub fn eachi<'a>(&'a self) -> Enumerate<VecIterator<'a, NodeRange>> {
self.entries.iter().enumerate()
}
pub fn repair_for_box_changes(&mut self, old_boxes: &[RenderBox], new_boxes: &[RenderBox]) {
let entries = &mut self.entries;
debug!("--- Old boxes: ---");
for old_boxes.iter().enumerate().advance |(i, box)| {
for (i, box) in old_boxes.iter().enumerate() {
debug!("%u --> %s", i, box.debug_str());
}
debug!("------------------");
debug!("--- New boxes: ---");
for new_boxes.iter().enumerate().advance |(i, box)| {
for (i, box) in new_boxes.iter().enumerate() {
debug!("%u --> %s", i, box.debug_str());
}
debug!("------------------");
debug!("--- Elem ranges before repair: ---");
for entries.iter().enumerate().advance |(i, nr)| {
for (i, nr) in entries.iter().enumerate() {
debug!("%u: %? --> %s", i, nr.range, nr.node.debug_str());
}
debug!("----------------------------------");
@ -126,7 +115,7 @@ impl ElementMapping {
}
}
debug!("--- Elem ranges after repair: ---");
for entries.iter().enumerate().advance |(i, nr)| {
for (i, nr) in entries.iter().enumerate() {
debug!("%u: %? --> %s", i, nr.range, nr.node.debug_str());
}
debug!("----------------------------------");

10
servo/src/components/main/pipeline.rs
Просмотреть файл

@ -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 extra::net::url::Url;
use extra::url::Url;
use compositing::CompositorChan;
use gfx::render_task::{RenderChan, RenderTask};
use gfx::render_task::{PaintPermissionGranted, PaintPermissionRevoked};
@ -52,7 +52,7 @@ impl Pipeline {
RenderTask::create(id,
render_port,
compositor_chan.clone(),
copy opts,
opts.clone(),
profiler_chan.clone());
LayoutTask::create(id,
@ -61,7 +61,7 @@ impl Pipeline {
script_pipeline.script_chan.clone(),
render_chan.clone(),
image_cache_task.clone(),
copy opts,
opts.clone(),
profiler_chan);
let new_layout_info = NewLayoutInfo {
@ -109,7 +109,7 @@ impl Pipeline {
RenderTask::create(id,
render_port,
compositor_chan.clone(),
copy opts,
opts.clone(),
profiler_chan.clone());
LayoutTask::create(id,
@ -118,7 +118,7 @@ impl Pipeline {
script_chan.clone(),
render_chan.clone(),
image_cache_task,
copy opts,
opts.clone(),
profiler_chan);
Pipeline::new(id,
subpage_id,

2
servo/src/components/main/platform/common/glfw_windowing.rs
Просмотреть файл

@ -25,7 +25,7 @@ static THROBBER: [char, ..8] = [ '⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯'
pub struct Application;
impl ApplicationMethods for Application {
pub fn new() -> Application {
fn new() -> Application {
glfw::init();
Application
}

93
servo/src/components/main/servo.rc
Просмотреть файл

@ -16,7 +16,7 @@ extern mod azure;
extern mod geom;
extern mod gfx (name = "gfx");
extern mod glfw;
extern mod http_client;
//extern mod http_client;
extern mod js;
extern mod layers;
extern mod newcss (name = "css");
@ -39,17 +39,21 @@ use compositing::{CompositorChan, CompositorTask};
use constellation::Constellation;
use servo_msg::constellation_msg::{ExitMsg, InitLoadUrlMsg};
#[cfg(not(test))]
use gfx::opts;
use servo_net::image_cache_task::ImageCacheTask;
use servo_net::resource_task::ResourceTask;
use servo_util::time::{Profiler, ProfilerChan, PrintMsg};
use extra::uv_global_loop;
pub use gfx::opts::Opts;
pub use gfx::text;
pub use servo_util::url::make_url;
use std::comm;
#[cfg(not(test))]
use std::os;
use std::rt::rtio::RtioTimer;
use std::rt::io::timer::Timer;
#[path="compositing/mod.rs"]
pub mod compositing;
@ -57,8 +61,8 @@ pub mod compositing;
pub mod macros;
pub mod css {
priv mod select_handler;
priv mod node_util;
mod select_handler;
mod node_util;
pub mod select;
pub mod matching;
@ -94,56 +98,75 @@ pub mod platform;
#[path = "util/mod.rs"]
pub mod util;
fn main() {
run(&opts::from_cmdline_args(os::args()))
#[cfg(not(test))]
#[start]
fn start(argc: int, argv: **u8, crate_map: *u8) -> int {
do std::rt::start_on_main_thread(argc, argv, crate_map) {
let opts = opts::from_cmdline_args(os::args());
run(opts)
}
}
fn run(opts: &Opts) {
fn run(opts: Opts) {
let (shutdown_port, shutdown_chan) = comm::stream();
// Create the profiler channel.
let (profiler_port, profiler_chan) = comm::stream();
let (compositor_port, compositor_chan) = comm::stream();
let profiler_chan = ProfilerChan::new(profiler_chan);
Profiler::create(profiler_port);
do opts.profiler_period.map |period| {
do opts.profiler_period.map |&period| {
let profiler_chan = profiler_chan.clone();
let period = *period;
let period = (period * 1000f) as u64;
do spawn {
let tm = Timer::new().unwrap();
loop {
extra::timer::sleep(&uv_global_loop::get(),
(period * 1000f) as uint);
tm.sleep(period);
profiler_chan.send(PrintMsg);
}
}
};
// Create the compositor.
let (compositor_port, compositor_chan) = comm::stream();
let compositor_chan = CompositorChan::new(compositor_chan);
CompositorTask::create(opts.clone(), compositor_port, profiler_chan.clone(), shutdown_chan);
let profiler_chan_clone = profiler_chan.clone();
// Create a Servo instance.
let opts_clone = opts.clone();
let resource_task = ResourceTask();
let image_cache_task = ImageCacheTask(resource_task.clone());
let constellation_chan = Constellation::start(compositor_chan.clone(),
opts,
resource_task,
image_cache_task,
profiler_chan.clone());
do spawn {
let profiler_chan = profiler_chan_clone.clone();
let compositor_chan = compositor_chan.clone();
// Send the URL command to the constellation.
for opts.urls.iter().advance |filename| {
constellation_chan.send(InitLoadUrlMsg(make_url(filename.clone(), None)))
let opts = &opts_clone.clone();
// Create a Servo instance.
let resource_task = ResourceTask();
let image_cache_task = ImageCacheTask(resource_task.clone());
let constellation_chan = Constellation::start(compositor_chan.clone(),
opts,
resource_task,
image_cache_task,
profiler_chan.clone());
// Send the URL command to the constellation.
for filename in opts.urls.iter() {
constellation_chan.send(InitLoadUrlMsg(make_url(filename.clone(), None)))
}
// Wait for the compositor to shut down.
shutdown_port.recv();
// Shut the constellation down.
debug!("master: Shut down");
let (exit_response_from_constellation, exit_chan) = comm::stream();
constellation_chan.send(ExitMsg(exit_chan));
exit_response_from_constellation.recv();
}
// Wait for the compositor to shut down.
shutdown_port.recv();
// Shut the constellation down.
debug!("master: Shut down");
let (exit_response_from_constellation, exit_chan) = comm::stream();
constellation_chan.send(ExitMsg(exit_chan));
exit_response_from_constellation.recv();
let compositor_task = CompositorTask::new(opts,
compositor_port,
profiler_chan,
shutdown_chan);
debug!("preparing to enter main loop");
compositor_task.run();
}

14
servo/src/components/main/windowing.rs
Просмотреть файл

@ -51,21 +51,21 @@ pub trait ApplicationMethods {
pub trait WindowMethods<A> {
/// Creates a new window.
pub fn new(app: &A) -> @mut Self;
fn new(app: &A) -> @mut Self;
/// Returns the size of the window.
pub fn size(&self) -> Size2D<f32>;
fn size(&self) -> Size2D<f32>;
/// Presents the window to the screen (perhaps by page flipping).
pub fn present(&mut self);
fn present(&mut self);
/// Spins the event loop and returns the next event.
pub fn recv(@mut self) -> WindowEvent;
fn recv(@mut self) -> WindowEvent;
/// Sets the ready state of the current page.
pub fn set_ready_state(@mut self, ready_state: ReadyState);
fn set_ready_state(@mut self, ready_state: ReadyState);
/// Sets the render state of the current page.
pub fn set_render_state(@mut self, render_state: RenderState);
fn set_render_state(@mut self, render_state: RenderState);
/// Returns the hidpi factor of the monitor.
pub fn hidpi_factor(@mut self) -> f32;
fn hidpi_factor(@mut self) -> f32;
}

2
servo/src/components/msg/compositor_msg.rs
Просмотреть файл

@ -61,7 +61,7 @@ pub trait RenderListener {
fn new_layer(&self, PipelineId, Size2D<uint>);
fn resize_layer(&self, PipelineId, Size2D<uint>);
fn delete_layer(&self, PipelineId);
fn paint(&self, id: PipelineId, layer_buffer_set: arc::ARC<LayerBufferSet>);
fn paint(&self, id: PipelineId, layer_buffer_set: arc::Arc<LayerBufferSet>);
fn set_render_state(&self, render_state: RenderState);
}

2
servo/src/components/msg/constellation_msg.rs
Просмотреть файл

@ -6,7 +6,7 @@
/// coupling between these two components
use std::comm::{Chan, SharedChan};
use extra::net::url::Url;
use extra::url::Url;
use extra::future::Future;
use geom::size::Size2D;

10
servo/src/components/net/image/holder.rs
Просмотреть файл

@ -8,18 +8,18 @@ use local_image_cache::LocalImageCache;
use std::util::replace;
use geom::size::Size2D;
use extra::net::url::Url;
use extra::arc::ARC;
use extra::url::Url;
use extra::arc::Arc;
// FIXME: Nasty coupling here This will be a problem if we want to factor out image handling from
// the network stack. This should probably be factored out into an interface and use dependency
// injection.
/// A struct to store image data. The image will be loaded once the first time it is requested,
/// and an ARC will be stored. Clones of this ARC are given out on demand.
/// and an Arc will be stored. Clones of this Arc are given out on demand.
pub struct ImageHolder {
url: Url,
image: Option<ARC<~Image>>,
image: Option<Arc<~Image>>,
cached_size: Size2D<int>,
local_image_cache: @mut LocalImageCache,
}
@ -65,7 +65,7 @@ impl ImageHolder {
}
}
pub fn get_image(&mut self) -> Option<ARC<~Image>> {
pub fn get_image(&mut self) -> Option<Arc<~Image>> {
debug!("get_image() %?", self.url);
// If this is the first time we've called this function, load

139
servo/src/components/net/image_cache_task.rs
Просмотреть файл

@ -13,8 +13,8 @@ use std::task::spawn;
use std::to_str::ToStr;
use std::util::replace;
use std::result;
use extra::arc::ARC;
use extra::net::url::Url;
use extra::arc::Arc;
use extra::url::Url;
pub enum Msg {
/// Tell the cache that we may need a particular image soon. Must be posted
@ -29,7 +29,7 @@ pub enum Msg {
Decode(Url),
/// Used by the decoder tasks to post decoded images back to the cache
priv StoreImage(Url, Option<ARC<~Image>>),
priv StoreImage(Url, Option<Arc<~Image>>),
/// Request an Image object for a URL. If the image is not is not immediately
/// available then ImageNotReady is returned.
@ -46,7 +46,7 @@ pub enum Msg {
}
pub enum ImageResponseMsg {
ImageReady(ARC<~Image>),
ImageReady(Arc<~Image>),
ImageNotReady,
ImageFailed
}
@ -157,21 +157,22 @@ struct ImageCache {
need_exit: Option<Chan<()>>,
}
#[deriving(Clone)]
enum ImageState {
Init,
Prefetching(AfterPrefetch),
Prefetched(@Cell<~[u8]>),
Decoding,
Decoded(@ARC<~Image>),
Decoded(@Arc<~Image>),
Failed
}
#[deriving(Clone)]
enum AfterPrefetch {
DoDecode,
DoNotDecode
}
#[allow(non_implicitly_copyable_typarams)]
impl ImageCache {
pub fn run(&mut self) {
let mut msg_handlers: ~[~fn(msg: &Msg)] = ~[];
@ -179,7 +180,7 @@ impl ImageCache {
loop {
let msg = self.port.recv();
for msg_handlers.iter().advance |handler| {
for handler in msg_handlers.iter() {
(*handler)(&msg)
}
@ -210,7 +211,7 @@ impl ImageCache {
// Wait until we have no outstanding requests and subtasks
// before exiting
let mut can_exit = true;
for self.state_map.each_value |state| {
for (_, state) in self.state_map.iter() {
match *state {
Prefetching(*) => can_exit = false,
Decoding => can_exit = false,
@ -231,37 +232,37 @@ impl ImageCache {
}
}
priv fn get_state(&self, url: Url) -> ImageState {
fn get_state(&self, url: Url) -> ImageState {
match self.state_map.find(&url) {
Some(state) => *state,
None => Init
}
}
priv fn set_state(&self, url: Url, state: ImageState) {
fn set_state(&self, url: Url, state: ImageState) {
self.state_map.insert(url, state);
}
priv fn prefetch(&self, url: Url) {
match self.get_state(copy url) {
fn prefetch(&self, url: Url) {
match self.get_state(url.clone()) {
Init => {
let to_cache = self.chan.clone();
let resource_task = self.resource_task.clone();
let url_cell = Cell::new(copy url);
let url_cell = Cell::new(url.clone());
do spawn {
let url = url_cell.take();
debug!("image_cache_task: started fetch for %s", url.to_str());
let image = load_image_data(copy url, resource_task.clone());
let image = load_image_data(url.clone(), resource_task.clone());
let result = if image.is_ok() {
Ok(Cell::new(result::unwrap(image)))
Ok(Cell::new(image.unwrap()))
} else {
Err(())
};
to_cache.send(StorePrefetchedImageData(copy url, result));
debug!("image_cache_task: ended fetch for %s", (copy url).to_str());
to_cache.send(StorePrefetchedImageData(url.clone(), result));
debug!("image_cache_task: ended fetch for %s", (url.clone()).to_str());
}
self.set_state(url, Prefetching(DoNotDecode));
@ -273,20 +274,20 @@ impl ImageCache {
}
}
priv fn store_prefetched_image_data(&self, url: Url, data: Result<Cell<~[u8]>, ()>) {
match self.get_state(copy url) {
fn store_prefetched_image_data(&self, url: Url, data: Result<Cell<~[u8]>, ()>) {
match self.get_state(url.clone()) {
Prefetching(next_step) => {
match data {
Ok(data_cell) => {
let data = data_cell.take();
self.set_state(copy url, Prefetched(@Cell::new(data)));
self.set_state(url.clone(), Prefetched(@Cell::new(data)));
match next_step {
DoDecode => self.decode(url),
_ => ()
}
}
Err(*) => {
self.set_state(copy url, Failed);
self.set_state(url.clone(), Failed);
self.purge_waiters(url, || ImageFailed);
}
}
@ -302,8 +303,8 @@ impl ImageCache {
}
}
priv fn decode(&self, url: Url) {
match self.get_state(copy url) {
fn decode(&self, url: Url) {
match self.get_state(url.clone()) {
Init => fail!(~"decoding image before prefetch"),
Prefetching(DoNotDecode) => {
@ -320,7 +321,7 @@ impl ImageCache {
let data = data_cell.take();
let to_cache = self.chan.clone();
let url_cell = Cell::new(copy url);
let url_cell = Cell::new(url.clone());
let decode = (self.decoder_factory)();
do spawn {
@ -328,11 +329,11 @@ impl ImageCache {
debug!("image_cache_task: started image decode for %s", url.to_str());
let image = decode(data);
let image = if image.is_some() {
Some(ARC(~image.unwrap()))
Some(Arc::new(~image.unwrap()))
} else {
None
};
to_cache.send(StoreImage(copy url, image));
to_cache.send(StoreImage(url.clone(), image));
debug!("image_cache_task: ended image decode for %s", url.to_str());
}
@ -345,17 +346,17 @@ impl ImageCache {
}
}
priv fn store_image(&self, url: Url, image: Option<ARC<~Image>>) {
fn store_image(&self, url: Url, image: Option<Arc<~Image>>) {
match self.get_state(copy url) {
match self.get_state(url.clone()) {
Decoding => {
match image {
Some(image) => {
self.set_state(copy url, Decoded(@image.clone()));
self.set_state(url.clone(), Decoded(@image.clone()));
self.purge_waiters(url, || ImageReady(image.clone()) );
}
None => {
self.set_state(copy url, Failed);
self.set_state(url.clone(), Failed);
self.purge_waiters(url, || ImageFailed );
}
}
@ -372,10 +373,10 @@ impl ImageCache {
}
priv fn purge_waiters(&self, url: Url, f: &fn() -> ImageResponseMsg) {
fn purge_waiters(&self, url: Url, f: &fn() -> ImageResponseMsg) {
match self.wait_map.pop(&url) {
Some(waiters) => {
for waiters.iter().advance |response| {
for response in waiters.iter() {
response.send(f());
}
}
@ -383,8 +384,8 @@ impl ImageCache {
}
}
priv fn get_image(&self, url: Url, response: Chan<ImageResponseMsg>) {
match self.get_state(copy url) {
fn get_image(&self, url: Url, response: Chan<ImageResponseMsg>) {
match self.get_state(url.clone()) {
Init => fail!(~"request for image before prefetch"),
Prefetching(DoDecode) => response.send(ImageNotReady),
Prefetching(DoNotDecode) | Prefetched(*) => fail!(~"request for image before decode"),
@ -394,8 +395,8 @@ impl ImageCache {
}
}
priv fn wait_for_image(&self, url: Url, response: Chan<ImageResponseMsg>) {
match self.get_state(copy url) {
fn wait_for_image(&self, url: Url, response: Chan<ImageResponseMsg>) {
match self.get_state(url.clone()) {
Init => fail!(~"request for image before prefetch"),
Prefetching(DoNotDecode) | Prefetched(*) => fail!(~"request for image before decode"),
@ -541,7 +542,7 @@ fn should_fail_if_requesting_image_before_requesting_decode() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Prefetch(url.clone()));
// no decode message
let (chan, _port) = stream();
@ -564,7 +565,7 @@ fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Prefetch(url));
url_requested.recv();
image_cache_task.exit();
@ -587,8 +588,8 @@ fn should_return_image_not_ready_if_data_has_not_arrived() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = stream();
image_cache_task.send(GetImage(url, response_chan));
assert!(response_port.recv() == ImageNotReady);
@ -617,8 +618,8 @@ fn should_return_decoded_image_data_if_data_has_arrived() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_image_chan.recv();
@ -654,15 +655,15 @@ fn should_return_decoded_image_data_for_multiple_requests() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_image.recv();
for iter::repeat(2) {
for _ in iter::repeat(2) {
let (response_chan, response_port) = stream();
image_cache_task.send(GetImage(copy url, response_chan));
image_cache_task.send(GetImage(url.clone(), response_chan));
match response_port.recv() {
ImageReady(_) => (),
_ => fail
@ -700,12 +701,12 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Prefetch(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
image_bin_sent.recv();
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
@ -744,14 +745,14 @@ fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
image_bin_sent.recv();
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
@ -784,8 +785,8 @@ fn should_return_failed_if_image_bin_cannot_be_fetched() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_prefetech.recv();
@ -822,14 +823,14 @@ fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_f
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_prefetech.recv();
let (response_chan, response_port) = stream();
image_cache_task.send(GetImage(copy url, response_chan));
image_cache_task.send(GetImage(url.clone(), response_chan));
match response_port.recv() {
ImageFailed => (),
_ => fail
@ -879,8 +880,8 @@ fn should_return_not_ready_if_image_is_still_decoding() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_prefetech.recv();
@ -922,8 +923,8 @@ fn should_return_failed_if_image_decode_fails() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_decode.recv();
@ -961,8 +962,8 @@ fn should_return_image_on_wait_if_image_is_already_loaded() {
}
}));
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
wait_for_decode.recv();
@ -991,8 +992,8 @@ fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = stream();
image_cache_task.send(WaitForImage(url, response_chan));
@ -1021,8 +1022,8 @@ fn should_return_image_failed_on_wait_if_image_fails_to_load() {
let image_cache_task = ImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = stream();
image_cache_task.send(WaitForImage(url, response_chan));
@ -1048,8 +1049,8 @@ fn sync_cache_should_wait_for_images() {
let image_cache_task = SyncImageCacheTask(mock_resource_task);
let url = make_url(~"file", None);
image_cache_task.send(Prefetch(copy url));
image_cache_task.send(Decode(copy url));
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = stream();
image_cache_task.send(GetImage(url, response_chan));

19
servo/src/components/net/local_image_cache.rs
Просмотреть файл

@ -15,7 +15,7 @@ use std::comm;
use std::comm::Port;
use std::task;
use servo_util::url::{UrlMap, url_map};
use extra::net::url::Url;
use extra::url::Url;
pub fn LocalImageCache(image_cache_task: ImageCacheTask) -> LocalImageCache {
LocalImageCache {
@ -33,14 +33,13 @@ pub struct LocalImageCache {
priv state_map: UrlMap<@mut ImageState>
}
priv struct ImageState {
struct ImageState {
prefetched: bool,
decoded: bool,
last_request_round: uint,
last_response: ImageResponseMsg
}
#[allow(non_implicitly_copyable_typarams)] // Using maps of Urls
impl LocalImageCache {
/// The local cache will only do a single remote request for a given
/// URL in each 'round'. Layout should call this each time it begins
@ -52,7 +51,7 @@ impl LocalImageCache {
pub fn prefetch(&self, url: &Url) {
let state = self.get_state(url);
if !state.prefetched {
self.image_cache_task.send(Prefetch(copy *url));
self.image_cache_task.send(Prefetch((*url).clone()));
state.prefetched = true;
}
}
@ -60,7 +59,7 @@ impl LocalImageCache {
pub fn decode(&self, url: &Url) {
let state = self.get_state(url);
if !state.decoded {
self.image_cache_task.send(Decode(copy *url));
self.image_cache_task.send(Decode((*url).clone()));
state.decoded = true;
}
}
@ -98,7 +97,7 @@ impl LocalImageCache {
}
let (response_port, response_chan) = comm::stream();
self.image_cache_task.send(GetImage(copy *url, response_chan));
self.image_cache_task.send(GetImage((*url).clone(), response_chan));
let response = response_port.recv();
match response {
@ -110,11 +109,11 @@ impl LocalImageCache {
// on the image to load and triggering layout
let image_cache_task = self.image_cache_task.clone();
assert!(self.on_image_available.is_some());
let on_image_available = self.on_image_available.get()();
let url = copy *url;
let on_image_available = self.on_image_available.unwrap()();
let url = (*url).clone();
do task::spawn {
let (response_port, response_chan) = comm::stream();
image_cache_task.send(WaitForImage(copy url, response_chan));
image_cache_task.send(WaitForImage(url.clone(), response_chan));
on_image_available(response_port.recv());
}
}
@ -134,7 +133,7 @@ impl LocalImageCache {
return port;
}
priv fn get_state(&self, url: &Url) -> @mut ImageState {
fn get_state(&self, url: &Url) -> @mut ImageState {
let state = do self.state_map.find_or_insert_with(url.clone()) |_| {
let new_state = @mut ImageState {
prefetched: false,

4
servo/src/components/net/net.rc
Просмотреть файл

@ -9,7 +9,7 @@
#[crate_type = "lib"];
extern mod geom;
extern mod http_client;
//extern mod http_client;
extern mod servo_util (name = "util");
extern mod stb_image;
extern mod extra;
@ -25,7 +25,7 @@ pub mod image {
}
pub mod file_loader;
pub mod http_loader;
//pub mod http_loader;
pub mod image_cache_task;
pub mod local_image_cache;
pub mod resource_task;

14
servo/src/components/net/resource_task.rs
Просмотреть файл

@ -5,11 +5,11 @@
//! A task that takes a URL and streams back the binary data.
use file_loader;
use http_loader;
//use http_loader;
use std::cell::Cell;
use std::comm::{Chan, Port, SharedChan};
use extra::net::url::{Url, to_str};
use extra::url::Url;
use util::spawn_listener;
pub enum ControlMsg {
@ -43,10 +43,10 @@ pub type LoaderTask = ~fn(url: Url, Chan<ProgressMsg>);
/// Create a ResourceTask with the default loaders
pub fn ResourceTask() -> ResourceTask {
let file_loader_factory: LoaderTaskFactory = file_loader::factory;
let http_loader_factory: LoaderTaskFactory = http_loader::factory;
//let http_loader_factory: LoaderTaskFactory = http_loader::factory;
let loaders = ~[
(~"file", file_loader_factory),
(~"http", http_loader_factory)
//(~"http", http_loader_factory)
];
create_resource_task_with_loaders(loaders)
}
@ -94,7 +94,7 @@ impl ResourceManager {
match self.get_loader_factory(&url) {
Some(loader_factory) => {
debug!("resource_task: loading url: %s", to_str(&url));
debug!("resource_task: loading url: %s", url.to_str());
loader_factory(url, progress_chan);
}
None => {
@ -105,7 +105,7 @@ impl ResourceManager {
}
fn get_loader_factory(&self, url: &Url) -> Option<LoaderTask> {
for self.loaders.iter().advance |scheme_loader| {
for scheme_loader in self.loaders.iter() {
match *scheme_loader {
(ref scheme, ref loader_factory) => {
if (*scheme) == url.scheme {
@ -142,7 +142,7 @@ fn test_bad_scheme() {
fn should_delegate_to_scheme_loader() {
let payload = ~[1, 2, 3];
let loader_factory = |_url: Url, progress_chan: Chan<ProgressMsg>| {
progress_chan.send(Payload(copy payload));
progress_chan.send(Payload(payload.clone()));
progress_chan.send(Done(Ok(())));
};
let loader_factories = ~[(~"snicklefritz", loader_factory)];

34
servo/src/components/script/dom/bindings/codegen/CodegenRust.py
Просмотреть файл

@ -1044,7 +1044,7 @@ for (uint32_t i = 0; i < length; ++i) {
# "if (!ConvertJSValueToString(cx, ${val}, ${valPtr}, %s, %s, %s)) {\n"
# " return false;\n"
# "}" % (nullBehavior, undefinedBehavior, varName))
strval = "str(strval.get())"
strval = "str(strval.unwrap())"
if isOptional:
strval = "Some(%s)" % strval
conversionCode = (
@ -1114,7 +1114,7 @@ for (uint32_t i = 0; i < length; ++i) {
" if result.is_err() {\n"
"%(handleInvalidEnumValueCode)s"
" }\n"
" let index = result.get();\n"
" let index = result.unwrap();\n"
" ${declName} = cast::transmute(index); //XXXjdm need some range checks up in here\n"
"}" % { "enumtype" : enum,
"values" : enum + "Values::strings",
@ -1511,7 +1511,7 @@ for (uint32_t i = 0; i < length; ++i) {
wrappingCode = ("if %s.is_none() {\n" % (result) +
CGIndenter(CGGeneric(setValue("JSVAL_NULL"))).define() + "\n" +
"}\n" +
"let mut %s = %s.get();\n" % (result, result))
"let mut %s = %s.unwrap();\n" % (result, result))
else:
wrappingCode = ""
if (not descriptor.interface.isExternal() and
@ -2746,10 +2746,10 @@ class CGGetPerInterfaceObject(CGAbstractMethod):
}*/
/* Check to see whether the interface objects are already installed */
let protoOrIfaceArray: *mut *JSObject = cast::transmute(GetProtoOrIfaceArray(aGlobal));
let cachedObject: *JSObject = *protoOrIfaceArray.offset(%s as uint);
let cachedObject: *JSObject = *protoOrIfaceArray.offset(%s as int);
if cachedObject.is_null() {
let tmp: *JSObject = CreateInterfaceObjects(aCx, aGlobal, aReceiver);
*protoOrIfaceArray.offset(%s as uint) = tmp;
*protoOrIfaceArray.offset(%s as int) = tmp;
tmp
} else {
cachedObject
@ -3623,7 +3623,7 @@ class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
templateValues = {'jsvalRef': '(*desc).value', 'jsvalPtr': 'ptr::to_mut_unsafe_ptr(&mut (*desc).value)',
'obj': 'proxy', 'successCode': fillDescriptor}
get = ("if index.is_some() {\n" +
" let index = index.get();\n" +
" let index = index.unwrap();\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define() + "\n" +
"}\n") % (self.descriptor.concreteType)
@ -3632,7 +3632,7 @@ class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
setOrIndexedGet += "if set != 0 {\n"
if indexedSetter:
setOrIndexedGet += (" if index.is_some() {\n" +
" let index = index.get();\n")
" let index = index.unwrap();\n")
if not 'IndexedCreator' in self.descriptor.operations:
# FIXME need to check that this is a 'supported property index'
assert False
@ -3677,7 +3677,7 @@ class CGDOMJSProxyHandler_getOwnPropertyDescriptor(CGAbstractExternMethod):
" if strval.is_err() {\n" +
" return 0;\n" +
" }\n" +
" let name = str(strval.get());\n" +
" let name = str(strval.unwrap());\n" +
"\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor, templateValues)).define() + "\n" +
@ -3721,7 +3721,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
raise TypeError("Can't handle creator that's different from the setter")
set += ("let index = GetArrayIndexFromId(cx, id);\n" +
"if index.is_some() {\n" +
" let index = index.get();\n" +
" let index = index.unwrap();\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyIndexedSetter(self.descriptor)).define() +
" return 1;\n" +
@ -3746,7 +3746,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
" if strval.is_err() {\n" +
" return 0;\n" +
" }\n" +
" let name = str(strval.get());\n" +
" let name = str(strval.unwrap());\n" +
"\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyNamedSetter(self.descriptor)).define() + "\n" +
@ -3762,7 +3762,7 @@ class CGDOMJSProxyHandler_defineProperty(CGAbstractExternMethod):
" if strval.is_err() {\n" +
" return 0;\n" +
" }\n" +
" let name = str(strval.get());\n" +
" let name = str(strval.unwrap());\n" +
" let this: %%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor)).define() +
" if (found) {\n"
@ -3787,7 +3787,7 @@ class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
if indexedGetter:
indexed = ("let index = GetArrayIndexFromId(cx, id);\n" +
"if index.is_some() {\n" +
" let index = index.get();\n" +
" let index = index.unwrap();\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor)).define() + "\n" +
" *bp = found as JSBool;\n" +
@ -3808,7 +3808,7 @@ class CGDOMJSProxyHandler_hasOwn(CGAbstractExternMethod):
" if strval.is_err() {\n" +
" return 0;\n" +
" }\n" +
" let name = str(strval.get());\n" +
" let name = str(strval.unwrap());\n" +
"\n" +
" let this: *%s = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyNamedGetter(self.descriptor)).define() + "\n" +
@ -3861,7 +3861,7 @@ if expando.is_not_null() {
if indexedGetter:
getIndexedOrExpando = ("let index = GetArrayIndexFromId(cx, id);\n" +
"if index.is_some() {\n" +
" let index = index.get();\n" +
" let index = index.unwrap();\n" +
" let this = UnwrapProxy(proxy);\n" +
CGIndenter(CGProxyIndexedGetter(self.descriptor, templateValues)).define())
getIndexedOrExpando += """
@ -3935,7 +3935,7 @@ class CGDOMJSProxyHandler_obj_toString(CGAbstractExternMethod):
JSString* jsresult;
return xpc_qsStringToJsstring(cx, result, &jsresult) ? jsresult : NULL;"""
return """ do str::as_c_str("%s") |s| {
return """ do "%s".to_c_str().with_ref |s| {
_obj_toString(cx, s)
}""" % self.descriptor.name
@ -4461,9 +4461,9 @@ class CGDictionary(CGThing):
# NOTE: jsids are per-runtime, so don't use them in workers
if True or self.workers: #XXXjdm hack until 'static mut' exists for global jsids
propName = member.identifier.name
propCheck = ('str::as_c_str("%s", |s| { JS_HasProperty(cx, RUST_JSVAL_TO_OBJECT(val), s, ptr::to_unsafe_ptr(&found)) })' %
propCheck = ('"%s".to_c_str().with_ref(|s| { JS_HasProperty(cx, RUST_JSVAL_TO_OBJECT(val), s, ptr::to_unsafe_ptr(&found)) })' %
propName)
propGet = ('str::as_c_str("%s", |s| { JS_GetProperty(cx, RUST_JSVAL_TO_OBJECT(val), s, ptr::to_unsafe_ptr(&temp)) })' %
propGet = ('"%s".to_c_str().with_ref(|s| { JS_GetProperty(cx, RUST_JSVAL_TO_OBJECT(val), s, ptr::to_unsafe_ptr(&temp)) })' %
propName)
else:
propId = self.makeIdName(member.identifier.name);

20
servo/src/components/script/dom/bindings/element.rs
Просмотреть файл

@ -21,8 +21,6 @@ use std::libc::c_uint;
use std::comm;
use std::ptr;
use std::ptr::null;
use std::result;
use std::str;
use js::glue::*;
use js::jsapi::*;
use js::jsapi::{JSContext, JSVal, JSObject, JSBool, JSFreeOp, JSPropertySpec};
@ -49,14 +47,14 @@ pub extern fn trace(tracer: *mut JSTracer, obj: *JSObject) {
return;
}
error!("tracing %s", name);
let mut node = node.get();
let mut node = node.unwrap();
let cache = node.get_wrappercache();
let wrapper = cache.get_wrapper();
assert!(wrapper.is_not_null());
unsafe {
(*tracer).debugPrinter = ptr::null();
(*tracer).debugPrintIndex = -1;
do str::as_c_str(name) |name| {
do name.to_c_str().with_ref |name| {
(*tracer).debugPrintArg = name as *libc::c_void;
JS_CallTracer(cast::transmute(tracer), wrapper, JSTRACE_OBJECT as u32);
}
@ -194,14 +192,14 @@ extern fn setAttribute(cx: *JSContext, argc: c_uint, vp: *JSVal) -> JSBool {
if strval.is_err() {
return 0;
}
arg0 = str(strval.get());
arg0 = str(strval.unwrap());
let arg1: DOMString;
let strval = jsval_to_str(cx, (*argv.offset(1)));
if strval.is_err() {
return 0;
}
arg1 = str(strval.get());
arg1 = str(strval.unwrap());
do node.as_mut_element |elem| {
elem.set_attr(&arg0, &arg1);
@ -211,7 +209,6 @@ extern fn setAttribute(cx: *JSContext, argc: c_uint, vp: *JSVal) -> JSBool {
}
}
#[allow(non_implicitly_copyable_typarams)]
extern fn HTMLImageElement_getWidth(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool {
unsafe {
let obj = JS_THIS_OBJECT(cx, cast::transmute(vp));
@ -241,7 +238,6 @@ extern fn HTMLImageElement_getWidth(cx: *JSContext, _argc: c_uint, vp: *mut JSVa
}
}
#[allow(non_implicitly_copyable_typarams)]
extern fn HTMLImageElement_setWidth(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool {
unsafe {
let obj = JS_THIS_OBJECT(cx, cast::transmute(vp));
@ -275,7 +271,7 @@ extern fn getTagName(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool {
let node = unwrap(obj);
do node.with_imm_element |elem| {
let s = str(copy elem.tag_name);
let s = str(elem.tag_name.clone());
*vp = domstring_to_jsval(cx, &s);
}
}
@ -295,9 +291,9 @@ pub fn create(cx: *JSContext, node: &mut AbstractNode<ScriptView>) -> jsobj {
//XXXjdm the parent should probably be the node parent instead of the global
//TODO error checking
let compartment = utils::get_compartment(cx);
let obj = result::unwrap(compartment.new_object_with_proto(~"GenericElementInstance",
proto,
compartment.global_obj.ptr));
let obj = compartment.new_object_with_proto(~"GenericElementInstance",
proto,
compartment.global_obj.ptr).unwrap();
let cache = node.get_wrappercache();
assert!(cache.get_wrapper().is_null());

3
servo/src/components/script/dom/bindings/node.rs
Просмотреть файл

@ -97,7 +97,6 @@ macro_rules! generate_element(
})
)
#[allow(non_implicitly_copyable_typarams)]
pub fn create(cx: *JSContext, node: &mut AbstractNode<ScriptView>) -> *JSObject {
match node.type_id() {
ElementNodeTypeId(HTMLElementTypeId) => generate_element!(HTMLElement),
@ -138,7 +137,6 @@ pub unsafe fn unwrap(obj: *JSObject) -> AbstractNode<ScriptView> {
AbstractNode::from_raw(raw)
}
#[allow(non_implicitly_copyable_typarams)]
extern fn getFirstChild(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool {
unsafe {
let obj = JS_THIS_OBJECT(cx, cast::transmute(vp));
@ -160,7 +158,6 @@ extern fn getFirstChild(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool
return 1;
}
#[allow(non_implicitly_copyable_typarams)]
extern fn getNextSibling(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool {
unsafe {
let obj = JS_THIS_OBJECT(cx, cast::transmute(vp));

8
servo/src/components/script/dom/bindings/proxyhandler.rs
Просмотреть файл

@ -68,7 +68,7 @@ pub extern fn defineProperty(cx: *JSContext, proxy: *JSObject, id: jsid,
pub fn _obj_toString(cx: *JSContext, className: *libc::c_char) -> *JSString {
unsafe {
let name = str::raw::from_buf(className as *u8);
let name = str::raw::from_c_str(className);
let nchars = "[object ]".len() + name.len();
let chars: *mut jschar = cast::transmute(JS_malloc(cx, (nchars + 1) as u64 * (size_of::<jschar>() as u64)));
if chars.is_null() {
@ -76,10 +76,10 @@ pub fn _obj_toString(cx: *JSContext, className: *libc::c_char) -> *JSString {
}
let result = ~"[object " + name + "]";
for result.iter().enumerate().advance |(i, c)| {
*chars.offset(i) = c as jschar;
for (i, c) in result.iter().enumerate() {
*chars.offset(i as int) = c as jschar;
}
*chars.offset(nchars) = 0;
*chars.offset(nchars as int) = 0;
let jsstr = JS_NewUCString(cx, cast::transmute(chars), nchars as u64);
if jsstr.is_null() {
JS_free(cx, cast::transmute(chars));

7
servo/src/components/script/dom/bindings/text.rs
Просмотреть файл

@ -16,7 +16,6 @@ use js::rust::{Compartment, jsobj};
use std::cast;
use std::libc;
use std::result;
extern fn finalize_text(_fop: *JSFreeOp, obj: *JSObject) {
debug!("text finalize: %?!", obj as uint);
@ -79,9 +78,9 @@ pub fn create(cx: *JSContext, node: &mut AbstractNode<ScriptView>) -> jsobj {
//XXXjdm the parent should probably be the node parent instead of the global
//TODO error checking
let compartment = utils::get_compartment(cx);
let obj = result::unwrap(compartment.new_object_with_proto(instance,
proto,
compartment.global_obj.ptr));
let obj = compartment.new_object_with_proto(instance,
proto,
compartment.global_obj.ptr).unwrap();
let cache = node.get_wrappercache();
assert!(cache.get_wrapper().is_null());

37
servo/src/components/script/dom/bindings/utils.rs
Просмотреть файл

@ -13,9 +13,7 @@ use std::hashmap::HashMap;
use std::libc;
use std::ptr;
use std::ptr::{null, to_unsafe_ptr};
use std::result;
use std::str;
use std::uint;
use std::unstable::intrinsics;
use js::glue::*;
use js::glue::{DefineFunctionWithReserved, GetObjectJSClass, RUST_OBJECT_TO_JSVAL};
@ -85,7 +83,7 @@ extern fn InterfaceObjectToString(cx: *JSContext, _argc: uint, vp: *mut JSVal) -
return 0;
}
let name = jsval_to_str(cx, *v).get();
let name = jsval_to_str(cx, *v).unwrap();
let retval = str(~"function " + name + "() {\n [native code]\n}");
*vp = domstring_to_jsval(cx, &retval);
return 1;
@ -204,7 +202,7 @@ pub fn jsval_to_str(cx: *JSContext, v: JSVal) -> Result<~str, ()> {
}
let strbuf = JS_EncodeString(cx, jsstr);
let buf = str::raw::from_buf(strbuf as *u8);
let buf = str::raw::from_c_str(strbuf);
JS_free(cx, strbuf as *libc::c_void);
Ok(buf)
}
@ -216,10 +214,10 @@ pub unsafe fn domstring_to_jsval(cx: *JSContext, string: &DOMString) -> JSVal {
JSVAL_NULL
}
&str(ref s) => {
str::as_buf(*s, |buf, len| {
do s.as_imm_buf |buf, len| {
let cbuf = cast::transmute(buf);
RUST_STRING_TO_JSVAL(JS_NewStringCopyN(cx, cbuf, len as libc::size_t))
})
}
}
}
}
@ -322,13 +320,13 @@ pub fn define_empty_prototype(name: ~str, proto: Option<~str>, compartment: @mut
compartment.register_class(prototype_jsclass(name.to_owned()));
//TODO error checking
let obj = result::unwrap(
let obj = (
match proto {
Some(s) => compartment.new_object_with_proto(name.to_owned(),
s,
compartment.global_obj.ptr),
None => compartment.new_object(name.to_owned(), null(), compartment.global_obj.ptr)
});
}).unwrap();
unsafe {
compartment.define_property(name.to_owned(), RUST_OBJECT_TO_JSVAL(obj.ptr),
@ -392,6 +390,7 @@ pub struct JSNativeHolder {
propertyHooks: *NativePropertyHooks
}
#[deriving(Clone)]
pub enum ConstantVal {
IntVal(i32),
UintVal(u32),
@ -401,6 +400,7 @@ pub enum ConstantVal {
VoidVal
}
#[deriving(Clone)]
pub struct ConstantSpec {
name: *libc::c_char,
value: ConstantVal
@ -454,7 +454,7 @@ pub fn CreateInterfaceObjects2(cx: *JSContext, global: *JSObject, receiver: *JSO
let mut interface = ptr::null();
if constructorClass.is_not_null() || constructor.is_not_null() {
interface = do str::as_c_str(name) |s| {
interface = do name.to_c_str().with_ref |s| {
CreateInterfaceObject(cx, global, receiver, constructorClass,
constructor, ctorNargs, proto,
staticMethods, constants, s)
@ -506,7 +506,7 @@ fn CreateInterfaceObject(cx: *JSContext, global: *JSObject, receiver: *JSObject,
}
if constructorClass.is_not_null() {
let toString = do str::as_c_str("toString") |s| {
let toString = do "toString".to_c_str().with_ref |s| {
DefineFunctionWithReserved(cx, constructor, s,
InterfaceObjectToString,
0, 0)
@ -666,7 +666,7 @@ impl WrapperCache {
}
pub fn WrapNewBindingObject(cx: *JSContext, scope: *JSObject,
mut value: @mut CacheableWrapper,
value: @mut CacheableWrapper,
vp: *mut JSVal) -> bool {
unsafe {
let cache = value.get_wrappercache();
@ -765,7 +765,7 @@ pub fn XrayResolveProperty(cx: *JSContext,
unsafe {
match attributes {
Some(attrs) => {
for attrs.iter().advance |&elem| {
for &elem in attrs.iter() {
let (attr, attr_id) = elem;
if attr_id == JSID_VOID || attr_id != id {
loop;
@ -815,20 +815,18 @@ fn InternJSString(cx: *JSContext, chars: *libc::c_char) -> Option<jsid> {
}
pub fn InitIds(cx: *JSContext, specs: &[JSPropertySpec], ids: &mut [jsid]) -> bool {
let mut rval = true;
for specs.iter().enumerate().advance |(i, spec)| {
for (i, spec) in specs.iter().enumerate() {
if spec.name.is_null() == true {
break;
return true;
}
match InternJSString(cx, spec.name) {
Some(id) => ids[i] = id,
None => {
rval = false;
return false;
}
}
}
rval
true
}
pub trait DerivedWrapper {
@ -853,6 +851,7 @@ impl DerivedWrapper for AbstractNode<ScriptView> {
}
}
#[deriving(ToStr)]
pub enum Error {
FailureUnknown
}
@ -877,12 +876,12 @@ pub fn FindEnumStringIndex(cx: *JSContext,
if chars.is_null() {
return Err(());
}
for values.iter().enumerate().advance |(i, value)| {
for (i, value) in values.iter().enumerate() {
if value.length != length as uint {
loop;
}
let mut equal = true;
for uint::iterate(0, length as uint) |j| {
for j in range(0, length as int) {
if value.value[j] as u16 != *chars.offset(j) {
equal = false;
break;

2
servo/src/components/script/dom/characterdata.rs
Просмотреть файл

@ -23,7 +23,7 @@ impl CharacterData {
}
pub fn Data(&self) -> DOMString {
copy self.data
self.data.clone()
}
pub fn SetData(&mut self, arg: &DOMString, _rv: &mut ErrorResult) {

5
servo/src/components/script/dom/clientrect.rs
Просмотреть файл

@ -10,7 +10,6 @@ use js::jsapi::{JSObject, JSContext, JSVal};
use js::glue::RUST_OBJECT_TO_JSVAL;
use std::cast;
use std::f32;
pub struct ClientRect {
wrapper: WrapperCache,
@ -54,11 +53,11 @@ impl ClientRect {
}
pub fn Width(&self) -> f32 {
f32::abs(self.right - self.left)
(self.right - self.left).abs()
}
pub fn Height(&self) -> f32 {
f32::abs(self.bottom - self.top)
(self.bottom - self.top).abs()
}
}

18
servo/src/components/script/dom/document.rs
Просмотреть файл

@ -18,7 +18,7 @@ use dom::htmltitleelement::HTMLTitleElement;
use js::jsapi::{JS_AddObjectRoot, JS_RemoveObjectRoot, JSObject, JSContext, JSVal};
use js::glue::RUST_OBJECT_TO_JSVAL;
use servo_util::tree::{TreeNodeRef, TreeUtils};
use servo_util::tree::TreeNodeRef;
use std::cast;
use std::ptr;
@ -115,7 +115,7 @@ impl Document {
}
impl WrappableDocument for Document {
pub fn init_wrapper(@mut self, cx: *JSContext) {
fn init_wrapper(@mut self, cx: *JSContext) {
self.wrap_object_shared(cx, ptr::null()); //XXXjdm a proper scope would be nice
}
}
@ -270,11 +270,11 @@ impl Document {
fail!("no SVG document yet")
},
_ => {
let _ = for self.root.traverse_preorder |node| {
let _ = for node in self.root.traverse_preorder() {
if node.type_id() != ElementNodeTypeId(HTMLTitleElementTypeId) {
loop;
}
for node.children().advance |child| {
for child in node.children() {
if child.is_text() {
do child.with_imm_text() |text| {
let s = text.parent.Data();
@ -299,17 +299,17 @@ impl Document {
},
_ => {
let (_scope, cx) = self.get_scope_and_cx();
let _ = for self.root.traverse_preorder |node| {
let _ = for node in self.root.traverse_preorder() {
if node.type_id() != ElementNodeTypeId(HTMLHeadElementTypeId) {
loop;
}
let mut has_title = false;
for node.children().advance |child| {
for child in node.children() {
if child.type_id() != ElementNodeTypeId(HTMLTitleElementTypeId) {
loop;
}
has_title = true;
for child.children().advance |title_child| {
for title_child in child.children() {
child.remove_child(title_child);
}
let new_text = unsafe {
@ -427,7 +427,7 @@ impl Document {
pub fn createHTMLCollection(&self, callback: &fn(elem: &Element) -> bool) -> @mut HTMLCollection {
let mut elements = ~[];
let _ = for self.root.traverse_preorder |child| {
let _ = for child in self.root.traverse_preorder() {
if child.is_element() {
do child.with_imm_element |elem| {
if callback(elem) {
@ -441,7 +441,7 @@ impl Document {
}
pub fn content_changed(&self) {
for self.window.iter().advance |window| {
for window in self.window.iter() {
window.content_changed()
}
}

14
servo/src/components/script/dom/element.rs
Просмотреть файл

@ -47,7 +47,7 @@ use js::jsapi::{JSContext, JSObject};
use std::cell::Cell;
use std::comm;
use std::str::eq_slice;
use extra::net::url;
use std::FromStr;
pub struct Element {
parent: Node<ScriptView>,
@ -252,7 +252,7 @@ impl<'self> Element {
pub fn get_attr(&'self self, name: &str) -> Option<&'self str> {
// FIXME: Need an each() that links lifetimes in Rust.
for self.attrs.iter().advance |attr| {
for attr in self.attrs.iter() {
if eq_slice(attr.name, name) {
let val: &str = attr.value;
return Some(val);
@ -265,7 +265,7 @@ impl<'self> Element {
let name = name.to_str();
let value_cell = Cell::new(value.to_str());
let mut found = false;
for self.attrs.mut_iter().advance |attr| {
for attr in self.attrs.mut_iter() {
if eq_slice(attr.name, name) {
attr.value = value_cell.take().clone();
found = true;
@ -279,7 +279,7 @@ impl<'self> Element {
if "style" == name {
self.style_attribute = Some(
Stylesheet::from_attribute(
url::from_str("http://www.example.com/").unwrap(),
FromStr::from_str("http://www.example.com/").unwrap(),
value.get_ref()));
}
@ -290,8 +290,8 @@ impl<'self> Element {
}
fn get_scope_and_cx(&self) -> (*JSObject, *JSContext) {
let doc = self.parent.owner_doc.get();
let win = doc.with_base(|doc| doc.window.get());
let doc = self.parent.owner_doc.unwrap();
let win = doc.with_base(|doc| doc.window.unwrap());
let cx = unsafe {(*win.page).js_info.get_ref().js_compartment.cx.ptr};
let cache = win.get_wrappercache();
let scope = cache.get_wrapper();
@ -419,7 +419,7 @@ impl Element {
debug!("no document");
None
}
}.get();
}.unwrap();
ClientRectList::new(rects, cx, scope)
}

2
servo/src/components/script/dom/event.rs
Просмотреть файл

@ -55,7 +55,7 @@ impl Event {
}
pub fn Type(&self) -> DOMString {
copy self.type_
self.type_.clone()
}
pub fn GetTarget(&self) -> Option<@mut EventTarget> {

2
servo/src/components/script/dom/formdata.rs
Просмотреть файл

@ -39,7 +39,7 @@ impl FormData {
pub fn Append(&mut self, name: &DOMString, value: @mut Blob, filename: Option<DOMString>) {
let blob = BlobData {
blob: value,
name: filename.get_or_default(str(~"default"))
name: filename.unwrap_or_default(str(~"default"))
};
self.data.insert(name.to_str(), blob);
}

6
servo/src/components/script/dom/htmldocument.rs
Просмотреть файл

@ -13,7 +13,7 @@ use dom::window::Window;
use js::jsapi::{JSObject, JSContext};
use servo_util::tree::TreeUtils;
use servo_util::tree::TreeNodeRef;
use std::libc;
use std::ptr;
@ -43,7 +43,7 @@ impl HTMLDocument {
}
impl WrappableDocument for HTMLDocument {
pub fn init_wrapper(@mut self, cx: *JSContext) {
fn init_wrapper(@mut self, cx: *JSContext) {
self.wrap_object_shared(cx, ptr::null()); //XXXjdm a proper scope would be nice
}
}
@ -69,7 +69,7 @@ impl HTMLDocument {
pub fn GetHead(&self) -> Option<AbstractNode<ScriptView>> {
let mut headNode: Option<AbstractNode<ScriptView>> = None;
let _ = for self.parent.root.traverse_preorder |child| {
let _ = for child in self.parent.root.traverse_preorder() {
if child.type_id() == ElementNodeTypeId(HTMLHeadElementTypeId) {
headNode = Some(child);
break;

2
servo/src/components/script/dom/htmliframeelement.rs
Просмотреть файл

@ -11,7 +11,7 @@ use geom::size::Size2D;
use servo_msg::constellation_msg::SubpageId;
use std::comm::ChanOne;
use extra::net::url::Url;
use extra::url::Url;
pub struct HTMLIFrameElement {
parent: HTMLElement,

2
servo/src/components/script/dom/htmlimageelement.rs
Просмотреть файл

@ -4,7 +4,7 @@
use dom::bindings::utils::{DOMString, null_string, ErrorResult};
use dom::htmlelement::HTMLElement;
use extra::net::url::Url;
use extra::url::Url;
pub struct HTMLImageElement {
parent: HTMLElement,

87
servo/src/components/script/dom/node.rs
Просмотреть файл

@ -20,11 +20,10 @@ use dom::window::Window;
use std::cast;
use std::cast::transmute;
use std::libc::c_void;
use std::uint;
use js::jsapi::{JSObject, JSContext};
use js::rust::Compartment;
use netsurfcss::util::VoidPtrLike;
use servo_util::tree::{TreeNode, TreeNodeRef, TreeUtils};
use servo_util::tree::{TreeNode, TreeNodeRef};
//
// The basic Node structure
@ -177,41 +176,39 @@ impl<View> Clone for AbstractNode<View> {
}
}
impl<View> TreeNode<AbstractNode<View>> for Node<View> {
fn parent_node(&self) -> Option<AbstractNode<View>> {
self.parent_node
}
fn first_child(&self) -> Option<AbstractNode<View>> {
self.first_child
}
fn last_child(&self) -> Option<AbstractNode<View>> {
self.last_child
}
fn prev_sibling(&self) -> Option<AbstractNode<View>> {
self.prev_sibling
}
fn next_sibling(&self) -> Option<AbstractNode<View>> {
self.next_sibling
}
fn set_parent_node(&mut self, new_parent_node: Option<AbstractNode<View>>) {
self.parent_node = new_parent_node
}
fn set_first_child(&mut self, new_first_child: Option<AbstractNode<View>>) {
self.first_child = new_first_child
}
fn set_last_child(&mut self, new_last_child: Option<AbstractNode<View>>) {
self.last_child = new_last_child
}
fn set_prev_sibling(&mut self, new_prev_sibling: Option<AbstractNode<View>>) {
self.prev_sibling = new_prev_sibling
}
fn set_next_sibling(&mut self, new_next_sibling: Option<AbstractNode<View>>) {
self.next_sibling = new_next_sibling
}
}
impl<View> TreeNodeRef<Node<View>> for AbstractNode<View> {
fn parent_node(node: &Node<View>) -> Option<AbstractNode<View>> {
node.parent_node
}
fn first_child(node: &Node<View>) -> Option<AbstractNode<View>> {
node.first_child
}
fn last_child(node: &Node<View>) -> Option<AbstractNode<View>> {
node.last_child
}
fn prev_sibling(node: &Node<View>) -> Option<AbstractNode<View>> {
node.prev_sibling
}
fn next_sibling(node: &Node<View>) -> Option<AbstractNode<View>> {
node.next_sibling
}
fn set_parent_node(node: &mut Node<View>, new_parent_node: Option<AbstractNode<View>>) {
node.parent_node = new_parent_node
}
fn set_first_child(node: &mut Node<View>, new_first_child: Option<AbstractNode<View>>) {
node.first_child = new_first_child
}
fn set_last_child(node: &mut Node<View>, new_last_child: Option<AbstractNode<View>>) {
node.last_child = new_last_child
}
fn set_prev_sibling(node: &mut Node<View>, new_prev_sibling: Option<AbstractNode<View>>) {
node.prev_sibling = new_prev_sibling
}
fn set_next_sibling(node: &mut Node<View>, new_next_sibling: Option<AbstractNode<View>>) {
node.next_sibling = new_next_sibling
}
// FIXME: The duplication between `with_base` and `with_mut_base` is ugly.
fn with_base<R>(&self, callback: &fn(&Node<View>) -> R) -> R {
self.transmute(callback)
@ -222,6 +219,8 @@ impl<View> TreeNodeRef<Node<View>> for AbstractNode<View> {
}
}
impl<View> TreeNode<AbstractNode<View>> for Node<View> { }
impl<'self, View> AbstractNode<View> {
// Unsafe accessors
@ -250,7 +249,7 @@ impl<'self, View> AbstractNode<View> {
/// allowed to call this. This is wildly unsafe and is therefore marked as such.
pub unsafe fn unsafe_layout_data<T>(self) -> @mut T {
do self.with_base |base| {
transmute(base.layout_data.get())
transmute(base.layout_data.unwrap())
}
}
/// Returns true if this node has layout data and false otherwise.
@ -438,7 +437,7 @@ impl<'self, View> AbstractNode<View> {
/// Dumps the node tree, for debugging, with indentation.
pub fn dump_indent(&self, indent: uint) {
let mut s = ~"";
for uint::range(0u, indent) |_i| {
for _ in range(0, indent) {
s.push_str(" ");
}
@ -446,7 +445,7 @@ impl<'self, View> AbstractNode<View> {
debug!("%s", s);
// FIXME: this should have a pure version?
for self.each_child() |kid| {
for kid in self.children() {
kid.dump_indent(indent + 1u)
}
}
@ -464,7 +463,7 @@ impl<'self, View> AbstractNode<View> {
}
impl<View> Iterator<AbstractNode<View>> for AbstractNodeChildrenIterator<View> {
pub fn next(&mut self) -> Option<AbstractNode<View>> {
fn next(&mut self) -> Option<AbstractNode<View>> {
let node = self.current_node;
self.current_node = self.current_node.chain(|node| node.next_sibling());
node
@ -483,14 +482,14 @@ impl Node<ScriptView> {
pub fn add_to_doc(&mut self, doc: AbstractDocument) {
self.owner_doc = Some(doc);
let mut node = self.first_child;
while node.is_some() {
for node.get().traverse_preorder |node| {
let mut cur_node = self.first_child;
while cur_node.is_some() {
for node in cur_node.unwrap().traverse_preorder() {
do node.with_mut_base |node_base| {
node_base.owner_doc = Some(doc);
}
};
node = node.get().next_sibling();
cur_node = cur_node.unwrap().next_sibling();
}
}

33
servo/src/components/script/dom/window.rs
Просмотреть файл

@ -18,13 +18,13 @@ use js::{JSVAL_NULL, JSPROP_ENUMERATE};
use std::cast;
use std::comm;
use std::comm::Chan;
use std::int;
use std::comm::SharedChan;
use std::io;
use std::ptr;
use std::int;
use std::rt::rtio::RtioTimer;
use std::rt::io::timer::Timer;
use js::jsapi::JSVal;
use extra::timer;
use extra::uv_global_loop;
pub enum TimerControlMsg {
TimerMessage_Fire(~TimerData),
@ -38,7 +38,7 @@ pub struct Window {
script_chan: ScriptChan,
compositor: @ScriptListener,
wrapper: WrapperCache,
timer_chan: Chan<TimerControlMsg>,
timer_chan: SharedChan<TimerControlMsg>,
}
#[unsafe_destructor]
@ -68,7 +68,7 @@ impl Window {
pub fn Document(&self) -> AbstractDocument {
unsafe {
(*self.page).frame.get().document
(*self.page).frame.unwrap().document
}
}
@ -142,18 +142,19 @@ impl BindingObject for Window {
impl Window {
pub fn SetTimeout(&self, _cx: *JSContext, callback: JSVal, timeout: i32) -> i32 {
let timeout = int::max(0, timeout) as uint;
let timeout = int::max(0, timeout) as u64;
// Post a delayed message to the per-window timer task; it will dispatch it
// to the relevant script handler that will deal with it.
let data = ~TimerData {
funval: callback,
args: ~[]
};
timer::delayed_send(&uv_global_loop::get(),
timeout,
&self.timer_chan,
TimerMessage_Fire(data));
let tm = Timer::new().unwrap();
let chan = self.timer_chan.clone();
do spawn {
tm.sleep(timeout);
chan.send(TimerMessage_Fire(~TimerData {
funval: callback,
args: ~[]
}));
}
return 0; //TODO return handle into list of active timers
}
@ -182,7 +183,7 @@ impl Window {
}
}
}
timer_chan
SharedChan::new(timer_chan)
},
};

6
servo/src/components/script/html/cssparse.rs
Просмотреть файл

@ -11,7 +11,7 @@ use std::task;
use newcss::stylesheet::Stylesheet;
use newcss::util::DataStream;
use servo_net::resource_task::{ResourceTask, ProgressMsg, Load, Payload, Done};
use extra::net::url::Url;
use extra::url::Url;
/// Where a style sheet comes from.
pub enum StylesheetProvenance {
@ -28,8 +28,8 @@ pub fn spawn_css_parser(provenance: StylesheetProvenance,
do task::spawn {
let url = do provenance_cell.with_ref |p| {
match *p {
UrlProvenance(ref the_url) => copy *the_url,
InlineProvenance(ref the_url, _) => copy *the_url
UrlProvenance(ref the_url) => (*the_url).clone(),
InlineProvenance(ref the_url, _) => (*the_url).clone()
}
};

27
servo/src/components/script/html/hubbub_html_parser.rs
Просмотреть файл

@ -54,19 +54,18 @@ use newcss::stylesheet::Stylesheet;
use std::cast;
use std::cell::Cell;
use std::comm;
use std::comm::{Chan, Port, SharedChan};
use std::comm::{Port, SharedChan};
use std::str::eq_slice;
use std::result;
use std::task;
use std::from_str::FromStr;
use hubbub::hubbub;
use servo_msg::constellation_msg::SubpageId;
use servo_net::image_cache_task::ImageCacheTask;
use servo_net::image_cache_task;
use servo_net::resource_task::{Done, Load, Payload, ResourceTask};
use servo_util::tree::TreeUtils;
use servo_util::tree::TreeNodeRef;
use servo_util::url::make_url;
use extra::net::url::Url;
use extra::net::url;
use extra::url::Url;
use extra::future::{Future, from_port};
use geom::size::Size2D;
@ -167,7 +166,7 @@ fn css_link_listener(to_parent: SharedChan<HtmlDiscoveryMessage>,
// Send the sheets back in order
// FIXME: Shouldn't wait until after we've recieved CSSTaskExit to start sending these
for result_vec.iter().advance |port| {
for port in result_vec.iter() {
to_parent.send(HtmlDiscoveredStyle(port.recv()));
}
}
@ -185,7 +184,7 @@ fn js_script_listener(to_parent: SharedChan<HtmlDiscoveryMessage>,
do task::spawn {
let (input_port, input_chan) = comm::stream();
// TODO: change copy to move once we can move into closures
resource_task.send(Load(copy url, input_chan));
resource_task.send(Load(url.clone(), input_chan));
let mut buf = ~[];
loop {
@ -273,7 +272,6 @@ fn build_element_from_tag(cx: *JSContext, tag: &str) -> AbstractNode<ScriptView>
}
}
#[allow(non_implicitly_copyable_typarams)]
pub fn parse_html(cx: *JSContext,
url: Url,
resource_task: ResourceTask,
@ -348,7 +346,7 @@ pub fn parse_html(cx: *JSContext,
debug!("-- attach attrs");
do node.as_mut_element |element| {
for tag.attributes.iter().advance |attr| {
for attr in tag.attributes.iter() {
element.set_attr(&str(attr.name.clone()), &str(attr.value.clone()));
}
}
@ -377,7 +375,7 @@ pub fn parse_html(cx: *JSContext,
let iframe_chan = iframe_chan.take();
let elem = &mut iframe_element.parent.parent;
let src_opt = elem.get_attr("src").map(|x| x.to_str());
for src_opt.iter().advance |src| {
for src in src_opt.iter() {
let iframe_url = make_url(src.clone(), Some(url2.clone()));
iframe_element.frame = Some(iframe_url.clone());
@ -404,7 +402,7 @@ pub fn parse_html(cx: *JSContext,
None => {}
Some(src) => {
let img_url = make_url(src, Some(url2.clone()));
image_element.image = Some(copy img_url);
image_element.image = Some(img_url.clone());
// inform the image cache to load this, but don't store a handle.
// TODO (Issue #84): don't prefetch if we are within a <noscript>
// tag.
@ -475,7 +473,6 @@ pub fn parse_html(cx: *JSContext,
},
complete_script: |script| {
// A little function for holding this lint attr
#[allow(non_implicitly_copyable_typarams)]
fn complete_script(script: hubbub::NodeDataPtr,
url: Url,
js_chan: SharedChan<JSMessage>) {
@ -500,12 +497,12 @@ pub fn parse_html(cx: *JSContext,
// We've reached the end of a <style> so we can submit all the text to the parser.
unsafe {
let style: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(style);
let url = url::from_str("http://example.com/"); // FIXME
let url = FromStr::from_str("http://example.com/"); // FIXME
let url_cell = Cell::new(url);
let mut data = ~[];
debug!("iterating over children %?", style.first_child());
for style.children().advance |child| {
for child in style.children() {
debug!("child = %?", child);
do child.with_imm_text() |text| {
data.push(text.parent.data.to_str()); // FIXME: Bad copy.
@ -513,7 +510,7 @@ pub fn parse_html(cx: *JSContext,
}
debug!("data = %?", data);
let provenance = InlineProvenance(result::unwrap(url_cell.take()), data.concat());
let provenance = InlineProvenance(url_cell.take().unwrap(), data.concat());
css_chan3.send(CSSTaskNewFile(provenance));
}
},

4
servo/src/components/script/layout_interface.rs
Просмотреть файл

@ -14,7 +14,7 @@ use geom::size::Size2D;
use geom::point::Point2D;
use gfx::geometry::Au;
use newcss::stylesheet::Stylesheet;
use extra::net::url::Url;
use extra::url::Url;
/// Asynchronous messages that script can send to layout.
///
@ -62,7 +62,7 @@ impl DocumentDamageLevel {
///
/// FIXME(pcwalton): This could be refactored to use `max` and the `Ord` trait, and this
/// function removed.
fn add(&mut self, new_damage: DocumentDamageLevel) {
pub fn add(&mut self, new_damage: DocumentDamageLevel) {
match (*self, new_damage) {
(ReflowDocumentDamage, new_damage) => *self = new_damage,
(MatchSelectorsDocumentDamage, _) => *self = MatchSelectorsDocumentDamage,

45
servo/src/components/script/script_task.rs
Просмотреть файл

@ -25,11 +25,9 @@ use servo_msg::constellation_msg::{PipelineId, SubpageId, RendererReadyMsg, Resi
use servo_msg::constellation_msg::{LoadIframeUrlMsg};
use servo_msg::constellation_msg;
use newcss::stylesheet::Stylesheet;
use std::cell::Cell;
use std::comm;
use std::comm::{Port, SharedChan, Select2};
use std::comm::{Port, SharedChan};
use std::io::read_whole_file;
use std::ptr::null;
use std::task::{SingleThreaded, task};
@ -50,8 +48,7 @@ use servo_net::image_cache_task::ImageCacheTask;
use servo_net::resource_task::ResourceTask;
use servo_util::tree::TreeNodeRef;
use servo_util::url::make_url;
use extra::net::url::Url;
use extra::net::url;
use extra::url::Url;
use extra::future::{from_value, Future};
/// Messages used to control the script task.
@ -162,7 +159,7 @@ impl PageTree {
pub fn find<'a> (&'a mut self, id: PipelineId) -> Option<&'a mut PageTree> {
if self.page.id == id { return Some(self); }
for self.inner.mut_iter().advance |page_tree| {
for page_tree in self.inner.mut_iter() {
let found = page_tree.find(id);
if found.is_some() { return found; }
}
@ -181,7 +178,7 @@ impl<'self> Iterator<@mut Page> for PageTreeIterator<'self> {
if !self.stack.is_empty() {
let next = self.stack.pop();
{
for next.inner.mut_iter().advance |child| {
for child in next.inner.mut_iter() {
self.stack.push(child);
}
}
@ -266,7 +263,7 @@ impl Page {
// Send new document and relevant styles to layout.
let reflow = ~Reflow {
document_root: do frame.document.with_base |doc| { doc.root },
url: copy self.url.get_ref().first(),
url: self.url.get_ref().first().clone(),
goal: goal,
window_size: self.window_size.get(),
script_chan: script_chan,
@ -485,20 +482,20 @@ impl ScriptTask {
/// Handles a request to execute a script.
fn handle_execute_msg(&mut self, id: PipelineId, url: Url) {
debug!("script: Received url `%s` to execute", url::to_str(&url));
debug!("script: Received url `%s` to execute", url.to_str());
let page_tree = self.page_tree.find(id).expect("ScriptTask: received fire timer msg for a
pipeline ID not associated with this script task. This is a bug.");
let js_info = page_tree.page.js_info.get_ref();
match read_whole_file(&Path(url.path)) {
Err(msg) => println(fmt!("Error opening %s: %s", url::to_str(&url), msg)),
Err(msg) => println(fmt!("Error opening %s: %s", url.to_str(), msg)),
Ok(bytes) => {
js_info.js_compartment.define_functions(debug_fns);
js_info.js_context.evaluate_script(js_info.js_compartment.global_obj,
bytes,
copy url.path,
url.path.clone(),
1);
}
}
@ -549,16 +546,16 @@ impl ScriptTask {
fn handle_resize_inactive_msg(&mut self, new_size: Size2D<uint>) {
self.page_tree.page.window_size = from_value(new_size);
let last_loaded_url = replace(&mut self.page_tree.page.url, None);
for last_loaded_url.iter().advance |last_loaded_url| {
self.page_tree.page.url = Some((last_loaded_url.first(), true));
for url in last_loaded_url.iter() {
self.page_tree.page.url = Some((url.first(), true));
}
}
/// Handles a request to exit the script task and shut down layout.
fn handle_exit_msg(&mut self) {
for self.page_tree.iter().advance |page| {
for page in self.page_tree.iter() {
page.join_layout();
do page.frame.get().document.with_mut_base |doc| {
do page.frame.unwrap().document.with_mut_base |doc| {
doc.teardown();
}
page.layout_chan.send(layout_interface::ExitMsg);
@ -574,10 +571,10 @@ impl ScriptTask {
message for a layout channel that is not associated with this script task. This
is a bug.").page;
let last_loaded_url = replace(&mut page.url, None);
for last_loaded_url.iter().advance |last_loaded_url| {
let (ref last_loaded_url, needs_reflow) = *last_loaded_url;
if *last_loaded_url == url {
page.url = Some((last_loaded_url.clone(), false));
for loaded in last_loaded_url.iter() {
let (ref loaded, needs_reflow) = *loaded;
if *loaded == url {
page.url = Some((loaded.clone(), false));
if needs_reflow {
page.reflow_all(ReflowForDisplay, self.chan.clone(), self.compositor);
}
@ -661,7 +658,7 @@ impl ScriptTask {
// Receive the JavaScript scripts.
assert!(js_scripts.is_some());
let js_scripts = js_scripts.swap_unwrap();
let js_scripts = js_scripts.take_unwrap();
debug!("js_scripts: %?", js_scripts);
// Perform the initial reflow.
@ -677,7 +674,7 @@ impl ScriptTask {
js_info.js_compartment.define_functions(debug_fns);
// Evaluate every script in the document.
for js_scripts.iter().advance |bytes| {
for bytes in js_scripts.iter() {
let _ = js_info.js_context.evaluate_script(js_info.js_compartment.global_obj,
bytes.clone(),
~"???",
@ -757,10 +754,10 @@ impl ScriptTask {
}
}
priv fn load_url_from_element(&self, page: @mut Page, element: &Element) {
fn load_url_from_element(&self, page: @mut Page, element: &Element) {
// if the node's element is "a," load url from href attr
let href = element.get_attr("href");
for href.iter().advance |href| {
let attr = element.get_attr("href");
for href in attr.iter() {
debug!("ScriptTask: clicked on link to %s", *href);
let current_url = do page.url.map |&(ref url, _)| {
url.clone()

12
servo/src/components/util/range.rs
Просмотреть файл

@ -2,8 +2,8 @@
* 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 std::uint;
use std::cmp::{max, min};
use std::iterator;
enum RangeRelation {
OverlapsBegin(/* overlap */ uint),
@ -15,6 +15,7 @@ enum RangeRelation {
EntirelyAfter
}
#[deriving(Clone)]
pub struct Range {
priv off: uint,
priv len: uint
@ -35,13 +36,8 @@ impl Range {
pub fn length(&self) -> uint { self.len }
pub fn end(&self) -> uint { self.off + self.len }
pub fn eachi(&self, callback: &fn(uint) -> bool) -> bool {
for uint::range(self.off, self.off + self.len) |i| {
if !callback(i) {
break
}
}
true
pub fn eachi(&self) -> iterator::Range<uint> {
range(self.off, self.off + self.len)
}
pub fn contains(&self, i: uint) -> bool {

16
servo/src/components/util/time.rs
Просмотреть файл

@ -26,7 +26,7 @@ impl ProfilerChan {
}
}
#[deriving(Eq)]
#[deriving(Eq, Clone)]
pub enum ProfilerCategory {
CompositingCategory,
LayoutQueryCategory,
@ -70,7 +70,7 @@ impl ProfilerCategory {
// enumeration of all ProfilerCategory types
// TODO(tkuehn): is there a better way to ensure proper order of categories?
priv fn empty_buckets() -> ProfilerBuckets {
fn empty_buckets() -> ProfilerBuckets {
let buckets = [
(CompositingCategory, ~[]),
(LayoutQueryCategory, ~[]),
@ -92,8 +92,8 @@ impl ProfilerCategory {
}
// ensure that the order of the buckets matches the order of the enum categories
priv fn check_order(vec: &ProfilerBuckets) {
for vec.iter().advance |&(category, _)| {
fn check_order(vec: &ProfilerBuckets) {
for &(category, _) in vec.iter() {
if category != vec[category as uint].first() {
fail!("Enum category does not match bucket index. This is a bug.");
}
@ -136,7 +136,7 @@ impl Profiler {
}
}
priv fn handle_msg(&mut self, msg: ProfilerMsg) {
fn handle_msg(&mut self, msg: ProfilerMsg) {
match msg {
TimeMsg(category, t) => match self.buckets[category as uint] {
//TODO(tkuehn): would be nice to have tuple.second_mut()
@ -151,11 +151,11 @@ impl Profiler {
self.last_msg = Some(msg);
}
priv fn print_buckets(&mut self) {
fn print_buckets(&mut self) {
println(fmt!("%31s %15s %15s %15s %15s %15s",
"_category_", "_mean (ms)_", "_median (ms)_",
"_min (ms)_", "_max (ms)_", "_bucket size_"));
for self.buckets.mut_iter().advance |bucket| {
for bucket in self.buckets.mut_iter() {
let (category, data) = match *bucket {
(category, ref mut data) => (category, data),
};
@ -163,7 +163,7 @@ impl Profiler {
let data_len = data.len();
if data_len > 0 {
let (mean, median, &min, &max) =
(data.iter().transform(|&x|x).sum() / (data_len as float),
(data.iter().map(|&x|x).sum() / (data_len as float),
data[data_len / 2],
data.iter().min().unwrap(),
data.iter().max().unwrap());

389
servo/src/components/util/tree.rs
Просмотреть файл

@ -4,204 +4,293 @@
//! Helper functions for garbage collected doubly-linked trees.
/// The basic trait. This function is meant to encapsulate a clonable reference to a tree node.
pub trait TreeNodeRef<N> : Clone {
// Macros to make add_child etc. less painful to write.
// Code outside this module should instead implement TreeNode
// and use its default methods.
macro_rules! get(
($node:expr, $fun:ident) => (
TreeNodeRef::$fun::<Node,Self>($node)
)
)
macro_rules! set(
($node:expr, $fun:ident, $val:expr) => (
TreeNodeRef::$fun::<Node,Self>($node, $val)
)
)
pub struct ChildIterator<Ref> {
priv current: Option<Ref>,
}
impl<Node, Ref: TreeNodeRef<Node>> Iterator<Ref> for ChildIterator<Ref> {
fn next(&mut self) -> Option<Ref> {
if self.current.is_none() {
return None;
}
// FIXME: Do we need two clones here?
let x = self.current.get_ref().clone();
self.current = x.with_base(|n| TreeNodeRef::next_sibling::<Node, Ref>(n));
Some(x.clone())
}
}
// FIXME: Do this without precomputing a vector of refs.
// Easy for preorder; harder for postorder.
pub struct TreeIterator<Ref> {
priv nodes: ~[Ref],
priv index: uint,
}
impl<Ref> TreeIterator<Ref> {
fn new(nodes: ~[Ref]) -> TreeIterator<Ref> {
TreeIterator {
nodes: nodes,
index: 0,
}
}
}
impl<Ref: Clone> Iterator<Ref> for TreeIterator<Ref> {
fn next(&mut self) -> Option<Ref> {
if self.index >= self.nodes.len() {
None
} else {
let v = self.nodes[self.index].clone();
self.index += 1;
Some(v)
}
}
}
/// A type implementing TreeNodeRef<Node> is a clonable reference to an underlying
/// node type Node.
///
/// We have to define both ref and node operations in the same trait, which makes
/// the latter more annoying to call (as static methods). But we provide non-static
/// proxies in trait TreeNode below.
pub trait TreeNodeRef<Node>: Clone {
// Fundamental operations on refs.
/// Borrows this node as immutable.
fn with_base<R>(&self, callback: &fn(&N) -> R) -> R;
fn with_base<R>(&self, callback: &fn(&Node) -> R) -> R;
/// Borrows this node as mutable.
fn with_mut_base<R>(&self, callback: &fn(&mut N) -> R) -> R;
}
fn with_mut_base<R>(&self, callback: &fn(&mut Node) -> R) -> R;
// Fundamental operations on nodes.
/// The contents of a tree node.
pub trait TreeNode<NR> {
/// Returns the parent of this node.
fn parent_node(&self) -> Option<NR>;
fn parent_node(node: &Node) -> Option<Self>;
/// Returns the first child of this node.
fn first_child(&self) -> Option<NR>;
fn first_child(node: &Node) -> Option<Self>;
/// Returns the last child of this node.
fn last_child(&self) -> Option<NR>;
fn last_child(node: &Node) -> Option<Self>;
/// Returns the previous sibling of this node.
fn prev_sibling(&self) -> Option<NR>;
fn prev_sibling(node: &Node) -> Option<Self>;
/// Returns the next sibling of this node.
fn next_sibling(&self) -> Option<NR>;
fn next_sibling(node: &Node) -> Option<Self>;
/// Sets the parent of this node.
fn set_parent_node(&mut self, new_parent: Option<NR>);
fn set_parent_node(node: &mut Node, new_parent: Option<Self>);
/// Sets the first child of this node.
fn set_first_child(&mut self, new_first_child: Option<NR>);
fn set_first_child(node: &mut Node, new_first_child: Option<Self>);
/// Sets the last child of this node.
fn set_last_child(&mut self, new_last_child: Option<NR>);
fn set_last_child(node: &mut Node, new_last_child: Option<Self>);
/// Sets the previous sibling of this node.
fn set_prev_sibling(&mut self, new_prev_sibling: Option<NR>);
fn set_prev_sibling(node: &mut Node, new_prev_sibling: Option<Self>);
/// Sets the next sibling of this node.
fn set_next_sibling(&mut self, new_next_sibling: Option<NR>);
}
fn set_next_sibling(node: &mut Node, new_next_sibling: Option<Self>);
// The tree utilities, operating on refs mostly.
/// A set of helper functions useful for operating on trees.
pub trait TreeUtils {
/// Returns true if this node is disconnected from the tree or has no children.
fn is_leaf(&self) -> bool;
fn is_leaf(&self) -> bool {
do self.with_base |this_node| {
(get!(this_node, first_child)).is_none()
}
}
/// Adds a new child to the end of this node's list of children.
///
/// Fails unless `new_child` is disconnected from the tree.
fn add_child(&self, new_child: Self);
fn add_child(&self, new_child: Self) {
do self.with_mut_base |this_node| {
do new_child.with_mut_base |new_child_node| {
assert!((get!(new_child_node, parent_node)).is_none());
assert!((get!(new_child_node, prev_sibling)).is_none());
assert!((get!(new_child_node, next_sibling)).is_none());
match get!(this_node, last_child) {
None => set!(this_node, set_first_child, Some(new_child.clone())),
Some(last_child) => {
do last_child.with_mut_base |last_child_node| {
assert!((get!(last_child_node, next_sibling)).is_none());
set!(last_child_node, set_next_sibling, Some(new_child.clone()));
set!(new_child_node, set_prev_sibling, Some(last_child.clone()));
}
}
}
set!(this_node, set_last_child, Some(new_child.clone()));
set!(new_child_node, set_parent_node, Some((*self).clone()));
}
}
}
/// Removes the given child from this node's list of children.
///
/// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.)
fn remove_child(&self, child: Self);
fn remove_child(&self, child: Self) {
do self.with_mut_base |this_node| {
do child.with_mut_base |child_node| {
assert!((get!(child_node, parent_node)).is_some());
match get!(child_node, prev_sibling) {
None => set!(this_node, set_first_child, get!(child_node, next_sibling)),
Some(prev_sibling) => {
do prev_sibling.with_mut_base |prev_sibling_node| {
set!(prev_sibling_node, set_next_sibling, get!(child_node, next_sibling));
}
}
}
match get!(child_node, next_sibling) {
None => set!(this_node, set_last_child, get!(child_node, prev_sibling)),
Some(next_sibling) => {
do next_sibling.with_mut_base |next_sibling_node| {
set!(next_sibling_node, set_prev_sibling, get!(child_node, prev_sibling));
}
}
}
set!(child_node, set_prev_sibling, None);
set!(child_node, set_next_sibling, None);
set!(child_node, set_parent_node, None);
}
}
}
/// Iterates over all children of this node.
fn each_child(&self, callback: &fn(Self) -> bool) -> bool;
fn children(&self) -> ChildIterator<Self> {
ChildIterator {
current: self.with_base(|n| get!(n, first_child)),
}
}
/// Iterates over this node and all its descendants, in preorder.
fn traverse_preorder(&self, callback: &fn(Self) -> bool) -> bool;
fn traverse_preorder(&self) -> TreeIterator<Self> {
self.traverse_preorder_prune(|_| false)
}
/// Iterates over this node and all its descendants, in postorder.
fn traverse_postorder(&self, callback: &fn(Self) -> bool) -> bool;
fn traverse_postorder(&self) -> TreeIterator<Self> {
self.traverse_postorder_prune(|_| false)
}
/// Like traverse_preorder but calls 'prune' first on each node. If it returns true then we
/// skip the whole subtree but continue iterating.
///
/// 'prune' is a separate function a) for compatibility with the 'for' protocol,
/// b) so that the postorder version can still prune before traversing.
fn traverse_preorder_prune(&self, prune: &fn(&Self) -> bool, callback: &fn(Self) -> bool) -> bool;
fn traverse_preorder_prune(&self, prune: &fn(&Self) -> bool) -> TreeIterator<Self> {
let mut nodes = ~[];
gather(self, &mut nodes, false, prune);
TreeIterator::new(nodes)
}
/// Like traverse_postorder but calls 'prune' first on each node. If it returns true then we
/// skip the whole subtree but continue iterating.
///
/// NB: 'prune' is called *before* traversing children, even though this is a
/// postorder traversal.
fn traverse_postorder_prune(&self, prune: &fn(&Self) -> bool, callback: &fn(Self) -> bool) -> bool;
}
impl<NR:TreeNodeRef<N>,N:TreeNode<NR>> TreeUtils for NR {
fn is_leaf(&self) -> bool {
do self.with_base |this_node| {
this_node.first_child().is_none()
}
}
fn add_child(&self, new_child: NR) {
do self.with_mut_base |this_node| {
do new_child.with_mut_base |new_child_node| {
assert!(new_child_node.parent_node().is_none());
assert!(new_child_node.prev_sibling().is_none());
assert!(new_child_node.next_sibling().is_none());
match this_node.last_child() {
None => this_node.set_first_child(Some(new_child.clone())),
Some(last_child) => {
do last_child.with_mut_base |last_child_node| {
assert!(last_child_node.next_sibling().is_none());
last_child_node.set_next_sibling(Some(new_child.clone()));
new_child_node.set_prev_sibling(Some(last_child.clone()));
}
}
}
this_node.set_last_child(Some(new_child.clone()));
new_child_node.set_parent_node(Some((*self).clone()));
}
}
}
fn remove_child(&self, child: NR) {
do self.with_mut_base |this_node| {
do child.with_mut_base |child_node| {
assert!(child_node.parent_node().is_some());
match child_node.prev_sibling() {
None => this_node.set_first_child(child_node.next_sibling()),
Some(prev_sibling) => {
do prev_sibling.with_mut_base |prev_sibling_node| {
prev_sibling_node.set_next_sibling(child_node.next_sibling());
}
}
}
match child_node.next_sibling() {
None => this_node.set_last_child(child_node.prev_sibling()),
Some(next_sibling) => {
do next_sibling.with_mut_base |next_sibling_node| {
next_sibling_node.set_prev_sibling(child_node.prev_sibling());
}
}
}
child_node.set_prev_sibling(None);
child_node.set_next_sibling(None);
child_node.set_parent_node(None);
}
}
}
fn each_child(&self, callback: &fn(NR) -> bool) -> bool {
let mut maybe_current = self.with_base(|n| n.first_child());
while !maybe_current.is_none() {
let current = maybe_current.get_ref().clone();
if !callback(current.clone()) {
break;
}
maybe_current = current.with_base(|n| n.next_sibling());
}
true
}
fn traverse_preorder_prune(&self, prune: &fn(&NR) -> bool, callback: &fn(NR) -> bool) -> bool {
// prune shouldn't mutate, so don't clone
if prune(self) {
return true;
}
if !callback((*self).clone()) {
return false;
}
for self.each_child |kid| {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
if !kid.traverse_preorder_prune(|a| prune(a), |a| callback(a)) {
return false;
}
}
true
}
fn traverse_postorder_prune(&self, prune: &fn(&NR) -> bool, callback: &fn(NR) -> bool) -> bool {
// prune shouldn't mutate, so don't clone
if prune(self) {
return true;
}
for self.each_child |kid| {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
if !kid.traverse_postorder_prune(|a| prune(a), |a| callback(a)) {
return false;
}
}
callback((*self).clone())
}
fn traverse_preorder(&self, callback: &fn(NR) -> bool) -> bool {
self.traverse_preorder_prune(|_| false, callback)
}
fn traverse_postorder(&self, callback: &fn(NR) -> bool) -> bool {
self.traverse_postorder_prune(|_| false, callback)
fn traverse_postorder_prune(&self, prune: &fn(&Self) -> bool) -> TreeIterator<Self> {
let mut nodes = ~[];
gather(self, &mut nodes, true, prune);
TreeIterator::new(nodes)
}
}
fn gather<Node, Ref: TreeNodeRef<Node>>(cur: &Ref, refs: &mut ~[Ref],
postorder: bool, prune: &fn(&Ref) -> bool) {
// prune shouldn't mutate, so don't clone
if prune(cur) {
return;
}
if !postorder {
refs.push(cur.clone());
}
for kid in cur.children() {
// FIXME: Work around rust#2202. We should be able to pass the callback directly.
gather(&kid, refs, postorder, |a| prune(a))
}
if postorder {
refs.push(cur.clone());
}
}
/// Access the fields of a node without a static TreeNodeRef method call.
/// If you make an impl TreeNodeRef<Node> for Ref then you should also make
/// impl TreeNode<Ref> for Node with an empty body.
pub trait TreeNode<Ref: TreeNodeRef<Self>> {
/// Returns the parent of this node.
fn parent_node(&self) -> Option<Ref> {
TreeNodeRef::parent_node::<Self,Ref>(self)
}
/// Returns the first child of this node.
fn first_child(&self) -> Option<Ref> {
TreeNodeRef::first_child::<Self,Ref>(self)
}
/// Returns the last child of this node.
fn last_child(&self) -> Option<Ref> {
TreeNodeRef::last_child::<Self,Ref>(self)
}
/// Returns the previous sibling of this node.
fn prev_sibling(&self) -> Option<Ref> {
TreeNodeRef::prev_sibling::<Self,Ref>(self)
}
/// Returns the next sibling of this node.
fn next_sibling(&self) -> Option<Ref> {
TreeNodeRef::next_sibling::<Self,Ref>(self)
}
/// Sets the parent of this node.
fn set_parent_node(&mut self, new_parent: Option<Ref>) {
TreeNodeRef::set_parent_node::<Self,Ref>(self, new_parent)
}
/// Sets the first child of this node.
fn set_first_child(&mut self, new_first_child: Option<Ref>) {
TreeNodeRef::set_first_child::<Self,Ref>(self, new_first_child)
}
/// Sets the last child of this node.
fn set_last_child(&mut self, new_last_child: Option<Ref>) {
TreeNodeRef::set_last_child::<Self,Ref>(self, new_last_child)
}
/// Sets the previous sibling of this node.
fn set_prev_sibling(&mut self, new_prev_sibling: Option<Ref>) {
TreeNodeRef::set_prev_sibling::<Self,Ref>(self, new_prev_sibling)
}
/// Sets the next sibling of this node.
fn set_next_sibling(&mut self, new_next_sibling: Option<Ref>) {
TreeNodeRef::set_next_sibling::<Self,Ref>(self, new_next_sibling)
}
}

18
servo/src/components/util/url.rs
Просмотреть файл

@ -2,11 +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 extra::net::url;
use extra::net::url::Url;
use extra::url;
use extra::url::Url;
use std::hashmap::HashMap;
use std::os;
use std::result;
/**
Create a URL object from a string. Does various helpful browsery things like
@ -17,10 +16,9 @@ Create a URL object from a string. Does various helpful browsery things like
is based off the current url
*/
#[allow(non_implicitly_copyable_typarams)]
pub fn make_url(str_url: ~str, current_url: Option<Url>) -> Url {
let schm = url::get_scheme(str_url);
let str_url = if result::is_err(&schm) {
let str_url = if schm.is_err() {
if current_url.is_none() {
// Assume we've been given a file path. If it's absolute just return
// it, otherwise make it absolute with the cwd.
@ -30,7 +28,7 @@ pub fn make_url(str_url: ~str, current_url: Option<Url>) -> Url {
~"file://" + os::getcwd().push(str_url).to_str()
}
} else {
let current_url = current_url.get();
let current_url = current_url.unwrap();
debug!("make_url: current_url: %?", current_url);
if str_url.starts_with("//") {
current_url.scheme + ":" + str_url
@ -41,11 +39,11 @@ pub fn make_url(str_url: ~str, current_url: Option<Url>) -> Url {
str_url.trim_left_chars(&'/')
} else {
let mut path = ~[];
for current_url.path.split_iter('/').advance |p| {
for p in current_url.path.split_iter('/') {
path.push(p.to_str());
}
let path = path.init();
let mut path = path.iter().transform(|x| copy *x).collect::<~[~str]>();
let mut path = path.iter().map(|x| (*x).clone()).collect::<~[~str]>();
path.push(str_url);
let path = path.connect("/");
@ -57,7 +55,7 @@ pub fn make_url(str_url: ~str, current_url: Option<Url>) -> Url {
};
// FIXME: Need to handle errors
url::from_str(str_url).get()
url::from_str(str_url).unwrap()
}
mod make_url_tests {
@ -119,6 +117,6 @@ mod make_url_tests {
pub type UrlMap<T> = @mut HashMap<Url, T>;
pub fn url_map<T: Copy>() -> UrlMap<T> {
pub fn url_map<T: Clone + 'static>() -> UrlMap<T> {
@mut HashMap::new()
}