diff --git a/src/rust b/src/rust index 9d966aef060..d546493096f 160000 --- a/src/rust +++ b/src/rust @@ -1 +1 @@ -Subproject commit 9d966aef060030b1d13a55f6768a8e3afb9a842f +Subproject commit d546493096f35e68cbcd9b5d3d7654e7a9345744 diff --git a/src/rust-core-text b/src/rust-core-text index e57128019bb..98e2d7e3870 160000 --- a/src/rust-core-text +++ b/src/rust-core-text @@ -1 +1 @@ -Subproject commit e57128019bb804ec99ef1d6cebd57f5e6c221a3e +Subproject commit 98e2d7e3870759fe91c93ba520452a700fec8756 diff --git a/src/rust-glut b/src/rust-glut index 0a95e429655..aaa25872d7f 160000 --- a/src/rust-glut +++ b/src/rust-glut @@ -1 +1 @@ -Subproject commit 0a95e429655d51e96de45af91a5ee02fad5a99f6 +Subproject commit aaa25872d7f6ba5eb4c61651f369d8d06e759d87 diff --git a/src/servo-gfx/compositor.rs b/src/servo-gfx/compositor.rs index e7fbdf74e7f..7a3681a5721 100644 --- a/src/servo-gfx/compositor.rs +++ b/src/servo-gfx/compositor.rs @@ -25,6 +25,6 @@ pub struct LayerBufferSet { /// submit them to be drawn to the display. pub trait Compositor { fn begin_drawing(&self, next_dt: comm::Chan); - fn draw(&self, next_dt: comm::Chan, +draw_me: LayerBufferSet); + fn draw(&self, next_dt: comm::Chan, draw_me: LayerBufferSet); } diff --git a/src/servo-gfx/font.rs b/src/servo-gfx/font.rs index 2daae21e05e..9178d69351f 100644 --- a/src/servo-gfx/font.rs +++ b/src/servo-gfx/font.rs @@ -386,7 +386,7 @@ pub impl Font { advance += glyph.advance(); } let bounds = Rect(Point2D(Au(0), -self.metrics.ascent), - Size2D(advance, self.metrics.ascent + self.metrics.descent)); + Size2D(advance, self.metrics.ascent + self.metrics.descent)); // TODO(Issue #125): support loose and tight bounding boxes; using the // ascent+descent and advance is sometimes too generous and diff --git a/src/servo-gfx/font_list.rs b/src/servo-gfx/font_list.rs index f014546c520..a67bf8dd951 100644 --- a/src/servo-gfx/font_list.rs +++ b/src/servo-gfx/font_list.rs @@ -96,10 +96,9 @@ impl FontFamily { } fn load_family_variations(@mut self, list: &FontListHandle) { - let this : &mut FontFamily = self; // FIXME: borrow checker workaround - if this.entries.len() > 0 { return; } + if self.entries.len() > 0 { return; } list.load_variations_for_family(self); - assert!(this.entries.len() > 0); + assert!(self.entries.len() > 0); } pub fn find_font_for_style(@mut self, list: &FontListHandle, style: &SpecifiedFontStyle) diff --git a/src/servo-gfx/geometry.rs b/src/servo-gfx/geometry.rs index e5835bf008b..d3b1f019df9 100644 --- a/src/servo-gfx/geometry.rs +++ b/src/servo-gfx/geometry.rs @@ -22,8 +22,8 @@ impl Mul for Au { fn mul(&self, other: &Au) -> Au { Au(**self * **other) } } -impl Quot for Au { - fn quot(&self, other: &Au) -> Au { Au(**self / **other) } +impl Div for Au { + fn div(&self, other: &Au) -> Au { Au(**self / **other) } } impl Rem for Au { diff --git a/src/servo-gfx/platform/macos/font.rs b/src/servo-gfx/platform/macos/font.rs index 213bea408ac..dbdbc2a0324 100644 --- a/src/servo-gfx/platform/macos/font.rs +++ b/src/servo-gfx/platform/macos/font.rs @@ -16,7 +16,7 @@ use geometry::Au; use platform::macos::font_context::FontContextHandle; use text::glyph::GlyphIndex; -use core_foundation::base::{CFIndex, CFWrapper}; +use core_foundation::base::CFIndex; use core_foundation::data::CFData; use core_foundation::string::UniChar; use core_graphics::data_provider::CGDataProvider; @@ -106,7 +106,7 @@ impl FontHandleMethods for FontHandle { fn boldness(&self) -> CSSFontWeight { // -1.0 to 1.0 - let normalized = unsafe { self.ctfont.all_traits().normalized_weight() }; + let normalized = self.ctfont.all_traits().normalized_weight(); // 0.0 to 9.0 let normalized = (normalized + 1.0) / 2.0 * 9.0; if normalized < 1.0 { return FontWeight100; } @@ -146,13 +146,11 @@ impl FontHandleMethods for FontHandle { fn glyph_h_advance(&self, glyph: GlyphIndex) -> Option { let glyphs = [glyph as CGGlyph]; - unsafe { - let advance = self.ctfont.get_advances_for_glyphs(kCTFontDefaultOrientation, - &glyphs[0], - ptr::null(), - 1); - return Some(advance as FractionalPixel); - } + let advance = self.ctfont.get_advances_for_glyphs(kCTFontDefaultOrientation, + &glyphs[0], + ptr::null(), + 1); + Some(advance as FractionalPixel) } fn get_metrics(&self) -> FontMetrics { diff --git a/src/servo-gfx/platform/macos/font_list.rs b/src/servo-gfx/platform/macos/font_list.rs index cdd4c7baeea..79698c1cdfd 100644 --- a/src/servo-gfx/platform/macos/font_list.rs +++ b/src/servo-gfx/platform/macos/font_list.rs @@ -42,11 +42,9 @@ pub impl FontListHandle { } fn load_variations_for_family(&self, family: @mut FontFamily) { - let fam: &mut FontFamily = family; // FIXME: borrow checker workaround - let family_name = &fam.family_name; - debug!("Looking for faces of family: %s", *family_name); + debug!("Looking for faces of family: %s", family.family_name); - let family_collection = core_text::font_collection::create_for_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 font = core_text::font::new_from_descriptor(&desc, 0.0); diff --git a/src/servo-net/image_cache_task.rs b/src/servo-net/image_cache_task.rs index 4a462cdc926..1b9d8415f61 100644 --- a/src/servo-net/image_cache_task.rs +++ b/src/servo-net/image_cache_task.rs @@ -373,20 +373,13 @@ impl ImageCache { } priv fn purge_waiters(&self, url: Url, f: &fn() -> ImageResponseMsg) { - match self.wait_map.find(&url) { - Some(waiters) => { - let waiters = *waiters; - let mut new_waiters = ~[]; - new_waiters <-> *waiters; - - for new_waiters.each |response| { - response.send(f()); + match self.wait_map.pop(&url) { + Some(waiters) => { + for waiters.each |response| { + response.send(f()); + } } - - *waiters <-> new_waiters; - self.wait_map.remove(&url); - } - None => () + None => () } } @@ -410,13 +403,11 @@ impl ImageCache { Prefetching(DoDecode) | Decoding => { // We don't have this image yet - match self.wait_map.find(&url) { - Some(waiters) => { - vec::push(*waiters, response); - } - None => { - self.wait_map.insert(url, @mut ~[response]); - } + if self.wait_map.contains_key(&url) { + let waiters = self.wait_map.find_mut(&url).unwrap(); + waiters.push(response); + } else { + self.wait_map.insert(url, @mut ~[response]); } } diff --git a/src/servo-net/local_image_cache.rs b/src/servo-net/local_image_cache.rs index 8df7f082bb7..eaa23d8e8de 100644 --- a/src/servo-net/local_image_cache.rs +++ b/src/servo-net/local_image_cache.rs @@ -76,12 +76,9 @@ pub impl LocalImageCache { match state.last_response { ImageReady(ref image) => { - // FIXME: appease borrowck - unsafe { - let (port, chan) = comm::stream(); - chan.send(ImageReady(clone_arc(image))); - return port; - } + let (port, chan) = comm::stream(); + chan.send(ImageReady(clone_arc(image))); + return port; } ImageNotReady => { if last_round == self.round_number { @@ -138,18 +135,14 @@ pub impl LocalImageCache { } priv fn get_state(&self, url: &Url) -> @mut ImageState { - match self.state_map.find(url) { - Some(state) => *state, - None => { - let new_state = @mut ImageState { - prefetched: false, - decoded: false, - last_request_round: 0, - last_response: ImageNotReady - }; - self.state_map.insert(copy *url, new_state); - self.get_state(url) - } + *do self.state_map.find_or_insert_with(url.clone()) |_| { + let new_state = @mut ImageState { + prefetched: false, + decoded: false, + last_request_round: 0, + last_response: ImageNotReady + }; + new_state } } } diff --git a/src/servo-util/url.rs b/src/servo-util/url.rs index e12ad9761cf..9df4e8c49b2 100644 --- a/src/servo-util/url.rs +++ b/src/servo-util/url.rs @@ -17,7 +17,7 @@ Create a URL object from a string. Does various helpful browsery things like */ #[allow(non_implicitly_copyable_typarams)] pub fn make_url(str_url: ~str, current_url: Option) -> Url { - let mut schm = url::get_scheme(str_url); + let schm = url::get_scheme(str_url); let str_url = if result::is_err(&schm) { if current_url.is_none() { // Assume we've been given a file path. If it's absolute just return diff --git a/src/servo/compositing/mod.rs b/src/servo/compositing/mod.rs index d2824674e4d..3ec1e9d7f36 100644 --- a/src/servo/compositing/mod.rs +++ b/src/servo/compositing/mod.rs @@ -288,7 +288,10 @@ fn Surface(backend: BackendType) -> Surface { /// A function for spawning into the platform's main thread. fn on_osmain(f: ~fn(po: Port)) -> Chan { let (setup_po, setup_ch) = comm::stream(); - do task::task().sched_mode(task::PlatformThread).spawn { + // FIXME: rust#6399 + let mut main_task = task::task(); + main_task.sched_mode(task::PlatformThread); + do main_task.spawn { let (po, ch) = comm::stream(); setup_ch.send(ch); f(po); diff --git a/src/servo/content/content_task.rs b/src/servo/content/content_task.rs index 56d0959923a..c26fddba911 100644 --- a/src/servo/content/content_task.rs +++ b/src/servo/content/content_task.rs @@ -65,7 +65,10 @@ pub fn ContentTask(layout_task: LayoutTask, let dom_event_port = Cell(dom_event_port); let dom_event_chan = Cell(dom_event_chan); - do task().sched_mode(SingleThreaded).spawn { + // FIXME: rust#6399 + let mut the_task = task(); + the_task.sched_mode(SingleThreaded); + do the_task.spawn { let content = Content(layout_task.clone(), control_port.take(), control_chan_copy.clone(), @@ -150,7 +153,7 @@ pub fn Content(layout_task: LayoutTask, }; cx.set_cx_private(ptr::to_unsafe_ptr(&*content) as *()); - unsafe { task::local_data::local_data_set(global_content_key, cast::transmute(content)); } + unsafe { local_data::local_data_set(global_content_key, cast::transmute(content)); } content } @@ -159,7 +162,7 @@ fn global_content_key(_: @Content) {} pub fn global_content() -> @Content { unsafe { - return task::local_data::local_data_get(global_content_key).get(); + return local_data::local_data_get(global_content_key).get(); } } @@ -170,7 +173,7 @@ pub fn task_from_context(cx: *JSContext) -> *mut Content { #[unsafe_destructor] impl Drop for Content { fn finalize(&self) { - unsafe { task::local_data::local_data_pop(global_content_key) }; + unsafe { local_data::local_data_pop(global_content_key) }; } } @@ -183,7 +186,7 @@ pub impl Content { } fn handle_msg(&mut self) -> bool { - match select2i(&self.control_port, &self.event_port) { + match select2i(&mut self.control_port, &mut self.event_port) { either::Left(*) => { let msg = self.control_port.recv(); self.handle_control_msg(msg) diff --git a/src/servo/dom/bindings/utils.rs b/src/servo/dom/bindings/utils.rs index 0fe45f79e04..d52af8760f2 100644 --- a/src/servo/dom/bindings/utils.rs +++ b/src/servo/dom/bindings/utils.rs @@ -608,8 +608,8 @@ pub fn WrapNewBindingObject(cx: *JSContext, scope: *JSObject, mut value: @mut CacheableWrapper, vp: *mut JSVal) -> bool { unsafe { - let mut cache = value.get_wrappercache(); - let mut obj = cache.get_wrapper(); + let cache = value.get_wrappercache(); + let obj = cache.get_wrapper(); if obj.is_not_null() /*&& js::GetObjectCompartment(obj) == js::GetObjectCompartment(scope)*/ { *vp = RUST_OBJECT_TO_JSVAL(obj); return true; diff --git a/src/servo/layout/block.rs b/src/servo/layout/block.rs index 4a441f4cc38..20df5912808 100644 --- a/src/servo/layout/block.rs +++ b/src/servo/layout/block.rs @@ -65,14 +65,12 @@ impl BlockLayout for FlowContext { fn with_block_box(&self, callback: &fn(box: RenderBox) -> ()) -> () { match *self { BlockFlow(*) => { - let box = self.block().box; - for box.each |&b| { + for self.block().box.each |&b| { callback(b); } }, RootFlow(*) => { - let mut box = self.root().box; - for box.each |&b| { + for self.root().box.each |&b| { callback(b); } }, diff --git a/src/servo/layout/box.rs b/src/servo/layout/box.rs index 67d96dcef67..9cf69bdd7f0 100644 --- a/src/servo/layout/box.rs +++ b/src/servo/layout/box.rs @@ -30,7 +30,7 @@ use servo_net::image::holder::ImageHolder; use servo_net::local_image_cache::LocalImageCache; use servo_util::range::*; use std::arc; -use std::cmp::FuzzyEq; +use core::cmp::ApproxEq; use std::net::url::Url; /// Render boxes (`struct RenderBox`) are the leaves of the layout tree. They cannot position @@ -168,15 +168,12 @@ pub impl RenderBox { match *self { GenericRenderBoxClass(generic_box) => callback(generic_box), ImageRenderBoxClass(image_box) => { - let image_box = &*image_box; // FIXME: Borrow check workaround. callback(&image_box.base) } TextRenderBoxClass(text_box) => { - let text_box = &*text_box; // FIXME: Borrow check workaround. callback(&text_box.base) } UnscannedTextRenderBoxClass(unscanned_text_box) => { - let unscanned_text_box = &*unscanned_text_box; // FIXME: Borrow check workaround. callback(&unscanned_text_box.base) } } @@ -188,16 +185,12 @@ pub impl RenderBox { match *self { GenericRenderBoxClass(generic_box) => callback(generic_box), ImageRenderBoxClass(image_box) => { - let image_box = &mut *image_box; // FIXME: Borrow check workaround. callback(&mut image_box.base) } TextRenderBoxClass(text_box) => { - let text_box = &mut *text_box; // FIXME: Borrow check workaround. callback(&mut text_box.base) } UnscannedTextRenderBoxClass(unscanned_text_box) => { - // FIXME: Borrow check workaround. - let unscanned_text_box = &mut *unscanned_text_box; callback(&mut unscanned_text_box.base) } } @@ -238,7 +231,6 @@ pub impl RenderBox { fn is_whitespace_only(&self) -> bool { match *self { UnscannedTextRenderBoxClass(unscanned_text_box) => { - let mut unscanned_text_box = &mut *unscanned_text_box; // FIXME: Borrow check. unscanned_text_box.text.is_whitespace() } _ => false @@ -269,8 +261,6 @@ pub impl RenderBox { } TextRenderBoxClass(text_box) => { - let text_box = &mut *text_box; // FIXME: Borrow check. - let mut pieces_processed_count: uint = 0; let mut remaining_width: Au = max_width; let mut left_range = Range::new(text_box.text_data.range.begin(), 0); @@ -379,7 +369,6 @@ pub impl RenderBox { } TextRenderBoxClass(text_box) => { - let mut text_box = &mut *text_box; // FIXME: Borrow check. text_box.text_data.run.min_width_for_range(&text_box.text_data.range) } @@ -401,8 +390,6 @@ pub impl RenderBox { } TextRenderBoxClass(text_box) => { - let mut text_box = &mut *text_box; // FIXME: Borrow check bug. - // A text box cannot span lines, so assume that this is an unsplit text box. // // TODO: If text boxes have been split to wrap lines, then they could report a @@ -567,8 +554,6 @@ pub impl RenderBox { match *self { UnscannedTextRenderBoxClass(*) => fail!(~"Shouldn't see unscanned boxes here."), TextRenderBoxClass(text_box) => { - let text_box = &mut *text_box; // FIXME: Borrow check bug. - let nearest_ancestor_element = self.nearest_ancestor_element(); let color = nearest_ancestor_element.style().color().to_gfx_color(); @@ -650,7 +635,7 @@ pub impl RenderBox { let nearest_ancestor_element = self.nearest_ancestor_element(); let bgcolor = nearest_ancestor_element.style().background_color(); - if !bgcolor.alpha.fuzzy_eq(&0.0) { + if !bgcolor.alpha.approx_eq(&0.0) { let mut l = list.take(); // FIXME: use with_mut_ref when available l.append_item(~DisplayItem::new_SolidColor(absolute_bounds, bgcolor.to_gfx_color())); list.put_back(l); @@ -783,13 +768,11 @@ impl DebugMethods for RenderBox { GenericRenderBoxClass(*) => ~"GenericRenderBox", ImageRenderBoxClass(*) => ~"ImageRenderBox", TextRenderBoxClass(text_box) => { - let mut text_box = &mut *text_box; // FIXME: Borrow check bug. fmt!("TextRenderBox(text=%s)", str::substr(text_box.text_data.run.text, text_box.text_data.range.begin(), text_box.text_data.range.length())) } UnscannedTextRenderBoxClass(text_box) => { - let mut text_box = &mut *text_box; // FIXME: Borrow check bug. fmt!("UnscannedTextRenderBox(%s)", text_box.text) } }; diff --git a/src/servo/layout/box_builder.rs b/src/servo/layout/box_builder.rs index 9a04148ced8..079231bc7ba 100644 --- a/src/servo/layout/box_builder.rs +++ b/src/servo/layout/box_builder.rs @@ -125,7 +125,6 @@ impl BoxGenerator { // depending on flow, make a box for this node. match self.flow { InlineFlow(inline) => { - let mut inline = &mut *inline; let node_range_start = inline.boxes.len(); self.range_stack.push(node_range_start); @@ -387,24 +386,38 @@ pub impl LayoutTreeBuilder { // check first/last child for whitespace-ness for first_child.each |first_flow| { if first_flow.starts_inline_flow() { - let boxes = &mut first_flow.inline().boxes; + // FIXME: workaround for rust#6393 + let mut do_remove = false; + { + let boxes = &first_flow.inline().boxes; if boxes.len() == 1 && boxes[0].is_whitespace_only() { debug!("LayoutTreeBuilder: pruning whitespace-only first child flow \ f%d from parent f%d", first_flow.id(), parent_flow.id()); + do_remove = true; + } + } + if (do_remove) { parent_flow.remove_child(*first_flow); } } } for last_child.each |last_flow| { if last_flow.starts_inline_flow() { - let boxes = &mut last_flow.inline().boxes; + // FIXME: workaround for rust#6393 + let mut do_remove = false; + { + let boxes = &last_flow.inline().boxes; if boxes.len() == 1 && boxes.last().is_whitespace_only() { debug!("LayoutTreeBuilder: pruning whitespace-only last child flow \ f%d from parent f%d", last_flow.id(), parent_flow.id()); + do_remove = true; + } + } + if (do_remove) { parent_flow.remove_child(*last_flow); } } diff --git a/src/servo/layout/flow.rs b/src/servo/layout/flow.rs index 231a5a09fd9..117d48b7ed5 100644 --- a/src/servo/layout/flow.rs +++ b/src/servo/layout/flow.rs @@ -76,17 +76,14 @@ impl TreeNodeRef for FlowContext { match *self { AbsoluteFlow(info) => callback(info), BlockFlow(info) => { - let info = &*info; // FIXME: Borrow check workaround. callback(&info.common) } FloatFlow(info) => callback(info), InlineBlockFlow(info) => callback(info), InlineFlow(info) => { - let info = &*info; // FIXME: Borrow check workaround. callback(&info.common) } RootFlow(info) => { - let info = &*info; // FIXME: Borrow check workaround. callback(&info.common) } TableFlow(info) => callback(info), @@ -96,17 +93,14 @@ impl TreeNodeRef for FlowContext { match *self { AbsoluteFlow(info) => callback(info), BlockFlow(info) => { - let info = &mut *info; // FIXME: Borrow check workaround. callback(&mut info.common) } FloatFlow(info) => callback(info), InlineBlockFlow(info) => callback(info), InlineFlow(info) => { - let info = &mut *info; // FIXME: Borrow check workaround. callback(&mut info.common) } RootFlow(info) => { - let info = &mut *info; // FIXME: Borrow check workaround. callback(&mut info.common) } TableFlow(info) => callback(info), @@ -388,7 +382,6 @@ impl DebugMethods for FlowContext { fn debug_str(&self) -> ~str { let repr = match *self { InlineFlow(inline) => { - let inline = &mut *inline; let mut s = inline.boxes.foldl(~"InlineFlow(children=", |s, box| { fmt!("%s b%d", *s, box.id()) }); @@ -396,14 +389,12 @@ impl DebugMethods for FlowContext { s }, BlockFlow(block) => { - let block = &mut *block; match block.box { Some(box) => fmt!("BlockFlow(box=b%d)", box.id()), None => ~"BlockFlow", } }, RootFlow(root) => { - let root = &mut *root; match root.box { Some(box) => fmt!("RootFlow(box=b%d)", box.id()), None => ~"RootFlow", diff --git a/src/servo/layout/inline.rs b/src/servo/layout/inline.rs index 6a0cf73fa34..b3cec67d5af 100644 --- a/src/servo/layout/inline.rs +++ b/src/servo/layout/inline.rs @@ -173,7 +173,7 @@ impl TextRunScanner { impl TextRunScanner { fn scan_for_runs(&mut self, ctx: &mut LayoutContext, flow: FlowContext) { - let inline = &mut *flow.inline(); + let inline = flow.inline(); assert!(inline.boxes.len() > 0); debug!("TextRunScanner: scanning %u boxes for text runs...", inline.boxes.len()); @@ -334,8 +334,7 @@ impl TextRunScanner { debug!("------------------"); debug!("--- Elem ranges: ---"); - let elems: &mut ElementMapping = &mut flow.inline().elems; - for elems.eachi_mut |i: uint, nr: &NodeRange| { + for flow.inline().elems.eachi_mut |i: uint, nr: &NodeRange| { debug!("%u: %? --> %s", i, nr.range, nr.node.debug_str()); () } debug!("--------------------"); @@ -386,43 +385,46 @@ impl LineboxScanner { pub fn scan_for_lines(&mut self, ctx: &LayoutContext) { self.reset_scanner(); - let boxes = &mut self.flow.inline().boxes; - let mut i = 0u; + { // FIXME: manually control borrow length + let inline: &InlineFlowData = self.flow.inline(); + let mut i = 0u; - loop { - // acquire the next box to lay out from work list or box list - let cur_box = if self.work_list.is_empty() { - if i == boxes.len() { - break + loop { + // acquire the next box to lay out from work list or box list + let cur_box = if self.work_list.is_empty() { + if i == inline.boxes.len() { + break + } + let box = inline.boxes[i]; i += 1; + debug!("LineboxScanner: Working with box from box list: b%d", box.id()); + box + } else { + let box = self.work_list.pop_front(); + debug!("LineboxScanner: Working with box from work list: b%d", box.id()); + box + }; + + let box_was_appended = self.try_append_to_line(ctx, cur_box); + if !box_was_appended { + debug!("LineboxScanner: Box wasn't appended, because line %u was full.", + self.line_spans.len()); + self.flush_current_line(); + } else { + debug!("LineboxScanner: appended a box to line %u", self.line_spans.len()); } - let box = boxes[i]; i += 1; - debug!("LineboxScanner: Working with box from box list: b%d", box.id()); - box - } else { - let box = self.work_list.pop_front(); - debug!("LineboxScanner: Working with box from work list: b%d", box.id()); - box - }; + } - let box_was_appended = self.try_append_to_line(ctx, cur_box); - if !box_was_appended { - debug!("LineboxScanner: Box wasn't appended, because line %u was full.", + if self.pending_line.range.length() > 0 { + debug!("LineboxScanner: Partially full linebox %u left at end of scanning.", self.line_spans.len()); self.flush_current_line(); - } else { - debug!("LineboxScanner: appended a box to line %u", self.line_spans.len()); } } - - if self.pending_line.range.length() > 0 { - debug!("LineboxScanner: Partially full linebox %u left at end of scanning.", - self.line_spans.len()); - self.flush_current_line(); + + { // FIXME: scope the borrow + let inline: &mut InlineFlowData = self.flow.inline(); + inline.elems.repair_for_box_changes(inline.boxes, self.new_boxes); } - - let boxes = &mut self.flow.inline().boxes; - let elems = &mut self.flow.inline().elems; - elems.repair_for_box_changes(*boxes, self.new_boxes); self.swap_out_results(); } @@ -431,10 +433,9 @@ impl LineboxScanner { self.line_spans.len(), self.flow.id()); - let inline_boxes = &mut self.flow.inline().boxes; - util::swap(inline_boxes, &mut self.new_boxes); - let lines = &mut self.flow.inline().lines; - util::swap(lines, &mut self.line_spans); + let inline: &mut InlineFlowData = self.flow.inline(); + util::swap(&mut inline.boxes, &mut self.new_boxes); + util::swap(&mut inline.lines, &mut self.line_spans); } fn flush_current_line(&mut self) { @@ -763,7 +764,6 @@ impl InlineFlowData { // TODO: We can use font metrics directly instead of re-measuring for the // bounding box. TextRenderBoxClass(text_box) => { - let text_box = &mut *text_box; // FIXME: borrow check workaround let range = &text_box.text_data.range; let run = &text_box.text_data.run; let text_bounds = run.metrics_for_range(range).bounding_box; @@ -814,7 +814,7 @@ impl InlineFlowData { self.common.position.size.height = cur_y; } - pub fn build_display_list_inline(&mut self, + pub fn build_display_list_inline(&self, builder: &DisplayListBuilder, dirty: &Rect, offset: &Point2D,